[1.7.2][Solved?]Block stopping to tick?

[Nimbleguy]

For some reason my block randomly stops ticking, and I need to keep it ticking.

TileEntityVoidWalker:

 

 

package aj.Java.Nullvoid.tileentity;

 

import java.io.IOException;

import java.util.List;

 

import cpw.mods.fml.client.FMLClientHandler;

import aj.Java.Nullvoid.VoidMod;

import aj.Java.Nullvoid.Dimention.TeleporterNullVoid;

import net.minecraft.client.Minecraft;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.entity.player.EntityPlayerMP;

import net.minecraft.inventory.IInventory;

import net.minecraft.inventory.Slot;

import net.minecraft.item.ItemStack;

import net.minecraft.nbt.NBTTagCompound;

import net.minecraft.nbt.NBTTagList;

import net.minecraft.server.MinecraftServer;

import net.minecraft.tileentity.TileEntity;

import net.minecraft.util.AxisAlignedBB;

import net.minecraft.util.ChatComponentText;

import net.minecraft.world.MinecraftException;

import net.minecraft.world.World;

import net.minecraft.world.chunk.Chunk;

import net.minecraft.world.chunk.storage.IChunkLoader;

 

public class TileEntityVoidWalker extends TileEntity implements IInventory,

IChunkLoader {

private ItemStack[] inv;

public Slot[] slots = new Slot[4];

private String playername = "";

private int timer = 0;

private int itimer = 0;

private boolean doITimer = false;

private boolean doTimer = false;

 

public TileEntityVoidWalker() {

inv = new ItemStack[5];

}

 

/**

* @Override public void onChunkUnload() { this.worldObj.getChunkProvider()

*          .loadChunk( this.worldObj.getChunkFromBlockCoords(this.xCoord,

*          this.zCoord).xPosition,

*          this.worldObj.getChunkFromBlockCoords(this.xCoord,

*          this.zCoord).zPosition); }

*/

@Override

public int getSizeInventory() {

// TODO Auto-generated method stub

return inv.length;

}

 

@Override

public ItemStack getStackInSlot(int i) {

// TODO Auto-generated method stub

return inv;

}

 

@Override

public ItemStack decrStackSize(int i, int j) {

ItemStack itemstack = getStackInSlot(i);

if (itemstack != null) {

if (itemstack.stackSize <= j) {

setInventorySlotContents(i, null);

} else {

itemstack = itemstack.splitStack(j);

}

}

return itemstack;

}

 

@Override

public ItemStack getStackInSlotOnClosing(int i) {

ItemStack itemstack = getStackInSlot(i);

setInventorySlotContents(i, null);

return itemstack;

}

 

@Override

public void setInventorySlotContents(int i, ItemStack itemstack) {

inv = itemstack;

 

if (itemstack != null && itemstack.stackSize > getInventoryStackLimit()) {

itemstack.stackSize = getInventoryStackLimit();

}

 

}

 

@Override

public int getInventoryStackLimit() {

// TODO Auto-generated method stub

return 256;

}

 

@Override

public boolean isUseableByPlayer(EntityPlayer entityplayer) {

// TODO Auto-generated method stub

return entityplayer.getDistanceSq(xCoord + 0.5D, yCoord + 0.5D,

zCoord + 0.5D) <= 64;

}

 

@Override

public boolean isItemValidForSlot(int i, ItemStack itemstack) {

switch (i) {

case 0:

if (itemstack.getItem().equals(VoidMod.ingotNull)) {

return true;

} else {

return false;

}

case 1:

if (itemstack.getItem().equals(VoidMod.ingotNull)) {

return true;

} else {

return false;

}

case 2:

if (itemstack.getItem().equals(VoidMod.ingotNull)) {

return true;

} else {

return false;

}

case 3:

if (itemstack.getItem().equals(VoidMod.circuts)) {

if (itemstack.getItemDamage() == 4) {

return true;

} else {

return false;

}

} else {

return false;

}

default:

return false;

}

}

 

@Override

public void writeToNBT(NBTTagCompound compound) {

super.writeToNBT(compound);

 

NBTTagList list = new NBTTagList();

 

for (int i = 0; i < getSizeInventory(); i++) {

ItemStack itemstack = getStackInSlot(i);

 

if (itemstack != null) {

NBTTagCompound item = new NBTTagCompound();

 

item.setByte("SlotVoidWalker", (byte) i);

item = itemstack.writeToNBT(item);

list.appendTag(item);

}

}

compound.setTag("ItemsVoidWalker", list);

compound.setString("PlayerInVoid", playername);

compound.setBoolean("doITimer", doITimer);

compound.setBoolean("doTimer", doTimer);

compound.setInteger("ITimer", itimer);

compound.setInteger("Timer", timer);

}

 

@Override

public void readFromNBT(NBTTagCompound compound) {

super.readFromNBT(compound);

timer = compound.getInteger("Timer");

itimer = compound.getInteger("ITimer");

doTimer = compound.getBoolean("doTimer");

doITimer = compound.getBoolean("doITimer");

playername = compound.getString("PlayerInVoid");

NBTTagList list = compound.getTagList("ItemsVoidWalker", 10);

 

for (int i = 0; i < list.tagCount(); i++) {

NBTTagCompound item = (NBTTagCompound) list.getCompoundTagAt(i);

int slot = item.getByte("SlotVoidWalker");

 

if (slot >= 0 && slot < getSizeInventory()) {

setInventorySlotContents(slot,

ItemStack.loadItemStackFromNBT(item));

}

}

}

 

@SuppressWarnings("rawtypes")

@Override

public void updateEntity() {

System.out.println("UPDATED");

if (this.worldObj.getBlockPowerInput(this.xCoord, this.yCoord,

this.zCoord) > 0) {

// System.out.println("REDSTONE");

List e = this.worldObj.getEntitiesWithinAABB(EntityPlayerMP.class,

AxisAlignedBB.getBoundingBox(xCoord - 3, yCoord - 3,

zCoord - 3, xCoord + 3, yCoord + 3, zCoord + 3));

for (int i = 0; i < e.size(); i++) {

// System.out.println("Found entity");

if (e.get(i) instanceof EntityPlayerMP) {

// System.out.println("Is a playermp");

EntityPlayerMP player = (EntityPlayerMP) e.get(i);

if (this.getStackInSlot(4) != null) {

if (this.getStackInSlot(4).getItem()

.equals(VoidMod.circuts)

&& this.getStackInSlot(4).getItemDamage() == 4) {

if (player.dimension == 0

&& playername.compareTo(player

.getDisplayName()) != 0

&& playername.compareTo("") != 0) {

MinecraftServer minecraft = FMLClientHandler

.instance().getServer();

EntityPlayerMP p = minecraft

.getConfigurationManager()

.getPlayerForUsername(playername);

if (p != null) {

if (p.dimension != VoidMod.NullVoidDimID) {

playername = "";

System.out.println("Exited");

}

}

}

if (player.dimension == 0

&& playername.compareTo("") == 0) {

// player.travelToDimension(VoidMod.NullVoidDimID);

// player.mcServer.getConfigurationManager().transferPlayerToDimension(player,

// VoidMod.NullVoidDimID);

if (player.timeUntilPortal > 0) {

player.timeUntilPortal = 10;

} else {

player.getEntityData()

.setFloat(

"NullGamma",

Minecraft.getMinecraft().gameSettings.gammaSetting);

Minecraft.getMinecraft().gameSettings.gammaSetting = -1F;

player.mcServer

.getConfigurationManager()

.transferPlayerToDimension(

player,

VoidMod.NullVoidDimID,

new TeleporterNullVoid(

player.mcServer

.worldServerForDimension(VoidMod.NullVoidDimID)));

player.timeUntilPortal = 10;

player.addStat(VoidMod.enterNull, 1);

playername = player.getDisplayName();

this.setInventorySlotContents(

4,

new ItemStack(VoidMod.circuts, 1, 0));

doITimer = true;

}

} else if (player.dimension == 0

&& (playername.compareTo(player

.getDisplayName()) == 0)) {

// player.travelToDimension(VoidMod.NullVoidDimID);

// player.mcServer.getConfigurationManager().transferPlayerToDimension(player,

// VoidMod.NullVoidDimID);

if (player.timeUntilPortal > 0) {

player.timeUntilPortal = 10;

} else {

player.getEntityData()

.setFloat(

"NullGamma",

Minecraft.getMinecraft().gameSettings.gammaSetting);

Minecraft.getMinecraft().gameSettings.gammaSetting = -1F;

player.mcServer

.getConfigurationManager()

.transferPlayerToDimension(

player,

VoidMod.NullVoidDimID,

new TeleporterNullVoid(

player.mcServer

.worldServerForDimension(VoidMod.NullVoidDimID)));

player.timeUntilPortal = 10;

player.addStat(VoidMod.enterNull, 1);

playername = player.getDisplayName();

this.setInventorySlotContents(

4,

new ItemStack(VoidMod.circuts, 1, 0));

doITimer = true;

}

} else if (player.dimension == VoidMod.NullVoidDimID) {

System.out.println("Player " + playername

+ " is in the nullvoid!");

// player.travelToDimension(0);

// player.mcServer.getConfigurationManager().transferPlayerToDimension(player,

// VoidMod.NullVoidDimID);

if (player.timeUntilPortal > 0) {

player.timeUntilPortal = 10;

} else {

Minecraft.getMinecraft().gameSettings.gammaSetting = player

.getEntityData().getFloat(

"NullGamma");

player.mcServer

.getConfigurationManager()

.transferPlayerToDimension(

player,

0,

new TeleporterNullVoid(

player.mcServer

.worldServerForDimension(0)));

player.timeUntilPortal = 10;

this.setInventorySlotContents(

4,

new ItemStack(VoidMod.circuts, 1, 0));

doITimer = true;

}

} else if (playername.compareTo(player

.getDisplayName()) != 0

&& playername.compareTo("") != 0) {

player.addChatMessage(new ChatComponentText(

"Player "

+ playername

+ " is already traversing the void!"));

}

} else {

player.addChatMessage(new ChatComponentText(

"Null cirtuit is not active!"));

}

} else {

player.addChatMessage(new ChatComponentText(

"Null circuit missing!"));

}

}

}

}

if ((timer >= 750 || itimer >= 350)) {

System.out.println("Timed");

doITimer = false;

doTimer = true;

timer = 0;

if (playername.compareTo("") != 0) {

MinecraftServer minecraft = FMLClientHandler.instance()

.getServer();

EntityPlayerMP p = minecraft.getConfigurationManager()

.getPlayerForUsername(playername);

if (p != null) {

System.out.println("Not null");

if (p.dimension == VoidMod.NullVoidDimID) {

boolean check = false;

boolean check1 = false;

boolean check2 = false;

boolean check3 = false;

if (getStackInSlot(0) != null) {

if (getStackInSlot(0).isItemEqual(

new ItemStack(VoidMod.ingotNull))) {

check = true;

check1 = true;

check2 = false;

check3 = false;

}

}

if (getStackInSlot(1) != null) {

if (getStackInSlot(1).isItemEqual(

new ItemStack(VoidMod.ingotNull))) {

check = true;

check3 = false;

check2 = true;

check1 = false;

}

}

if (getStackInSlot(2) != null) {

if (getStackInSlot(2).isItemEqual(

new ItemStack(VoidMod.ingotNull))) {

check = true;

check3 = true;

check2 = false;

check1 = false;

}

}

if (check) {

if (check3) {

this.setInventorySlotContents(3,

decrStackSize(2, 1));

} else if (check2) {

this.setInventorySlotContents(2,

decrStackSize(1, 1));

} else if (check1) {

this.setInventorySlotContents(1,

decrStackSize(0, 1));

}

doITimer = false;

doTimer = true;

timer = 0;

itimer = 0;

System.out.println("Decremented");

} else if (!check) {

Minecraft.getMinecraft().gameSettings.gammaSetting = p

.getEntityData().getFloat("NullGamma");

p.addChatMessage(new ChatComponentText(

"Out of Null Crystals! Ejecting from void to prevent harm..."));

p.mcServer

.getConfigurationManager()

.transferPlayerToDimension(

p,

0,

new TeleporterNullVoid(p.mcServer

.worldServerForDimension(0)));

p.timeUntilPortal = 10;

}

}

}

}

} else {

if (!doITimer && doTimer) {

timer++;

doITimer = false;

itimer = 0;

System.out.println("Timer " + timer);

}

if (doITimer) {

System.out.println("ITimer: " + itimer);

itimer++;

}

}

if (playername.compareTo("") == 0) {

doITimer = false;

doTimer = false;

timer = 0;

itimer = 0;

}

if (playername.compareTo("") != 0) {

MinecraftServer minecraft = FMLClientHandler.instance().getServer();

EntityPlayerMP p = minecraft.getConfigurationManager()

.getPlayerForUsername(playername);

if (p != null) {

if (p.dimension != VoidMod.NullVoidDimID) {

doITimer = false;

doTimer = false;

timer = 0;

itimer = 0;

playername = "";

}

}

}

 

}

 

@Override

public String getInventoryName() {

// TODO Auto-generated method stub

return "The Voidwalker";

}

 

@Override

public boolean hasCustomInventoryName() {

// TODO Auto-generated method stub

return true;

}

 

@Override

public void openInventory() {

// TODO Auto-generated method stub

 

}

 

@Override

public void closeInventory() {

// TODO Auto-generated method stub

 

}

 

@Override

public Chunk loadChunk(World var1, int var2, int var3) throws IOException {

return null;

}

 

@Override

public void saveChunk(World var1, Chunk var2) throws MinecraftException,

IOException {

 

}

 

@Override

public void saveExtraChunkData(World var1, Chunk var2) {

// TODO Auto-generated method stub

 

}

 

@Override

public void chunkTick() {

// TODO Auto-generated method stub

 

}

 

@Override

public void saveExtraData() {

// TODO Auto-generated method stub

 

}

 

}

 

 

