Minecraft Forums

• Data Types

• boolean

• byte

• short

• int

• long

• float

• double

• char

• String

• Variables

• Local

• Instance

• Class

• Parameter

• Naming

• Default Values

• Classes

• Objects

• Inheritance

• Packages

• Literals

• Integer

• Floating Point

• Character and String

• Class

• Using Underscores

• Arrays

• Expressions, Statements, and Blocks

• If and Else Statements

• Switch Statements

• Reflection

• Annotations (@)

int cpus = 1;

int cadence = 0;
int speed = 0;
int gear = 1;

class Computer {
int numOfScreens = 1;
int numOfGPUs = 1;
int clockSpeed = 3;

public void checkScreens(int numOfScreens) {
numOfScreens = newValue;
}

public void clockGPUs(int numOfGPUs) {
int newSpeed = numOfGPUs + 1 * clockSpeed;
System.out.println(newSpeed);
}
}

class ComputerDemo {
public static void main(String[] args) {

//Create two different Computer Objects
Computer com1 = new Computer();
Computer com2 = new Computer();

//Invoke methods on these objects
com1.clockGPUs(100);
com2.clockGPUs(321);
}
}

• Modularity: The source code for the object can be maintained without fear of messing up any existing code, and can be passed around the program easily.

• Information-Hiding: Because you only interact directly with methods, the internal structure of how things work is hidden from the outside world, or any plugins that are created, unless you want it to be seen.

• Re-Usable Code: If the object already exists in the code, or is written by someone else, you can use it in your program. This allows you to only write what you absolutely need, and not more.

• Plug, chug, and debug: If something you write turns out to be bad or problematic, you can simply remove it, and plug in a default dummy object or method in it's place. If something breaks in Runtime, it's easily fixable.

class GamingComputer extends Computer {

//new fields and methods defining a gaming computer
}

boolean result = true;
char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;

// The number 26, in decimal
int decVal = 26;
// The number 26, in hexadecimal
int hexVal = 0x1a;
// The number 26, in binary
int binVal = 0b11010;

double d1 = 123.4;
// same value as d1, but in scientific notation
double d2 = 1.234e2;
float f1 = 123.4f;

long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;

• At the beginning or end of a number

• Adjacent to a decimal point in a floating point literal

• Prior to an F or L suffix

• In positions where a string of digits is expected

// Invalid: cannot put underscores
// adjacent to a decimal point
float pi1 = 3_.1415F;
// Invalid: cannot put underscores
// adjacent to a decimal point
float pi2 = 3._1415F;
// Invalid: cannot put underscores
// prior to an L suffix
long socialSecurityNumber1 = 999_99_9999_L;

// This is an identifier,
//not a numeric literal
int x1 = _52;
// OK (decimal literal)
int x2 = 5_2;
// Invalid: cannot put underscores
// At the end of a literal
int x3 = 52_;
// OK (decimal literal)
int x4 = 5_______2;

// Invalid: cannot put underscores
// in the 0x radix prefix
int x5 = 0_x52;
// Invalid: cannot put underscores
// at the beginning of a number
int x6 = 0x_52;
// OK (hexadecimal literal)
int x7 = 0x5_2;
// Invalid: cannot put underscores
// at the end of a number
int x8 = 0x52_;

class ArrayDemo {
public static void main(String[] args) {
// declares an array of integers
int[] anArray;

// allocates memory for 10 integers
anArray = new int[10];

// initialize first element
anArray[0] = 100;
// initialize second element
anArray[1] = 200;
// etc.
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;

System.out.println("Element at index 0: "
+ anArray[0]);
System.out.println("Element at index 1: "
+ anArray[1]);
System.out.println("Element at index 2: "
+ anArray[2]);
System.out.println("Element at index 3: "
+ anArray[3]);
System.out.println("Element at index 4: "
+ anArray[4]);
System.out.println("Element at index 5: "
+ anArray[5]);
System.out.println("Element at index 6: "
+ anArray[6]);
System.out.println("Element at index 7: "
+ anArray[7]);
System.out.println("Element at index 8: "
+ anArray[8]);
System.out.println("Element at index 9: "
+ anArray[9]);
}
}

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000

// declares an array of integers
int[] anArray;

byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;

// this form is discouraged
float anArrayOfFloats[];

// create an array of integers
anArray = new int[10];

ArrayDemo.java:4: Variable anArray may not have been initialized.

anArray[0] = 100; // initialize first element
anArray[1] = 200; // initialize second element
anArray[2] = 300; // etc.

System.out.println("Element 1 at index 0: " + anArray[0]);
System.out.println("Element 2 at index 1: " + anArray[1]);
System.out.println("Element 3 at index 2: " + anArray[2]);

int[] anArray = {
100, 200, 300,
400, 500, 600,
700, 800, 900, 1000
};

class MultiDimArrayDemo {
public static void main(String[] args) {
String[][] names = {
{"Mr. ", "Mrs. ", "Ms. "},
{"Smith", "Jones"}
};
// Mr. Smith
System.out.println(names[0][0] + names[1][0]);
// Ms. Jones
System.out.println(names[0][2] + names[1][1]);
}
}

Mr. Smith
Ms. Jones

System.out.println(anArray.length);

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

class ArrayCopyDemo {
public static void main(String[] args) {
char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
'i', 'n', 'a', 't', 'e', 'd' };
char[] copyTo = new char[7];

System.arraycopy(copyFrom, 2, copyTo, 0, 7);
System.out.println(new String(copyTo));
}
}

caffein

int cadence = 0;
anArray[0] = 100;
System.out.println("Element 1 at index 0: " + anArray[0]);

int result = 1 + 2; // result is now 3
if (value1 == value2)
System.out.println("value1 == value2");

1 * 2 * 3

x + y / 100 // ambiguous

(x + y) / 100 // unambiguous, recommended

x + y / 100

x + (y / 100) // unambiguous, recommended

// assignment statement
aValue = 8933.234;
// increment statement
aValue++;
// method invocation statement
System.out.println("Hello World!");
// object creation statement
Computer myComputer = new Computer();

// declaration statement
double aValue = 8933.234;

class BlockDemo {
public static void main(String[] args) {
boolean condition = true;
if (condition) { // begin block 1
System.out.println("Condition is true.");
} // end block one
else { // begin block 2
System.out.println("Condition is false.");
} // end block 2
}
}

void turnonGPU {
// the "if" clause: GPU must be on
if (isRunning){
// the "then" clause: increase ison by 1
ison1++;
}
}

void turnonGPU() {
// same as above, but without braces
if (ison)
ison1++;
}

void isGPUOn() {
if (ison) {
ison1++;
} else {
System.err.println("The GPU has " + "been already On!");
}
}

class IfElseDemo {
public static void main(String[] args) {

int testscore = 76;
char grade;

if (testscore >= 90) {
grade = 'A';
} else if (testscore >= 80) {
grade = 'B';
} else if (testscore >= 70) {
grade = 'C';
} else if (testscore >= 60) {
grade = 'D';
} else {
grade = 'F';
}
System.out.println("Grade = " + grade);
}
}

