protected void registerHooks(ModifierHookMap.Builder hookBuilder)

某些特殊强化的函数在“钩”内。这个函数给强化注册了“钩

”使得这些强化的函数可以被运行。

@Override
protected void registerHooks(Builder hookBuilder) {
  hookBuilder.addHook(this, TinkerHooks.PROJECTILE_HIT, TinkerHooks.CONDITIONAL_STAT);
} //给强化注册了两个钩，分别是ProjectileHitModifierHook和ConditionalStatModifierHook。
//ProjectileHitModifierHook是箭矢击中目标的钩，包含两个函数，允许触发一些特殊效果，例如给予射击者贪婪BUFF
//ConditionalStatModifierHook是工具的实时属性的钩，包含两个函数，允许改变工具的实时属性（拉弓速度等）

getPriority

public int getPriority() {
  return DEFAULT_PRIORITY; //默认优先级为100
}

优先级数值越高，强化运行越早。

在匠魂3中，不毁强化不能阻止黏液覆层消耗。因为不毁的优先级为125，黏液覆层的优先级为150。

黏液覆层运行更早，消耗更早（不毁的原理是取消耐久消耗事件）。

addInformation

public void addInformation(IToolStackView tool, int level, @Nullable Player player, List<Component> tooltip, slimeknights.tconstruct.library.utils.TooltipKey tooltipKey, TooltipFlag tooltipFlag)

“光照提速”强化：

@Override
public void addInformation(IToolStackView tool, int level, @Nullable Player player, List<Component> tooltip, TooltipKey tooltipKey, TooltipFlag tooltipFlag) {
  addStatTooltip(tool, ToolStats.MINING_SPEED, TinkerTags.Items.HARVEST, 9 * getScaledLevel(tool, level), tooltip);
}

addStatTooltip、addPercentTooltip等函数会稍后讲解

addVolatileData

public void addVolatileData(ToolRebuildContext context, int level, ModDataNBT volatileData)

“厚积”强化：

@Override
public void addVolatileData(ToolRebuildContext context, int level, ModDataNBT volatileData) {
  OverslimeModifier overslime = TinkerModifiers.overslime.get(); //黏液覆层
  overslime.setFriend(volatileData); //设置黏液之友
  overslime.addCapacity(volatileData, level * 25); //增加上限
  overslime.multiplyCapacity(volatileData, 1f + (level * 0.5f)); //增加上限
}

public void addToolStats(ToolRebuildContext context, int level, ModifierStatsBuilder builder)

“晶固”强化：

@Override
public void addToolStats(ToolRebuildContext context, int level, ModifierStatsBuilder builder) {
  ToolStats.VELOCITY.add(builder, level * 0.1f); //箭矢初速度
}

public void beforeRemoved(IToolStackView tool, RestrictedCompoundTag tag)

“火焰保护”强化：

@Override
public void beforeRemoved(IToolStackView tool, RestrictedCompoundTag tag) {
  EnchantmentModifier.removeEnchantmentData(tag, Enchantments.FIRE_PROTECTION); //移除附魔信息
}

public void onRemoved(IToolStackView tool)

“装饰”强化：

@Override
public void onRemoved(IToolStackView tool) {
  tool.getPersistentData().remove(getId());
}

public int onDamageTool(IToolStackView tool, int level, int amount, @Nullable LivingEntity holder) {
  return amount;
}

“不毁”强化：

@Override
public int onDamageTool(IToolStackView tool, int level, int amount, @Nullable LivingEntity holder) {
  return 0; //工具消耗了0耐久，相当于取消了耐久消耗事件
} //返回值是耐久消耗值，整型

public float getRepairFactor(IToolStackView toolStack, int level, float factor) {
  return factor;
}

“培植”强化：

@Override
public float getRepairFactor(IToolStackView toolStack, int level, float factor) {
  // +50% repair per level 翻译：每级增加50%回复值
  return (factor * (1 + (level * 0.5f)));
} //返回值是耐久回复值，单精度浮点

public void onInventoryTick(IToolStackView tool, int level, Level world, LivingEntity holder, int itemSlot, boolean isSelected, boolean isCorrectSlot, ItemStack stack)

“同调”强化（暮色森林联动）：