BlockVoidWalker:

 

 

package aj.Java.Nullvoid.block;

 

import aj.Java.Nullvoid.VoidMod;

import aj.Java.Nullvoid.tileentity.TileEntityVoidWalker;

import net.minecraft.block.Block;

import net.minecraft.block.BlockContainer;

import net.minecraft.block.material.Material;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.tileentity.TileEntity;

import net.minecraft.world.ChunkCoordIntPair;

import net.minecraft.world.IBlockAccess;

import net.minecraft.world.World;

import net.minecraftforge.common.ForgeChunkManager;

import net.minecraftforge.common.ForgeChunkManager.Ticket;

import net.minecraftforge.common.ForgeChunkManager.Type;

 

public class BlockVoidWalker extends BlockContainer {

public Ticket ticket = null;

 

public BlockVoidWalker() {

super(Material.iron);

setCreativeTab(VoidMod.ctab);

setHardness(20F);

setResistance(40F);

}

 

@Override

public boolean onBlockActivated(World world, int x, int y, int z,

EntityPlayer player, int side, float hitX, float hitY, float hitZ) {

if (!world.isRemote) {

player.openGui(VoidMod.me, VoidMod.guiWalker, world, x, y, z);

}

return true;

}

 

@Override

public TileEntity createNewTileEntity(World var1, int var2) {

return new TileEntityVoidWalker();

}

 

@Override

public boolean canConnectRedstone(IBlockAccess world, int x, int y, int z,

int side) {

return true;

}

 

@Override

public void onBlockAdded(World world, int x, int y, int z) {

super.onBlockAdded(world, x, y, z);

this.ticket = ForgeChunkManager.requestTicket(VoidMod.me, world,

Type.NORMAL);

if (this.ticket != null) {

ForgeChunkManager.forceChunk(ForgeChunkManager.requestTicket(

VoidMod.me, world, Type.NORMAL),

new ChunkCoordIntPair(

world.getChunkFromBlockCoords(x, z).xPosition,

world.getChunkFromBlockCoords(x, z).zPosition));

}

}

 

@Override

public void breakBlock(World world, int x, int y, int z, Block block,

int meta) {

super.breakBlock(world, x, y, z, block, meta);

if (this.ticket != null) {

ForgeChunkManager.unforceChunk(ticket,

new ChunkCoordIntPair(

world.getChunkFromBlockCoords(x, z).xPosition,

world.getChunkFromBlockCoords(x, z).zPosition));

}

}

}

 

 

EDIT:It randomly stopped and now ticks properly...