public class SwitchDemo {
public static void main(String[] args) {

int month = 8;
String monthString;
switch (month) {
case 1: monthString = "January";
break;
case 2: monthString = "February";
break;
case 3: monthString = "March";
break;
case 4: monthString = "April";
break;
case 5: monthString = "May";
break;
case 6: monthString = "June";
break;
case 7: monthString = "July";
break;
case 8: monthString = "August";
break;
case 9: monthString = "September";
break;
case 10: monthString = "October";
break;
case 11: monthString = "November";
break;
case 12: monthString = "December";
break;
default: monthString = "Invalid month";
break;
}
System.out.println(monthString);
}
}

int month = 8;
if (month == 1) {
System.out.println("January");
} else if (month == 2) {
System.out.println("February");
}
... // and so on

public class SwitchDemoFallThrough {

public static void main(String args[]) {
java.util.ArrayList<String> futureMonths =
new java.util.ArrayList<String>();

int month = 8;

switch (month) {
case 1: futureMonths.add("January");
case 2: futureMonths.add("February");
case 3: futureMonths.add("March");
case 4: futureMonths.add("April");
case 5: futureMonths.add("May");
case 6: futureMonths.add("June");
case 7: futureMonths.add("July");
case 8: futureMonths.add("August");
case 9: futureMonths.add("September");
case 10: futureMonths.add("October");
case 11: futureMonths.add("November");
case 12: futureMonths.add("December");
break;
default: break;
}

if (futureMonths.isEmpty()) {
System.out.println("Invalid month number");
} else {
for (String monthName : futureMonths) {
System.out.println(monthName);
}
}
}
}

August
September
October
November
December

class SwitchDemo2 {
public static void main(String[] args) {

int month = 2;
int year = 2000;
int numDays = 0;

switch (month) {
case 1: case 3: case 5:
case 7: case 8: case 10:
case 12:
numDays = 31;
break;
case 4: case 6:
case 9: case 11:
numDays = 30;
break;
case 2:
if (((year % 4 == 0) &&
!(year % 100 == 0))
|| (year % 400 == 0))
numDays = 29;
else
numDays = 28;
break;
default:
System.out.println("Invalid month.");
break;
}
System.out.println("Number of Days = "
+ numDays);
}
}

Number of Days = 29

public class StringSwitchDemo {

public static int getMonthNumber(String month) {

int monthNumber = 0;

if (month == null) {
return monthNumber;
}

switch (month.toLowerCase()) {
case "january":
monthNumber = 1;
break;
case "february":
monthNumber = 2;
break;
case "march":
monthNumber = 3;
break;
case "april":
monthNumber = 4;
break;
case "may":
monthNumber = 5;
break;
case "june":
monthNumber = 6;
break;
case "july":
monthNumber = 7;
break;
case "august":
monthNumber = 8;
break;
case "september":
monthNumber = 9;
break;
case "october":
monthNumber = 10;
break;
case "november":
monthNumber = 11;
break;
case "december":
monthNumber = 12;
break;
default:
monthNumber = 0;
break;
}

return monthNumber;
}

public static void main(String[] args) {

String month = "August";

int returnedMonthNumber =
StringSwitchDemo.getMonthNumber(month);

if (returnedMonthNumber == 0) {
System.out.println("Invalid month");
} else {
System.out.println(returnedMonthNumber);
}
}
}

import java.lang.reflect.*;

public class CallingMethod {
public static void main(String[] args) {
String firstName= new String("Deepak");
String lastName=new String("Kumar");
String result = new String("");
Class cls = String.class;
Class[] parametertype = new Class[] {String.class};
Object[] arguments = new Object[] {lastName};
try {
Method concatMethod =
cls.getMethod("concat", parametertype);
result = (String)
concatMethod.invoke(firstName,arguments);
System.out.println(" Concatenated String is =>
"+result);
}catch (Exception e) {
System.out.println(e);
}
}
}

1. Information for the compiler — Annotations can be used by the compiler to detect errors or suppress warnings.
2. Compiler-time and deployment-time processing — Software tools can process annotation information to generate code, XML files, and so forth.
3. Runtime processing — Some annotations are available to be examined at runtime.
4. Annotations can be applied to a program's declarations of classes, fields, methods, and other program elements.

@Author(
name = "Erik Melton",
date = "1/2/2013"
)
class MyClass() { }

@SuppressWarnings(value = "unchecked")
void myMethod() { }

@SuppressWarnings("unchecked")
void myMethod() { }

@Override
void mySuperMethod() { }

public class LMFAO extends LMAO {

// Author: Erik Melton
// Date: 1/2/2013
// Current revision: 6
// Last modified: 1/3/2013
// By: Erik Melton
// Reviewers: Citricsquid, Lord_Ralex, Jbond98

// class code goes here

}

@interface ClassPreamble {
String author();
String date();
int currentRevision() default 1;
String lastModified() default "N/A";
String lastModifiedBy() default "N/A";
// Note use of array
String[] reviewers();
}

@ClassPreamble (
author = "John Doe",
date = "3/17/2002",
currentRevision = 6,
lastModified = "4/12/2004",
lastModifiedBy = "Jane Doe",
// Note array notation
reviewers = {"Alice", "Bob", "Cindy"}
)
public class LMFAO extends LMAO {

// class code goes here

}

// import this to use @Documented
import java.lang.annotation.*;

@Documented
@interface ClassPreamble {

// Annotation element definitions

}

// Javadoc comment follows
/**
* @deprecated
* explanation of why it
* was deprecated
*/
@Deprecated
static void deprecatedMethod() { }
}

// mark method as a superclass method
// that has been overridden
@Override
int overriddenMethod() { }

// use a deprecated method and tell
// compiler not to generate a warning
@SuppressWarnings("deprecation")
void useDeprecatedMethod() {
// deprecation warning
// - suppressed
objectOne.deprecatedMethod();
}

@SuppressWarnings({"unchecked", "deprecation"})

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@interface AnnotationForRuntime {

// Elements that give information
// for runtime processing

}

ModLoader.addRecipe(new ItemStack(cobblestone, 1), new Object [] {" #", Character.valueOf('#'), new ItemStack(Item.dyePowder, 1, 12)});

Character.valueOf('#'), new ItemStack(Item.dyePowder, amount, damageValue)});

Please click that little right below this post, it will make my day

C:\Java\jdk1.7.0\bin;C:\Windows\System32\;C:\Windows\;C:\Windows\System32\Wbem

package net.minecraft.src;

import java.util.Random;
			
public class mod_*** extends BaseMod
{			
	 public void load()	
	 {			
			
	 }
	
	 public String getVersion()
	 {			
return "1.4.2";
	 }
	
}

package net.minecraft.src;

import java.util.Random;

public class mod_*** extends BaseMod

public void load()
	 {		
		
	 }

public String getVersion()
	 {
return "1.4.2";
	 }

