Java ToolCore类代码示例

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@Override
public boolean beforeBlockBreak (ToolCore tool, ItemStack stack, int x, int y, int z, EntityLivingBase entity)
{
	try{
		NBTTagCompound tags = stack.getTagCompound().getCompoundTag("InfiTool");

		if (entity instanceof EntityPlayer && ((EntityPlayer) entity).capabilities.isCreativeMode)
			return false;
		boolean rValue = false;
		for(ItemModifier mod : ModifyBuilder.instance.itemModifiers)
			if(mod instanceof TActiveMod && tags.hasKey(mod.key))
				if(((TActiveMod) mod).midStreamModify(tool, tags, stack, x, y, z, entity))
					rValue = true;

		return rValue;
	}
	catch(Throwable th){}
	return false;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@Override
protected boolean canModify (ItemStack tool, ItemStack[] input)
{
    if (tool.getItem() instanceof ToolCore)
    {
        ToolCore toolItem = (ToolCore) tool.getItem();
        if (!validType(toolItem))
            return false;

        if (matchingAmount(input) > max)
            return false;

        NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool");
        if (!tags.hasKey(key))
            return tags.getInteger("Modifiers") > 0 && matchingAmount(input) <= max;

        int keyPair[] = tags.getIntArray(key);

        if (keyPair[0] + matchingAmount(input) <= keyPair[1])
            return true;
        else if (keyPair[0] == keyPair[1])
            return tags.getInteger("Modifiers") > 0;
    }

    return false;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
public void updateTool (ToolCore tool, NBTTagCompound tags, ItemStack stack, World world, Entity entity)
{
    if (!world.isRemote && entity instanceof EntityLivingBase && !((EntityLivingBase) entity).isSwingInProgress && stack.getTagCompound() != null)
    {
        if (tags.hasKey(key))
        {
            int chance = tags.getInteger(key) / max;
            int check = world.canBlockSeeTheSky((int) entity.posX, (int) entity.posY, (int) entity.posZ) ? 350 : 1150;
            // REGROWING AMMO :OOoo
            if(tool instanceof IAmmo && random.nextInt(check*3) < chance) // ammo regenerates at a much slower rate
            {
                IAmmo ammothing = (IAmmo)tool;
                if(ammothing.getAmmoCount(stack) > 0) // must have ammo
                    ammothing.addAmmo(1, stack);
            }
            // selfrepairing tool. LAAAAAME
            else if (random.nextInt(check) < chance)
            {
                AbilityHelper.healTool(stack, 1, (EntityLivingBase) entity, true);
            }
        }
    }
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@SubscribeEvent
public void handleBedrockMod(final ToolCraftedEvent event) {
    if (!(event.tool.getItem() instanceof ToolCore)) {
        return;
    }
    final NBTTagCompound tag = event.tool.getTagCompound();
    if (tag == null) {
        return;
    }
    this.assignProperSlowness(tag);
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@Override
public int postDamage(int modDamage, int currentDamage, ToolCore tool,
		NBTTagCompound tags, NBTTagCompound toolTags, ItemStack stack,
		EntityLivingBase player, Entity entity) {
	// TODO Auto-generated method stub
	return 0;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@Override
public void modify(ItemStack[] recipe, ItemStack tool) {
	super.modify(recipe, tool);
	NBTTagCompound tags = tool.getTagCompound();

       // update modifiers (only applies if it's not an upgrade)
       if (!tags.hasKey(key))
       {
           int modifiers = tags.getCompoundTag("InfiTool").getInteger("Modifiers");
           modifiers -= 1;
           tags.getCompoundTag("InfiTool").setInteger("Modifiers", modifiers);
       }

       tags.getCompoundTag("InfiTool").setBoolean(key, true);

       // set the charge values
       int charge = currEnergy;

       // add already present charge in the tool
       if (tags.hasKey("Energy"))
           charge += tags.getInteger("Energy");
       int maxCharge = maxEnergy;

       int maxExtract = extractionRate;
       int maxReceive = receiveRate;

       // make sure we don't overcharge
       charge = Math.min(charge, maxCharge);

       tags.setInteger("Energy", charge);
       tags.setInteger("EnergyMax", maxCharge);
       tags.setInteger("EnergyExtractionRate", maxExtract);
       tags.setInteger("EnergyReceiveRate", maxReceive);

       tags.setInteger(key, 1);
       ToolCore toolcore = (ToolCore) tool.getItem();
       //tool.setItemDamage(1 + (toolcore.getMaxEnergyStored(tool) - charge) * (tool.getMaxDamage() - 1) / toolcore.getMaxEnergyStored(tool));
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@Override
protected boolean canModify (ItemStack tool, ItemStack[] input)
{
	if (tool.getItem() instanceof ToolCore)
	{
		ToolCore toolItem = (ToolCore) tool.getItem();
		if (!validType(toolItem))
			return false;

		if (matchingAmount(input) > max)
			return false;

		NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool");

		if (TModifiers.hasProperty(tags, ModProperty.SILK_TOUCH) && !withSilktouch)
			return false;

		if (TModifiers.hasProperty(tags, ModProperty.AUTOSMELT) && !withAutosmelt)
			return false;

		if (!tags.hasKey(key))
			return tags.getInteger("Modifiers") > 0 && matchingAmount(input) <= max;

			int keyPair[] = tags.getIntArray(key);
			if (keyPair[0] + matchingAmount(input) <= max)
				return true;
	}
	return false;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@Override
public int postDamage(int modDamage, int currentDamage, ToolCore tool,
		NBTTagCompound tags, NBTTagCompound toolTags, ItemStack stack,
		EntityLivingBase player, Entity entity) {
	int level = tags.getInteger(key) / max;
	player.heal(level);
	return 0;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
public boolean validType (ToolCore tool)
{
	List list = Arrays.asList(tool.getTraits());

	for(String type : validTypes)
		if(list.contains(type))
			return true;
	return validTypes.length == 0;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
public boolean validType (ToolCore tool)
{
    List list = Arrays.asList(tool.getTraits());

    // handled by the windup modifier
    if(list.contains("windup"))
        return false;
    return list.contains("harvest") || list.contains("utility");
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@Override
public int postDamage(int modDamage, int currentDamage, ToolCore tool,
		NBTTagCompound tags, NBTTagCompound toolTags, ItemStack stack,
		EntityLivingBase player, Entity entity) {
	int level = toolTags.getInteger(key) / max;
	entity.setFire(level * 5);
	return 0;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
public void updateTool (ToolCore tool, ItemStack stack, World world, Entity entity)
{
	try{
		NBTTagCompound tags = stack.getTagCompound().getCompoundTag("InfiTool");

		for(ItemModifier mod : ModifyBuilder.instance.itemModifiers)
			if(mod instanceof TActiveMod && tags.hasKey(mod.key))
				((TActiveMod) mod).updateTool(tool, tags, stack, world, entity);
	}
	catch(Throwable th){}
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
public int baseAttackDamage (int earlyModDamage, int damage, ToolCore tool, NBTTagCompound tags, NBTTagCompound toolTags, ItemStack stack, EntityLivingBase player, Entity entity)
{
	try{
	}
	catch(Throwable th){}
	return earlyModDamage;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
public boolean midStreamModify (ToolCore toolItem, NBTTagCompound nbtTags, ItemStack tool, int x, int y, int z, EntityLivingBase entity)
{
	NBTTagCompound tags = nbtTags;
	if (!tags.hasKey(key))
		return false;

	int keyPair[] = tags.getIntArray(key);
	if (keyPair[0] == max)
		return false;

	if (random.nextInt(50) == 0)
	{
		keyPair[0] += 1;
		tags.setIntArray(key, keyPair);
		updateModTag(tool, keyPair);
	}

	List list = Arrays.asList(toolItem.getTraits());
	if (list.contains("weapon"))
		for(int i = luckValues.length - 1; i >= 0; i--)
			if(keyPair[0] >= luckValues[i])
			{
				addEnchantment(tool, Enchantment.looting, i + 1);
				break;
			}

	if (list.contains("harvest"))
		for(int i = luckValues.length - 1; i >= 0; i--)
			if(keyPair[0] >= luckValues[i])
			{
				addEnchantment(tool, Enchantment.fortune, i + 1);
				break;
			}
	return false;
}
 

import tconstruct.library.tools.ToolCore; //导入依赖的package包/类
@Override
public boolean matches (ItemStack[] input, ItemStack tool)
{
    NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool");

    // not on ammo weapons, since they don't have durability technically
    String[] traits = ((IModifyable) tool.getItem()).getTraits();
    for(String trait : traits)
        if("ammo".equals(trait))
            return false;

    if(!super.matches(input, tool))
    	return false;

    // battery too big for our tool?
    if(PHConstruct.balancedFluxModifier && tags.getInteger("TotalDurability") < maxEnergy/1000) // durability needs to be at least 1/1000th of the charge
        return false;

    // check if we already have a flux modifier
    if (tags.getBoolean(key))
    {
        // only allow if it's an upgrade
        // remark: we use the ToolCores function here instead of accessing the tag directly, to achieve backwards compatibility with tools without tags.
        int a = maxEnergy;
        int b = ((ToolCore) tool.getItem()).getMaxEnergyStored(tool);
        return a > b;
    }
    // otherwise check if we have enough modfiers
    else if (tags.getInteger("Modifiers") < 1)
        return false;

    // all requirements satisfied!
    return true;
}