Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

[1.8] [UNSOLVED] GUI ArrayIndexOutOfBoundsException Error


TheDogePwner
 Share

Recommended Posts

Hi,

 

I have a problem with my custom GUI.

 

Here is my TileNuclearBoiler:

package com.mod.gui.boiler;

import java.util.Arrays;

import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagIntArray;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.server.gui.IUpdatePlayerListBox;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityFurnace;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.ChatComponentTranslation;
import net.minecraft.util.IChatComponent;
import net.minecraft.util.MathHelper;
import net.minecraft.world.EnumSkyBlock;

import com.mod.block.NCBlock;
import com.mod.main.NuclearCraft;

/**
* User: brandon3055 Date: 06/01/2015
*
* TileInventorySmelting is an advanced sided inventory that works like a
* vanilla furnace except that it has 5 input and output slots, 4 fuel slots and
* cooks at up to four times the speed. The input slots are used sequentially
* rather than in parallel, i.e. the first slot cooks, then the second, then the
* third, etc The fuel slots are used in parallel. The more slots burning in
* parallel, the faster the cook time. The code is heavily based on
* TileEntityFurnace.
*/
public class TileNuclearBoiler extends TileEntity implements IInventory,
	IUpdatePlayerListBox {
// Create and initialize the itemStacks variable that will store store the
// itemStacks
public static final Item[] itemList = { NuclearCraft.uraniumIngot,
		Item.getItemFromBlock(NuclearCraft.uraniumBlock) };
public static final Item[] validFuels = { Items.lava_bucket };
public static final int FUEL_SLOTS_COUNT = 1;
public static final int INPUT_SLOTS_COUNT = 1;
public static final int OUTPUT_SLOTS_COUNT = 1;
public static final int TOTAL_SLOTS_COUNT = FUEL_SLOTS_COUNT
		+ INPUT_SLOTS_COUNT + OUTPUT_SLOTS_COUNT;

public static final int FIRST_FUEL_SLOT = 0;
public static final int FIRST_INPUT_SLOT = FIRST_FUEL_SLOT
		+ FUEL_SLOTS_COUNT;
public static final int FIRST_OUTPUT_SLOT = FIRST_INPUT_SLOT
		+ INPUT_SLOTS_COUNT;

private ItemStack[] itemStacks = new ItemStack[TOTAL_SLOTS_COUNT];

/** The number of burn ticks remaining on the current piece of fuel */
private int[] burnTimeRemaining = new int[FUEL_SLOTS_COUNT];
/**
 * The initial fuel value of the currently burning fuel (in ticks of burn
 * duration)
 */
private int[] burnTimeInitialValue = new int[FUEL_SLOTS_COUNT];

/** The number of ticks the current item has been cooking */
private short cookTime;
/** The number of ticks required to cook an item */
private static final short COOK_TIME_FOR_COMPLETION = 800; // vanilla value
															// is 200 = 10
															// seconds

private int cachedNumberOfBurningSlots = -1;

/**
 * Returns the amount of fuel remaining on the currently burning item in the
 * given fuel slot.
 * 
 * @fuelSlot the number of the fuel slot (0..3)
 * @return fraction remaining, between 0 - 1
 */
public double fractionOfFuelRemaining(int fuelSlot) {
	if (burnTimeInitialValue[fuelSlot] <= 0)
		return 0;
	double fraction = burnTimeRemaining[fuelSlot]
			/ (double) burnTimeInitialValue[fuelSlot];
	return MathHelper.clamp_double(fraction, 0.0, 1.0);
}

/**
 * return the remaining burn time of the fuel in the given slot
 * 
 * @param fuelSlot
 *            the number of the fuel slot (0..3)
 * @return seconds remaining
 */
public int secondsOfFuelRemaining(int fuelSlot) {
	if (burnTimeRemaining[fuelSlot] <= 0)
		return 0;
	return burnTimeRemaining[fuelSlot] / 20; // 20 ticks per second
}

/**
 * Get the number of slots which have fuel burning in them.
 * 
 * @return number of slots with burning fuel, 0 - FUEL_SLOTS_COUNT
 */
public int numberOfBurningFuelSlots() {
	int burningCount = 0;
	for (int burnTime : burnTimeRemaining) {
		if (burnTime > 0)
			++burningCount;
	}
	return burningCount;
}

/**
 * Returns the amount of cook time completed on the currently cooking item.
 * 
 * @return fraction remaining, between 0 - 1
 */
public double fractionOfCookTimeComplete() {
	double fraction = cookTime / (double) COOK_TIME_FOR_COMPLETION;
	return MathHelper.clamp_double(fraction, 0.0, 1.0);
}

// This method is called every tick to update the tile entity, i.e.
// - see if the fuel has run out, and if so turn the furnace "off" and
// slowly uncook the current item (if any)
// - see if any of the items have finished smelting
// It runs both on the server and the client.
@Override
public void update() {
	// If there is nothing to smelt or there is no room in the output, reset
	// cookTime and return
	if (canSmelt()) {
		int numberOfFuelBurning = burnFuel();

		// If fuel is available, keep cooking the item, otherwise start
		// "uncooking" it at double speed
		if (numberOfFuelBurning > 0) {
			cookTime += numberOfFuelBurning;
		} else {
			cookTime -= 2;
		}

		if (cookTime < 0)
			cookTime = 0;

		// If cookTime has reached maxCookTime smelt the item and reset
		// cookTime
		if (cookTime >= COOK_TIME_FOR_COMPLETION) {
			smeltItem();
			cookTime = 0;
		}
	} else {
		cookTime = 0;
	}

	// when the number of burning slots changes, we need to force the block
	// to re-render, otherwise the change in
	// state will not be visible. Likewise, we need to force a lighting
	// recalculation.
	// The block update (for renderer) is only required on client side, but
	// the lighting is required on both, since
	// the client needs it for rendering and the server needs it for crop
	// growth etc
	int numberBurning = numberOfBurningFuelSlots();
	if (cachedNumberOfBurningSlots != numberBurning) {
		cachedNumberOfBurningSlots = numberBurning;
		if (worldObj.isRemote) {
			worldObj.markBlockForUpdate(pos);
		}
		worldObj.checkLightFor(EnumSkyBlock.BLOCK, pos);
	}
}

/**
 * for each fuel slot: decreases the burn time, checks if burnTimeRemaining
 * = 0 and tries to consume a new piece of fuel if one is available
 * 
 * @return the number of fuel slots which are burning
 */
private int burnFuel() {
	int burningCount = 0;
	boolean inventoryChanged = false;
	// Iterate over all the fuel slots
	for (int i = 0; i < FUEL_SLOTS_COUNT; i++) {
		int fuelSlotNumber = i + FIRST_FUEL_SLOT;
		if (burnTimeRemaining[i] > 0) {
			--burnTimeRemaining[i];
			++burningCount;
		}
		if (burnTimeRemaining[i] == 0) {
			if (itemStacks[fuelSlotNumber] != null
					&& getItemBurnTime(itemStacks[fuelSlotNumber]) > 0) {
				// If the stack in this slot is not null and is fuel, set
				// burnTimeRemaining & burnTimeInitialValue to the
				// item's burn time and decrease the stack size
				burnTimeRemaining[i] = burnTimeInitialValue[i] = getItemBurnTime(itemStacks[fuelSlotNumber]);
				--itemStacks[fuelSlotNumber].stackSize;
				++burningCount;
				inventoryChanged = true;
				// If the stack size now equals 0 set the slot contents to
				// the items container item. This is for fuel
				// items such as lava buckets so that the bucket is not
				// consumed. If the item dose not have
				// a container item getContainerItem returns null which sets
				// the slot contents to null
				if (itemStacks[fuelSlotNumber].stackSize == 0) {
					itemStacks[fuelSlotNumber] = itemStacks[fuelSlotNumber]
							.getItem().getContainerItem(
									itemStacks[fuelSlotNumber]);
				}
			}
		}
	}
	if (inventoryChanged)
		markDirty();
	return burningCount;
}

/**
 * Check if any of the input items are smeltable and there is sufficient
 * space in the output slots
 * 
 * @return true if smelting is possible
 */
private boolean canSmelt() {
	return smeltItem(false);
}

/**
 * Smelt an input item into an output slot, if possible
 */
private void smeltItem() {
	smeltItem(true);
}

/**
 * checks that there is an item to be smelted in one of the input slots and
 * that there is room for the result in the output slots If desired,
 * performs the smelt
 * 
 * @param performSmelt
 *            if true, perform the smelt. if false, check whether smelting
 *            is possible, but don't change the inventory
 * @return false if no items can be smelted, true otherwise
 */
private boolean smeltItem(boolean performSmelt) {
	Integer firstSuitableInputSlot = null;
	Integer firstSuitableOutputSlot = null;
	ItemStack result = null;

	// finds the first input slot which is smeltable and whose result fits
	// into an output slot (stacking if possible)
	for (int inputSlot = FIRST_INPUT_SLOT; inputSlot < FIRST_INPUT_SLOT
			+ INPUT_SLOTS_COUNT; inputSlot++) {
		if (itemStacks[inputSlot] != null) {
			result = getSmeltingResultForItem(itemStacks[inputSlot]);
			if (result != null) {
				// find the first suitable output slot- either empty, or
				// with identical item that has enough space
				for (int outputSlot = FIRST_OUTPUT_SLOT; outputSlot < FIRST_OUTPUT_SLOT
						+ OUTPUT_SLOTS_COUNT; outputSlot++) {
					ItemStack outputStack = itemStacks[outputSlot];
					if (outputStack == null) {
						firstSuitableInputSlot = inputSlot;
						firstSuitableOutputSlot = outputSlot;
						break;
					}

					if (outputStack.getItem() == result.getItem()
							&& (!outputStack.getHasSubtypes() || outputStack
									.getMetadata() == outputStack
									.getMetadata())
							&& ItemStack.areItemStackTagsEqual(outputStack,
									result)) {
						int combinedSize = itemStacks[outputSlot].stackSize
								+ result.stackSize;
						if (combinedSize <= getInventoryStackLimit()
								&& combinedSize <= itemStacks[outputSlot]
										.getMaxStackSize()) {
							firstSuitableInputSlot = inputSlot;
							firstSuitableOutputSlot = outputSlot;
							break;
						}
					}
				}
				if (firstSuitableInputSlot != null)
					break;
			}
		}
	}

	if (firstSuitableInputSlot == null)
		return false;
	if (!performSmelt)
		return true;

	// alter input and output
	itemStacks[firstSuitableInputSlot].stackSize--;
	if (itemStacks[firstSuitableInputSlot].stackSize <= 0)
		itemStacks[firstSuitableInputSlot] = null;
	if (itemStacks[firstSuitableOutputSlot] == null) {
		itemStacks[firstSuitableOutputSlot] = result.copy(); // Use deep
																// .copy()
																// to avoid
																// altering
																// the
																// recipe
	} else {
		itemStacks[firstSuitableOutputSlot].stackSize += result.stackSize;
	}
	markDirty();
	return true;
}

// returns the smelting result for the given stack. Returns null if the
// given stack can not be smelted
public static ItemStack getSmeltingResultForItem(ItemStack stack) {
	Item input = stack.getItem();

	if (input == Item.getItemFromBlock(NuclearCraft.uraniumOre)) {
		return new ItemStack(NuclearCraft.plutoniumIngot);
	}
	return null;
}

// returns the number of ticks the given item will burn. Returns 0 if the
// given item is not a valid fuel
public static short getItemBurnTime(ItemStack stack) {
	int burntime;
	Item inputFuel = stack.getItem();
	if (inputFuel == NuclearCraft.plutoniumExtraction) {
		return 1600;
	}
	return 0;
}

// Gets the number of slots in the inventory
@Override
public int getSizeInventory() {
	return itemStacks.length;
}

// Gets the stack in the given slot
@Override
public ItemStack getStackInSlot(int i) {
	return itemStacks[i];
}

/**
 * Removes some of the units from itemstack in the given slot, and returns
 * as a separate itemstack
 * 
 * @param slotIndex
 *            the slot number to remove the items from
 * @param count
 *            the number of units to remove
 * @return a new itemstack containing the units removed from the slot
 */
@Override
public ItemStack decrStackSize(int slotIndex, int count) {
	ItemStack itemStackInSlot = getStackInSlot(slotIndex);
	if (itemStackInSlot == null)
		return null;

	ItemStack itemStackRemoved;
	if (itemStackInSlot.stackSize <= count) {
		itemStackRemoved = itemStackInSlot;
		setInventorySlotContents(slotIndex, null);
	} else {
		itemStackRemoved = itemStackInSlot.splitStack(count);
		if (itemStackInSlot.stackSize == 0) {
			setInventorySlotContents(slotIndex, null);
		}
	}
	markDirty();
	return itemStackRemoved;
}

// overwrites the stack in the given slotIndex with the given stack
@Override
public void setInventorySlotContents(int slotIndex, ItemStack itemstack) {
	itemStacks[slotIndex] = itemstack;
	if (itemstack != null && itemstack.stackSize > getInventoryStackLimit()) {
		itemstack.stackSize = getInventoryStackLimit();
	}
	markDirty();
}

// This is the maximum number if items allowed in each slot
// This only affects things such as hoppers trying to insert items you need
// to use the container to enforce this for players
// inserting items via the gui
@Override
public int getInventoryStackLimit() {
	return 64;
}

// Return true if the given player is able to use this block. In this case
// it checks that
// 1) the world tileentity hasn't been replaced in the meantime, and
// 2) the player isn't too far away from the centre of the block
@Override
public boolean isUseableByPlayer(EntityPlayer player) {
	if (this.worldObj.getTileEntity(this.pos) != this)
		return false;
	final double X_CENTRE_OFFSET = 0.5;
	final double Y_CENTRE_OFFSET = 0.5;
	final double Z_CENTRE_OFFSET = 0.5;
	final double MAXIMUM_DISTANCE_SQ = 8.0 * 8.0;
	return player.getDistanceSq(pos.getX() + X_CENTRE_OFFSET, pos.getY()
			+ Y_CENTRE_OFFSET, pos.getZ() + Z_CENTRE_OFFSET) < MAXIMUM_DISTANCE_SQ;
}

// Return true if the given stack is allowed to be inserted in the given
// slot
// Unlike the vanilla furnace, we allow anything to be placed in the fuel
// slots
static public boolean isItemValidForFuelSlot(ItemStack itemStack) {
	return true;
}

// Return true if the given stack is allowed to be inserted in the given
// slot
// Unlike the vanilla furnace, we allow anything to be placed in the fuel
// slots
static public boolean isItemValidForInputSlot(ItemStack itemStack) {
	return true;
}

// Return true if the given stack is allowed to be inserted in the given
// slot
// Unlike the vanilla furnace, we allow anything to be placed in the fuel
// slots
static public boolean isItemValidForOutputSlot(ItemStack itemStack) {
	return false;
}

// ------------------------------

// This is where you save any data that you don't want to lose when the tile
// entity unloads
// In this case, it saves the state of the furnace (burn time etc) and the
// itemstacks stored in the fuel, input, and output slots
@Override
public void writeToNBT(NBTTagCompound parentNBTTagCompound) {
	super.writeToNBT(parentNBTTagCompound); // The super call is required to
											// save and load the tiles
											// location

	// // Save the stored item stacks

	// to use an analogy with Java, this code generates an array of hashmaps
	// The itemStack in each slot is converted to an NBTTagCompound, which
	// is effectively a hashmap of key->value pairs such
	// as slot=1, id=2353, count=1, etc
	// Each of these NBTTagCompound are then inserted into NBTTagList, which
	// is similar to an array.
	NBTTagList dataForAllSlots = new NBTTagList();
	for (int i = 0; i < this.itemStacks.length; ++i) {
		if (this.itemStacks[i] != null) {
			NBTTagCompound dataForThisSlot = new NBTTagCompound();
			dataForThisSlot.setByte("Slot", (byte) i);
			this.itemStacks[i].writeToNBT(dataForThisSlot);
			dataForAllSlots.appendTag(dataForThisSlot);
		}
	}
	// the array of hashmaps is then inserted into the parent hashmap for
	// the container
	parentNBTTagCompound.setTag("Items", dataForAllSlots);

	// Save everything else
	parentNBTTagCompound.setShort("CookTime", cookTime);
	parentNBTTagCompound.setTag("burnTimeRemaining", new NBTTagIntArray(
			burnTimeRemaining));
	parentNBTTagCompound.setTag("burnTimeInitial", new NBTTagIntArray(
			burnTimeInitialValue));
}

// This is where you load the data that you saved in writeToNBT
@Override
public void readFromNBT(NBTTagCompound nbtTagCompound) {
	super.readFromNBT(nbtTagCompound); // The super call is required to save
										// and load the tiles location
	final byte NBT_TYPE_COMPOUND = 10; // See NBTBase.createNewByType() for
										// a listing
	NBTTagList dataForAllSlots = nbtTagCompound.getTagList("Items",
			NBT_TYPE_COMPOUND);

	Arrays.fill(itemStacks, null); // set all slots to empty
	for (int i = 0; i < dataForAllSlots.tagCount(); ++i) {
		NBTTagCompound dataForOneSlot = dataForAllSlots.getCompoundTagAt(i);
		byte slotNumber = dataForOneSlot.getByte("Slot");
		if (slotNumber >= 0 && slotNumber < this.itemStacks.length) {
			this.itemStacks[slotNumber] = ItemStack
					.loadItemStackFromNBT(dataForOneSlot);
		}
	}

	// Load everything else. Trim the arrays (or pad with 0) to make sure
	// they have the correct number of elements
	cookTime = nbtTagCompound.getShort("CookTime");
	burnTimeRemaining = Arrays.copyOf(
			nbtTagCompound.getIntArray("burnTimeRemaining"),
			FUEL_SLOTS_COUNT);
	burnTimeInitialValue = Arrays
			.copyOf(nbtTagCompound.getIntArray("burnTimeInitial"),
					FUEL_SLOTS_COUNT);
	cachedNumberOfBurningSlots = -1;
}

// When the world loads from disk, the server needs to send the TileEntity
// information to the client
// it uses getDescriptionPacket() and onDataPacket() to do this
@Override
public Packet getDescriptionPacket() {
	NBTTagCompound nbtTagCompound = new NBTTagCompound();
	writeToNBT(nbtTagCompound);
	final int METADATA = 0;
	return new S35PacketUpdateTileEntity(this.pos, METADATA, nbtTagCompound);
}

@Override
public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
	readFromNBT(pkt.getNbtCompound());
}

