687 lines
16 KiB
Java
687 lines
16 KiB
Java
package tinker.tconstruct.tools;
|
|
|
|
import ic2.api.IBoxable;
|
|
import ic2.api.ICustomElectricItem;
|
|
|
|
import java.util.List;
|
|
import java.util.Random;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.creativetab.CreativeTabs;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityLiving;
|
|
import net.minecraft.entity.item.EntityItem;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.EnumToolMaterial;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.item.crafting.FurnaceRecipes;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.MinecraftForge;
|
|
import tinker.tconstruct.AbilityHelper;
|
|
import tinker.tconstruct.TConstruct;
|
|
import tinker.tconstruct.TConstructContent;
|
|
import tinker.tconstruct.crafting.ToolBuilder;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
|
|
/* NBTTags
|
|
* Main tag - InfiTool
|
|
*
|
|
* Required:
|
|
* Head: Render tag, above the handle
|
|
* Handle: Render tag, bottom layer
|
|
*
|
|
* Damage: Replacement for metadata
|
|
* MaxDamage: ItemStacks only read setMaxDamage()
|
|
* Broken: Represents whether the tool is broken (boolean)
|
|
* Attack: How much damage a mob will take
|
|
*
|
|
* Others:
|
|
* Accessory: Render tag, above head. Sword guards, binding, etc
|
|
* Effects: Render tag, top layer. Fancy effects like moss or diamond edge.
|
|
* Render order: Handle > Head > Accessory > Effect1 > Effect2 > Effect3
|
|
*
|
|
* Durability: 10% chance to not use damage per level
|
|
* Shoddy: Mines slower, does more damage
|
|
* Spiny: Mines faster, does less damage
|
|
* Awareness: Glows in the presence of mobs
|
|
*/
|
|
|
|
public abstract class ToolCore extends Item
|
|
implements ICustomElectricItem, IBoxable//, IItemElectric
|
|
{
|
|
Random random = new Random();
|
|
String toolTexture;
|
|
public int damageVsEntity;
|
|
|
|
public ToolCore(int itemID, int baseDamage, String texture)
|
|
{
|
|
super(itemID);
|
|
this.maxStackSize = 1;
|
|
this.setMaxDamage(100);
|
|
this.setItemName("InfiTool");
|
|
this.setCreativeTab(TConstruct.toolTab);
|
|
toolTexture = texture;
|
|
damageVsEntity = baseDamage;
|
|
}
|
|
|
|
/** Determines what type of heads the tool has.
|
|
* 0: no heads
|
|
* 1: one head
|
|
* 2: two heads
|
|
* 3: Two heads, different uses
|
|
* @return The head type
|
|
*/
|
|
public abstract int getHeadType();
|
|
|
|
/* Texture */
|
|
@Override
|
|
public String getTextureFile ()
|
|
{
|
|
return toolTexture;
|
|
}
|
|
|
|
public String getToolName ()
|
|
{
|
|
return this.getClass().getSimpleName();
|
|
}
|
|
|
|
/* Rendering */
|
|
@SideOnly(Side.CLIENT)
|
|
@Override
|
|
public boolean requiresMultipleRenderPasses ()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
@Override
|
|
public int getRenderPasses (int metadata)
|
|
{
|
|
return 6;
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
@Override
|
|
public int getIconIndex (ItemStack stack, int pass)
|
|
{
|
|
if (!stack.hasTagCompound())
|
|
return 255;
|
|
|
|
NBTTagCompound tags = stack.getTagCompound();
|
|
if (tags.hasKey("InfiTool"))
|
|
{
|
|
if (pass == 0) // Handle
|
|
{
|
|
return tags.getCompoundTag("InfiTool").getInteger("RenderHandle");
|
|
}
|
|
|
|
if (pass == 1) // Head
|
|
{
|
|
if (tags.getCompoundTag("InfiTool").getBoolean("Broken"))
|
|
return tags.getCompoundTag("InfiTool").getInteger("RenderHead") + 192;
|
|
|
|
return tags.getCompoundTag("InfiTool").getInteger("RenderHead") + 64;
|
|
}
|
|
|
|
if (pass == 2) // Accessory
|
|
{
|
|
if (tags.getCompoundTag("InfiTool").hasKey("RenderAccessory"))
|
|
{
|
|
int index = tags.getCompoundTag("InfiTool").getInteger("RenderAccessory");
|
|
if (index == -1)
|
|
return 32;
|
|
return index + 32;
|
|
}
|
|
}
|
|
|
|
if (pass == 3)
|
|
{
|
|
if (tags.getCompoundTag("InfiTool").hasKey("Effect1"))
|
|
return tags.getCompoundTag("InfiTool").getInteger("Effect1") + 224;
|
|
else
|
|
return 255;
|
|
}
|
|
|
|
if (pass == 4)
|
|
{
|
|
if (tags.getCompoundTag("InfiTool").hasKey("Effect2"))
|
|
return tags.getCompoundTag("InfiTool").getInteger("Effect2") + 224;
|
|
else
|
|
return 255;
|
|
}
|
|
|
|
if (pass == 5)
|
|
{
|
|
if (tags.getCompoundTag("InfiTool").hasKey("Effect3"))
|
|
return tags.getCompoundTag("InfiTool").getInteger("Effect3") + 224;
|
|
else
|
|
return 255;
|
|
}
|
|
}
|
|
|
|
return 255; //Keep 255 blank
|
|
}
|
|
|
|
int renderDamageBar (int damage, int maxDamage, boolean broken)
|
|
{
|
|
//setTextureFile(ToolItems.craftingTexture);
|
|
if (damage == 0 || broken)
|
|
return 255;
|
|
return 240 + (damage * 13 / maxDamage);
|
|
}
|
|
|
|
/* Tags and information about the tool */
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public void addInformation (ItemStack stack, EntityPlayer player, List list, boolean par4)
|
|
{
|
|
if (!stack.hasTagCompound())
|
|
return;
|
|
|
|
NBTTagCompound tags = stack.getTagCompound();
|
|
if (tags.hasKey("charge"))
|
|
{
|
|
String color = "";
|
|
//double joules = this.getJoules(stack);
|
|
int power = tags.getInteger("charge");
|
|
|
|
if (power != 0)
|
|
{
|
|
if (power <= this.getMaxCharge() / 3)
|
|
color = "\u00a74";
|
|
else if (power > this.getMaxCharge() * 2 / 3)
|
|
color = "\u00a72";
|
|
else
|
|
color = "\u00a76";
|
|
}
|
|
|
|
String charge = new StringBuilder().append(color).append(tags.getInteger("charge")).append("/").append(getMaxCharge()).append(" En").toString();
|
|
list.add(charge);
|
|
}
|
|
if (tags.hasKey("InfiTool"))
|
|
{
|
|
boolean broken = tags.getCompoundTag("InfiTool").getBoolean("Broken");
|
|
if (broken)
|
|
list.add("\u00A7oBroken");
|
|
else
|
|
{
|
|
int head = tags.getCompoundTag("InfiTool").getInteger("Head") + 1;
|
|
int handle = tags.getCompoundTag("InfiTool").getInteger("Handle") + 1;
|
|
int binding = tags.getCompoundTag("InfiTool").getInteger("Accessory") + 1;
|
|
|
|
String headName = getAbilityNameForType(head);
|
|
if (!headName.equals(""))
|
|
list.add(getColorCodeForType(head) + headName);
|
|
|
|
String handleName = getAbilityNameForType(handle);
|
|
if (!handleName.equals("") && handle != head)
|
|
list.add(getColorCodeForType(handle) + handleName);
|
|
|
|
String bindingName = getAbilityNameForType(binding);
|
|
if (!bindingName.equals("") && binding != head && binding != handle)
|
|
list.add(getColorCodeForType(binding) + bindingName);
|
|
|
|
String reinforced = getReinforcedName(head, handle, binding);
|
|
if (!reinforced.equals(""))
|
|
list.add(reinforced);
|
|
|
|
boolean displayToolTips = true;
|
|
int tipNum = 0;
|
|
while (displayToolTips)
|
|
{
|
|
tipNum++;
|
|
String tooltip = "Tooltip"+tipNum;
|
|
if (tags.getCompoundTag("InfiTool").hasKey(tooltip))
|
|
{
|
|
String tipName = tags.getCompoundTag("InfiTool").getString(tooltip);
|
|
if (!tipName.equals(""))
|
|
list.add(tipName);
|
|
}
|
|
else
|
|
displayToolTips = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static String getColorCodeForType (int type)
|
|
{
|
|
String colorCode = "\u00A7";
|
|
switch (type)
|
|
{
|
|
case 1:
|
|
return colorCode + "e"; //Wood
|
|
case 2:
|
|
return ""; //Stone
|
|
case 3:
|
|
return colorCode + "f"; //Iron
|
|
case 4:
|
|
return colorCode + "8"; //Flint
|
|
case 5:
|
|
return colorCode + "2"; //Cactus
|
|
case 6:
|
|
return colorCode + "e"; //Bone
|
|
case 7:
|
|
return colorCode + "d"; //Obsidian
|
|
case 8:
|
|
return colorCode + "4"; //Netherrack
|
|
case 9:
|
|
return colorCode + "a"; //Slime
|
|
case 10:
|
|
return colorCode + "f"; //Paper
|
|
case 11:
|
|
return colorCode + "3"; //Cobalt
|
|
case 12:
|
|
return colorCode + "4"; //Ardite
|
|
case 13:
|
|
return colorCode + "5"; //Manyullyn
|
|
}
|
|
return colorCode;
|
|
}
|
|
|
|
public String getAbilityNameForType (int type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case 1:
|
|
return ""; //Wood
|
|
case 2:
|
|
return "Shoddy"; //Stone
|
|
case 3:
|
|
return ""; //Iron
|
|
case 4:
|
|
return "Shoddy"; //Flint
|
|
case 5:
|
|
return "Spiny"; //Cactus
|
|
case 6:
|
|
return ""; //Bone
|
|
case 7:
|
|
return ""; //Obsidian
|
|
case 8:
|
|
return "Shoddy"; //Netherrack
|
|
case 9:
|
|
return ""; //Slime
|
|
case 10:
|
|
return "Writable"; //Paper
|
|
case 11:
|
|
return ""; //Cobalt
|
|
case 12:
|
|
return ""; //Ardite
|
|
case 13:
|
|
return "Awareness"; //Manyullyn
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
//This method is temporary
|
|
public static String getReinforcedName(int head, int handle, int accessory)
|
|
{
|
|
if (head == 7 || handle == 7 || accessory == 7)
|
|
return "\u00A7dReinforced III";
|
|
else if (head == 11 || handle == 11 || accessory == 11)
|
|
return "\u00A73Reinforced II";
|
|
else if (head == 3 || handle == 3 || accessory == 3)
|
|
return "\u00A7fReinforced I";
|
|
return "";
|
|
}
|
|
|
|
static String[] toolMaterialNames = {
|
|
"Wooden ", "Stone ", "Iron ", "Flint ", "Cactus ", "Bone ", "Obsidian ", "Nethrrack ", "Slime ", "Paper ", "Cobalt ", "Ardite ", "Manyullyn "
|
|
};
|
|
|
|
/* Creative mode tools */
|
|
public void getSubItems (int id, CreativeTabs tab, List list)
|
|
{
|
|
for (int i = 0; i < 13; i++)
|
|
{
|
|
Item accessory = getAccessoryItem();
|
|
ItemStack accessoryStack = accessory != null ? new ItemStack(getAccessoryItem(), 1, i) : null;
|
|
ItemStack tool = ToolBuilder.instance.buildTool(new ItemStack(getHeadItem(), 1, i), new ItemStack(getHandleItem(), 1, i), accessoryStack, toolMaterialNames[i]+getToolName());
|
|
tool.getTagCompound().getCompoundTag("InfiTool").setBoolean("Built", true);
|
|
list.add( tool );
|
|
}
|
|
}
|
|
|
|
protected abstract Item getHeadItem();
|
|
protected abstract Item getAccessoryItem();
|
|
|
|
protected Item getHandleItem()
|
|
{
|
|
return TConstructContent.toolRod;
|
|
}
|
|
|
|
public void onUpdate(ItemStack stack, World world, Entity entity, int par4, boolean par5)
|
|
{
|
|
if (entity instanceof EntityLiving)
|
|
{
|
|
NBTTagCompound tags = stack.getTagCompound().getCompoundTag("InfiTool");
|
|
if (tags.hasKey("Moss"))
|
|
{
|
|
int chance = tags.getInteger("Moss");
|
|
if (random.nextInt(200) < chance)
|
|
{
|
|
AbilityHelper.damageTool(stack, -1, (EntityLiving)entity, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Tool uses */
|
|
@Override
|
|
public boolean onBlockStartBreak(ItemStack stack, int x, int y, int z, EntityPlayer player)
|
|
{
|
|
NBTTagCompound tags = stack.getTagCompound().getCompoundTag("InfiTool");
|
|
World world = player.worldObj;
|
|
int bID = player.worldObj.getBlockId(x, y, z);
|
|
int meta = world.getBlockMetadata(x, y, z);
|
|
Block block = Block.blocksList[bID];
|
|
|
|
if (tags.getBoolean("Lava") && block.quantityDropped(meta, 0, random) != 0)
|
|
{
|
|
ItemStack result = FurnaceRecipes.smelting().getSmeltingResult(new ItemStack(bID, 1, meta));
|
|
if (result == null)
|
|
result = FurnaceRecipes.smelting().getSmeltingResult(new ItemStack(block.idDropped(bID, random, 0), 1, block.damageDropped(meta)));
|
|
if (result != null)
|
|
{
|
|
System.out.println("Woo~");
|
|
world.setBlockWithNotify(x, y, z, 0);
|
|
if (!player.capabilities.isCreativeMode)
|
|
onBlockDestroyed(stack, world, bID, x, y, z, player);
|
|
if (!world.isRemote)
|
|
{
|
|
EntityItem entityitem = new EntityItem(world, x+0.5, y+0.5, z+0.5, result.copy());
|
|
|
|
entityitem.delayBeforeCanPickup = 10;
|
|
world.spawnEntityInWorld(entityitem);
|
|
world.playAuxSFX(2001, x, y, z, bID + (meta << 12));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onBlockDestroyed (ItemStack itemstack, World world, int bID, int x, int y, int z, EntityLiving player)
|
|
{
|
|
return AbilityHelper.onBlockChanged(itemstack, world, bID, x, y, z, player, random);
|
|
}
|
|
|
|
@Override
|
|
public boolean hitEntity (ItemStack stack, EntityLiving mob, EntityLiving player)
|
|
{
|
|
AbilityHelper.hitEntity(stack, mob, player);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public float getStrVsBlock (ItemStack stack, Block block, int meta)
|
|
{
|
|
NBTTagCompound tags = stack.getTagCompound();
|
|
if (tags.getCompoundTag("InfiTool").getBoolean("Broken"))
|
|
return 0.1f;
|
|
return 1f;
|
|
}
|
|
|
|
//Vanilla repairs
|
|
public boolean isItemTool (ItemStack par1ItemStack)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//Complete override of attacking
|
|
/*public boolean onLeftClickEntity(ItemStack stack, EntityPlayer player, Entity entity)
|
|
{
|
|
return true;
|
|
}*/
|
|
|
|
public int getDamageVsEntity(Entity par1Entity)
|
|
{
|
|
return this.damageVsEntity;
|
|
}
|
|
|
|
/* Enchanting */
|
|
public int getItemEnchantability ()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//Changes how much durability the base tool has
|
|
public float getDurabilityModifier ()
|
|
{
|
|
return 1f;
|
|
}
|
|
|
|
public boolean isFull3D()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* IC2 Support
|
|
* Every tool can be an electric tool if you modify it right
|
|
*/
|
|
@Override
|
|
public boolean canBeStoredInToolbox (ItemStack itemstack)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean canProvideEnergy ()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public int getChargedItemId ()
|
|
{
|
|
return this.itemID;
|
|
}
|
|
|
|
@Override
|
|
public int getEmptyItemId ()
|
|
{
|
|
return this.itemID;
|
|
}
|
|
|
|
@Override
|
|
public int getMaxCharge ()
|
|
{
|
|
return 10000;
|
|
}
|
|
|
|
@Override
|
|
public int getTier ()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int getTransferLimit ()
|
|
{
|
|
return 32;
|
|
}
|
|
|
|
@Override
|
|
public int charge (ItemStack stack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate)
|
|
{
|
|
NBTTagCompound tags = stack.getTagCompound();
|
|
if (!tags.hasKey("charge")) //|| !tags.getCompoundTag("InfiTool").getBoolean("Electric"))
|
|
return 0;
|
|
|
|
if (amount > 0)
|
|
{
|
|
if (amount > getTransferLimit() && !ignoreTransferLimit)
|
|
{
|
|
amount = getTransferLimit();
|
|
}
|
|
|
|
int charge = tags.getInteger("charge");
|
|
|
|
if (amount > getMaxCharge() - charge)
|
|
{
|
|
amount = getMaxCharge() - charge;
|
|
}
|
|
|
|
charge += amount;
|
|
|
|
if (!simulate)
|
|
{
|
|
tags.setInteger("charge", charge);
|
|
stack.setItemDamage(1 + (getMaxCharge() - charge) * (stack.getMaxDamage() - 2) / getMaxCharge());
|
|
}
|
|
|
|
return amount;
|
|
}
|
|
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int discharge (ItemStack stack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate)
|
|
{
|
|
NBTTagCompound tags = stack.getTagCompound();
|
|
if (!tags.hasKey("charge"))// || !tags.getCompoundTag("InfiTool").getBoolean("Electric"))
|
|
return 0;
|
|
|
|
if (amount > 0)
|
|
{
|
|
if (amount > getTransferLimit() && !ignoreTransferLimit)
|
|
{
|
|
amount = getTransferLimit();
|
|
}
|
|
|
|
int charge = tags.getInteger("charge");
|
|
|
|
if (amount > charge)
|
|
{
|
|
amount = charge;
|
|
}
|
|
|
|
charge -= amount;
|
|
|
|
if (!simulate)
|
|
{
|
|
tags.setInteger("charge", charge);
|
|
stack.setItemDamage(1 + (getMaxCharge() - charge) * (stack.getMaxDamage() - 1) / getMaxCharge());
|
|
}
|
|
|
|
return amount;
|
|
}
|
|
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean canUse (ItemStack itemStack, int amount)
|
|
{
|
|
//TODO: Investigate this
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canShowChargeToolTip (ItemStack itemStack)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/* Universal Electricity Support
|
|
* Temporarily disabled due to bugginess
|
|
*/
|
|
|
|
/*@Override
|
|
public double getJoules (Object... data)
|
|
{
|
|
if (data[0] instanceof ItemStack)
|
|
{
|
|
ItemStack itemStack = (ItemStack) data[0];
|
|
|
|
if (itemStack.stackTagCompound == null) { return 0; }
|
|
int electricityStored = itemStack.stackTagCompound.getInteger("charge");
|
|
//itemStack.setItemDamage((int) (getMaxJoules(itemStack) - electricityStored));
|
|
itemStack.setItemDamage((int) (1 + (getMaxCharge() - electricityStored) * (itemStack.getMaxDamage() - 1) / getMaxCharge()));
|
|
return electricityStored;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
@Override
|
|
public void setJoules (double joules, Object... data)
|
|
{
|
|
if (data[0] instanceof ItemStack)
|
|
{
|
|
ItemStack itemStack = (ItemStack) data[0];
|
|
|
|
if (itemStack.stackTagCompound == null)
|
|
{
|
|
itemStack.setTagCompound(new NBTTagCompound());
|
|
}
|
|
|
|
double electricityStored = ( Math.max(Math.min(joules, this.getMaxJoules(itemStack)), 0) );
|
|
itemStack.stackTagCompound.setInteger("charge", (int) electricityStored);
|
|
//itemStack.setItemDamage((int) (getMaxJoules() - electricityStored));
|
|
itemStack.setItemDamage((int) (1 + (getMaxCharge() - electricityStored) * (itemStack.getMaxDamage() - 1) / getMaxCharge()));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public double getMaxJoules (Object... data)
|
|
{
|
|
return 10000;
|
|
}
|
|
|
|
@Override
|
|
public double getVoltage ()
|
|
{
|
|
return 120;
|
|
}
|
|
|
|
@Override
|
|
public double onReceive (double amps, double voltage, ItemStack itemStack)
|
|
{
|
|
double rejectedElectricity = Math.max((this.getJoules(itemStack) + this.getJoules(amps, voltage, 1)) - this.getMaxJoules(itemStack), 0);
|
|
this.setJoules(this.getJoules(itemStack) + this.getJoules(amps, voltage, 1) - rejectedElectricity, itemStack);
|
|
return rejectedElectricity;
|
|
}
|
|
|
|
public static double getJoules(double amps, double voltage, double seconds)
|
|
{
|
|
return amps * voltage * seconds;
|
|
}
|
|
|
|
@Override
|
|
public double onUse (double joulesNeeded, ItemStack itemStack)
|
|
{
|
|
double electricityToUse = Math.min(this.getJoules(itemStack), joulesNeeded);
|
|
this.setJoules(this.getJoules(itemStack) - electricityToUse, itemStack);
|
|
return electricityToUse;
|
|
}
|
|
|
|
@Override
|
|
public boolean canReceiveElectricity ()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean canProduceElectricity ()
|
|
{
|
|
return true;
|
|
}*/
|
|
}
|