package net.minecraft.src;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Random;
public class mod_wolfestone extends BaseMod
{
public static final Block oreWolfestone = new BlockWolfestoneOre(160, 0).setStepSound(Block.soundStoneFootstep).setBlockName("oreWolfestone").setHardness(4.5F).setResistance(5F).setLightValue(0.375F);
public void load()
{
oreWolfestone.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/textures/Wolfestone Ore.png");
ModLoader.registerBlock(oreWolfestone);
ModLoader.addName(oreWolfestone, "Wolfestone Ore");
}
public String getVersion()
{
return "Wolfestone Mod V2.0 Minecraft 1.3.2";
}
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Random;

public static final Block oreWolfestone = new BlockWolfestoneOre(160, 0).setStepSound(Block.soundStoneFootstep).setBlockName("oreWolfestone").setHardness(4.5F).setResistance(5F).setLightValue(0.375F);

public static final Block oreWolfestone = new BlockWolfestoneOre

new BlockWolfestoneOre

(160, 0)

.setStepSound(Block.soundStoneFootstep)

.setBlockName("oreWolfestone")

.setHardness(4.5F)

.setResistance(5F)

.setLightValue(0.375F)

oreWolfestone.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/textures/Wolfestone Ore.png");

ModLoader.registerBlock(oreWolfestone);

ModLoader.addName(oreWolfestone, "Wolfestone Ore");

public String getVersion()
{
return "Wolfestone Mod V2.0 Minecraft 1.3.2";
}

package net.minecraft.src;
import java.util.Random;
public class BlockWolfestoneOre extends Block
{
public BlockWolfestoneOre(int par1, int par2)
{
	 super(par1, par2, Material.rock);
	 this.setCreativeTab(CreativeTabs.tabBlock);
}

public int quantityDropped(int par1)
{
	 return (1);
}

public int idDropped(int par1, Random par2Random, int par3)
{
	 return mod_wolfestone.wolfestone.shiftedIndex;
}
}

public class BlockWolfestoneOre extends Block

public BlockWolfestoneOre(int par1, int par2)

super(par1, par2, Material.rock);

this.setCreativeTab(CreativeTabs.tabBlock);

public int quantityDropped(int par1)
{
	 return (1);
}

public int idDropped(int par1, Random par2Random, int par3)
{
	 return mod_wolfestone.wolfestone.shiftedIndex;
}

public static final Block oreWolfestone = new BlockWolfestoneOre(160, 0).setStepSound(Block.soundStoneFootstep).setBlockName("oreWolfestone").setHardness(4.5F).setResistance(5F).setLightValue(0.375F);

public static final Block oreWolfestone = new Block(160, 0).setStepSound(Block.soundStoneFootstep).setBlockName("oreWolfestone").setHardness(4.5F).setResistance(5F).setLightValue(0.375F);

package net.minecraft.src;
import java.util.Random;
public class mod_YourMod extends BaseMod
{
public static final Item yourItem = new ItemYourItem(5000).setItemName("yourItem");
public void load()
{
yourItem.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourItem.png");

ModLoader.addName(yourItem, "Your Item");

yourItem.setCreativeTabs(CreativeTabs.tabMaterials);
}

public String getVersion()
{
return "1.3.2";
}
}

public static final Item yourItem = new ItemYourItem(5000).setItemName("yourItem");

wolfestone.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/Wolfestone.png");

ModLoader.addName(yourItem, "Your Item");

yourItem.setCreativeTabs(CreativeTabs.tabMaterials);

package net.minecraft.src;
import java.util.Random;
public class BlockWolfestoneOre extends Block
{
public BlockWolfestoneOre(int par1, int par2)
{
	 super(par1, par2, Material.rock);
	 this.setCreativeTab(CreativeTabs.tabBlock);
}

public int quantityDropped(int par1)
{
	 return (1);
}

public int idDropped(int par1, Random par2Random, int par3)
{
	 return mod_wolfestone.wolfestone.shiftedIndex;
}
}

this.setCreativeTabs(CreativeTabs.tabBlock);

YourItem.setCreativeTabs(CreativeTabs.tabMaterials);

yourItem.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/YourItem.png");

yourBlock.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/textures/YourBlock.png");

ModLoader.addRecipe(new ItemStack(blockWolfestone, 1), new Object [] {"###", "###", "###", Character.valueOf('#'), mod_wolfestone.wolfestone});

"###",
"###",
"###",

Character.valueOf('#'), mod_wolfestone.wolfestone

ModLoader.addRecipe(new ItemStack(wolfestoneBow, 1), new Object [] {" #X", "M X", " #X", Character.valueOf('#'), Item.stick, Character.valueOf('X'), Item.silk, Character.valueOf('M'), mod_wolfestone.wolfestoneShard});

ModLoader.addRecipe(new ItemStack(wolfestoneShard, 4), new Object [] {"#", Character.valueOf('#'), mod_wolfestone.wolfestone});

ModLoader.addShapelessRecipe(new ItemStack(wolfestoneShard, 4), new Object[]{ wolfestone });

ModLoader.addRecipe(new ItemStack(torchWolfestone, 8), new Object [] {"#", "X", Character.valueOf('#'), mod_wolfestone.wolfestoneShard, Character.valueOf('X'), Item.stick});

package net.minecraft.src;
public class mod_YourModName extends BaseMod
{
public static final Item nameHere = new ItemFood(5000, 6, 1F, true).setItemName("anyNameHere");

public void load()
{
foodNameHere.iconIndex = ModLoader.addOverride("/gui/items.png", "/image.png");
	
ModLoader.addName(foodNameHere, "My Food");
}
public String getVersion()
{
			 return "1.3.1 MyModDescription";
}
}

public static final Item nameHere = new ItemFood(5000, 6, 1F, true).setItemName("anyNameHere");

ModLoader.addSmelting(yourItem.shiftedIndex, new ItemStack(yourSmeltedItem, 1), 1.0F);

1. yourItem.shiftedIndex, this parameter has to be an integer, so we would use .shiftedIndex to find the item ID of our item. Put the name of your item you want to input into your furnace where it says yourItem.
2. new ItemStack(yourSmeltedItem, 1), this parameter takes a new instance of the class ItemStack, which takes two more parameters: yourSmeltedItem which is what the furnace will output once the input is smelted, and 1, this number is the amount you will get of the output once it is smelted.
3. 1.0F, the last parameter is a float, which means that it can be a decimal number. This is how much XP you will receive after each successful smelt.

ModLoader.addSmelting(yourBlock.blockID, new ItemStack(yourSmeltedBlock, 1), 1.0F);

1. yourBlock.blockID, this parameter has to be an integer, so we would use .blockID to find the block ID of our block. This is the only difference between items and blocks. Put the name of your item you want to input into your furnace where it says yourBlock.
2. new ItemStack(yourSmeltedBlock, 1), this parameter takes a new instance of the class ItemStack, which takes two more parameters: yourSmeltedBlock which is what the furnace will output once the input is smelted, and 1, this number is the amount you will get of the output once it is smelted. Even though this references the class ItemStack, this still works for Blocks!
3. 1.0F, the last parameter is a float, which means that it can be a decimal number. This is how much XP you will receive after each successful smelt.

public int addFuel(int par1, int par2)
{
if(par1 == yourFuelItem.shiftedIndex)
{
return 9600;
}
if(par1 == yourFuelBlock.blockID)
{
return 14400;
}
	 return 0;
}

if(par1 == yourFuelItem.shiftedIndex)
{
return 9600;
}

if(par1 == yourFuelBlock.blockID)
{
return 14400;
}

public void generateSurface(World world, Random random, int i, int j)
{
for(int k = 0; k < 5; k++)
{
	 int randPosX = i + random.nextInt(16);
	 int randPosY = random.nextInt(128);
	 int randPosZ = j + random.nextInt(16);
	 (new WorldGenMinable(yourOreBlockName.blockID, 17)).generate(world, random, randPosX, randPosY, randPosZ);
}
}

public void generateSurface(World world, Random random, int i, int j)

for(int k = 0; k < 5; k++)

int randPosX = i + random.nextInt(16);
	 int randPosY = random.nextInt(128);
	 int randPosZ = j + random.nextInt(16);

(new WorldGenMinable(yourOreBlockName.blockID, 17)).generate(world, random, randPosX, randPosY, randPosZ);

public void generateNether(World world, Random rand, int i, int j)
{
	 for(int m = 0; m < 7; m++)
	 {
		 int randPosX = i + rand.nextInt(16);
		 int randPosY = rand.nextInt(128);
		 int randPosZ = j + rand.nextInt(16);
		 (new NetherGenMinable(yourNetherOre.blockID, 15)).generate(world, rand, randPosX, randPosY, randPosZ);
	 }
}

package net.minecraft.src;
import java.util.Random;
public class NetherGenMinable extends WorldGenerator
{
/** The block ID of the ore to be placed using this generator. */
private int minableBlockId;
/** The number of blocks to generate. */
private int numberOfBlocks;
public NetherGenMinable(int par1, int par2)
{
	 this.minableBlockId = par1;
	 this.numberOfBlocks = par2;
}
public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5)
{
	 float var6 = par2Random.nextFloat() * (float)Math.PI;
	 double var7 = (double)((float)(par3 + 8) + MathHelper.sin(var6) * (float)this.numberOfBlocks / 8.0F);
	 double var9 = (double)((float)(par3 + 8) - MathHelper.sin(var6) * (float)this.numberOfBlocks / 8.0F);
	 double var11 = (double)((float)(par5 + 8) + MathHelper.cos(var6) * (float)this.numberOfBlocks / 8.0F);
	 double var13 = (double)((float)(par5 + 8) - MathHelper.cos(var6) * (float)this.numberOfBlocks / 8.0F);
	 double var15 = (double)(par4 + par2Random.nextInt(3) - 2);
	 double var17 = (double)(par4 + par2Random.nextInt(3) - 2);
	 for (int var19 = 0; var19 <= this.numberOfBlocks; ++var19)
	 {
		 double var20 = var7 + (var9 - var7) * (double)var19 / (double)this.numberOfBlocks;
		 double var22 = var15 + (var17 - var15) * (double)var19 / (double)this.numberOfBlocks;
		 double var24 = var11 + (var13 - var11) * (double)var19 / (double)this.numberOfBlocks;
		 double var26 = par2Random.nextDouble() * (double)this.numberOfBlocks / 16.0D;
		 double var28 = (double)(MathHelper.sin((float)var19 * (float)Math.PI / (float)this.numberOfBlocks) + 1.0F) * var26 + 1.0D;
		 double var30 = (double)(MathHelper.sin((float)var19 * (float)Math.PI / (float)this.numberOfBlocks) + 1.0F) * var26 + 1.0D;
		 int var32 = MathHelper.floor_double(var20 - var28 / 2.0D);
		 int var33 = MathHelper.floor_double(var22 - var30 / 2.0D);
		 int var34 = MathHelper.floor_double(var24 - var28 / 2.0D);
		 int var35 = MathHelper.floor_double(var20 + var28 / 2.0D);
		 int var36 = MathHelper.floor_double(var22 + var30 / 2.0D);
		 int var37 = MathHelper.floor_double(var24 + var28 / 2.0D);
		 for (int var38 = var32; var38 <= var35; ++var38)
		 {
			 double var39 = ((double)var38 + 0.5D - var20) / (var28 / 2.0D);
			 if (var39 * var39 < 1.0D)
			 {
				 for (int var41 = var33; var41 <= var36; ++var41)
				 {
					 double var42 = ((double)var41 + 0.5D - var22) / (var30 / 2.0D);
					 if (var39 * var39 + var42 * var42 < 1.0D)
					 {
						 for (int var44 = var34; var44 <= var37; ++var44)
						 {
							 double var45 = ((double)var44 + 0.5D - var24) / (var28 / 2.0D);
							 if (var39 * var39 + var42 * var42 + var45 * var45 < 1.0D && par1World.getBlockId(var38, var41, var44) == Block.netherrack.blockID)
							 {
								 par1World.setBlock(var38, var41, var44, this.minableBlockId);
							 }
						 }
					 }
				 }
			 }
		 }
	 }
	 return true;
}
}