@Override
public void onInventoryTick(IToolStackView tool, int level, Level world, LivingEntity holder, int itemSlot, boolean isSelected, boolean isCorrectSlot, ItemStack stack) {
    if (!world.isClientSide() && holder instanceof Player player && !(holder instanceof FakePlayer)) {
       if (!isCorrectSlot) return;
       if (!needsRepair(tool)) return;

       int healPower = 0;

       NonNullList<ItemStack> playerInv = player.getInventory().items;

       for (int i = 0; i < 9; i++) {
          if (i != itemSlot) {
             ItemStack invSlot = playerInv.get(i);
             if (invSlot.is(TFItems.STEELEAF_INGOT.get())) {
                healPower += invSlot.getCount();
             } else if (invSlot.is(TFBlocks.STEELEAF_BLOCK.get().asItem())) {
                healPower += invSlot.getCount() * 9;
             } else if (TFItemStackUtils.hasToolMaterial(invSlot, TwilightItemTier.STEELEAF)) {
                healPower += 1;
             }
          }
       }

       ToolDamageUtil.repair(tool, averageInt(healPower * REPAIR_DAMPENER)); //回复耐久
    }
}

processLoot

public List<ItemStack> processLoot(IToolStackView tool, int level, List<ItemStack> generatedLoot, LootContext context) {
  return generatedLoot;
}

“美味”强化：

@Override
public List<ItemStack> processLoot(IToolStackView tool, int level, List<ItemStack> generatedLoot, LootContext context) {
  // if no damage source, probably not a mob
  // otherwise blocks breaking (where THIS_ENTITY is the player) start dropping bacon
  if (!context.hasParam(LootContextParams.DAMAGE_SOURCE)) {
    return generatedLoot;
  }

  // must have an entity
  Entity entity = context.getParamOrNull(LootContextParams.THIS_ENTITY);
  if (entity != null && entity.getType().is(TinkerTags.EntityTypes.BACON_PRODUCER)) {
    // at tasty 1, 2, 3, and 4 its a 2%, 4.15%, 6.25%, 8% per level
    int looting = context.getLootingModifier();
    if (RANDOM.nextInt(48 / level) <= looting) {
      // bacon
      generatedLoot.add(new ItemStack(TinkerCommons.bacon)); //向战利品中添加培根
    }
  }
  return generatedLoot;
} //返回值是生成的战利品，列表

public boolean canPerformAction(IToolStackView tool, int level, ToolAction toolAction) {
  return false;
}

“招架”强化：

@Override
public boolean canPerformAction(IToolStackView tool, int level, ToolAction toolAction) {
  return toolAction == ToolActions.SHIELD_BLOCK; //工具是否能进行格挡动作
} //返回值为工具是否可以进行特殊动作，布尔

public void onBreakSpeed(IToolStackView tool, int level, BreakSpeed event, Direction sideHit, boolean isEffective, float miningSpeedModifier)

“悬空”强化：

@Override
public void onBreakSpeed(IToolStackView tool, int level, BreakSpeed event, Direction sideHit, boolean isEffective, float miningSpeedModifier) {
  // the speed is reduced when not on the ground, cancel out
  if (!event.getEntity().isOnGround()) {
    event.setNewSpeed(event.getNewSpeed() * 5);
  }
}

public Boolean removeBlock(IToolStackView tool, int level, ToolHarvestContext context) {
  return null;
}

“荧光”强化：

@Nullable
@Override
public Boolean removeBlock(IToolStackView tool, int level, ToolHarvestContext context) {
  if (context.getState().is(TinkerCommons.glow.get()) && tool.getDefinitionData().getModule(ToolModuleHooks.INTERACTION).canInteract(tool, getId(), InteractionSource.LEFT_CLICK)) {
    return false;
  }
  return null;
} //返回值为布尔，若为true，则覆盖原版的方块移除逻辑并终止其他与方块破坏结果有关的强化；若为false，不移除方块；若为null，运行原版的方块移除逻辑

public void afterBlockBreak(IToolStackView tool, int level, ToolHarvestContext context)

“动力”强化：

@Override
public void afterBlockBreak(IToolStackView tool, int level, ToolHarvestContext context) {
  if (context.canHarvest() && context.isEffective() && !context.isAOE()) {
    // 32 blocks gets you to max, effect is stronger at higher levels
    LivingEntity living = context.getLiving();
    int effectLevel = Math.min(31, TinkerModifiers.momentumEffect.get().getLevel(living) + 1); //效果等级递增
    // funny formula from 1.12, guess it makes faster tools have a slightly shorter effect
    int duration = (int) ((10f / tool.getStats().get(ToolStats.MINING_SPEED)) * 1.5f * 20f);
    TinkerModifiers.momentumEffect.get().apply(living, duration, effectLevel, true); //给玩家施加动力效果
  }
}

public void finishBreakingBlocks(IToolStackView tool, int level, ToolHarvestContext context)