// ------------------------

// set all slots to empty
@Override
public void clear() {
	Arrays.fill(itemStacks, null);
}

// will add a key for this container to the lang file so we can name it in
// the GUI
@Override
public String getName() {
	return "Nuclear Boiler";
}

@Override
public boolean hasCustomName() {
	return false;
}

// standard code to look up what the human-readable name is
@Override
public IChatComponent getDisplayName() {
	return this.hasCustomName() ? new ChatComponentText(this.getName())
			: new ChatComponentTranslation(this.getName());
}

// Fields are used to send non-inventory information from the server to
// interested clients
// The container code caches the fields and sends the client any fields
// which have changed.
// The field ID is limited to byte, and the field value is limited to short.
// (if you use more than this, they get cast down
// in the network packets)
// If you need more than this, or shorts are too small, use a custom packet
// in your container instead.

private static final byte COOK_FIELD_ID = 0;
private static final byte FIRST_BURN_TIME_REMAINING_FIELD_ID = 1;
private static final byte FIRST_BURN_TIME_INITIAL_FIELD_ID = FIRST_BURN_TIME_REMAINING_FIELD_ID
		+ (byte) FUEL_SLOTS_COUNT;
private static final byte NUMBER_OF_FIELDS = FIRST_BURN_TIME_INITIAL_FIELD_ID
		+ (byte) FUEL_SLOTS_COUNT;