public static final Achievement achievementName = new Achievement(5000, "achievementName", 4, 9, Item.diamond, null).registerAchievement();

• 5000 is your achievement ID. Try to go over 5,000 just to be safe.
• "achievementName" this is again, just the coding name of your achievement. Make sure that is the same as the achievementName before it.
• 4, 9, is the position of your achievement on the achievement grid. You'll pretty much have to just guess and check this one.
• Item.diamond this is what the achievement image will look like when you get it. You can change this to anything you want.
• null keep this as is for now, I'll explain what this does further in the tutorial.

ModLoader.addAchievementDesc(achievementName, "Achievement Name", "Achievement Description");

• Where it says achievementName you must put the coding name of your achievement.
• Change "Achievement Name" to what you want the actual in-game name of the achievement to be when you get it.
• Lastly, change "Achievement Description" this is what will be underneath your achievement name in the achievement grid; moreover, the achievement description. Try not to make this too long.

public void takenFromCrafting(EntityPlayer entityplayer, ItemStack itemstack, IInventory iinventory)
{
if(itemstack.itemID == Block.blockDiamond.blockID)
{
	 entityplayer.addStat(achievementName, 1);
}
}

• Change Block.blockDiamond.blockID to the block or item that you want to trigger the achievement once crafted.
• Lastly, change achievementName to the coding name of your achievement.

static Achievement buildBetterPickaxe = AchievementList.buildBetterPickaxe;

public static final Achievement achievementName = new Achievement(5000, "achievementName", 4, 9, Item.diamond, null).registerAchievement();

public static final Achievement achievementName = new Achievement(5000, "achievementName", 4, 9, Item.diamond, buildBetterPickaxe).registerAchievement();

.setSpecial()

public static final Achievement achievementName = new Achievement(5000, "achievementName", 4, 9, Item.diamond, buildBetterPickaxe).setSpecial().registerAchievement();

