@Override public List<List<ItemStack>> getItems() { return TinkerHarvestTools.pickaxe.getRequiredComponents().stream() .map(PartMaterialType::getPossibleParts) .flatMap(Collection::stream) .map(this::getItems) .collect(Collectors.toList()); }
@Override protected boolean canApplyCustom(ItemStack stack) throws TinkerGuiException { return !((ToolCore) stack.getItem()).hasCategory(Category.NO_MELEE); }
public ToolCore(PartMaterialType... requiredComponents) { super(requiredComponents); this.setCreativeTab(TinkerRegistry.tabTools); this.setNoRepair(); // >_> TinkerRegistry.registerTool(this); addCategory(Category.TOOL); }
protected void addDefaultSubItems(List<ItemStack> subItems, Material... fixedMaterials) { for(Material head : TinkerRegistry.getAllMaterials()) { List<Material> mats = new ArrayList<>(requiredComponents.length); for(int i = 0; i < requiredComponents.length; i++) { if(fixedMaterials.length > i && fixedMaterials[i] != null && requiredComponents[i].isValidMaterial(fixedMaterials[i])) { mats.add(fixedMaterials[i]); } else { // todo: check for applicability with stats mats.add(head); } } ItemStack tool = buildItem(mats); // only valid ones if(hasValidMaterials(tool)) { subItems.add(tool); if(!Config.listAllMaterials) { break; } } } }
public void recurse(ToolCore tool, ImmutableList<Material> materials, List<Triple<ItemStack, ImmutableList<Material>, Object[]>> results, Function<ItemStack, ?> fns[]) { // not enough materials yet, recurse if(tool.getRequiredComponents().size() > materials.size()) { for(Material mat : TinkerRegistry.getAllMaterials()) { if(!mat.hasStats(MaterialTypes.HEAD)) { continue; } ImmutableList.Builder<Material> mats = ImmutableList.builder(); mats.addAll(materials); mats.add(mat); recurse(tool, mats.build(), results, fns); } } // enough materials, build it and do stuff with it! else { ItemStack stack = tool.buildItem(materials); Object[] values = new Object[fns.length]; for(int i = 0; i < fns.length; i++) { values[i] = fns[i].apply(stack); } results.add(Triple.of(stack, materials, values)); } }
if(isEffective(state) || ToolHelper.isToolEffective(stack, state)) { return ToolHelper.calcDigSpeed(stack, state); for(int index : getRepairParts()) { if(index < materials.size()) { nameMaterials.add(materials.get(index)); public void getSubItems(CreativeTabs tab, NonNullList<ItemStack> subItems) { if(this.isInCreativeTab(tab)) { addDefaultSubItems(subItems); super.onUpdate(stack, worldIn, entityIn, itemSlot, isSelected); onUpdateTraits(stack, worldIn, entityIn, itemSlot, isSelected); stack.setTagCompound(tag); switchItemsInHands(entityLiving); boolean effective = isEffective(state) || ToolHelper.isToolEffective(stack, worldIn.getBlockState(pos)); int damage = effective ? 1 : 2; afterBlockBreak(stack, worldIn, state, pos, entityLiving, damage, effective); return hasCategory(Category.TOOL);
for(int i = 0; i < tool.getRequiredComponents().size(); i++) { builder.add(material); ItemStack builtTool = tool.buildItem(builder.build()); if(tool.hasValidMaterials(builtTool)) { displayTools.add(new ElementTinkerItem(builtTool));
toolInfo.setCaption(tool.getLocalizedToolName()); toolInfo.setText(tool.getLocalizedDescription()); List<PartMaterialType> pms = tool.getRequiredComponents(); for(int i = 0; i < pms.size(); i++) { PartMaterialType pmt = pms.get(i);
if (tool.hasCategory(Category.HARVEST)) { out.put("miningSpeed", ToolHelper.getActualMiningSpeed(stack)); List<PartMaterialType> component = tool.getRequiredComponents();
protected ItemStackList getDemoTools(ItemStack[][] inputItems) { ItemStackList demo = ItemStackList.withSize(tool.size()); for(int i = 0; i < tool.size(); i++) { if(tool.get(i) instanceof ToolCore) { ToolCore core = (ToolCore) tool.get(i); List<Material> mats = ImmutableList.of(TinkerMaterials.wood, TinkerMaterials.cobalt, TinkerMaterials.ardite, TinkerMaterials.manyullyn); mats = mats.subList(0, core.getRequiredComponents().size()); demo.set(i, ((ToolCore) tool.get(i)).buildItemForRendering(mats)); } else if(tool != null) { demo.set(i, new ItemStack(tool.get(i))); } if(!demo.get(i).isEmpty()) { modifier.apply(demo.get(i)); } } return demo; } }
@Override public boolean onBlockStartBreak(ItemStack itemstack, BlockPos pos, EntityPlayer player) { if(!ToolHelper.isBroken(itemstack) && this instanceof IAoeTool && ((IAoeTool) this).isAoeHarvestTool()) { for(BlockPos extraPos : ((IAoeTool) this).getAOEBlocks(itemstack, player.getEntityWorld(), player, pos)) { breakExtraBlock(itemstack, player.getEntityWorld(), player, extraPos, pos); } } // this is a really dumb hack. // Basically when something with silktouch harvests a block from the offhand // the game can't detect that. so we have to switch around the items in the hands for the break call // it's switched back in onBlockDestroyed if(DualToolHarvestUtils.shouldUseOffhand(player, pos, player.getHeldItemMainhand())) { ItemStack off = player.getHeldItemOffhand(); switchItemsInHands(player); // remember, off is in the mainhand now NBTTagCompound tag = TagUtil.getTagSafe(off); tag.setLong(TAG_SWITCHED_HAND_HAX, player.getEntityWorld().getTotalWorldTime()); off.setTagCompound(tag); } return breakBlock(itemstack, pos, player); }
continue; ItemStack stack = tool.buildItem(ImmutableList.of(mat1, head, mat2)); int d = ToolHelper.getDurabilityStat(stack); String s = String.format("<td bgcolor=\"%s\">%s</td>", Integer s = String.format("<td bgcolor=\"%s\">%s</td>", Integer.toHexString(floatToCol(sp / ref.miningspeed)), df.format(sp)); speed.add(s); float at = ToolHelper.getAttackStat(stack) * tool.damagePotential(); s = String.format("<td bgcolor=\"%s\">%s</td>", Integer.toHexString(floatToCol(at / ref.attack)), df.format(at)); att.add(s);
protected ItemStack getInfiTool(String name) { // The InfiHarvester! List<Material> materials = ImmutableList.of(TinkerMaterials.slime, TinkerMaterials.cobalt, TinkerMaterials.ardite, TinkerMaterials.ardite); materials = materials.subList(0, requiredComponents.length); ItemStack tool = buildItem(materials); tool.setStackDisplayName(name); InfiTool.INSTANCE.apply(tool); return tool; }
/** Returns the actual attack speed */ public static float getActualAttackSpeed(ItemStack stack) { float speed = getAttackSpeedStat(stack); if(!stack.isEmpty() && stack.getItem() instanceof ToolCore) { speed *= ((ToolCore) stack.getItem()).attackSpeed(); } return speed; }
public static void initRenderer() { if(TinkerHarvestTools.pickaxe != null) { TinkerRegistry.tabTools.setDisplayIcon(TinkerHarvestTools.pickaxe.buildItemForRendering(ImmutableList.of(RenderMaterials[0], RenderMaterials[1], RenderMaterials[2]))); } if(TinkerTools.pickHead != null) { TinkerRegistry.tabParts.setDisplayIcon(TinkerTools.pickHead.getItemstackWithMaterial(RenderMaterials[2])); } IReloadableResourceManager resourceManager = (IReloadableResourceManager) mc.getResourceManager(); resourceManager.registerReloadListener(MaterialRenderInfoLoader.INSTANCE); resourceManager.registerReloadListener(CustomTextureCreator.INSTANCE); // Font renderer for tooltips and GUIs fontRenderer = new CustomFontRenderer(mc.gameSettings, new ResourceLocation("textures/font/ascii.png"), mc.renderEngine); if(mc.gameSettings.language != null) { fontRenderer.setUnicodeFlag(mc.getLanguageManager().isCurrentLocaleUnicode() || mc.gameSettings.forceUnicodeFont); fontRenderer.setBidiFlag(mc.getLanguageManager().isCurrentLanguageBidirectional()); } resourceManager.registerReloadListener(fontRenderer); // Font Renderer for the tinker books FontRenderer bookRenderer = new CustomFontRenderer(mc.gameSettings, new ResourceLocation("textures/font/ascii.png"), mc.renderEngine); bookRenderer.setUnicodeFlag(true); if(mc.gameSettings.language != null) { fontRenderer.setBidiFlag(mc.getLanguageManager().isCurrentLanguageBidirectional()); } TinkerBook.INSTANCE.fontRenderer = bookRenderer; MinecraftForge.EVENT_BUS.register(CrosshairRenderEvents.INSTANCE); }
ImmutableList<Material> manyMaterials = ImmutableList.of(TinkerMaterials.wood, TinkerMaterials.manyullyn, TinkerMaterials.manyullyn); ItemStack wood = TinkerHarvestTools.pickaxe.buildItem(woodMaterials); ItemStack stone = TinkerHarvestTools.pickaxe.buildItem(stoneMaterials); ItemStack iron = TinkerHarvestTools.pickaxe.buildItem(ironMaterials); ItemStack extra = TinkerHarvestTools.pickaxe.buildItem(cobaltMaterials); new ItemStack(Items.DIAMOND_PICKAXE), new ItemStack(Items.GOLDEN_PICKAXE)); wood = TinkerHarvestTools.shovel.buildItem(woodMaterials); stone = TinkerHarvestTools.shovel.buildItem(stoneMaterials); iron = TinkerHarvestTools.shovel.buildItem(ironMaterials); extra = TinkerHarvestTools.shovel.buildItem(cobaltMaterials); new ItemStack(Items.DIAMOND_SHOVEL), new ItemStack(Items.GOLDEN_SHOVEL)); wood = TinkerHarvestTools.hatchet.buildItem(woodMaterials); stone = TinkerHarvestTools.hatchet.buildItem(stoneMaterials); iron = TinkerHarvestTools.hatchet.buildItem(ironMaterials); extra = TinkerHarvestTools.hatchet.buildItem(cobaltMaterials); new ItemStack(Items.DIAMOND_AXE), new ItemStack(Items.GOLDEN_AXE)); wood = TinkerMeleeWeapons.broadSword.buildItem(woodMaterials); stone = TinkerMeleeWeapons.broadSword.buildItem(stoneMaterials); iron = TinkerMeleeWeapons.broadSword.buildItem(ironMaterials); extra = TinkerMeleeWeapons.broadSword.buildItem(manyMaterials);
private void registerExtraTraitModifiers(Material material, ToolCore tool) { tool.getRequiredComponents().forEach(pmt -> registerExtraTraitModifiers(material, tool, pmt)); }
/** * Called when an entity is getting damaged with the tool. * Reduce the tools durability accordingly * player can be null! */ public void reduceDurabilityOnHit(ItemStack stack, EntityPlayer player, float damage) { damage = Math.max(1f, damage / 10f); if(!hasCategory(Category.WEAPON)) { damage *= 2; } ToolHelper.damageTool(stack, (int) damage, player); }
/** * Register a tool, making it known to tinkers' systems. * All toolparts used to craft the tool will be registered as well. */ public static void registerTool(ToolCore tool) { tools.add(tool); for(PartMaterialType pmt : tool.getRequiredComponents()) { for(IToolPart tp : pmt.getPossibleParts()) { registerToolPart(tp); } } }
public List<String> getInformation(ItemStack stack, boolean detailed) { TooltipBuilder info = new TooltipBuilder(stack); info.addDurability(!detailed); if(hasCategory(Category.HARVEST)) { info.addHarvestLevel(); info.addMiningSpeed(); } if(hasCategory(Category.LAUNCHER)) { info.addDrawSpeed(); info.addRange(); info.addProjectileBonusDamage(); } info.addAttack(); if(ToolHelper.getFreeModifiers(stack) > 0) { info.addFreeModifiers(); } if(detailed) { info.addModifierInfo(); } return info.getTooltip(); }