@Override
public int getField(int id) {
	if (id == COOK_FIELD_ID)
		return cookTime;
	if (id >= FIRST_BURN_TIME_REMAINING_FIELD_ID
			&& id < FIRST_BURN_TIME_REMAINING_FIELD_ID + FUEL_SLOTS_COUNT) {
		return burnTimeRemaining[id - FIRST_BURN_TIME_REMAINING_FIELD_ID];
	}
	if (id >= FIRST_BURN_TIME_INITIAL_FIELD_ID
			&& id < FIRST_BURN_TIME_INITIAL_FIELD_ID + FUEL_SLOTS_COUNT) {
		return burnTimeInitialValue[id - FIRST_BURN_TIME_INITIAL_FIELD_ID];
	}
	throw new IllegalArgumentException(
			"Invalid field ID in TileNuclearBoiler.getField:" + id);
}

@Override
public void setField(int id, int value) {
	if (id == COOK_FIELD_ID) {
		cookTime = (short) value;
	} else if (id >= FIRST_BURN_TIME_REMAINING_FIELD_ID
			&& id < FIRST_BURN_TIME_REMAINING_FIELD_ID + FUEL_SLOTS_COUNT) {
		burnTimeRemaining[id - FIRST_BURN_TIME_REMAINING_FIELD_ID] = value;
	} else if (id >= FIRST_BURN_TIME_INITIAL_FIELD_ID
			&& id < FIRST_BURN_TIME_INITIAL_FIELD_ID + FUEL_SLOTS_COUNT) {
		burnTimeInitialValue[id - FIRST_BURN_TIME_INITIAL_FIELD_ID] = value;
	} else {
		System.err
				.println("Invalid field ID in TileInventorySmelting.setField:"
						+ id);
	}
}

@Override
public int getFieldCount() {
	return NUMBER_OF_FIELDS;
}

// -----------------------------------------------------------------------------------------------------------
// The following methods are not needed for this example but are part of
// IInventory so they must be implemented

// Unused unless your container specifically uses it.
// Return true if the given stack is allowed to go in the given slot
@Override
public boolean isItemValidForSlot(int slotIndex, ItemStack itemstack) {
	return false;
}

/**
 * This method removes the entire contents of the given slot and returns it.
 * Used by containers such as crafting tables which return any items in
 * their slots when you close the GUI
 * 
 * @param slotIndex
 * @return
 */
@Override
public ItemStack getStackInSlotOnClosing(int slotIndex) {
	ItemStack itemStack = getStackInSlot(slotIndex);
	if (itemStack != null)
		setInventorySlotContents(slotIndex, null);
	return itemStack;
}

@Override
public void openInventory(EntityPlayer player) {
}

@Override
public void closeInventory(EntityPlayer player) {
}

}

 

Here is my NuclearBoilrt class:

package com.mod.gui.boiler;

import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyInteger;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.InventoryHelper;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumWorldBlockLayer;
import net.minecraft.util.MathHelper;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

import com.mod.main.GuiHandler;
import com.mod.main.NuclearCraft;

public class NuclearBoiler extends BlockContainer {
public NuclearBoiler() {
	super(Material.rock);
	setCreativeTab(NuclearCraft.nuclearTab);
	setUnlocalizedName("NuclearBoiler");
}

@Override
public TileEntity createNewTileEntity(World worldIn, int meta) {
	return new TileNuclearBoiler();
}

@Override
public boolean onBlockActivated(World worldIn, BlockPos pos,
		IBlockState state, EntityPlayer playerIn, EnumFacing side,
		float hitX, float hitY, float hitZ) {
	if (worldIn.isRemote)
		return true;

	playerIn.openGui(NuclearCraft.instance, GuiHandler.getGuiID(), worldIn,
			pos.getX(), pos.getY(), pos.getZ());
	return true;
}

@Override
public void breakBlock(World worldIn, BlockPos pos, IBlockState state) {
	TileEntity tileEntity = worldIn.getTileEntity(pos);
	if (tileEntity instanceof IInventory) {
		InventoryHelper.dropInventoryItems(worldIn, pos,
				(IInventory) tileEntity);
	}
	super.breakBlock(worldIn, pos, state);
}

@Override
public IBlockState getActualState(IBlockState state, IBlockAccess worldIn,
		BlockPos pos) {
	TileEntity tileEntity = worldIn.getTileEntity(pos);
	if (tileEntity instanceof TileNuclearBoiler) {
		TileNuclearBoiler tileInventoryFurnace = (TileNuclearBoiler) tileEntity;
		int burningSlots = tileInventoryFurnace.numberOfBurningFuelSlots();
		burningSlots = MathHelper.clamp_int(burningSlots, 0, 4);
		return getDefaultState().withProperty(BURNING_SIDES_COUNT,
				burningSlots);
	}
	return state;
}

@Override
public IBlockState getStateFromMeta(int meta) {
	return this.getDefaultState();
	// return this.getDefaultState().withProperty(BURNING_SIDES_COUNT,
	// Integer.valueOf(meta));
}

@Override
public int getMetaFromState(IBlockState state) {
	return 0;
}

@Override
protected BlockState createBlockState() {
	return new BlockState(this, new IProperty[] { BURNING_SIDES_COUNT });
}

public static final PropertyInteger BURNING_SIDES_COUNT = PropertyInteger
		.create("burnbving_sides_count", 0, 4);

private static final int LIGHT_VALUE = 15; // light value for a
											// single side burning

public int getLightValue(IBlockAccess world, BlockPos pos) {
	int lightValue = 0;
	IBlockState blockState = getActualState(getDefaultState(), world, pos);
	int burningSides = (Integer) blockState.getValue(BURNING_SIDES_COUNT);

	if (burningSides == 0) {
		lightValue = 0;
	} else {
		lightValue = 15;
	}
	lightValue = MathHelper.clamp_int(lightValue, 0, LIGHT_VALUE);
	return lightValue;
}

@SideOnly(Side.CLIENT)
public EnumWorldBlockLayer getBlockLayer() {
	return EnumWorldBlockLayer.SOLID;
}

@Override
public boolean isOpaqueCube() {
	return false;
}

@Override
public boolean isFullCube() {
	return false;
}

@Override
public int getRenderType() {
	return 3;
}
}

 