package net.minecraft.src;
public class mod_yourMod extends BaseMod
{
public static final Item yourPickaxe = (new ItemPickaxe(200, EnumToolMaterial.MATERIALNAME)).setItemName("yourPickaxe");
public static final Item yourAxe = (new ItemAxe(201, EnumToolMaterial.MATERIALNAME)).setItemName("yourAxe");
public static final Item yourShovel = (new ItemSpade(202, EnumToolMaterial.MATERIALNAME)).setItemName("yourShovel");
public static final Item yourSword = (new ItemSword(203, EnumToolMaterial.MATERIALNAME)).setItemName("yourSword");
public static final Item yourHoe = (new ItemHoe(204, EnumToolMaterial.MATERIALNAME)).setItemName("yourHoe");

public void load()
{
yourPickaxe.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourPickaxe.png");
yourAxe.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourAxe.png");
yourShovel.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourShovel.png");
yourSword.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourSword.png");
yourHoe.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourHoe.png");

ModLoader.addRecipe(new ItemStack(yourPickaxe, 1), new Object [] {"###", " X ", " X ", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourShovel, 1), new Object [] {"#", "X", "X", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourSword, 1), new Object [] {"#", "#", "X", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourAxe, 1), new Object [] {"##", "#X ", " X", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourAxe, 1), new Object [] {"##", "X#", "X ", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourHoe, 1), new Object [] {"##", " X", " X", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourHoe, 1), new Object [] {"##", "X ", "X ", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});

ModLoader.addName(yourPickaxe, "Pickaxe Name");
ModLoader.addName(yourAxe, "Axe Pickaxe Name");
ModLoader.addName(yourShovel, "Shovel Pickaxe Name");
ModLoader.addName(yourSword, "Sword Pickaxe Name");
ModLoader.addName(yourHoe, "Hoe Pickaxe Name");
}

public String getVersion()
{
return "1.3.2";
}
}