“末影传送”强化：

@Override
public void finishBreakingBlocks(IToolStackView tool, int level, ToolHarvestContext context) {
  if (context.canHarvest()) {
    BlockPos pos = context.getPos();
    LivingEntity living = context.getLiving();
    if (tryTeleport(living, pos.getX() + 0.5f, pos.getY(), pos.getZ() + 0.5f)) { //传送玩家到破坏的方块处
      ToolDamageUtil.damageAnimated(tool, 2, living);
    }
  }
}

public float getEntityDamage(IToolStackView tool, int level, ToolAttackContext context, float baseDamage, float damage){
  return damage;
}

“贪婪”强化：

public float getEntityDamage(IToolStackView tool, int level, ToolAttackContext context, float baseDamage, float damage) {
  // gives +2 damage per level at max
  return damage + (getBonus(context.getAttacker(), level, TinkerModifiers.insatiableEffect.get()) * tool.getMultiplier(ToolStats.ATTACK_DAMAGE));
} //返回值是造成的伤害，单精度浮点

public float beforeEntityHit(IToolStackView tool, int level, ToolAttackContext context, float damage, float baseKnockback, float knockback) {
  return knockback;
}

@Override
public float beforeEntityHit(IToolStackView tool, int level, ToolAttackContext context, float damage, float baseKnockback, float knockback) {
  // do not boost unarmed attacks twice, thats a bit too much knockback for the cost
  if (!context.getAttacker().getItemInHand(context.getHand()).isEmpty()) {
    return knockback + level * 0.5f;
  }
  return knockback; //返回值为造成的击退，单精度浮点
}

public int afterEntityHit(IToolStackView tool, int level, ToolAttackContext context, float damageDealt) {
  return 0;
}

@Override
public int afterEntityHit(IToolStackView tool, int level, ToolAttackContext context, float damageDealt) {
  LivingEntity target = context.getLivingTarget();
  if (target != null) {
    target.setSecondsOnFire(Math.round(getEffectiveLevel(tool, level) * 5));
  }
  return 0; //返回值为对工具的额外耐久消耗，整型
}

public void failedEntityHit(IToolStackView tool, int level, ToolAttackContext context) {}

某些强化会在命中实体后施加特殊效果，但可能出现并未造成伤害的情况

，此时需要通过此方法移除施加效果（非必要）

“怒火”强化：

@Override
public void failedEntityHit(IToolStackView tool, int level, ToolAttackContext context) {
  // conclusion of vanilla hack: we don't want the target on fire if we did not hit them
  LivingEntity target = context.getLivingTarget();
  if (target != null && target.isOnFire()) { //工具点燃了目标
    target.clearFire();
  }
}

public float getProtectionModifier(IToolStackView tool, int level, EquipmentContext context, EquipmentSlot slotType, DamageSource source, float modifierValue) {
  return modifierValue;
}

每1点返回值减免4%伤害，相当于1级保护魔咒。

可正可负，正则减免伤害，负则增加伤害。

“爆炸保护”强化：

@Override
public float getProtectionModifier(IToolStackView tool, int level, EquipmentContext context, EquipmentSlot slotType, DamageSource source, float modifierValue) {
  if (!source.isBypassMagic() && !source.isBypassInvul() && source.isExplosion()) { //伤害来源是爆炸
    modifierValue += getScaledLevel(tool, level) * 2.5f;
  }
  return modifierValue; //返回值是保护系数，单精度浮点
}

public boolean isSourceBlocked(IToolStackView tool, int level, EquipmentContext context, EquipmentSlot slotType, DamageSource source, float amount) {
  return false;
}

“远距防摔”强化：

@Override
public boolean isSourceBlocked(IToolStackView tool, int level, EquipmentContext context, EquipmentSlot slotType, DamageSource source, float amount) {
  return source.isFall(); //返回值是是否免疫此伤害，布尔类型。若伤害类型为摔落，则source.isFall()返回值为true,免疫伤害
}

public void onAttacked(IToolStackView tool, int level, EquipmentContext context, EquipmentSlot slotType, DamageSource source, float amount, boolean isDirectDamage) {}

“润湿”强化：