Here is my GuiNuclearBoiler class:

package com.mod.gui.boiler;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

import com.mod.gui.refinery.TileRefinery;
import com.mod.main.NuclearCraft;

import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.util.ResourceLocation;

public class GuiNuclearBoiler extends GuiContainer {
private static final ResourceLocation texture = new ResourceLocation(
		NuclearCraft.MODID, "textures/gui/NuclearBoiler.png");
private TileNuclearBoiler tileEntity;

final int COOK_BAR_XPOS = 42;
final int COOK_BAR_YPOS = 34;
final int COOK_BAR_ICON_U = 177; // texture position of white arrow icon on
									// GUI background image
final int COOK_BAR_ICON_V = 14;
final int COOK_BAR_WIDTH = 66;
final int COOK_BAR_HEIGHT = 19;

final int FLAME_XPOS = 64;
final int FLAME_YPOS = 21;
final int FLAME_ICON_U = 176;
final int FLAME_ICON_V = 0;
final int FLAME_WIDTH = 14;
final int FLAME_HEIGHT = 14;
final int FLAME_X_SPACING = 18;

public GuiNuclearBoiler(InventoryPlayer invPlayer, TileNuclearBoiler tile) {
	super(new ContainerNuclearBoiler(invPlayer, tile));

	this.tileEntity = tile;

	// width and height
	xSize = 176;
	ySize = 207;
}

@Override
protected void drawGuiContainerBackgroundLayer(float partialTicks,
		int mouseX, int mouseY) {
	// Bind the image texture
	Minecraft.getMinecraft().getTextureManager().bindTexture(texture);
	// Draw the image
	GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
	drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, ySize);

	// get cook progress as a double between 0 and 1
	double cookProgress = tileEntity.fractionOfCookTimeComplete();
	// draw the cook progress bar
	drawTexturedModalRect(guiLeft + COOK_BAR_XPOS, guiTop + COOK_BAR_YPOS,
			COOK_BAR_ICON_U, COOK_BAR_ICON_V,
			(int) (cookProgress * COOK_BAR_WIDTH), COOK_BAR_HEIGHT);

	// draw the fuel remaining bar for each fuel slot flame
	drawTexturedModalRect(guiLeft + (FLAME_XPOS - 1), guiTop + FLAME_YPOS,
			FLAME_ICON_U, FLAME_ICON_V, FLAME_WIDTH, FLAME_HEIGHT);
}

@Override
protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
	super.drawGuiContainerForegroundLayer(mouseX, mouseY);

	final int LABEL_XPOS = 65;
	final int LABEL_YPOS = 5;
	fontRendererObj.drawString(tileEntity.getDisplayName()
			.getUnformattedText(), LABEL_XPOS, LABEL_YPOS, Color.darkGray
			.getRGB());

	List<String> hoveringText = new ArrayList<String>();

	// If the mouse is over the progress bar add the progress bar hovering
	// text
	if (isInRect(guiLeft + COOK_BAR_XPOS, guiTop + COOK_BAR_YPOS,
			COOK_BAR_WIDTH, COOK_BAR_HEIGHT, mouseX, mouseY)) {
		int cookPercentage = (int) (tileEntity.fractionOfCookTimeComplete() * 100);
		hoveringText.add("Progress: " + cookPercentage + "%");
	}

	// If the mouse is over one of the burn time indicator add the burn time
	// indicator hovering text
	if (isInRect(guiLeft + (FLAME_XPOS - 1), guiTop + FLAME_YPOS, FLAME_WIDTH,
			FLAME_HEIGHT, mouseX, mouseY)) {
		hoveringText.add("Fuel time: "
				+ tileEntity.secondsOfFuelRemaining(0) + "s");
	}
	// If hoveringText is not empty draw the hovering text
	if (!hoveringText.isEmpty()) {
		drawHoveringText(hoveringText, mouseX - guiLeft, mouseY - guiTop,
				fontRendererObj);
	}
}

// Returns true if the given x,y coordinates are within the given rectangle
public static boolean isInRect(int x, int y, int xSize, int ySize,
		int mouseX, int mouseY) {
	return ((mouseX >= x && mouseX <= x + xSize) && (mouseY >= y && mouseY <= y
			+ ySize));
}
}

 

And my ContainerNuclearBoiler class:

package com.mod.gui.boiler;