public static final Item yourPickaxe = new ItemPickaxe(200, EnumToolMaterial.MATERIALNAME).setItemName("yourPickaxe");
public static final Item yourAxe = new ItemAxe(201, EnumToolMaterial.MATERIALNAME).setItemName("yourAxe");
public static final Item yourShovel = new ItemSpade(202, EnumToolMaterial.MATERIALNAME.setItemName("yourShovel");
public static final Item yourSword = new ItemSword(203, EnumToolMaterial.MATERIALNAME).setItemName("yourSword");
public static final Item yourHoe = new ItemHoe(204, EnumToolMaterial.MATERIALNAME).setItemName("yourHoe");

• Change yourPickaxe/Axe/Shovel/Sword/Hoe to the name of your tools.
• EnumToolMaterial.MATERIALNAME is going to be the material that your tools are made of, change this to whatever you want.
• The rest should be very familiar to your other item initiations.

yourPickaxe.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourPickaxe.png");
yourAxe.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourAxe.png");
yourShovel.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourShovel.png");
yourSword.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourSword.png");
yourHoe.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourHoe.png");

ModLoader.addRecipe(new ItemStack(yourPickaxe, 1), new Object [] {"###", " X ", " X ", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourShovel, 1), new Object [] {"#", "X", "X", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourSword, 1), new Object [] {"#", "#", "X", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourAxe, 1), new Object [] {"##", "#X ", " X", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourAxe, 1), new Object [] {"##", "X#", "X ", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourHoe, 1), new Object [] {"##", " X", " X", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});
ModLoader.addRecipe(new ItemStack(yourHoe, 1), new Object [] {"##", "X ", "X ", Character.valueOf('#'), yourItem, Character.valueOf('X'), Item.stick});

ModLoader.addName(yourPickaxe, "Pickaxe Name");
ModLoader.addName(yourAxe, "Axe Pickaxe Name");
ModLoader.addName(yourShovel, "Shovel Pickaxe Name");
ModLoader.addName(yourSword, "Sword Pickaxe Name");
ModLoader.addName(yourHoe, "Hoe Pickaxe Name");

package net.minecraft.src;
public enum EnumToolMaterial
{
WOOD(0, 59, 2.0F, 0, 15),
STONE(1, 131, 4.0F, 1, 5),
IRON(2, 250, 6.0F, 2, 14),
EMERALD(3, 1561, 8.0F, 3, 10),
GOLD(0, 32, 12.0F, 0, 22),
MATERIALNAME(3, 1248, 6F, 3, 10);
/**
	 * The level of material this tool can harvest (3 = DIAMOND, 2 = IRON, 1 = STONE, 0 = IRON/GOLD)
	 */
private final int harvestLevel;
/**
	 * The number of uses this material allows. (wood = 59, stone = 131, iron = 250, diamond = 1561, gold = 32)
	 */
private final int maxUses;
/**
	 * The strength of this tool material against blocks which it is effective against.
	 */
private final float efficiencyOnProperMaterial;
/** Damage versus entities. */
private final int damageVsEntity;
/** Defines the natural enchantability factor of the material. */
private final int enchantability;
private EnumToolMaterial(int par3, int par4, float par5, int par6, int par7)
{
	 this.harvestLevel = par3;
	 this.maxUses = par4;
	 this.efficiencyOnProperMaterial = par5;
	 this.damageVsEntity = par6;
	 this.enchantability = par7;
}
/**
	 * The number of uses this material allows. (wood = 59, stone = 131, iron = 250, diamond = 1561, gold = 32)
	 */
public int getMaxUses()
{
	 return this.maxUses;
}
/**
	 * The strength of this tool material against blocks which it is effective against.
	 */
public float getEfficiencyOnProperMaterial()
{
	 return this.efficiencyOnProperMaterial;
}
/**
	 * Damage versus entities.
	 */
public int getDamageVsEntity()
{
	 return this.damageVsEntity;
}
/**
	 * The level of material this tool can harvest (3 = DIAMOND, 2 = IRON, 1 = STONE, 0 = IRON/GOLD)
	 */
public int getHarvestLevel()
{
	 return this.harvestLevel;
}
/**
	 * Return the natural enchantability factor of the material.
	 */
public int getEnchantability()
{
	 return this.enchantability;
}
}

MATERIALNAME(3, 1248, 6F, 3, 10);

• Replace MATERIALNAME with the name of your material. (Caps is proper syntax for this)
• 3 is the harvest level of your tool material. This is the level of material this tool can harvest (3 = DIAMOND, 2 = IRON, 1 = STONE, 0 = IRON/GOLD)
• 1248 is the number of uses this material allows before it breaks. (wood = 59, stone = 131, iron = 250, diamond = 1561, gold = 32)
• 6F is how fast this material can mine blocks that it is supposed to mine; such as how fast a pickaxe mines stone.
• 3 is how many half hearts of damage your tool will do to a mob or enemy. This will do 1.5 full hearts of damage.
• 10 is the natural enchantability factor. You'll have to play around with this one.

package net.minecraft.src;
public class mod_yourMod extends BaseMod
{
public static final Item yourHelmet = new ItemArmor(5001, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 0).setItemName("yourHelmet");
public static final Item yourChestplate = new ItemArmor(5002, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 1).setItemName("yourChestplate");
public static final Item yourLeggings = new ItemArmor(5003, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 2).setItemName("yourLeggings");
public static final Item yourBoots = new ItemArmor(5004, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 3).setItemName("yourBoots");

public void load()
{
yourHelmet.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourHelmet.png");
yourChestplate.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourChestplate.png");
yourLeggings.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourLeggings.png");
yourBoots.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/yourBoots.png");

ModLoader.addRecipe(new ItemStack(yourHelmet, 1), new Object [] {"###", "# #", Character.valueOf('#'), yourItem});
ModLoader.addRecipe(new ItemStack(yourChestplate, 1), new Object [] {"# #", "###", "###", Character.valueOf('#'), yourItem});
ModLoader.addRecipe(new ItemStack(yourLeggings, 1), new Object [] {"###", "# #", "# #", Character.valueOf('#'), yourItem});
ModLoader.addRecipe(new ItemStack(yourBoots, 1), new Object [] {"# #", "# #", Character.valueOf('#'), yourItem});
ModLoader.addName(yourHelmet, "Helmet");
ModLoader.addName(yourChestplate, "Chestplate");
ModLoader.addName(yourLeggings, "Leggings");
ModLoader.addName(yourBoots, "Boots");
}

public String getVersion()
{
return "1.3.2";
}
}

public static final Item yourHelmet = new ItemArmor(5001, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 0).setItemName("yourHelmet");
public static final Item yourChestplate = new ItemArmor(5002, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 1).setItemName("yourChestplate");
public static final Item yourLeggings = new ItemArmor(5003, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 2).setItemName("yourLeggings");
public static final Item yourBoots = new ItemArmor(5004, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 3).setItemName("yourBoots");

new ItemArmor(5001, EnumArmorMaterial.ARMORMATERIAL, ModLoader.addArmor("yourarmor"), 0)

• Change EnumArmorMaterial.ARMORMATERIAL to whatever armor material you are planning on making your armor out of.
• Change ModLoader.addArmor("yourarmor") to whatever you want the prefix of the armor overlay textures to be. You will have to make new png files called yourarmor_1 and yourarmor_2 in order for the overlay to show up in-game. An example of these textures can be found in the bin/minecraft.jar/armor folder.

package net.minecraft.src;
public enum EnumArmorMaterial
{
CLOTH(5, new int[]{1, 3, 2, 1}, 15),
CHAIN(15, new int[]{2, 5, 4, 1}, 12),
IRON(15, new int[]{2, 6, 5, 2}, 9),
GOLD(7, new int[]{2, 5, 3, 1}, 25),
DIAMOND(33, new int[]{3, 8, 6, 3}, 10),
ARMORMATERIAL(38, new int[]{4, 12, 8, 4}, 18);
/**
	 * Holds the maximum damage factor (each piece multiply this by it's own value) of the material, this is the item
	 * damage (how much can absorb before breaks)
	 */
private int maxDamageFactor;
/**
	 * Holds the damage reduction (each 1 points is half a shield on gui) of each piece of armor (helmet, plate, legs
	 * and boots)
	 */
private int[] damageReductionAmountArray;
/** Return the enchantability factor of the material */
private int enchantability;
private EnumArmorMaterial(int par3, int[] par4ArrayOfInteger, int par5)
{
	 this.maxDamageFactor = par3;
	 this.damageReductionAmountArray = par4ArrayOfInteger;
	 this.enchantability = par5;
}
/**
	 * Returns the durability for a armor slot of for this type.
	 */
public int getDurability(int par1)
{
	 return ItemArmor.getMaxDamageArray()[par1] * this.maxDamageFactor;
}
/**
	 * Return the damage reduction (each 1 point is a half a shield on gui) of the piece index passed (0 = helmet, 1 =
	 * plate, 2 = legs and 3 = boots)
	 */
public int getDamageReductionAmount(int par1)
{
	 return this.damageReductionAmountArray[par1];
}
/**
	 * Return the enchantability factor of the material.
	 */
public int getEnchantability()
{
	 return this.enchantability;
}
}

ARMORMATERIAL(38, new int[]{4, 12, 8, 4}, 18);

• The 38 is the overall damage factor that your armor can absorb before it breaks.
• The new int[]{4, 12, 8, 4} controls the damage factor per item of armor. Helmet, Chestplate, Leggings, Boots.
• The 18 controls the max enchantibility factor of the armor.

public void generateSurface(World world, Random rand, int chunkX, int chunkZ)
{
BiomeGenBase biome = world.getWorldChunkManager().getBiomeGenAt(chunkX, chunkZ);
WorldGenYourTree tree = new WorldGenYourTree(); //Change this to the World Gens or your tree and make sure that the parameters match if you get errors!
if(biome instanceof BiomeGenForest)
{
for(int c = 0; c < 3; c++)
{
int Xcoord = chunkX + rand.nextInt(16);
int Zcoord = chunkZ + rand.nextInt(16);
	int i = world.getHeightValue(Xcoord, Zcoord);
	tree.generate(world, rand, Xcoord, i, Zcoord);
}
}
}

package net.minecraft.src;

import java.util.Random;

public class WorldGenYourTree extends WorldGenerator
{
public WorldGenYourTree()
{
}

public boolean generate(World world, Random random, int i, int j, int k)
{
	 int l = random.nextInt(1) + 4;
	 boolean flag = true;
	 if(j < 1 || j + l + 1 > 256)
	 {
		 return false;
	 }
	 for(int i1 = j; i1 <= j + 1 + l; i1++)
	 {
		 byte byte0 = 1;
		 if(i1 == j)
		 {
			 byte0 = 0;
		 }
		 if(i1 >= (j + 1 + l) - 2)
		 {
			 byte0 = 2;
		 }
		 for(int i2 = i - byte0; i2 <= i + byte0 && flag; i2++)
		 {
			 for(int l2 = k - byte0; l2 <= k + byte0 && flag; l2++)
			 {
				 if(i1 >= 0 && i1 < 256)
				 {
					 int j3 = world.getBlockId(i2, i1, l2);
					 if(j3 != 0 && j3 != mod_yourMod.yourLeaf.blockID) //Change this to your leaf block.
					 {
						 flag = false;
					 }
				 } else
				 {
					 flag = false;
				 }
			 }
		 }
	 }
	 if(!flag)
	 {
		 return false;
	 }
	 int j1 = world.getBlockId(i, j - 1, k);
	 if(j1 != Block.grass.blockID && j1 != Block.dirt.blockID || j >= 256 - l - 1) //This determines on what blocks your tree can generate.
	 {
		 return false;
	 }
	 world.setBlock(i, j - 1, k, Block.dirt.blockID); //Also determines what block your tree can generate on.
	 for(int k1 = (j - 3) + l; k1 <= j + l; k1++)
	 {
		 int j2 = k1 - (j + l);
		 int i3 = 1 - j2 / 2;
		 for(int k3 = i - i3; k3 <= i + i3; k3++)
		 {
			 int l3 = k3 - i;
			 for(int i4 = k - i3; i4 <= k + i3; i4++)
			 {
				 int j4 = i4 - k;
				 if((Math.abs(l3) != i3 || Math.abs(j4) != i3 || random.nextInt(2) != 0 && j2 != 0) && !Block.opaqueCubeLookup[world.getBlockId(k3, k1, i4)])
				 {
					 setBlockAndMetadata(world, k3, k1, i4, mod_yourMod.yourLeaf.blockID, 0); //Change to your leaf block.
				 }
			 }
		 }
	 }
	 for(int l1 = 0; l1 < l; l1++)
	 {
		 int k2 = world.getBlockId(i, j + l1, k);
		 if(k2 == 0 || k2 == mod_yourMod.yourLeaf.blockID)
		 {
			 setBlockAndMetadata(world, i, j + l1, k, mod_yourMod.yourWood.blockID, 0); //Change to your wood block.
		 }
	 }
	 return true;
}
}

package net.minecraft.src;

import java.util.Random;


public class BlockYourLog extends Block
{
protected BlockYourLog(int i)
{
	 super(i, Material.wood);
}


public int quantityDropped(Random random)
{
	 return 1;
}

public int idDropped(int i, Random random, int j)
{
	 return mod_yourMod.yourLog.blockID; //Change to your wood block
}


public void harvestBlock(World world, EntityPlayer entityplayer, int i, int j, int k, int l)
{
	 super.harvestBlock(world, entityplayer, i, j, k, l);
}

public void onBlockRemoval(World world, int i, int j, int k)
{
	 byte byte0 = 4;
	 int l = byte0 + 1;
	 if(world.checkChunksExist(i - l, j - l, k - l, i + l, j + l, k + l))
	 {
		 for(int i1 = -byte0; i1 <= byte0; i1++)
		 {
			 for(int j1 = -byte0; j1 <= byte0; j1++)
			 {
				 for(int k1 = -byte0; k1 <= byte0; k1++)
				 {
					 int l1 = world.getBlockId(i + i1, j + j1, k + k1);
					 if(l1 != mod_yourMod.yourLeaf.blockID) //Change to your leaf block.
					 {
						 continue;
					 }
					 int i2 = world.getBlockMetadata(i + i1, j + j1, k + k1);
					 if((i2 & 8) == 0)
					 {
						 world.setBlockMetadata(i + i1, j + j1, k + k1, i2 | 8);
					 }
				 }
			 }
		 }
	 }
}

public int getBlockTextureFromSideAndMetadata(int i, int j)
{
	 if(i == 0)
return mod_yourMod.yourLogBottom;
if(i == 1)
return mod_yourMod.yourLogBottom;
if(i == 2)
return mod_yourMod.yourLogSide;
if(i == 3)
return mod_yourMod.yourLogSide;
if(i == 4)
return mod_yourMod.yourLogSide;
if(i == 5)
return mod_yourMod.yourLogSide;

	 if(j == 1)
	 {
		 return 116;
	 }
	 return j != 2 ? 20 : 117;
}


public int damageDropped(int i)
{
	 return i;
}
}

package net.minecraft.src;
import java.util.Random;
public class BlockYourLeaf extends BlockLeavesBase
{
private int baseIndexInPNG;
int adjacentTreeBlocks[];

protected BlockYourLeaf(int i, int j)
{
	 super(i, j, Material.leaves, false);
	 setTickRandomly(true);
}

public int getBlockColor()
{
	 double d = 0.5D;
	 double d1 = 1.0D;
	 return 0;
}
public void onBlockRemoval(World world, int i, int j, int k)
{
	 int l = 1;
	 int i1 = l + 1;
	 if(world.checkChunksExist(i - i1, j - i1, k - i1, i + i1, j + i1, k + i1))
	 {
		 for(int j1 = -l; j1 <= l; j1++)
		 {
			 for(int k1 = -l; k1 <= l; k1++)
			 {
				 for(int l1 = -l; l1 <= l; l1++)
				 {
					 int i2 = world.getBlockId(i + j1, j + k1, k + l1);
					 if(i2 == mod_yourMod.yourSapling.blockID) //Change to your sapling block.
					 {
						 int j2 = world.getBlockMetadata(i + j1, j + k1, k + l1);
						 world.setBlockMetadata(i + j1, j + k1, k + l1, j2 | 8);
					 }
				 }
			 }
		 }
	 }
}
public void updateTick(World world, int i, int j, int k, Random random)
{
	 if(world.isRemote)
	 {
		 return;
	 }
	 int l = world.getBlockMetadata(i, j, k);
	 if((l & 8) != 0 && (l & 4) == 0)
	 {
		 byte byte0 = 4;
		 int i1 = byte0 + 1;
		 byte byte1 = 32;
		 int j1 = byte1 * byte1;
		 int k1 = byte1 / 2;
		 if(adjacentTreeBlocks == null)
		 {
			 adjacentTreeBlocks = new int[byte1 * byte1 * byte1];
		 }
		 if(world.checkChunksExist(i - i1, j - i1, k - i1, i + i1, j + i1, k + i1))
		 {
			 for(int l1 = -byte0; l1 <= byte0; l1++)
			 {
				 for(int k2 = -byte0; k2 <= byte0; k2++)
				 {
					 for(int i3 = -byte0; i3 <= byte0; i3++)
					 {
						 int k3 = world.getBlockId(i + l1, j + k2, k + i3);
						 if(k3 == mod_yourMod.yourLog.blockID) //Change to your wood block.
						 {
							 adjacentTreeBlocks[(l1 + k1) * j1 + (k2 + k1) * byte1 + (i3 + k1)] = 0;
							 continue;
						 }
						 if(k3 == mod_yourMod.yourLeaf.blockID) //Change to your leaf block.
						 {
							 adjacentTreeBlocks[(l1 + k1) * j1 + (k2 + k1) * byte1 + (i3 + k1)] = -2;
						 } else
						 {
							 adjacentTreeBlocks[(l1 + k1) * j1 + (k2 + k1) * byte1 + (i3 + k1)] = -1;
						 }
					 }
				 }
			 }
			 for(int i2 = 1; i2 <= 4; i2++)
			 {
				 for(int l2 = -byte0; l2 <= byte0; l2++)
				 {
					 for(int j3 = -byte0; j3 <= byte0; j3++)
					 {
						 for(int l3 = -byte0; l3 <= byte0; l3++)
						 {
							 if(adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] != i2 - 1)
							 {
								 continue;
							 }
							 if(adjacentTreeBlocks[((l2 + k1) - 1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] == -2)
							 {
								 adjacentTreeBlocks[((l2 + k1) - 1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] = i2;
							 }
							 if(adjacentTreeBlocks[(l2 + k1 + 1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] == -2)
							 {
								 adjacentTreeBlocks[(l2 + k1 + 1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] = i2;
							 }
							 if(adjacentTreeBlocks[(l2 + k1) * j1 + ((j3 + k1) - 1) * byte1 + (l3 + k1)] == -2)
							 {
								 adjacentTreeBlocks[(l2 + k1) * j1 + ((j3 + k1) - 1) * byte1 + (l3 + k1)] = i2;
							 }
							 if(adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1 + 1) * byte1 + (l3 + k1)] == -2)
							 {
								 adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1 + 1) * byte1 + (l3 + k1)] = i2;
							 }
							 if(adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + ((l3 + k1) - 1)] == -2)
							 {
								 adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + ((l3 + k1) - 1)] = i2;
							 }
							 if(adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + (l3 + k1 + 1)] == -2)
							 {
								 adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + (l3 + k1 + 1)] = i2;
							 }
						 }
					 }
				 }
			 }
		 }
		 int j2 = adjacentTreeBlocks[k1 * j1 + k1 * byte1 + k1];
		 if(j2 >= 0)
		 {
			 world.setBlockMetadata(i, j, k, l & -9);
		 } else
		 {
			 removeLeaves(world, i, j, k);
		 }
	 }
}
private void removeLeaves(World world, int i, int j, int k)
{
	 dropBlockAsItem(world, i, j, k, world.getBlockMetadata(i, j, k), 0);
	 world.setBlockWithNotify(i, j, k, 0);
}
public int quantityDropped(Random random)
{
	 return random.nextInt(20) != 0 ? 0 : 1;
}
public int idDropped(int i, Random random, int j)
{
	 return mod_yourMod.yourSapling.blockID; //Makes your leaves drop your type of sapling.
}
public void dropBlockAsItemWithChance(World world, int i, int j, int k, int l, float f, int i1)
{
	 super.dropBlockAsItemWithChance(world, i, j, k, l, f, i1);
	 if (!world.isRemote && (l & 3) == 0 && world.rand.nextInt(50) == 0)
	 {
		 dropBlockAsItem_do(world, i, j, k, new ItemStack(Item.apple.shiftedIndex, 1, 0)); //Makes your leaf have a 1/50 chance to drop an apple.
	 }
}
public void harvestBlock(World world, EntityPlayer entityplayer, int i, int j, int k, int l)
{
	 if (!world.isRemote && entityplayer.getCurrentEquippedItem() != null && entityplayer.getCurrentEquippedItem().itemID == Item.shears.shiftedIndex)
	 {
		 entityplayer.addStat(StatList.mineBlockStatArray[blockID], 1);
		 dropBlockAsItem_do(world, i, j, k, new ItemStack(Block.leaves.blockID, 1, l & 3));
	 }
	 else
	 {
		 super.harvestBlock(world, entityplayer, i, j, k, l);
	 }
}
public int damageDropped(int i)
{
	 return i & 3;
}
public boolean isOpaqueCube()
{
	 return !graphicsLevel;
}
public int getBlockTextureFromSideAndMetadata(int i, int j)
{
	 if((j & 3) == 1)
	 {
		 return blockIndexInTexture;
	 }else{
		 return blockIndexInTexture;		
	 }
}
public void setGraphicsLevel(boolean flag)
{
	 graphicsLevel = flag;
}
public void onEntityWalking(World world, int i, int j, int k, Entity entity)
{
	 super.onEntityWalking(world, i, j, k, entity);
}
}