@Override
public void onAttacked(IToolStackView tool, int level, EquipmentContext context, EquipmentSlot slotType, DamageSource source, float amount, boolean isDirectDamage) {
  Entity attacker = source.getEntity();
  if (doesTrigger(source, isDirectDamage)) {
    // 25% chance of working per level, 50% per level on shields
    if (RANDOM.nextInt(slotType.getType() == Type.HAND ? 2 : 4) < level) {
      FluidStack fluid = getFluid(tool);
      if (!fluid.isEmpty()) {
        LivingEntity self = context.getEntity();
        Player player = self instanceof Player p ? p : null;
        SpillingFluid recipe = SpillingFluidManager.INSTANCE.find(fluid.getFluid());
        if (recipe.hasEffects()) {
          FluidStack remaining = recipe.applyEffects(fluid, level, createContext(self, player, attacker, fluid));
          if (player == null || !player.isCreative()) {
            setFluid(tool, remaining);
          }
        }
      }
    }
  }
}

public void attackWithArmor(IToolStackView tool, int level, EquipmentContext context, EquipmentSlot slotType, LivingEntity target, DamageSource source, float amount, boolean isDirectDamage) {}

“惊险”强化（未知黏液头颅特性）

@Override
public void attackWithArmor(IToolStackView tool, int level, EquipmentContext context, EquipmentSlot slotType, LivingEntity target, DamageSource source, float amount, boolean isDirectDamage) {
  if (isDirectDamage && !source.isProjectile()) {
    LivingEntity attacker = context.getEntity();
    int attackerAir = attacker.getAirSupply();
    int maxAir = attacker.getMaxAirSupply();
    if (attackerAir < maxAir) {
      attacker.setAirSupply(Math.min(attackerAir + 60, maxAir));
    }
    target.setAirSupply(Math.max(-20, target.getAirSupply() - 60)); //将目标的空气转换为自身的空气
  }
}

public void onUnequip(IToolStackView tool, int level, EquipmentChangeContext context) {}

“远视”强化：

@Override
public void onEquip(IToolStackView tool, int level, EquipmentChangeContext context) {
  if (!tool.isBroken()) {
    ResourceLocation key = SLOT_KEYS[context.getChangedSlot().getFilterFlag()];
    context.getTinkerData().ifPresent(data -> data.computeIfAbsent(TinkerDataKeys.FOV_MODIFIER).set(key, 1 / (1 + 0.05f * level))); //lambda表达式，移除对玩家视场角的更改
  }
}

public void onEquip(IToolStackView tool, int level, EquipmentChangeContext context) {}

“金质”强化：

@Override
public void onEquip(IToolStackView tool, int level, EquipmentChangeContext context) {
  // adding a helmet? activate bonus
  if (context.getChangedSlot() == EquipmentSlot.HEAD) {
    context.getTinkerData().ifPresent(data -> { //lambda表达式
      GoldGuardGold gold = data.get(TOTAL_GOLD);
      if (gold == null) {
        data.computeIfAbsent(TOTAL_GOLD).initialize(context);
      } else {
        gold.setGold(EquipmentSlot.HEAD, tool.getVolatileData().getBoolean(ModifiableArmorItem.PIGLIN_NEUTRAL), context.getEntity()); //使猪灵中立
      }
    });
  }
}

public boolean shouldDisplay(boolean advanced) {
  return true;
}

若返回值为true，则会在所有界面上显示。

若为false，仅会在工匠站（砧）以及强化调配台上显示。

public double getDamagePercentage(IToolStackView tool, int level) {
  return Double.NaN;
}

返回值为Double.NaN则为默认。

为0则不显示（相当于满耐久）。

其他值（0~1）则为损坏率，1为彻底损坏。

“耐久护盾”强化（是黏液覆层、石盾之类强化的API）：

@Override
public double getDamagePercentage(IToolStackView tool, int level) {
  int shield = getShield(tool);
  if (shield > 0) {
    int cap = getShieldCapacity(tool, level);
    if (shield > cap) {
      return 0; //覆层为满，不显示
    }
    return ((double) (cap - shield) / cap); //覆层消耗，显示覆层余量
  }
  return Double.NaN; //双精度浮点，覆层耗尽，显示正常耐久条
}

@Nullable
public Boolean showDurabilityBar(IToolStackView tool, int level) {
  return null;
}

返回值为true则显示，为false则不显示。

“黏液覆层”强化：

@Nullable
@Override

public Boolean showDurabilityBar(IToolStackView tool, int level) {
  // only show as fully repaired if overslime is full
  return getOverslime(tool) < getCapacity(tool); //布尔类型
}

public int getDurabilityRGB(IToolStackView tool, int level) {
  return -1;
}

“不毁”强化：

@Override
public int getDurabilityRGB(IToolStackView tool, int level) {
  return 0xFFFFFF; //返回值为颜色代码，一般为16进制数，即RGB颜色
}