import com.mod.gui.refinery.TileRefinery;
import com.mod.gui.refinery.ContainerRefinery.SlotFuel;
import com.mod.gui.refinery.ContainerRefinery.SlotOutput;
import com.mod.gui.refinery.ContainerRefinery.SlotSmeltableInput;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ICrafting;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class ContainerNuclearBoiler extends Container {

// Stores the tile entity instance for later use
private TileNuclearBoiler tile;

private int[] cachedFields;

private final int HOTBAR_SLOT_COUNT = 9;
private final int PLAYER_INVENTORY_ROW_COUNT = 3;
private final int PLAYER_INVENTORY_COLUMN_COUNT = 9;
private final int PLAYER_INVENTORY_SLOT_COUNT = PLAYER_INVENTORY_COLUMN_COUNT
		* PLAYER_INVENTORY_ROW_COUNT;
private final int VANILLA_SLOT_COUNT = HOTBAR_SLOT_COUNT
		+ PLAYER_INVENTORY_SLOT_COUNT;

public final int FUEL_SLOTS_COUNT = TileNuclearBoiler.FUEL_SLOTS_COUNT;
public final int INPUT_SLOTS_COUNT = TileNuclearBoiler.INPUT_SLOTS_COUNT;
public final int OUTPUT_SLOTS_COUNT = TileNuclearBoiler.OUTPUT_SLOTS_COUNT;
public final int FURNACE_SLOTS_COUNT = FUEL_SLOTS_COUNT + INPUT_SLOTS_COUNT
		+ OUTPUT_SLOTS_COUNT;

// slot index is the unique index for all slots in this container i.e. 0 -
// 35 for invPlayer then 36 - 49 for tileInventoryFurnace
private final int VANILLA_FIRST_SLOT_INDEX = 0;
private final int FIRST_FUEL_SLOT_INDEX = VANILLA_FIRST_SLOT_INDEX
		+ VANILLA_SLOT_COUNT;
private final int FIRST_INPUT_SLOT_INDEX = FIRST_FUEL_SLOT_INDEX
		+ FUEL_SLOTS_COUNT;
private final int FIRST_OUTPUT_SLOT_INDEX = FIRST_INPUT_SLOT_INDEX
		+ INPUT_SLOTS_COUNT;

// slot number is the slot number within each component; i.e. invPlayer
// slots 0 - 35, and tileInventoryFurnace slots 0 - 14
private final int FIRST_FUEL_SLOT_NUMBER = 0;
private final int FIRST_INPUT_SLOT_NUMBER = FIRST_FUEL_SLOT_NUMBER
		+ FUEL_SLOTS_COUNT;
private final int FIRST_OUTPUT_SLOT_NUMBER = FIRST_INPUT_SLOT_NUMBER
		+ INPUT_SLOTS_COUNT;

public ContainerNuclearBoiler(InventoryPlayer invPlayer,
		TileNuclearBoiler tile) {
	this.tile = tile;

	final int SLOT_X_SPACING = 18;
	final int SLOT_Y_SPACING = 18;
	final int HOTBAR_XPOS = 8;
	final int HOTBAR_YPOS = 142;
	// Add the players hotbar to the gui - the [xpos, ypos] location of each
	// item
	for (int x = 0; x < HOTBAR_SLOT_COUNT; x++) {
		int slotNumber = x;
		addSlotToContainer(new Slot(invPlayer, slotNumber, HOTBAR_XPOS
				+ SLOT_X_SPACING * x, HOTBAR_YPOS));
	}

	final int PLAYER_INVENTORY_XPOS = 8;
	final int PLAYER_INVENTORY_YPOS = 84;
	// Add the rest of the players inventory to the gui
	for (int y = 0; y < PLAYER_INVENTORY_ROW_COUNT; y++) {
		for (int x = 0; x < PLAYER_INVENTORY_COLUMN_COUNT; x++) {
			int slotNumber = HOTBAR_SLOT_COUNT + y
					* PLAYER_INVENTORY_COLUMN_COUNT + x;
			int xpos = PLAYER_INVENTORY_XPOS + x * SLOT_X_SPACING;
			int ypos = PLAYER_INVENTORY_YPOS + y * SLOT_Y_SPACING;
			addSlotToContainer(new Slot(invPlayer, slotNumber, xpos, ypos));
		}
	}

	// FUEL SLOTS
	addSlotToContainer(new SlotFuel(tile, 0, 44, 18));
	//addSlotToContainer(new SlotFuel(tile, 1, 79, 18));

	// INPUT SLOTS
	addSlotToContainer(new SlotSmeltableInput(tile, 2, 21, 35));

	// OUTPUT SLOT
	addSlotToContainer(new SlotOutput(tile, 3, 114, 35));
}

// Checks each tick to make sure the player is still able to access the
// inventory and if not closes the gui
@Override
public boolean canInteractWith(EntityPlayer player) {
	return tile.isUseableByPlayer(player);
}

// This is where you specify what happens when a player shift clicks a slot
// in the gui
// (when you shift click a slot in the TileEntity Inventory, it moves it to
// the first available position in the hotbar and/or
// player inventory. When you you shift-click a hotbar or player inventory
// item, it moves it to the first available
// position in the TileEntity inventory - either input or fuel as
// appropriate for the item you clicked)
// At the very least you must override this and return null or the game will
// crash when the player shift clicks a slot
// returns null if the source slot is empty, or if none of the source slot
// items could be moved.
// otherwise, returns a copy of the source stack
@Override
public ItemStack transferStackInSlot(EntityPlayer player,
		int sourceSlotIndex) {
	Slot sourceSlot = (Slot) inventorySlots.get(sourceSlotIndex);
	if (sourceSlot == null || !sourceSlot.getHasStack())
		return null;
	ItemStack sourceStack = sourceSlot.getStack();
	ItemStack copyOfSourceStack = sourceStack.copy();

	// Check if the slot clicked is one of the vanilla container slots
	if (sourceSlotIndex >= VANILLA_FIRST_SLOT_INDEX
			&& sourceSlotIndex < VANILLA_FIRST_SLOT_INDEX
					+ VANILLA_SLOT_COUNT) {
		// This is a vanilla container slot so merge the stack into one of
		// the furnace slots
		// If the stack is smeltable try to merge merge the stack into the
		// input slots
		if (TileRefinery.getSmeltingResultForItem(sourceStack) != null) {
			if (!mergeItemStack(sourceStack, FIRST_INPUT_SLOT_INDEX,
					FIRST_INPUT_SLOT_INDEX + INPUT_SLOTS_COUNT, false)) {
				return null;
			}
		} else if (TileRefinery.getItemBurnTime(sourceStack) > 0) {
			if (!mergeItemStack(sourceStack, FIRST_FUEL_SLOT_INDEX,
					FIRST_FUEL_SLOT_INDEX + FUEL_SLOTS_COUNT, true)) {
				// Setting the boolean to true places the stack in the
				// bottom slot first
				return null;
			}
		} else {
			return null;
		}
	} else if (sourceSlotIndex >= FIRST_FUEL_SLOT_INDEX
			&& sourceSlotIndex < FIRST_FUEL_SLOT_INDEX
					+ FURNACE_SLOTS_COUNT) {
		// This is a furnace slot so merge the stack into the players
		// inventory: try the hotbar first and then the main inventory
		// because the main inventory slots are immediately after the hotbar
		// slots, we can just merge with a single call
		if (!mergeItemStack(sourceStack, VANILLA_FIRST_SLOT_INDEX,
				VANILLA_FIRST_SLOT_INDEX + VANILLA_SLOT_COUNT, false)) {
			return null;
		}
	} else {
		System.err.print("Invalid slotIndex:" + sourceSlotIndex);
		return null;
	}

	// If stack size == 0 (the entire stack was moved) set slot contents to
	// null
	if (sourceStack.stackSize == 0) {
		sourceSlot.putStack(null);
	} else {
		sourceSlot.onSlotChanged();
	}

	sourceSlot.onPickupFromSlot(player, sourceStack);
	return copyOfSourceStack;
}

/* Client Synchronization */

// This is where you check if any values have changed and if so send an
// update to any clients accessing this container
// The container itemstacks are tested in Container.detectAndSendChanges, so
// we don't need to do that
// We iterate through all of the TileEntity Fields to find any which have
// changed, and send them.
// You don't have to use fields if you don't wish to; just manually match
// the ID in sendProgressBarUpdate with the value in
// updateProgressBar()
// The progress bar values are restricted to shorts. If you have a larger
// value (eg int), it's not a good idea to try and split it
// up into two shorts because the progress bar values are sent
// independently, and unless you add synchronisation logic at the
// receiving side, your int value will be wrong until the second short
// arrives. Use a custom packet instead.
@Override
public void detectAndSendChanges() {
	super.detectAndSendChanges();

	boolean allFieldsHaveChanged = false;
	boolean fieldHasChanged[] = new boolean[tile.getFieldCount()];
	if (cachedFields == null) {
		cachedFields = new int[tile.getFieldCount()];
		allFieldsHaveChanged = true;
	}
	for (int i = 0; i < cachedFields.length; ++i) {
		if (allFieldsHaveChanged || cachedFields[i] != tile.getField(i)) {
			cachedFields[i] = tile.getField(i);
			fieldHasChanged[i] = true;
		}
	}

	// go through the list of crafters (players using this container) and
	// update them if necessary
	for (int i = 0; i < this.crafters.size(); ++i) {
		ICrafting icrafting = (ICrafting) this.crafters.get(i);
		for (int fieldID = 0; fieldID < tile.getFieldCount(); ++fieldID) {
			if (fieldHasChanged[fieldID]) {
				// Note that although sendProgressBarUpdate takes 2 ints on
				// a server these are truncated to shorts
				icrafting.sendProgressBarUpdate(this, fieldID,
						cachedFields[fieldID]);
			}
		}
	}
}

// Called when a progress bar update is received from the server. The two
// values (id and data) are the same two
// values given to sendProgressBarUpdate. In this case we are using fields
// so we just pass them to the tileEntity.
@SideOnly(Side.CLIENT)
@Override
public void updateProgressBar(int id, int data) {
	tile.setField(id, data);
}

// SlotFuel is a slot for fuel items
public class SlotFuel extends Slot {
	public SlotFuel(IInventory inventoryIn, int index, int xPosition,
			int yPosition) {
		super(inventoryIn, index, xPosition, yPosition);
	}

	// if this function returns false, the player won't be able to insert
	// the given item into this slot
	@Override
	public boolean isItemValid(ItemStack stack) {
		return TileRefinery.isItemValidForFuelSlot(stack);
	}
}

// SlotSmeltableInput is a slot for input items
public class SlotSmeltableInput extends Slot {
	public SlotSmeltableInput(IInventory inventoryIn, int index,
			int xPosition, int yPosition) {
		super(inventoryIn, index, xPosition, yPosition);
	}

	// if this function returns false, the player won't be able to insert
	// the given item into this slot
	@Override
	public boolean isItemValid(ItemStack stack) {
		return TileRefinery.isItemValidForInputSlot(stack);
	}
}

// SlotOutput is a slot that will not accept any items
public class SlotOutput extends Slot {
	public SlotOutput(IInventory inventoryIn, int index, int xPosition,
			int yPosition) {
		super(inventoryIn, index, xPosition, yPosition);
	}

	// if this function returns false, the player won't be able to insert
	// the given item into this slot
	@Override
	public boolean isItemValid(ItemStack stack) {
		return TileRefinery.isItemValidForOutputSlot(stack);
	}
}
}

 