package net.minecraft.src;

import java.util.Random;

public class BlockYourSapling extends BlockFlower
{
protected BlockYourSapling(int i, int j)
{
	 super(i, j);
	 float f = 0.4F;
	 setBlockBounds(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, f * 2.0F, 0.5F + f);
}

protected boolean canThisPlantGrowOnThisBlockID(int i)
{
	 return i == Block.grass.blockID; //Makes this grow on grass.
}


public void updateTick(World world, int i, int j, int k, Random random)
{
	 if(world.isRemote)
	 {
		 return;
	 }
	 super.updateTick(world, i, j, k, random);
	
	 if(world.getBlockLightValue(i, j + 1, k) >= 9 && random.nextInt(7) == 0)
	 {
		 int l = world.getBlockMetadata(i, j, k);
		 if((l & 8) == 0)
		 {
			 world.setBlockMetadataWithNotify(i, j, k, l | 8);
		 } else
		 {
			 growTree(world, i, j, k, random);
		 }
	 }
}
public int getBlockTextureFromSideAndMetadata(int i, int j)
{
	 j &= 3;
	 if(j == 1)
	 {
		 return blockIndexInTexture; //63
	 }
	 if(j == 2)
	 {
		 return blockIndexInTexture; //79
	 } else
	 {
		 return blockIndexInTexture;
	 }
}
public void growTree(World world, int i, int j, int k, Random random)
{
	 int l = world.getBlockMetadata(i, j, k) & 3;
	 world.setBlock(i, j, k, 0);
	 Object obj = null;
	 obj = new WorldGenYourTree();
	 if(!((WorldGenerator) (obj)).generate(world, random, i, j, k))
	 {
		 world.setBlockAndMetadata(i, j, k, blockID, l);
	 }
}
public int damageDropped(int i)
{
	 return i & 3;
}
}

