Minecraft Forums

all the adfly links are going to phishing sites now.

Quote from Lilyo

Sorry, Alanay will be in charge of the continuation from now on. If you want to help him out you can PM him. I'll ask a mod to lock this thread.

Quote from nikman96

PLEASE DO THIS!

Quote from MaestroVen

Hello Folks, this is my first post!

I updated Jungle Ruins to 1.2.2 a while back ago. Custom made enchantment tables and cauldrons and a few other items. The rest are simple copy and pastes out of the default minecraft texture pack. I tried to keep with the themes of Jungle Ruins.

This is one of my favorite texture packs. Also Trigonous you're work is amazing this post is mainly for you. Feel free to copy and paste anything I've done.

MaestroVen Fan Update: Please take note this pack does not contain any of the new blocks for 1.2.5

SCREENSHOT!


Download:

http://www.mediafire.com/?q4fhi4i19kuv761

Quote from Gigfran_Enfys

I hate your avatar.

It's a nice update though. You should probably keep reposting for every new page, with all the impatient internetters around.

Quote from ZeDwarf

But.. Its 50 pages. Is there a continuation thread somewhere? If so, where?

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

//  I honestly don't know what this is doing, except that it happens on block ticks. I'm assuming
//  the int's par2, par3, and par4 are the x, y, z, coords, and I think par5Random just randomizes
//  the process a bit, but being a noobie coder I could just have no idea.

{
		if (par1World.isRemote)
		{
			return;
		}

// As far as I can tell, this voids out this entire section of code if you are on SMP instead of SSP

		int i = par1World.getBlockMetadata(par2, par3, par4);

		if ((i & 8) != 0 && (i & 4) == 0)

//  I'm assuming this is weeding out player-placed blocks from the naturally-generated ones,
//  but because I don't know where that metadata is defined or what it is I don't know for sure.

		{
			byte byte0 = 4;
			int j = byte0 + 1;
			byte byte1 = 32;
			int k = byte1 * byte1;
			int l = byte1 / 2;

			if (adjacentTreeBlocks == null)
			{
				adjacentTreeBlocks = new int[byte1 * byte1 * byte1];
			}

//  limits searching for adjacent wood/leaf blocks to a 32-block cube

			if (par1World.checkChunksExist(par2 - j, par3 - j, par4 - j, par2 + j, par3 + j, par4 + j))

//  Makes sure that it only checks for nearby leaf and wood blocks in existing chunks

			{
				for (int i1 = -byte0; i1 <= byte0; i1++)
				{
					for (int l1 = -byte0; l1 <= byte0; l1++)
					{
						for (int j2 = -byte0; j2 <= byte0; j2++)
						{
							int l2 = par1World.getBlockId(par2 + i1, par3 + l1, par4 + j2);

							if (l2 == Block.wood.blockID)
							{
								adjacentTreeBlocks[(i1 + l) * k + (l1 + l) * byte1 + (j2 + l)] = 0;
								continue;
							}

							if (l2 == Block.leaves.blockID)
							{
								adjacentTreeBlocks[(i1 + l) * k + (l1 + l) * byte1 + (j2 + l)] = -2;
							}
							else
							{
								adjacentTreeBlocks[(i1 + l) * k + (l1 + l) * byte1 + (j2 + l)] = -1;
							}
						}
					}
				}

				for (int j1 = 1; j1 <= 4; j1++)
				{
					for (int i2 = -byte0; i2 <= byte0; i2++)
					{
						for (int k2 = -byte0; k2 <= byte0; k2++)
						{
							for (int i3 = -byte0; i3 <= byte0; i3++)
							{
								if (adjacentTreeBlocks[(i2 + l) * k + (k2 + l) * byte1 + (i3 + l)] != j1 - 1)
								{
									continue;
								}

								if (adjacentTreeBlocks[((i2 + l) - 1) * k + (k2 + l) * byte1 + (i3 + l)] == -2)
								{
									adjacentTreeBlocks[((i2 + l) - 1) * k + (k2 + l) * byte1 + (i3 + l)] = j1;
								}

								if (adjacentTreeBlocks[(i2 + l + 1) * k + (k2 + l) * byte1 + (i3 + l)] == -2)
								{
									adjacentTreeBlocks[(i2 + l + 1) * k + (k2 + l) * byte1 + (i3 + l)] = j1;
								}

								if (adjacentTreeBlocks[(i2 + l) * k + ((k2 + l) - 1) * byte1 + (i3 + l)] == -2)
								{
									adjacentTreeBlocks[(i2 + l) * k + ((k2 + l) - 1) * byte1 + (i3 + l)] = j1;
								}

								if (adjacentTreeBlocks[(i2 + l) * k + (k2 + l + 1) * byte1 + (i3 + l)] == -2)
								{
									adjacentTreeBlocks[(i2 + l) * k + (k2 + l + 1) * byte1 + (i3 + l)] = j1;
								}

								if (adjacentTreeBlocks[(i2 + l) * k + (k2 + l) * byte1 + ((i3 + l) - 1)] == -2)
								{
									adjacentTreeBlocks[(i2 + l) * k + (k2 + l) * byte1 + ((i3 + l) - 1)] = j1;
								}

								if (adjacentTreeBlocks[(i2 + l) * k + (k2 + l) * byte1 + (i3 + l + 1)] == -2)
								{
									adjacentTreeBlocks[(i2 + l) * k + (k2 + l) * byte1 + (i3 + l + 1)] = j1;
								}
							}
						}
					}
				}
			}

//  To me the previous section looks like it's checking for wood near the leaf block,
//  to decide if it needs to decay

			int k1 = adjacentTreeBlocks[l * k + l * byte1 + l];

			if (k1 >= 0)
			{
				par1World.setBlockMetadata(par2, par3, par4, i & -9);

//  I don't know what this is doing to the metadata at all
			}
			else
			{
				removeLeaves(par1World, par2, par3, par4);
			}
		}
	}