Here is the crash stacktrace:

[10:20:44] [main/INFO] [GradleStart]: Extra: []
[10:20:44] [main/INFO] [GradleStart]: Running with arguments: [--userProperties, {}, --assetsDir, C:/Users/student/.gradle/caches/minecraft/assets, --assetIndex, 1.8, --accessToken, {REDACTED}, --version, 1.8, --tweakClass, net.minecraftforge.fml.common.launcher.FMLTweaker, --tweakClass, net.minecraftforge.gradle.tweakers.CoremodTweaker]
[10:20:44] [main/INFO] [LaunchWrapper]: Loading tweak class name net.minecraftforge.fml.common.launcher.FMLTweaker
[10:20:44] [main/INFO] [LaunchWrapper]: Using primary tweak class name net.minecraftforge.fml.common.launcher.FMLTweaker
[10:20:44] [main/INFO] [LaunchWrapper]: Loading tweak class name net.minecraftforge.gradle.tweakers.CoremodTweaker
[10:20:44] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.common.launcher.FMLTweaker
[10:20:44] [main/INFO] [FML]: Forge Mod Loader version 8.99.116.1449 for Minecraft 1.8 loading
[10:20:44] [main/INFO] [FML]: Java is Java HotSpot(TM) 64-Bit Server VM, version 1.8.0_31, running on Windows 8.1:amd64:6.3, installed at C:\Program Files\Java\jre1.8.0_31
[10:20:44] [main/INFO] [FML]: Managed to load a deobfuscated Minecraft name- we are in a deobfuscated environment. Skipping runtime deobfuscation
[10:20:44] [main/WARN] [FML]: The coremod codechicken.core.launch.CodeChickenCorePlugin does not have a MCVersion annotation, it may cause issues with this version of Minecraft
[10:20:44] [main/WARN] [FML]: The coremod codechicken.lib.asm.CCLCorePlugin does not have a MCVersion annotation, it may cause issues with this version of Minecraft
[10:20:44] [main/WARN] [FML]: The coremod codechicken.lib.asm.CCLCorePlugin does not have a MCVersion annotation, it may cause issues with this version of Minecraft
[10:20:44] [main/WARN] [FML]: The coremod codechicken.nei.asm.NEICorePlugin does not have a MCVersion annotation, it may cause issues with this version of Minecraft
[10:20:44] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.gradle.tweakers.CoremodTweaker
[10:20:44] [main/INFO] [GradleStart]: Injecting location in coremod net.minecraftforge.fml.relauncher.FMLCorePlugin
[10:20:44] [main/INFO] [GradleStart]: Injecting location in coremod net.minecraftforge.classloading.FMLForgePlugin
[10:20:44] [main/INFO] [GradleStart]: Injecting location in coremod codechicken.core.asm.MCPDeobfuscationTransformer.LoadPlugin
[10:20:44] [main/INFO] [GradleStart]: Injecting location in coremod codechicken.lib.asm.CCLCorePlugin
[10:20:44] [main/INFO] [GradleStart]: Injecting location in coremod codechicken.core.launch.CodeChickenCorePlugin
[10:20:44] [main/INFO] [GradleStart]: Injecting location in coremod codechicken.lib.asm.CCLCorePlugin
[10:20:44] [main/INFO] [GradleStart]: Injecting location in coremod codechicken.nei.asm.NEICorePlugin
[10:20:44] [main/INFO] [LaunchWrapper]: Loading tweak class name net.minecraftforge.fml.common.launcher.FMLInjectionAndSortingTweaker
[10:20:44] [main/INFO] [LaunchWrapper]: Loading tweak class name net.minecraftforge.fml.common.launcher.FMLDeobfTweaker
[10:20:44] [main/INFO] [LaunchWrapper]: Loading tweak class name net.minecraftforge.gradle.tweakers.AccessTransformerTweaker
[10:20:44] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.common.launcher.FMLInjectionAndSortingTweaker
[10:20:44] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.common.launcher.FMLInjectionAndSortingTweaker
[10:20:44] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.relauncher.CoreModManager$FMLPluginWrapper
[10:20:44] [main/ERROR] [FML]: The binary patch set is missing. Either you are in a development environment, or things are not going to work!
[10:20:45] [main/ERROR] [FML]: FML appears to be missing any signature data. This is not a good thing
[10:20:45] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.relauncher.CoreModManager$FMLPluginWrapper
[10:20:45] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.relauncher.CoreModManager$FMLPluginWrapper
[10:20:46] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.relauncher.CoreModManager$FMLPluginWrapper
[10:20:46] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.relauncher.CoreModManager$FMLPluginWrapper
[10:20:46] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.relauncher.CoreModManager$FMLPluginWrapper
[10:20:46] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.relauncher.CoreModManager$FMLPluginWrapper
[10:20:46] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.common.launcher.FMLDeobfTweaker
[10:20:46] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.gradle.tweakers.AccessTransformerTweaker
[10:20:46] [main/INFO] [GradleStart]: Remapping AccessTransformer rules...
[10:20:46] [main/INFO] [LaunchWrapper]: Loading tweak class name net.minecraftforge.fml.common.launcher.TerminalTweaker
[10:20:46] [main/INFO] [LaunchWrapper]: Calling tweak class net.minecraftforge.fml.common.launcher.TerminalTweaker
[10:20:46] [main/INFO] [LaunchWrapper]: Launching wrapped minecraft {net.minecraft.client.main.Main}
[10:20:47] [Client thread/INFO]: Setting user: Player85
[10:20:50] [Client thread/INFO]: LWJGL Version: 2.9.1
[10:20:51] [Client thread/INFO] [sTDOUT]: [net.minecraftforge.fml.client.SplashProgress:start:235]: ---- Minecraft Crash Report ----

WARNING: coremods are present:
  CCLCorePlugin (CodeChickenLib-1.8-1.1.2.133-dev.jar)
  CodeChickenCorePlugin (CodeChickenCore-1.8-1.0.5.36-universal.jar)
  CCCDeobfPlugin (unknown)
  NEICorePlugin (NotEnoughItems-1.8-1.0.5.104-universal.jar)
Contact their authors BEFORE contacting forge

// You should try our sister game, Minceraft!

Time: 6/19/15 10:20 AM
Description: Loading screen debug info

This is just a prompt for computer specs to be printed. THIS IS NOT A ERROR


A detailed walkthrough of the error, its code path and all known details is as follows:
---------------------------------------------------------------------------------------

-- System Details --
Details:
Minecraft Version: 1.8
Operating System: Windows 8.1 (amd64) version 6.3
Java Version: 1.8.0_31, Oracle Corporation
Java VM Version: Java HotSpot(TM) 64-Bit Server VM (mixed mode), Oracle Corporation
Memory: 798468864 bytes (761 MB) / 1037959168 bytes (989 MB) up to 1037959168 bytes (989 MB)
JVM Flags: 3 total; -Xincgc -Xmx1024M -Xms1024M
IntCache: cache: 0, tcache: 0, allocated: 0, tallocated: 0
FML: 
Loaded coremods (and transformers): 
CCLCorePlugin (CodeChickenLib-1.8-1.1.2.133-dev.jar)
  codechicken.lib.asm.ClassHeirachyManager
  codechicken.lib.asm.RenderHookTransformer
CodeChickenCorePlugin (CodeChickenCore-1.8-1.0.5.36-universal.jar)
  codechicken.core.asm.InterfaceDependancyTransformer
  codechicken.core.asm.TweakTransformer
  codechicken.core.asm.DelegatedTransformer
  codechicken.core.asm.DefaultImplementationTransformer
CCCDeobfPlugin (unknown)
  
NEICorePlugin (NotEnoughItems-1.8-1.0.5.104-universal.jar)
  codechicken.nei.asm.NEITransformer