public static final BiomeGenBase biomeName = (new BiomeGenYourBiome(40)).setBiomeName("Biome Name");

• Change biomeName to the coding name of your biome.
• (new BiomeGenYourBiome(40) casts your BiomeGen class upon a new Biome ID. Make sure that the number you put here is lower than 127 because of java's byte limit.
• .setBiomeName("biomeName") sets the in-game name of your biome. This is only visible from the F3 (debug) menu when you're in that biome.

ModLoader.addBiome(nameHere);

public static void generateSurface(World world, Random rand, int chunkX, int chunkZ)
{
BiomeGenBase biome = world.getWorldChunkManager().getBiomeGenAt(chunkX, chunkZ);
	
	 WorldGenYourTree tree = new WorldGenYourTree();
	
	 if(biome instanceof BiomeGenYourBiome)
	 {
		 for(int x = 0; x < 8; x++)
		 {
		 tree = new WorldGenYourTree();
		 int Xcoord = chunkX + rand.nextInt(16);
		 int Zcoord = chunkZ + rand.nextInt(16);
		 int i = world.getHeightValue(Xcoord, Zcoord);
		 tree.generate(world, rand, Xcoord, i, Zcoord);
		 }
	 }
}

package net.minecraft.src;
import java.util.Random;
public class BiomeGenWolfeland extends BiomeGenBase
{
public BiomeGenWolfeland(int par1)
{
	 super(par1);
	 this.spawnableCreatureList.clear();
	 this.spawnableMonsterList.clear();
	 this.spawnableWaterCreatureList.clear();
	 this.topBlock = (byte)mod_wolfestone.wolfeGrass.blockID;
	 this.fillerBlock = (byte)mod_wolfestone.wolfeDirt.blockID;
	 this.minHeight = -0.4F;
	 this.maxHeight = 0.54F;
}

• this.spawnableCreatureList.clear(); This clears any passive mobs from spawning in your biome.
• this.spawnableMonsterList.clear(); This clears any monsters from spawning in your biome at night.
• this.spawnableWaterCreatureList.clear(); This clears squid from spawning in your biome. If you want to know how to spawn a specific creature in the biome, have a look at the other BiomeGen classes.
• this.topBlock = (byte)mod_yourMod.yourGrass.blockID; Sets the top block for your biome. This is the first layer that you see, such as grass in most biomes. This will work for any block. You can even set this to lava, but it will get really messy...
• this.fillerBlock = (byte)mod_yourMod.yourDirt.blockID; This sets the filler block for your biome. The filler block is the block 4-5 layers deep after the top block. This is usually dirt in most cases, but again, you can set this to anything you like.
• this.minHeight = -0.4F; This sets the minimum height for you biome. Setting this below 0F, makes lakes able to generate in your biome.
• this.maxHeight = 0.54F; Sets the maximum height for you biome. If you want large mountains, try setting larger numbers.

Please click that little right below this post, it will make my day