Forge Dimension Chunk generation

[Alasar]

Hi,

I'm new here in this Forum but I'll try to explain my problem as easy as possible and hope for fast help.

Im trying to create a new Dimension (actually more than one) only with Forge. I know that Dimension API could do more, but I like to be independent from it.

I registred the world provider and createt the teleporter, but I keep ending up in the Nether while teleporting.

Here's the code of my teleporter-related classes:

 

package Alasar.TheVoid.common;

 

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Random;

 

import net.minecraft.src.Block;

import net.minecraft.src.ChunkCoordIntPair;

import net.minecraft.src.Direction;

import net.minecraft.src.Entity;

import net.minecraft.src.LongHashMap;

import net.minecraft.src.MathHelper;

import net.minecraft.src.PortalPosition;

import net.minecraft.src.Teleporter;

import net.minecraft.src.WorldServer;

 

public class InterRealmTeleporter extends Teleporter

{

  private final WorldServer field_85192_a;

  private final Random random;

  private final LongHashMap field_85191_c = new LongHashMap();

  private final List field_85190_d = new ArrayList();

 

  public InterRealmTeleporter(WorldServer par1WorldServer) {

    super(par1WorldServer);

    this.field_85192_a = par1WorldServer;

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

  }

 

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

  {

      if (this.getField_85192_a().provider.dimensionId != 3)

      {

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

          {

              this.func_85188_a(par1Entity);

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

          }

      }

      else

      {

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

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

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

          byte var12 = 1;

          byte var13 = 0;

 

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

          {

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

              {

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

                  {

                      int var17 = var9 + var15 * var12 + var14 * var13;

                      int var18 = var10 + var16;

                      int var19 = var11 + var15 * var13 - var14 * var12;

                      boolean var20 = var16 < 0;

                      this.getField_85192_a().setBlockWithNotify(var17, var18, var19, var20 ? TVMain.ecryb.blockID : 0);

                  }

              }

          }

 

          par1Entity.setLocationAndAngles((double)var9, (double)var10, (double)var11, 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 var9 = 128;

      double var10 = -1.0D;

      int var12 = 0;

      int var13 = 0;

      int var14 = 0;

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

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

      long var17 = ChunkCoordIntPair.chunkXZ2Int(var15, var16);

      boolean var19 = true;

      double var27;

      int var48;

 

      if (this.field_85191_c.containsItem(var17))

      {

          PortalPosition var20 = (PortalPosition)this.field_85191_c.getValueByKey(var17);

          var10 = 0.0D;

          var12 = var20.posX;

          var13 = var20.posY;

          var14 = var20.posZ;

          var20.field_85087_d = this.getField_85192_a().getTotalWorldTime();

          var19 = false;

      }

      else

      {

          for (var48 = var15 - var9; var48 <= var15 + var9; ++var48)

          {

              double var21 = (double)var48 + 0.5D - par1Entity.posX;

 

              for (int var23 = var16 - var9; var23 <= var16 + var9; ++var23)

              {

                  double var24 = (double)var23 + 0.5D - par1Entity.posZ;

 

                  for (int var26 = this.getField_85192_a().getActualHeight() - 1; var26 >= 0; --var26)

                  {

                      if (this.getField_85192_a().getBlockId(var48, var26, var23) == TVMain.ecryb.blockID)

                      {

                          while (this.getField_85192_a().getBlockId(var48, var26 - 1, var23) == TVMain.ecryb.blockID)

                          {

                              --var26;

                          }

 

                          var27 = (double)var26 + 0.5D - par1Entity.posY;

                          double var29 = var21 * var21 + var27 * var27 + var24 * var24;

 

                          if (var10 < 0.0D || var29 < var10)

                          {

                              var10 = var29;

                              var12 = var48;

                              var13 = var26;

                              var14 = var23;

                          }

                      }

                  }

              }

          }

      }

return true;

  }

  public boolean func_85188_a(Entity par1Entity)

  {

      byte var2 = 16;

      double var3 = -1.0D;

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

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

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

      int var8 = var5;

      int var9 = var6;

      int var10 = var7;

      int var11 = 0;

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

      int var13;

      double var14;

      double var17;

      int var16;

      int var19;

      int var21;

      int var20;

      int var23;

      int var22;

      int var25;

      int var24;

      int var27;

      int var26;

      double var31;

      double var32;

 

      for (var13 = var5 - var2; var13 <= var5 + var2; ++var13)

      {

          var14 = (double)var13 + 0.5D - par1Entity.posX;

 

          for (var16 = var7 - var2; var16 <= var7 + var2; ++var16)

          {

              var17 = (double)var16 + 0.5D - par1Entity.posZ;

              label274:

 

              for (var19 = this.getField_85192_a().getActualHeight() - 1; var19 >= 0; --var19)

              {

                  if (this.getField_85192_a().isAirBlock(var13, var19, var16))

                  {

                      while (var19 > 0 && this.getField_85192_a().isAirBlock(var13, var19 - 1, var16))

                      {

                          --var19;

                      }

 

                      for (var20 = var12; var20 < var12 + 4; ++var20)

                      {

                          var21 = var20 % 2;

                          var22 = 1 - var21;

 

                          if (var20 % 4 >= 2)

                          {

                              var21 = -var21;

                              var22 = -var22;

                          }

 

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

                          {

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

                              {

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

                                  {

                                      var26 = var13 + (var24 - 1) * var21 + var23 * var22;

                                      var27 = var19 + var25;

                                      int var28 = var16 + (var24 - 1) * var22 - var23 * var21;

 

                                      if (var25 < 0 && !this.getField_85192_a().getBlockMaterial(var26, var27, var28).isSolid() || var25 >= 0 && !this.getField_85192_a().isAirBlock(var26, var27, var28))

                                      {

                                          continue label274;

                                      }

                                  }

                              }

                          }

 

                          var32 = (double)var19 + 0.5D - par1Entity.posY;

                          var31 = var14 * var14 + var32 * var32 + var17 * var17;

 

                          if (var3 < 0.0D || var31 < var3)

                          {

                              var3 = var31;

                              var8 = var13;

                              var9 = var19;

                              var10 = var16;

                              var11 = var20 % 4;

                          }

                      }

                  }

              }

          }

      }

 

      if (var3 < 0.0D)

      {

          for (var13 = var5 - var2; var13 <= var5 + var2; ++var13)

          {

              var14 = (double)var13 + 0.5D - par1Entity.posX;

 

              for (var16 = var7 - var2; var16 <= var7 + var2; ++var16)

              {

                  var17 = (double)var16 + 0.5D - par1Entity.posZ;

                  label222:

 

                  for (var19 = this.getField_85192_a().getActualHeight() - 1; var19 >= 0; --var19)

                  {

                      if (this.getField_85192_a().isAirBlock(var13, var19, var16))

                      {

                          while (var19 > 0 && this.getField_85192_a().isAirBlock(var13, var19 - 1, var16))

                          {

                              --var19;

                          }

 

                          for (var20 = var12; var20 < var12 + 2; ++var20)

                          {

                              var21 = var20 % 2;

                              var22 = 1 - var21;

 

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

                              {

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

                                  {

                                      var25 = var13 + (var23 - 1) * var21;

                                      var26 = var19 + var24;

                                      var27 = var16 + (var23 - 1) * var22;

 

                                      if (var24 < 0 && !this.getField_85192_a().getBlockMaterial(var25, var26, var27).isSolid() || var24 >= 0 && !this.getField_85192_a().isAirBlock(var25, var26, var27))

                                      {

                                          continue label222;

                                      }

                                  }

                              }

 

                              var32 = (double)var19 + 0.5D - par1Entity.posY;

                              var31 = var14 * var14 + var32 * var32 + var17 * var17;

 

                              if (var3 < 0.0D || var31 < var3)

                              {

                                  var3 = var31;

                                  var8 = var13;

                                  var9 = var19;

                                  var10 = var16;

                                  var11 = var20 % 2;

                              }

                          }

                      }

                  }

              }

          }

      }

 

      int var29 = var8;

      int var15 = var9;

      var16 = var10;

      int var30 = var11 % 2;

      int var18 = 1 - var30;

 

      if (var11 % 4 >= 2)

      {

          var30 = -var30;

          var18 = -var18;

      }

 

      boolean var33;

 

      if (var3 < 0.0D)

      {

          if (var9 < 70)

          {

              var9 = 70;

          }

 

          if (var9 > this.getField_85192_a().getActualHeight() - 10)

          {

              var9 = this.getField_85192_a().getActualHeight() - 10;

          }

 

          var15 = var9;

 

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

          {

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

              {

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

                  {

                      var22 = var29 + (var20 - 1) * var30 + var19 * var18;

                      var23 = var15 + var21;

                      var24 = var16 + (var20 - 1) * var18 - var19 * var30;

                      var33 = var21 < 0;

                      this.getField_85192_a().setBlockWithNotify(var22, var23, var24, var33 ? TVMain.ecryb.blockID : 0);

                  }

              }

          }

      }

 

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

      {

          this.getField_85192_a().editingBlocks = true;

 

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

          {

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

              {

                  var22 = var29 + (var20 - 1) * var30;

                  var23 = var15 + var21;

                  var24 = var16 + (var20 - 1) * var18;

                  var33 = var20 == 0 || var20 == 3 || var21 == -1 || var21 == 3;

                  this.getField_85192_a().setBlockWithNotify(var22, var23, var24, var33 ? TVMain.ecryb.blockID : TVMain.bportal.blockID);

              }

          }

 

          this.getField_85192_a().editingBlocks = false;

 

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

          {

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

              {

                  var22 = var29 + (var20 - 1) * var30;

                  var23 = var15 + var21;

                  var24 = var16 + (var20 - 1) * var18;

                  this.getField_85192_a().notifyBlocksOfNeighborChange(var22, var23, var24, this.getField_85192_a().getBlockId(var22, var23, var24));

              }

          }

      }

 

      return true;

  }

  public void func_85189_a(long par1)

  {

      if (par1 % 100L == 0L)

      {

          Iterator var3 = this.field_85190_d.iterator();

          long var4 = par1 - 600L;

 

          while (var3.hasNext())

          {

              Long var6 = (Long)var3.next();

              PortalPosition var7 = (PortalPosition)this.field_85191_c.getValueByKey(var6.longValue());

 

              if (var7 == null || var7.field_85087_d < var4)

              {

                  var3.remove();

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

              }

          }

      }

  }

}

 

 

 

package Alasar.TheVoid.common;

 

import java.util.ArrayList;

import java.util.List;

 

import net.minecraft.src.AxisAlignedBB;

import net.minecraft.src.Block;

import net.minecraft.src.BlockPortal;

import net.minecraft.src.CreativeTabs;

import net.minecraft.src.IBlockAccess;

import net.minecraft.src.Material;

import net.minecraft.src.ModLoader;

import net.minecraft.src.Teleporter;

import net.minecraft.src.World;

import net.minecraft.src.WorldProviderBase;

 

public class BlockBPortal extends BlockPortal

{

//Look in BlockPortalBase.java to see the full array of hooks you can use for your portal block.

 

public BlockBPortal(int i)

{

super(i, 5);

//Get a unique sprite index for the portal texture so that it doesn't override another

//texture.

this.setCreativeTab(CreativeTabs.tabBlock);

}

 

public WorldProviderBase getDimension()

{

return new WorldProviderBedDim();

}

 

public Teleporter getTeleporter()

{

return new InterRealmTeleporter(null);

}

 

//You can get to this dimension from the overworld (0) and Nether (-1).

 

 

//You should probably make the portal non-solid so you can step into it...

public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k)

{

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)

{

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

{

float f = 0.5F;

float f2 = 0.125F;

setBlockBounds(0.5F - f, 0.0F, 0.5F - f2, 0.5F + f, 1.0F, 0.5F + f2);

}

else

{

float f1 = 0.125F;

float f3 = 0.5F;

setBlockBounds(0.5F - f1, 0.0F, 0.5F - f3, 0.5F + f1, 1.0F, 0.5F + f3);

}

}

public List canTeleportFromDimension()

{

        ArrayList arraylist = new ArrayList();

        arraylist.add(Integer.valueOf(0));//player can teleport from overworld to this dimension

        arraylist.add(Integer.valueOf(-1));//player can teleport from Nether to this dimension

        return arraylist;

}

/**

* Is this block (a) opaque and ( 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)

*/

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)

{

    int i = 0;

    int j = 0;

 

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

    {

        i = 1;

    }

 

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

    {

        j = 1;

    }

 

    if (i == j)

    {

        return false;

    }

 

    if (par1World.getBlockId(par2 - i, par3, par4 - j) == 0)

    {

        par2 -= i;

        par4 -= j;

    }

 

    for (int k = -1; k <= 2; k++)

    {

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

        {

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

 

            if ((k == -1 || k == 2) && (i1 == -1 || i1 == 3))

            {

                continue;

            }

 

            int k1 = par1World.getBlockId(par2 + i * k, par3 + i1, par4 + j * k);

 

            if (flag)

            {

                if (k1 != TVMain.ecryb.blockID)

                {

                    return false;

                }

 

                continue;

            }

 

            if (k1 != 0 && k1 != Block.fire.blockID)

            {

                return false;

            }

        }

    }

 

    par1World.editingBlocks = true;

 

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

    {

        for (int j1 = 0; j1 < 3; j1++)

        {

            par1World.setBlockWithNotify(par2 + i * l, par3 + j1, par4 + j * l, TVMain.bportal.blockID);

        }

    }

 

    par1World.editingBlocks = false;

    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)

{

    int i = 0;

    int j = 1;

 

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

    {

        i = 1;

        j = 0;

    }

 

    int k;

 

    for (k = par3; par1World.getBlockId(par2, k - 1, par4) == blockID; k--) { }

 

    if (par1World.getBlockId(par2, k - 1, par4) != TVMain.ecryb.blockID)

    {

        par1World.setBlockWithNotify(par2, par3, par4, 0);

        return;

    }

 

    int l;

 

    for (l = 1; l < 4 && par1World.getBlockId(par2, k + l, par4) == blockID; l++) { }

 

    if (l != 3 || par1World.getBlockId(par2, k + l, par4) != TVMain.ecryb.blockID)

    {

        par1World.setBlockWithNotify(par2, par3, par4, 0);

        return;

    }

 

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

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

 

    if (flag && flag1)

    {

        par1World.setBlockWithNotify(par2, par3, par4, 0);

        return;

    }

 

    if ((par1World.getBlockId(par2 + i, par3, par4 + j) != TVMain.ecryb.blockID || par1World.getBlockId(par2 - i, par3, par4 - j) != blockID) && (par1World.getBlockId(par2 - i, par3, par4 - j) != TVMain.ecryb.blockID || par1World.getBlockId(par2 + i, par3, par4 + j) != blockID))

    {

        par1World.setBlockWithNotify(par2, par3, par4, 0);

        return;

    }

    else

    {

        return;

    }

}

 

/**

* 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) == blockID)

{

return false;

}

 

boolean flag = par1IBlockAccess.getBlockId(par2 - 1, par3, par4) == blockID && par1IBlockAccess.getBlockId(par2 - 2, par3, par4) != blockID;

boolean flag1 = par1IBlockAccess.getBlockId(par2 + 1, par3, par4) == blockID && par1IBlockAccess.getBlockId(par2 + 2, par3, par4) != blockID;

boolean flag2 = par1IBlockAccess.getBlockId(par2, par3, par4 - 1) == blockID && par1IBlockAccess.getBlockId(par2, par3, par4 - 2) != blockID;

boolean flag3 = par1IBlockAccess.getBlockId(par2, par3, par4 + 1) == blockID && par1IBlockAccess.getBlockId(par2, par3, par4 + 2) != blockID;

boolean flag4 = flag || flag1;

boolean flag5 = flag2 || flag3;

 

if (flag4 && par5 == 4)

{

return true;

}

 

if (flag4 && par5 == 5)

{

return true;

}

 

if (flag5 && par5 == 2)

{

return true;

}

 

return flag5 && par5 == 3;

}

 

 

 

public boolean displayPortalOverlay()

{

return true;

}

 

public int getOverlayTexture()

{

return blockIndexInTexture;

}

 

public int getPortalDelay()

{

        return 85;//default

}

 

 

 

public String getEnteringMessage() {

 

 

 

return "Entering The InterRealm";

 

 

 

 

 

 

 

}

 

 

public String getLeavingMessage() {

 

return "Exiting The InterRealm";

}

 

}

 

Thanks for your help beforehand.

Greets Alasar

[Kore]

Can you highlight the actual teleporting code and stuff to deal with dimensions, I will try to help if you would kindly post that

[Alasar]

Somehow can't I color the actual  code.

Don't know what I'm doing wrong, there are tags around it like it should

[Kore]

Put it in a spoiler not code

 

 

[glow=green,2,300]LIKE THIS[/glow]

 

 

 

[glow=red,2,300]NOT LIKE THIS[/glow]

[Alasar]

Works now (the color)

Thanks for the help in advance.

[opssemnik]

what? your portal block class its wrong i dont see any

 

 

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

    {

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

        {

EntityPlayerMP playerMp = (EntityPlayerMP)par5Entity;         

MinecraftServer.getServer().getConfigurationManager().transferPlayerToDimension(playerMp,DIMENSIONID, new InterRealmTeleporter(playerMp.getServerForPlayer());       

    }

 

 

OBS: The DIMNESIONID you need to CHANGE to YOUR DIMENSION ID

[Alasar]

Thanks a lot.

But now I get an error:

 

at Alasar.TheVoid.common.BlockBPortal.onEntityCollidedWithBlock(BlockBPortal.java:285)

at net.minecraft.src.Entity.doBlockCollisions(Entity.java:975)

at net.minecraft.src.Entity.moveEntity(Entity.java:919)

at net.minecraft.src.EntityPlayerSP.moveEntity(EntityPlayerSP.java:55)

at net.minecraft.src.EntityLiving.moveEntityWithHeading(EntityLiving.java:1469)

at net.minecraft.src.EntityPlayer.moveEntityWithHeading(EntityPlayer.java:1718)

at net.minecraft.src.EntityLiving.onLivingUpdate(EntityLiving.java:1751)

at net.minecraft.src.EntityPlayer.onLivingUpdate(EntityPlayer.java:513)

at net.minecraft.src.EntityPlayerSP.onLivingUpdate(EntityPlayerSP.java:238)

at net.minecraft.src.EntityLiving.onUpdate(EntityLiving.java:778)

at net.minecraft.src.EntityPlayer.onUpdate(EntityPlayer.java:281)

at net.minecraft.src.EntityClientPlayerMP.onUpdate(EntityClientPlayerMP.java:57)

at net.minecraft.src.World.updateEntityWithOptionalForce(World.java:2258)

at net.minecraft.src.World.updateEntity(World.java:2221)

 

Do you know what I did wrong?

[Kore]

to tell I will need the classes that are referenced for the portal

[opssemnik]

sorry instead of if (par5Entity.ridingEntity == null && par5Entity.riddenByEntity == null && par5Entity instanceof EntityPlayerMP)

        {

its

 

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

if(par5Entity instanceof EntityPlayerMP)     

{

 

 

[Alasar]

Thanks for the help, I think its working now.

But now I just get Errors while generating the chunks (I get nothing done without a Tutorial or help, I know )

They look like this:

 

net.minecraft.src.ReportedException: Exception generating new chunk

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.ChunkProviderServer.loadChunk(ChunkProviderServer.java:124)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.ChunkProviderServer.provideChunk(ChunkProviderServer.java:150)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.World.getChunkFromChunkCoords(World.java:496)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.World.spawnEntityInWorld(World.java:1503)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.ServerConfigurationManager.playerLoggedIn(ServerConfigurationManager.java:175)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.ServerConfigurationManager.initializeConnectionToPlayer(ServerConfigurationManager.java:94)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.IntegratedServerListenThread.networkTick(IntegratedServerListenThread.java:99)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.server.MinecraftServer.updateTimeLightAndEntities(MinecraftServer.java:696)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.server.MinecraftServer.tick(MinecraftServer.java:592)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.IntegratedServer.tick(IntegratedServer.java:110)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.server.MinecraftServer.run(MinecraftServer.java:499)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.ThreadMinecraftServer.run(ThreadMinecraftServer.java:17)

2012-12-28 07:17:37 [iNFO] [sTDERR] Caused by: java.lang.NullPointerException

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.WorldChunkManager.getBiomesForGeneration(WorldChunkManager.java:141)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.ChunkProviderGenerate.generateTerrain(ChunkProviderGenerate.java:104)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.ChunkProviderGenerate.provideChunk(ChunkProviderGenerate.java:278)

2012-12-28 07:17:37 [iNFO] [sTDERR] at net.minecraft.src.ChunkProviderServer.loadChunk(ChunkProviderServer.java:115)

2012-12-28 07:17:37 [iNFO] [sTDERR] ... 11 more

 

 

Here are my Worldprovider, Chunkprovider, Chunkmanager and the Chunk Class itself:

 

package Alasar.TheVoid.common;

 

import java.util.Arrays;

import java.util.List;

import java.util.Random;

import net.minecraft.src.BiomeGenBase;

import net.minecraft.src.ChunkPosition;

import net.minecraft.src.WorldChunkManager;

 

public class BedRealmWorldChunkManager extends WorldChunkManager

{

  private BiomeGenBase biomeGenerator;

  private float hellTemperature;

  private float rainfall;

 

  public BedRealmWorldChunkManager(BiomeGenBase par1BiomeGenBase)

  {

    this.biomeGenerator = par1BiomeGenBase;

  }

 

  public BiomeGenBase a(int par1, int par2)

  {

    return this.biomeGenerator;

  }

 

  public BiomeGenBase[] a(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)

  {

    if ((par1ArrayOfBiomeGenBase == null) || (par1ArrayOfBiomeGenBase.length < par4 * par5))

    {

      par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];

    }

 

    Arrays.fill(par1ArrayOfBiomeGenBase, 0, par4 * par5, this.biomeGenerator);

    return par1ArrayOfBiomeGenBase;

  }

 

  public float[] b(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)

  {

    if ((par1ArrayOfFloat == null) || (par1ArrayOfFloat.length < par4 * par5))

    {

      par1ArrayOfFloat = new float[par4 * par5];

    }

 

    Arrays.fill(par1ArrayOfFloat, 0, par4 * par5, this.hellTemperature);

    return par1ArrayOfFloat;

  }

 

  public float[] a(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)

  {

    if ((par1ArrayOfFloat == null) || (par1ArrayOfFloat.length < par4 * par5))

    {

      par1ArrayOfFloat = new float[par4 * par5];

    }

 

    Arrays.fill(par1ArrayOfFloat, 0, par4 * par5, this.rainfall);

    return par1ArrayOfFloat;

  }

 

  public BiomeGenBase[] b(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)

  {

    if ((par1ArrayOfBiomeGenBase == null) || (par1ArrayOfBiomeGenBase.length < par4 * par5))

    {

      par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];

    }

 

    Arrays.fill(par1ArrayOfBiomeGenBase, 0, par4 * par5, this.biomeGenerator);

    return par1ArrayOfBiomeGenBase;

  }

 

  public BiomeGenBase[] a(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5, boolean par6)

  {

    return b(par1ArrayOfBiomeGenBase, par2, par3, par4, par5);

  }

 

  public ChunkPosition a(int par1, int par2, int par3, List par4List, Random par5Random)

  {

    return par4List.contains(this.biomeGenerator) ? new ChunkPosition(par1 - par3 + par5Random.nextInt(par3 * 2 + 1), 0, par2 - par3 + par5Random.nextInt(par3 * 2 + 1)) : null;

  }

 

  public boolean a(int par1, int par2, int par3, List par4List)

  {

    return par4List.contains(this.biomeGenerator);

  }

}

 

 

 

package Alasar.TheVoid.common;

 

import net.minecraft.src.BiomeGenBase;

import net.minecraft.src.IChunkProvider;

import net.minecraft.src.WorldChunkManagerHell;

import net.minecraft.src.WorldProviderBase;

 

public class BedRealmWorldProvider extends WorldProviderBase

{

 

//The WorldProvider covers all the basics of the dimension. Look in WorldProviderBase.java and

//WorldProvider.java for all the potential qualities you can assign to your dimension.

 

public BedRealmWorldProvider()

{

}

 

//The save file will be called DIM65 (DIM + id number).

public int getDimensionID()

{

 

return 3;

 

}

 

public boolean renderClouds()

{

 

return true;

 

}

public boolean renderEndSky()

{

    return false;

}

public boolean renderVoidFog()

{

 

return true;

 

}

 

 

 

public float setMoonSize()

{

return 2.1F;

}

 

public float setSunSize()

{

 

return 1.0F;

 

}

 

 

 

public String getSunTexture()

{

 

return null;

 

}

 

public String getMoonTexture()

{

 

return "/Blocks/moon.png";

 

}

 

public boolean renderStars()

{

 

return true;

 

}

 

 

public boolean darkenSkyDuringRain()

{

 

return true;

 

}

 

public String getRespawnMessage()

{

 

return " Leaving The Forbidden Forest ";

 

}

 

//You can use an existing WorldChunkManager, or create your own. You must create your own to

//add multiple unique biomes to a dimension.

public void registerWorldChunkManager()

{

 

worldChunkMgr = new BedRealmWorldChunkManager(BedRealmBiomeBase.InterRealm);

 

}

 

//This is where you define your terrain generator.

public IChunkProvider getChunkProvider()

{

 

return new ChunkProviderBedDim(worldObj, worldObj.getSeed(), false);

 

}

 

//Note that, if you respawn in the dimension, you will end up at the coordinates of your

//overworld spawn point, not at the location of your first entrance to the dimension or

//something like that. Note also that beds don't work if you cannot respawn in the dimension.

public boolean canRespawnHere()

{

 

return false;

 

}

 

public float calculateCelestialAngle(long par1, float par3)

{

 

return 0.5F;

 

}

 

@Override

public String getDimensionName() {

// TODO Auto-generated method stub

return null;

}

 

}

 

 

 

 

 

package Alasar.TheVoid.common;

 

import net.minecraft.src.*;

 

public class BedRealmBiomeBase extends BiomeGenBase{

public static final BiomeGenBase InterRealm = new BedRealmBiomeBase(42).setColor(353825).setTemperatureRainfall(0.7F, 0.8F);;

public BedRealmBiomeBase(int id){

super(id);

topBlock = (byte) Block.bedrock.blockID;

fillerBlock = (byte) Block.bedrock.blockID;

}

}

 

 

package Alasar.TheVoid.common;

 

import java.util.List;

import java.util.Random;

 

import net.minecraft.src.BiomeGenBase;

import net.minecraft.src.Block;

import net.minecraft.src.BlockSand;

import net.minecraft.src.Chunk;

import net.minecraft.src.ChunkPosition;

import net.minecraft.src.EnumCreatureType;

import net.minecraft.src.IChunkProvider;

import net.minecraft.src.IProgressUpdate;

import net.minecraft.src.MapGenBase;

import net.minecraft.src.MapGenCaves;

import net.minecraft.src.MapGenMineshaft;

import net.minecraft.src.MapGenRavine;

import net.minecraft.src.MapGenScatteredFeature;

import net.minecraft.src.MapGenStronghold;

import net.minecraft.src.MapGenVillage;

import net.minecraft.src.MathHelper;

import net.minecraft.src.NoiseGeneratorOctaves;

import net.minecraft.src.SpawnerAnimals;

import net.minecraft.src.World;

import net.minecraft.src.WorldGenDungeons;

import net.minecraft.src.WorldGenLakes;

 

public class ChunkProviderBedDim 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 StronghoFld 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];

 

    public ChunkProviderBedDim(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, ;

    }

 

    /**

    * 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.bedrock.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)

    {

        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.bedrock.blockID)

                        {

                            if (var13 == -1)

                            {

                                if (var12 == 0)

                                {

                                    var14 = 0;

                                    var15 = (byte)Block.bedrock.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)

    {

        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 = true;

        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;

 

        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 (!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 (!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.waterStill.blockID)).generate(this.worldObj, this.rand, var12, var13, var14);

            }

        }

 

        for (var12 = 0; 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;

 

        for (var12 = 0; 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.setBlockWithNotify(var12 + var4, var14 - 1, var13 + var5, Block.ice.blockID);

                }

 

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

                {

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

                }

            }

        }

 

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

    }

 

@Override

public void recreateStructures(int var1, int var2) {

// TODO Auto-generated method stub

 

}

}

 

 

 

I know it kinda sucks to read all that code only to help me,

but I think that's this forum about, isn't it?

Anyway would help me a lot

Thanks in advance