GL info: ' Vendor: 'NVIDIA Corporation' Version: '4.5.0 NVIDIA 350.12' Renderer: 'GeForce GT 755M/PCIe/SSE2'
[10:20:51] [Client thread/INFO] [MinecraftForge]: Attempting early MinecraftForge initialization
[10:20:51] [Client thread/INFO] [FML]: MinecraftForge v11.14.3.1449 Initialized
[10:20:51] [Client thread/INFO] [FML]: Replaced 204 ore recipies
[10:20:51] [Client thread/INFO] [FML]: Preloading CrashReport classes
[10:20:51] [Client thread/INFO] [MinecraftForge]: Completed early MinecraftForge initialization
[10:20:51] [Client thread/INFO] [FML]: Found 0 mods from the command line. Injecting into mod discoverer
[10:20:51] [Client thread/INFO] [FML]: Searching C:\Users\student\Desktop\Lucas B\forge-1.8-11.14.3.1449-src\eclipse\mods for mods
[10:20:51] [Client thread/INFO] [FML]: Also searching C:\Users\student\Desktop\Lucas B\forge-1.8-11.14.3.1449-src\eclipse\mods\1.8 for mods
[10:20:52] [Client thread/INFO] [FML]: Forge Mod Loader has identified 6 mods to load
[10:20:52] [Client thread/INFO] [FML]: Attempting connection with missing mods [mcp, FML, Forge, CodeChickenCore, NotEnoughItems, nuclearcraft] at CLIENT
[10:20:52] [Client thread/INFO] [FML]: Attempting connection with missing mods [mcp, FML, Forge, CodeChickenCore, NotEnoughItems, nuclearcraft] at SERVER
[10:20:53] [Client thread/INFO]: Reloading ResourceManager: Default, FMLFileResourcePack:Forge Mod Loader, FMLFileResourcePack:Minecraft Forge, FMLFileResourcePack:Not Enough Items, FMLFileResourcePack:NuclearCraft
[10:20:53] [Client thread/INFO] [FML]: Processing ObjectHolder annotations
[10:20:53] [Client thread/INFO] [FML]: Found 384 ObjectHolder annotations
[10:20:53] [Client thread/INFO] [FML]: Identifying ItemStackHolder annotations
[10:20:53] [Client thread/INFO] [FML]: Found 0 ItemStackHolder annotations
[10:20:53] [Client thread/INFO] [FML]: Configured a dormant chunk cache size of 0
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:75]: Entering preinitalization phase..
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:76]: Registering items...
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:91]: Items registered.
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:92]: Registering blocks...
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:104]: Blocks registered.
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:105]: Registering tile entities...
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:110]: Tile entities registered.
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:111]: Registering gui handler...
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:116]: Gui handler registered.
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:117]: Registering fuel handler...
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:119]: Fuel handler registered.
[10:20:53] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:preinit:120]: Preinitalization phase ended.
[10:20:53] [Client thread/INFO] [FML]: Applying holder lookups
[10:20:53] [Client thread/INFO] [FML]: Holder lookups applied
[10:20:53] [Client thread/INFO] [FML]: Injecting itemstacks
[10:20:53] [Client thread/INFO] [FML]: Itemstack injection complete
[10:20:53] [sound Library Loader/INFO]: Starting up SoundSystem...
[10:20:53] [Thread-10/INFO]: Initializing LWJGL OpenAL
[10:20:53] [Thread-10/INFO]: (The LWJGL binding of OpenAL.  For more information, see http://www.lwjgl.org)
[10:20:53] [Thread-10/INFO]: OpenAL initialized.
[10:20:54] [sound Library Loader/INFO]: Sound engine started
[10:20:55] [Client thread/INFO]: Created: 512x512 textures-atlas
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=3 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=2 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=4 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=0 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=2 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=1 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#inventory not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=4 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=3 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=1 not found
[10:20:56] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=0 not found
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:init:125]: Entering initalization phase...
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:init:126]: Texturing items...
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:init:128]: Items textured.
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:init:129]: Texturing blocks...
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:init:131]: Blocks textured.
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:init:132]: Registering ore generator...
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:init:134]: Ore generator registered.
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:init:135]: Initalization phase ended.
[10:20:57] [Client thread/INFO] [FML]: Injecting itemstacks
[10:20:57] [Client thread/INFO] [FML]: Itemstack injection complete
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:140]: Entering postinitalization phase...
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:141]: Registering item recipes...
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:143]: Item recipes registered.
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:144]: Registering block recipes...
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:146]: Block recipes registered.
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:147]: Registering smelting recipes...
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:149]: Smelting recipes registered.
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:150]: Registering special names..
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:152]: Special names registered.
[10:20:57] [Client thread/INFO] [sTDOUT]: [com.mod.main.NuclearCraft:postinit:153]: Postinitalization phase ended.
[10:20:57] [Client thread/INFO] [FML]: Forge Mod Loader has successfully loaded 6 mods
[10:20:57] [Client thread/INFO]: Reloading ResourceManager: Default, FMLFileResourcePack:Forge Mod Loader, FMLFileResourcePack:Minecraft Forge, FMLFileResourcePack:Not Enough Items, FMLFileResourcePack:NuclearCraft
[10:20:57] [Client thread/INFO]: SoundSystem shutting down...
[10:20:57] [Client thread/WARN]: Author: Paul Lamb, www.paulscode.com
[10:20:57] [sound Library Loader/INFO]: Starting up SoundSystem...
[10:20:57] [Thread-13/INFO]: Initializing LWJGL OpenAL
[10:20:57] [Thread-13/INFO]: (The LWJGL binding of OpenAL.  For more information, see http://www.lwjgl.org)
[10:20:57] [Thread-13/INFO]: OpenAL initialized.
[10:20:58] [sound Library Loader/INFO]: Sound engine started
[10:20:59] [Client thread/INFO]: Created: 512x512 textures-atlas
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=3 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=2 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=4 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=0 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=2 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=1 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#inventory not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=4 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:Refinery#burnbving_sides_count=3 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=1 not found
[10:20:59] [Client thread/ERROR] [FML]: Model definition for location nuclearcraft:NuclearBoiler#burnbving_sides_count=0 not found
[10:21:17] [server thread/INFO]: Starting integrated minecraft server version 1.8
[10:21:17] [server thread/INFO]: Generating keypair
[10:21:17] [server thread/INFO] [FML]: Injecting existing block and item data into this server instance
[10:21:17] [server thread/INFO] [FML]: Applying holder lookups
[10:21:17] [server thread/INFO] [FML]: Holder lookups applied
[10:21:18] [server thread/INFO] [FML]: Loading dimension 0 (Swag) (net.minecraft.server.integrated.IntegratedServer@57ab7ad9)
[10:21:18] [server thread/INFO] [FML]: Loading dimension 1 (Swag) (net.minecraft.server.integrated.IntegratedServer@57ab7ad9)
[10:21:18] [server thread/INFO] [FML]: Loading dimension -1 (Swag) (net.minecraft.server.integrated.IntegratedServer@57ab7ad9)
[10:21:18] [server thread/INFO]: Preparing start region for level 0
[10:21:19] [server thread/INFO]: Changing view distance to 12, from 10
[10:21:20] [Netty Local Client IO #0/INFO] [FML]: Server protocol version 2
[10:21:20] [Netty Server IO #1/INFO] [FML]: Client protocol version 2
[10:21:20] [Netty Server IO #1/INFO] [FML]: Client attempting to join with 6 mods : CodeChickenCore@1.0.5.36,NotEnoughItems@1.0.5.104,FML@8.0.99.99,Forge@11.14.3.1449,mcp@9.05,nuclearcraft@1.0.0
[10:21:20] [Netty Local Client IO #0/INFO] [FML]: [Netty Local Client IO #0] Client side modded connection established
[10:21:20] [server thread/INFO] [FML]: [server thread] Server side modded connection established
[10:21:20] [server thread/INFO]: Player85[local:E:686f6c5a] logged in with entity id 119 at (-135.1219394250137, 67.0, 164.79377712835569)
[10:21:20] [server thread/INFO]: Player85 joined the game
[10:21:22] [pool-2-thread-1/WARN]: Couldn't look up profile properties for com.mojang.authlib.GameProfile@203a658f[id=c843d906-43ab-3137-9682-b42949d12a2f,name=Player85,properties={},legacy=false]
com.mojang.authlib.exceptions.AuthenticationException: The client has sent too many requests within a certain amount of time
at com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService.makeRequest(YggdrasilAuthenticationService.java:65) ~[YggdrasilAuthenticationService.class:?]
at com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService.fillGameProfile(YggdrasilMinecraftSessionService.java:158) [YggdrasilMinecraftSessionService.class:?]
at com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService$1.load(YggdrasilMinecraftSessionService.java:53) [YggdrasilMinecraftSessionService$1.class:?]
at com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService$1.load(YggdrasilMinecraftSessionService.java:50) [YggdrasilMinecraftSessionService$1.class:?]
at com.google.common.cache.LocalCache$LoadingValueReference.loadFuture(LocalCache.java:3524) [guava-17.0.jar:?]
at com.google.common.cache.LocalCache$Segment.loadSync(LocalCache.java:2317) [guava-17.0.jar:?]
at com.google.common.cache.LocalCache$Segment.lockedGetOrLoad(LocalCache.java:2280) [guava-17.0.jar:?]
at com.google.common.cache.LocalCache$Segment.get(LocalCache.java:2195) [guava-17.0.jar:?]
at com.google.common.cache.LocalCache.get(LocalCache.java:3934) [guava-17.0.jar:?]
at com.google.common.cache.LocalCache.getOrLoad(LocalCache.java:3938) [guava-17.0.jar:?]
at com.google.common.cache.LocalCache$LocalLoadingCache.get(LocalCache.java:4821) [guava-17.0.jar:?]
at com.google.common.cache.LocalCache$LocalLoadingCache.getUnchecked(LocalCache.java:4827) [guava-17.0.jar:?]
at com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService.fillProfileProperties(YggdrasilMinecraftSessionService.java:148) [YggdrasilMinecraftSessionService.class:?]
at net.minecraft.client.resources.SkinManager$3.run(SkinManager.java:138) [skinManager$3.class:?]
at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source) [?:1.8.0_31]
at java.util.concurrent.FutureTask.run(Unknown Source) [?:1.8.0_31]
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source) [?:1.8.0_31]
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source) [?:1.8.0_31]
at java.lang.Thread.run(Unknown Source) [?:1.8.0_31]
[10:21:22] [server thread/FATAL] [FML]: Exception caught executing FutureTask: java.util.concurrent.ExecutionException: java.lang.ArrayIndexOutOfBoundsException: 3
java.util.concurrent.ExecutionException: java.lang.ArrayIndexOutOfBoundsException: 3
at java.util.concurrent.FutureTask.report(Unknown Source) ~[?:1.8.0_31]
at java.util.concurrent.FutureTask.get(Unknown Source) ~[?:1.8.0_31]
at net.minecraftforge.fml.common.FMLCommonHandler.callFuture(FMLCommonHandler.java:715) [FMLCommonHandler.class:?]
at net.minecraft.server.MinecraftServer.updateTimeLightAndEntities(MinecraftServer.java:727) [MinecraftServer.class:?]
at net.minecraft.server.MinecraftServer.tick(MinecraftServer.java:669) [MinecraftServer.class:?]
at net.minecraft.server.integrated.IntegratedServer.tick(IntegratedServer.java:171) [integratedServer.class:?]
at net.minecraft.server.MinecraftServer.run(MinecraftServer.java:540) [MinecraftServer.class:?]
at java.lang.Thread.run(Unknown Source) [?:1.8.0_31]
Caused by: java.lang.ArrayIndexOutOfBoundsException: 3
at com.mod.gui.boiler.TileNuclearBoiler.getStackInSlot(TileNuclearBoiler.java:354) ~[TileNuclearBoiler.class:?]
at net.minecraft.inventory.Slot.getStack(Slot.java:79) ~[slot.class:?]
at net.minecraft.inventory.Container.getInventory(Container.java:75) ~[Container.class:?]
at net.minecraft.inventory.Container.addCraftingToCrafters(Container.java:61) ~[Container.class:?]
at net.minecraftforge.fml.common.network.internal.FMLNetworkHandler.openGui(FMLNetworkHandler.java:92) ~[FMLNetworkHandler.class:?]
at net.minecraft.entity.player.EntityPlayer.openGui(EntityPlayer.java:2577) ~[EntityPlayer.class:?]
at com.mod.gui.boiler.NuclearBoiler.onBlockActivated(NuclearBoiler.java:44) ~[NuclearBoiler.class:?]
at net.minecraft.server.management.ItemInWorldManager.activateBlockOrUseItem(ItemInWorldManager.java:476) ~[itemInWorldManager.class:?]
at net.minecraft.network.NetHandlerPlayServer.processPlayerBlockPlacement(NetHandlerPlayServer.java:624) ~[NetHandlerPlayServer.class:?]
at net.minecraft.network.play.client.C08PacketPlayerBlockPlacement.processPacket(C08PacketPlayerBlockPlacement.java:67) ~[C08PacketPlayerBlockPlacement.class:?]
at net.minecraft.network.play.client.C08PacketPlayerBlockPlacement.processPacket(C08PacketPlayerBlockPlacement.java:114) ~[C08PacketPlayerBlockPlacement.class:?]
at net.minecraft.network.PacketThreadUtil$1.run(PacketThreadUtil.java:24) ~[PacketThreadUtil$1.class:?]
at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source) ~[?:1.8.0_31]
at java.util.concurrent.FutureTask.run(Unknown Source) ~[?:1.8.0_31]
at net.minecraftforge.fml.common.FMLCommonHandler.callFuture(FMLCommonHandler.java:714) ~[FMLCommonHandler.class:?]
... 5 more
[10:21:22] [server thread/ERROR]: Encountered an unexpected exception
net.minecraft.util.ReportedException: Ticking entity
at net.minecraft.server.MinecraftServer.updateTimeLightAndEntities(MinecraftServer.java:781) ~[MinecraftServer.class:?]
at net.minecraft.server.MinecraftServer.tick(MinecraftServer.java:669) ~[MinecraftServer.class:?]
at net.minecraft.server.integrated.IntegratedServer.tick(IntegratedServer.java:171) ~[integratedServer.class:?]
at net.minecraft.server.MinecraftServer.run(MinecraftServer.java:540) [MinecraftServer.class:?]
at java.lang.Thread.run(Unknown Source) [?:1.8.0_31]
Caused by: java.lang.ArrayIndexOutOfBoundsException: 3
at com.mod.gui.boiler.TileNuclearBoiler.getStackInSlot(TileNuclearBoiler.java:354) ~[TileNuclearBoiler.class:?]
at net.minecraft.inventory.Slot.getStack(Slot.java:79) ~[slot.class:?]
at net.minecraft.inventory.Container.detectAndSendChanges(Container.java:97) ~[Container.class:?]
at com.mod.gui.boiler.ContainerNuclearBoiler.detectAndSendChanges(ContainerNuclearBoiler.java:196) ~[ContainerNuclearBoiler.class:?]
at net.minecraft.entity.player.EntityPlayerMP.onUpdate(EntityPlayerMP.java:263) ~[EntityPlayerMP.class:?]
at net.minecraft.world.World.updateEntityWithOptionalForce(World.java:2031) ~[World.class:?]
at net.minecraft.world.WorldServer.updateEntityWithOptionalForce(WorldServer.java:758) ~[WorldServer.class:?]
at net.minecraft.world.World.updateEntity(World.java:1997) ~[World.class:?]
at net.minecraft.world.World.updateEntities(World.java:1823) ~[World.class:?]
at net.minecraft.world.WorldServer.updateEntities(WorldServer.java:587) ~[WorldServer.class:?]
at net.minecraft.server.MinecraftServer.updateTimeLightAndEntities(MinecraftServer.java:775) ~[MinecraftServer.class:?]
... 4 more
[10:21:22] [server thread/ERROR]: This crash report has been saved to: C:\Users\student\Desktop\Lucas B\forge-1.8-11.14.3.1449-src\eclipse\.\crash-reports\crash-2015-06-19_10.21.22-server.txt
[10:21:22] [server thread/INFO]: Stopping server
[10:21:22] [server thread/INFO]: Saving players
[10:21:23] [server thread/INFO]: Saving worlds
[10:21:23] [server thread/INFO]: Saving chunks for level 'Swag'/Overworld
[10:21:23] [server thread/INFO]: Saving chunks for level 'Swag'/Nether
[10:21:23] [server thread/INFO]: Saving chunks for level 'Swag'/The End
[10:21:23] [server thread/INFO] [FML]: Unloading dimension 0
[10:21:23] [server thread/INFO] [FML]: Unloading dimension -1
[10:21:23] [server thread/INFO] [FML]: Unloading dimension 1
[10:21:23] [server thread/INFO] [FML]: Applying holder lookups
[10:21:23] [server thread/INFO] [FML]: Holder lookups applied
[10:21:23] [server thread/INFO] [FML]: The state engine was in incorrect state SERVER_STOPPING and forced into state SERVER_STOPPED. Errors may have been discarded.

Sup bruh.

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

 Share



×
×
  • Create New...

Important Information

By using this site, you agree to our Privacy Policy.