From 79e46cb381c6131732c628109925e02010ec8cc3 Mon Sep 17 00:00:00 2001 From: mDiyo Date: Wed, 1 Jan 2014 22:11:15 -0800 Subject: [PATCH] Initial exosuit recipes and modifiers --- resources/assets/tinker/lang/en_US.lang | 45 +++ .../assets/tinker/textures/gui/chestside.png | Bin 0 -> 1400 bytes .../tinker/textures/gui/tinkertable.png | Bin 0 -> 1043 bytes src/tconstruct/TConstruct.java | 2 +- .../blocks/CraftingStationBlock.java | 5 +- .../blocks/logic/CraftingStationLogic.java | 62 ++- src/tconstruct/client/TProxyClient.java | 2 +- .../client/gui/CraftingStationGui.java | 372 +++++++++++++++++- src/tconstruct/common/TContent.java | 141 +++---- src/tconstruct/common/TProxyCommon.java | 1 + .../inventory/CraftingStationContainer.java | 67 +++- src/tconstruct/items/OreBerries.java | 2 +- src/tconstruct/items/armor/ExoArmor.java | 43 +- src/tconstruct/library/armor/ArmorCore.java | 40 +- src/tconstruct/library/armor/ArmorMod.java | 54 +++ .../library/armor/EnumArmorPart.java | 2 +- .../library/crafting/ToolBuilder.java | 98 ++++- src/tconstruct/library/tools/ToolMod.java | 30 +- src/tconstruct/modifiers/ModElectric.java | 87 ---- .../modifiers/armor/AModDamageBoost.java | 98 +++++ .../modifiers/armor/AModHealthBoost.java | 89 +++++ .../armor/AModKnockbackResistance.java | 89 +++++ .../modifiers/armor/AModMoveSpeed.java | 88 +++++ .../modifiers/armor/AModProtection.java | 43 ++ .../modifiers/armor/ArmorModTypeFilter.java | 119 ++++++ .../modifiers/{ => tools}/ModAntiSpider.java | 13 +- .../modifiers/{ => tools}/ModAttack.java | 23 +- .../modifiers/{ => tools}/ModAutoSmelt.java | 2 +- .../modifiers/{ => tools}/ModBlaze.java | 17 +- .../modifiers/{ => tools}/ModBoolean.java | 2 +- .../modifiers/{ => tools}/ModButtertouch.java | 2 +- .../modifiers/{ => tools}/ModDurability.java | 2 +- .../{ => tools}/ModExtraModifier.java | 2 +- .../modifiers/{ => tools}/ModFlux.java | 4 +- .../modifiers/{ => tools}/ModInteger.java | 2 +- .../modifiers/{ => tools}/ModLapis.java | 13 +- .../modifiers/{ => tools}/ModPiston.java | 16 +- .../modifiers/{ => tools}/ModPotion.java | 2 +- .../modifiers/{ => tools}/ModRedstone.java | 16 +- .../modifiers/{ => tools}/ModReinforced.java | 2 +- .../modifiers/{ => tools}/ModRepair.java | 2 +- .../modifiers/{ => tools}/ModSmite.java | 14 +- .../modifiers/{ => tools}/TActiveOmniMod.java | 19 +- .../modifiers/tools/ToolModTypeFilter.java | 106 +++++ src/tconstruct/util/TEventHandler.java | 44 +-- 45 files changed, 1534 insertions(+), 348 deletions(-) create mode 100644 resources/assets/tinker/textures/gui/chestside.png create mode 100644 resources/assets/tinker/textures/gui/tinkertable.png create mode 100644 src/tconstruct/library/armor/ArmorMod.java delete mode 100644 src/tconstruct/modifiers/ModElectric.java create mode 100644 src/tconstruct/modifiers/armor/AModDamageBoost.java create mode 100644 src/tconstruct/modifiers/armor/AModHealthBoost.java create mode 100644 src/tconstruct/modifiers/armor/AModKnockbackResistance.java create mode 100644 src/tconstruct/modifiers/armor/AModMoveSpeed.java create mode 100644 src/tconstruct/modifiers/armor/AModProtection.java create mode 100644 src/tconstruct/modifiers/armor/ArmorModTypeFilter.java rename src/tconstruct/modifiers/{ => tools}/ModAntiSpider.java (87%) rename src/tconstruct/modifiers/{ => tools}/ModAttack.java (86%) rename src/tconstruct/modifiers/{ => tools}/ModAutoSmelt.java (94%) rename src/tconstruct/modifiers/{ => tools}/ModBlaze.java (89%) rename src/tconstruct/modifiers/{ => tools}/ModBoolean.java (97%) rename src/tconstruct/modifiers/{ => tools}/ModButtertouch.java (99%) rename src/tconstruct/modifiers/{ => tools}/ModDurability.java (98%) rename src/tconstruct/modifiers/{ => tools}/ModExtraModifier.java (96%) rename src/tconstruct/modifiers/{ => tools}/ModFlux.java (96%) rename src/tconstruct/modifiers/{ => tools}/ModInteger.java (97%) rename src/tconstruct/modifiers/{ => tools}/ModLapis.java (95%) rename src/tconstruct/modifiers/{ => tools}/ModPiston.java (89%) rename src/tconstruct/modifiers/{ => tools}/ModPotion.java (95%) rename src/tconstruct/modifiers/{ => tools}/ModRedstone.java (91%) rename src/tconstruct/modifiers/{ => tools}/ModReinforced.java (98%) rename src/tconstruct/modifiers/{ => tools}/ModRepair.java (99%) rename src/tconstruct/modifiers/{ => tools}/ModSmite.java (87%) rename src/tconstruct/modifiers/{ => tools}/TActiveOmniMod.java (97%) create mode 100644 src/tconstruct/modifiers/tools/ToolModTypeFilter.java diff --git a/resources/assets/tinker/lang/en_US.lang b/resources/assets/tinker/lang/en_US.lang index aeddf5a2efb..4d26f5745c0 100644 --- a/resources/assets/tinker/lang/en_US.lang +++ b/resources/assets/tinker/lang/en_US.lang @@ -6,6 +6,7 @@ crafters.ToolStation=Tool Station crafters.ToolForge=Tool Forge crafters.PartBuilder=Part Builder crafters.PatternShaper=Stencil Table +crafters.TinkerTable=Tinker Table inventory.PatternChest=Pattern Chest crafters.Smeltery=Smeltery crafters.Frypan=Frying Pan @@ -604,6 +605,8 @@ achievement.tconstruct.preparedFight.desc=Create your first weapon achievement.tconstruct.enemySlayer.desc=Slay a mob achievement.tconstruct.dualConvenience.desc=Kill a mob with a frying pan, and then cook their meat in it +armortype.ExoArmor=Exosuit + knapsack.tooltip=A Knapsack to hold your things. strangefood1.tooltip=It smells terrible, but if you strangefood2.tooltip=have nothing else to eat... @@ -670,3 +673,45 @@ smeltery.drain.tooltip1=Works both as input and output for smeltery.drain.tooltip2=fluids in the Smeltery smeltery.brick.tooltip1=Smeltery structure block smeltery.brick.tooltip2=(Safe for decoration) + +gui.smeltery1=Fuel +gui.landmine=Landmine +gui.partcrafter1=Tool Part Crafting +gui.partcrafter2=Tool Part Building +gui.partcrafter3=Place a pattern and a material on the left to get started. +gui.partcrafter4=Base Durability: +gui.partcrafter5=Handle Modifier: +gui.partcrafter6=Mining Speed: +gui.partcrafter7=Mining Level: +gui.partcrafter8=Mining Level: +gui.partcrafter9= Heart +gui.partcrafter10= Hearts +gui.partcrafter11=Attack: +gui.partcrafter.mining1=Stone +gui.partcrafter.mining2=Iron +gui.partcrafter.mining3=Redstone +gui.partcrafter.mining4=Obsidian +gui.partcrafter.mining5=Cobalt +gui.partcrafter.mining6=Manyullyn +gui.stenciltable1=Next Pattern +gui.stenciltable2=Previous Pattern +gui.toolforge1=Repair and Modification +gui.toolforge2=The main way to repair or change your tools. Place a tool and a material on the left to get started. +gui.toolstation1=Durability: +gui.toolstation2=Durability: +gui.toolstation3=Attack: +gui.toolstation4=Bonus: +gui.toolstation5=Loss: +gui.toolstation6=Draw Speed: +gui.toolstation7=Arrow Speed: +gui.toolstation8=Weight: +gui.toolstation9=Accuracy: +gui.toolstation10=Base Attack: +gui.toolstation11=Shortbow Attack: +gui.toolstation12=Mining Speeds: +gui.toolstation13=Harvest Levels: +gui.toolstation14=Mining Speed: +gui.toolstation15=Mining Level: +gui.toolstation16=Usage Speed: +gui.toolstation17=Modifiers +gui.toolstation18=Modifiers remaining: diff --git a/resources/assets/tinker/textures/gui/chestside.png b/resources/assets/tinker/textures/gui/chestside.png new file mode 100644 index 0000000000000000000000000000000000000000..f199772bf7ca558417725a9f66d6004ba7661a5c GIT binary patch literal 1400 zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|G$6&6|H(?D8gCb z5n0T@z%2~Ij105pNB{-dOFVsD+3)hO3Co(TiTtdEaktaqI2fz`RFR5)FaX zN9JXmHA_&Onjr3R)BUWO$JNlE`*@^Ety~v+77PELbA0Edi@k@<)q?*W`{2%bMXT=P z^KX0h+Wt={-Yw`=sBcmjeni4cQ}I~FdF}hp73(TLSAV{|?(F^g58u8$TV--=-uBni zr4P=QXJlYu5MXcs`2&+7mRJ1Ve&3!wJ#~$L>*V#OcbBF`q;J378+Ux(_N~unE9x5^ z`&hv<{q#{Q<2A-t!>eN-mwmhA&hUW;w~-)A5;nd&$9&`c_lFfWeRYDb&ul&?67zW5 zH=8yAFHO~!4?oL~&gR>^uJoNxd#7T{gdnb^Qv{N?JfHf$(o3_?j`2=h3QutCv*_b4 z3f1o<859^A7#NrsIKYesh8-*@0zjFN!!8TDuFY)9zH@EfY>tqNR%%Q)KT8WYO2rI} z3Fel9FU~!g6E%|~Md`w0^@iKsJ%OJ=`~#QI?R_K3VB&)j9V?C>Q(X~%y;P6MkD)=> zp}6QAh_&`s-uA@ZcXtU`Fm8GAZSCgo-^<0B)fo~Fa2^nuYUaFu^f0)UYhzRQs?dd+x?RFWxg> z``3GN&gM>sscVy!F7yO>JuI*=DddtktTO-SHOb!x!Ws5`+^%uukh25MbP7&XFKc9H z@cTT7yl#~|ljDknaO0~eUQA6ko}k`9WFBMoDGAWL1TLC z>z-7lfMg$*RoQdbt1*?viWi^rW2kw5ObYC-pVwU$tb6Umv5@B{_dR2V6(`=C|Nk|Q zaY~Tg)i>Yljh|>R|1tbxyLpE20btl<8*DzxlECTj;)p$)u`on1erEV_fMs6kTH|X; zYD_<^KGahn;+{j{CH|0I`2c+cR_}X zA82_8o{7MW4U-sV_;CZ18z^&a5o~zFVdQ&MBb@0K8iCWdHyG literal 0 HcmV?d00001 diff --git a/resources/assets/tinker/textures/gui/tinkertable.png b/resources/assets/tinker/textures/gui/tinkertable.png new file mode 100644 index 0000000000000000000000000000000000000000..3fab5f839702d69ee3b6ded8dd1acde189876b28 GIT binary patch literal 1043 zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|G$6&6|H(?D8gCb z5n0T@z;_6Q8AUa`8i0cAC7!;n?00$C7Lm z^>b;il;Dk%^5XVOBc~nhD?KiIz@Bl({r6$5Yj_U}2ns&7xW)Nq19QR0W(Ec(1`Y-V z2B2F|7y*5!)$1~@m!34v+aB$6dCJu}+j9T9DKhNen-KJ+R{pX{s_F65Av;(ZSQrEt z96+8&V>Bqo>Kv?m`|;XS|2?dl3@JKab&t=l;J&2Gkih<-zJBVjefD={1RCOJEYtic zGViU*{5j8dh`TY|E6I;K-RbbzhMRjHD>(s9Sj@|98l`O=|BDlob;pqTQ$fw ztcYM?SrAsnu!Gg&=h0tx<15AO%NUZFm>xW0X9W3e#}7w_m_G^(dUZeM2{#_Fj!pYYxw?Vlg(`h2Cb{x*4`Gn!vqfr^gt<4@?+u3KO4AS zP3c-`tg_M`OE61Jcbnz2JyyrB zudCN!xXnI6>G=AOX3N)D-U}+_#u^pS$YDz0bYN)UvbE)ZuqOU-u3u!a#ktGt*~^tC zSX!Q`v=KaUy?K8o`-WNu%{djxey?QInJU?cFwau(#GE(J3xLXJPW}rdYct3;W6pAQ zCda-x98bi+X`*4eO)bZZkc8r*8J{b(4Dz`Sd}CZv@M^8)%3_;2WyJW^QuGGcZOfU0 zWtKDTh9tICxBqSK_jWPyy}ai1rihpoCF~bs)`zclG_+y3bNn&Wx@j#=_2r=aNE7gY aWgo-FJ#H)W15_MA7I?b)xvX chest; //TODO: These are prototypes + public WeakReference doubleChest; + public WeakReference patternChest; + public WeakReference furnace; + public boolean tinkerTable; + public boolean stencilTable; + public CraftingStationLogic() { - super(11); //9 for crafting, 1 for output, 1 for plans + super(17); //9 for crafting, 1 for output, 6 for extensions, 1 for plans } @Override public Container getGuiContainer (InventoryPlayer inventoryplayer, World world, int x, int y, int z) { + chest = null; + doubleChest = null; + patternChest = null; + furnace = null; + tinkerTable = false; + for (int yPos = y - 1; yPos <= y + 1; yPos++) + { + for (int xPos = x - 1; xPos <= x + 1; xPos++) + { + for (int zPos = z - 1; zPos <= z + 1; zPos++) + { + TileEntity tile = world.getBlockTileEntity(xPos, yPos, zPos); + if (chest == null && tile instanceof TileEntityChest) + { + chest = new WeakReference(tile); + checkForChest(world, xPos + 1, yPos, zPos); + checkForChest(world, xPos - 1, yPos, zPos); + checkForChest(world, xPos, yPos, zPos + 1); + checkForChest(world, xPos, yPos, zPos - 1); + } + else if (patternChest == null && tile instanceof PatternChestLogic) + patternChest = new WeakReference(tile); + else if (furnace == null && (tile instanceof TileEntityFurnace || tile instanceof FurnaceLogic)) + furnace = new WeakReference(tile); + else if (tinkerTable == false && tile instanceof ToolStationLogic) + tinkerTable = true; + } + } + } + return new CraftingStationContainer(inventoryplayer, this, x, y, z); } + void checkForChest (World world, int x, int y, int z) + { + TileEntity tile = world.getBlockTileEntity(x, y, z); + if (tile instanceof TileEntityChest) + doubleChest = new WeakReference(tile); + } + @Override protected String getDefaultName () { - return "crafters.craftingstation"; + return "crafters.CraftingStation"; } public boolean canDropInventorySlot (int slot) @@ -39,7 +87,7 @@ public boolean canDropInventorySlot (int slot) @Override public int[] getAccessibleSlotsFromSide (int var1) { - return new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + return new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; } @Override @@ -51,6 +99,6 @@ public boolean canInsertItem (int i, ItemStack itemstack, int j) @Override public boolean canExtractItem (int i, ItemStack itemstack, int j) { - return i != 0; + return true; } } diff --git a/src/tconstruct/client/TProxyClient.java b/src/tconstruct/client/TProxyClient.java index 5e49dcd00f7..9450221ba81 100644 --- a/src/tconstruct/client/TProxyClient.java +++ b/src/tconstruct/client/TProxyClient.java @@ -85,7 +85,7 @@ public Object getClientGuiElement (int ID, EntityPlayer player, World world, int if (ID == landmineID) return new GuiLandmine(new ContainerLandmine(player, (TileEntityLandmine) world.getBlockTileEntity(x, y, z))); if (ID == craftingStationID) - return new CraftingStationGui(player.inventory, (CraftingStationLogic) world.getBlockTileEntity(x, y, z), x, y, z); + return new CraftingStationGui(player.inventory, (CraftingStationLogic) world.getBlockTileEntity(x, y, z), world, x, y, z); if (ID == furnaceID) return new FurnaceGui(player.inventory, (FurnaceLogic) world.getBlockTileEntity(x, y, z)); diff --git a/src/tconstruct/client/gui/CraftingStationGui.java b/src/tconstruct/client/gui/CraftingStationGui.java index 8ceb5120517..bd667fe3bfd 100644 --- a/src/tconstruct/client/gui/CraftingStationGui.java +++ b/src/tconstruct/client/gui/CraftingStationGui.java @@ -1,43 +1,383 @@ package tconstruct.client.gui; +import java.math.RoundingMode; +import java.text.DecimalFormat; +import java.util.Arrays; +import java.util.List; + +import net.minecraft.client.gui.GuiTextField; import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; import org.lwjgl.opengl.GL11; import tconstruct.blocks.logic.CraftingStationLogic; -import tconstruct.inventory.CraftingStationContainer; +import tconstruct.library.armor.ArmorCore; +import tconstruct.library.tools.ToolCore; public class CraftingStationGui extends GuiContainer { - public CraftingStationGui(InventoryPlayer inventoryplayer, CraftingStationLogic logic, int x, int y, int z) - { - super(new CraftingStationContainer(inventoryplayer, logic, x, y, z)); - } + public boolean active; + public String toolName; + public GuiTextField text; + public String title, body = ""; + CraftingStationLogic logic; - /*public void onGuiClosed () + public CraftingStationGui(InventoryPlayer inventory, CraftingStationLogic logic, World world, int x, int y, int z) { - TConstruct.logger.info("Gui Closed"); - super.onGuiClosed(); - }*/ + super(logic.getGuiContainer(inventory, world, x, y, z)); + this.logic = logic; + //text = new GuiTextField(this.fontRenderer, this.xSize / 2 - 5, 8, 30, 12); + //this.text.setText(""); + title = "\u00A7nRepair and Modification"; + body = "The main way to repair or change your tools or armor.\n\nPlace an item and a material on the left to get started."; + toolName = ""; + } @Override protected void drawGuiContainerForegroundLayer (int par1, int par2) { - fontRenderer.drawString("Crafting", 28, 6, 0x404040); - fontRenderer.drawString("Inventory", 8, (ySize - 96) + 2, 0x404040); + this.fontRenderer.drawString(StatCollector.translateToLocal(logic.tinkerTable ? "crafters.TinkerTable" : logic.getInvName()), 8, 6, 0x202020); + this.fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 0x202020); + if (logic.chest != null) + this.fontRenderer.drawString(StatCollector.translateToLocal(logic.chest.get().getInvName()), -108, this.ySize - 160, 0x202020); + //this.fontRenderer.drawString(toolName + "_", this.xSize / 2 - 18, 8, 0xffffff); + + if (logic.tinkerTable) + { + if (logic.isStackInSlot(0)) + drawToolStats(); + else + drawToolInformation(); + } + } + + void drawToolStats () + { + ItemStack stack = logic.getStackInSlot(0); + if (stack.getItem() instanceof ToolCore) + { + ToolCore tool = (ToolCore) stack.getItem(); + NBTTagCompound tags = stack.getTagCompound().getCompoundTag("InfiTool"); + this.drawCenteredString(fontRenderer, "\u00A7n" + tool.getToolName(), xSize + 63, 8, 0xffffff); + + drawModularToolStats(stack, tool, tags); + } + else if (stack.getItem() instanceof ArmorCore) + { + ArmorCore armor = (ArmorCore) stack.getItem(); + NBTTagCompound tags = stack.getTagCompound().getCompoundTag("TinkerArmor"); + this.drawCenteredString(fontRenderer, "\u00A7n" + StatCollector.translateToLocal("armortype."+armor.getArmorName()), xSize + 63, 8, 0xffffff); + + drawModularArmorStats(stack, armor, tags); + } + } + + void drawModularArmorStats (ItemStack stack, ArmorCore tool, NBTTagCompound tags) + { + int modifiers = tags.getInteger("Modifiers"); + int base = 24; + int offset = 0; + if (modifiers > 0) + { + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation18") + tags.getInteger("Modifiers"), xSize + 8, base + offset * 10, 0xffffff); + offset++; + } + } + + void drawModularToolStats (ItemStack stack, ToolCore tool, NBTTagCompound tags) + { + List categories = Arrays.asList(tool.toolCategories()); + final int durability = tags.getInteger("Damage"); + final int maxDur = tags.getInteger("TotalDurability"); + int availableDurability = maxDur - durability; + + //Durability + int base = 24; + int offset = 0; + if (maxDur > 0) + { + if (maxDur >= 10000) + { + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation1"), xSize + 8, base + offset * 11, 0xffffff); + offset++; + fontRenderer.drawString("- " + availableDurability + "/" + maxDur, xSize + 8, base + offset * 10, 0xffffff); + offset++; + } + else + { + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation2") + availableDurability + "/" + maxDur, xSize + 8, base + offset * 10, 0xffffff); + offset++; + } + } + + final float stonebound = tags.getFloat("Shoddy"); + //Attack + if (categories.contains("weapon")) + { + int attack = (int) (tags.getInteger("Attack")); + float stoneboundDamage = (float) Math.log(durability / 72f + 1) * -2 * stonebound; + attack += stoneboundDamage; + attack *= tool.getDamageModifier(); + if (attack < 1) + attack = 1; + + String heart = attack == 2 ? StatCollector.translateToLocal("gui.partcrafter9") : StatCollector.translateToLocal("gui.partcrafter10"); + if (attack % 2 == 0) + this.fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation3") + attack / 2 + heart, xSize + 8, base + offset * 10, 0xffffff); + else + this.fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation3") + attack / 2f + heart, xSize + 8, base + offset * 10, 0xffffff); + offset++; + + if (stoneboundDamage != 0) + { + heart = stoneboundDamage == 2 ? StatCollector.translateToLocal("gui.partcrafter9") : StatCollector.translateToLocal("gui.partcrafter10"); + String bloss = stoneboundDamage > 0 ? StatCollector.translateToLocal("gui.toolstation4") : StatCollector.translateToLocal("gui.toolstation5"); + this.fontRenderer.drawString(bloss + (int) stoneboundDamage / 2 + heart, xSize + 8, base + offset * 10, 0xffffff); + offset++; + } + offset++; + } + + if (categories.contains("bow")) + { + DecimalFormat df = new DecimalFormat("##.##"); + df.setRoundingMode(RoundingMode.DOWN); + int drawSpeed = tags.getInteger("DrawSpeed"); + float flightSpeed = tags.getFloat("FlightSpeed"); + float trueDraw = drawSpeed / 20f * flightSpeed; + this.fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation6") + df.format(trueDraw) + "s", xSize + 8, base + offset * 10, 0xffffff); + offset++; + this.fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation7") + df.format(flightSpeed) + "x", xSize + 8, base + offset * 10, 0xffffff); + offset++; + offset++; + } + + if (categories.contains("ammo")) + { + DecimalFormat df = new DecimalFormat("##.##"); + df.setRoundingMode(RoundingMode.DOWN); + int attack = (int) (tags.getInteger("Attack")); + float mass = tags.getFloat("Mass"); + float shatter = tags.getFloat("BreakChance"); + float accuracy = tags.getFloat("Accuracy"); + + this.fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation10"), xSize + 8, base + offset * 10, 0xffffff); + offset++; + String heart = attack == 2 ? StatCollector.translateToLocal("gui.partcrafter9") : StatCollector.translateToLocal("gui.partcrafter10"); + if (attack % 2 == 0) + this.fontRenderer.drawString("- " + attack / 2 + heart, xSize + 8, base + offset * 10, 0xffffff); + else + this.fontRenderer.drawString("- " + attack / 2f + heart, xSize + 8, base + offset * 10, 0xffffff); + offset++; + int minAttack = attack; + int maxAttack = attack * 2; + heart = StatCollector.translateToLocal("gui.partcrafter10"); + this.fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation11"), xSize + 8, base + offset * 10, 0xffffff); + offset++; + this.fontRenderer.drawString(df.format(minAttack / 2f) + "-" + df.format(maxAttack / 2f) + heart, xSize + 8, base + offset * 10, 0xffffff); + offset++; + offset++; + + this.fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation8") + df.format(mass), xSize + 8, base + offset * 10, 0xffffff); + offset++; + this.fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation9") + df.format(accuracy - 4) + "%", xSize + 8, base + offset * 10, 0xffffff); + offset++; + /*this.fontRenderer.drawString("Chance to break: " + df.format(shatter)+"%", xSize + 8, base + offset * 10, 0xffffff); + offset++;*/ + offset++; + } + + //Mining + if (categories.contains("dualharvest")) + { + float mineSpeed = tags.getInteger("MiningSpeed") / 100f; + float mineSpeed2 = tags.getInteger("MiningSpeed2") / 100f; + float stoneboundSpeed = (float) Math.log(durability / 90f + 1) * 2 * stonebound; + DecimalFormat df = new DecimalFormat("##.##"); + df.setRoundingMode(RoundingMode.DOWN); + float trueSpeed = mineSpeed + stoneboundSpeed; + float trueSpeed2 = mineSpeed + stoneboundSpeed; + + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation12"), xSize + 8, base + offset * 10, 0xffffff); + offset++; + fontRenderer.drawString("- " + df.format(trueSpeed) + ", " + df.format(trueSpeed2), xSize + 8, base + offset * 10, 0xffffff); + offset++; + if (stoneboundSpeed != 0) + { + String bloss = stoneboundSpeed > 0 ? StatCollector.translateToLocal("gui.toolstation4") : StatCollector.translateToLocal("gui.toolstation5"); + fontRenderer.drawString(bloss + df.format(stoneboundSpeed), xSize + 8, base + offset * 10, 0xffffff); + offset++; + } + offset++; + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation13"), xSize + 8, base + offset * 10, 0xffffff); + offset++; + fontRenderer + .drawString("- " + getHarvestLevelName(tags.getInteger("HarvestLevel")) + ", " + getHarvestLevelName(tags.getInteger("HarvestLevel2")), xSize + 8, base + offset * 10, 0xffffff); + offset++; + offset++; + } + else if (categories.contains("harvest")) + { + float mineSpeed = tags.getInteger("MiningSpeed"); + int heads = 1; + + if (tags.hasKey("MiningSpeed2")) + { + mineSpeed += tags.getInteger("MiningSpeed2"); + heads++; + } + + if (tags.hasKey("MiningSpeedHandle")) + { + mineSpeed += tags.getInteger("MiningSpeedHandle"); + heads++; + } + + if (tags.hasKey("MiningSpeedExtra")) + { + mineSpeed += tags.getInteger("MiningSpeedExtra"); + heads++; + } + + float trueSpeed = mineSpeed / (heads * 100f); + + float stoneboundSpeed = (float) Math.log(durability / 90f + 1) * 2 * stonebound; + DecimalFormat df = new DecimalFormat("##.##"); + df.setRoundingMode(RoundingMode.DOWN); + trueSpeed += stoneboundSpeed; + if (trueSpeed < 0) + trueSpeed = 0; + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation14") + df.format(trueSpeed), xSize + 8, base + offset * 10, 0xffffff); + offset++; + if (stoneboundSpeed != 0) + { + String bloss = stoneboundSpeed > 0 ? StatCollector.translateToLocal("gui.toolstation4") : StatCollector.translateToLocal("gui.toolstation5"); + fontRenderer.drawString(bloss + df.format(stoneboundSpeed), xSize + 8, base + offset * 10, 0xffffff); + offset++; + } + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation15") + getHarvestLevelName(tags.getInteger("HarvestLevel")), xSize + 8, base + offset * 10, 0xffffff); + offset++; + offset++; + } + else if (categories.contains("utility")) + { + float mineSpeed = tags.getInteger("MiningSpeed"); + float trueSpeed = mineSpeed / (100f); + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation16") + trueSpeed, xSize + 8, base + offset * 10, 0xffffff); + offset++; + offset++; + } + + int modifiers = tags.getInteger("Modifiers"); + if (modifiers > 0) + { + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation18") + tags.getInteger("Modifiers"), xSize + 8, base + offset * 10, 0xffffff); + offset++; + } + if (tags.hasKey("Tooltip1")) + { + fontRenderer.drawString(StatCollector.translateToLocal("gui.toolstation17"), xSize + 8, base + offset * 10, 0xffffff); + } + + boolean displayToolTips = true; + int tipNum = 0; + while (displayToolTips) + { + tipNum++; + String tooltip = "ModifierTip" + tipNum; + if (tags.hasKey(tooltip)) + { + String tipName = tags.getString(tooltip); + fontRenderer.drawString("- " + tipName, xSize + 8, base + (offset + tipNum) * 10, 0xffffff); + } + else + displayToolTips = false; + } + } + + protected String getHarvestLevelName (int num) + { + switch (num) + { + case 0: + return StatCollector.translateToLocal("gui.partcrafter.mining1"); + case 1: + return StatCollector.translateToLocal("gui.partcrafter.mining2"); + case 2: + return StatCollector.translateToLocal("gui.partcrafter.mining3"); + case 3: + return StatCollector.translateToLocal("gui.partcrafter.mining4"); + case 4: + return StatCollector.translateToLocal("gui.partcrafter.mining5"); + case 5: + return StatCollector.translateToLocal("gui.partcrafter.mining6"); + default: + return String.valueOf(num); + } } - private static final ResourceLocation background = new ResourceLocation("tinker", "textures/gui/crafting.png"); + void drawToolInformation () + { + this.drawCenteredString(fontRenderer, title, xSize + 63, 8, 0xffffff); + fontRenderer.drawSplitString(body, xSize + 8, 24, 115, 0xffffff); + } + + private static final ResourceLocation background = new ResourceLocation("tinker", "textures/gui/tinkertable.png"); + private static final ResourceLocation description = new ResourceLocation("tinker", "textures/gui/description.png"); + private static final ResourceLocation icons = new ResourceLocation("tinker", "textures/gui/icons.png"); + private static final ResourceLocation chest = new ResourceLocation("tinker", "textures/gui/chestside.png"); @Override - protected void drawGuiContainerBackgroundLayer (float f, int i, int j) + protected void drawGuiContainerBackgroundLayer (float par1, int par2, int par3) { + // Draw the background GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); this.mc.getTextureManager().bindTexture(background); - int l = (width - xSize) / 2; - int i1 = (height - ySize) / 2; - drawTexturedModalRect(l, i1, 0, 0, xSize, ySize); + int cornerX = (this.width - this.xSize) / 2; + int cornerY = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(cornerX, cornerY, 0, 0, this.xSize, this.ySize); + + if (active) + { + this.drawTexturedModalRect(cornerX + 62, cornerY, 0, this.ySize, 112, 22); + } + + this.mc.getTextureManager().bindTexture(icons); + // Draw the slots + + if (logic.tinkerTable && !logic.isStackInSlot(5)) + this.drawTexturedModalRect(cornerX + 47, cornerY + 33, 0, 233, 18, 18); + + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.getTextureManager().bindTexture(icons); + + //Draw chest side + if (logic.chest != null) + { + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.getTextureManager().bindTexture(chest); + if (logic.doubleChest == null) + this.drawTexturedModalRect(cornerX - 116, cornerY, 0, 0, 121, this.ySize); + else + this.drawTexturedModalRect(cornerX - 116, cornerY, 125, 0, 122, this.ySize + 21); + } + + // Draw description + if (logic.tinkerTable) + { + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.getTextureManager().bindTexture(description); + cornerX = (this.width + this.xSize) / 2; + cornerY = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(cornerX, cornerY, 0, 0, 126, this.ySize + 30); + } + } + } diff --git a/src/tconstruct/common/TContent.java b/src/tconstruct/common/TContent.java index b014017e20e..38694459fbe 100644 --- a/src/tconstruct/common/TContent.java +++ b/src/tconstruct/common/TContent.java @@ -43,7 +43,8 @@ import tconstruct.library.crafting.*; import tconstruct.library.tools.ToolCore; import tconstruct.library.util.IPattern; -import tconstruct.modifiers.*; +import tconstruct.modifiers.tools.*; +import tconstruct.modifiers.armor.*; import tconstruct.util.*; import tconstruct.util.config.*; @@ -266,9 +267,9 @@ public class TContent implements IFuelHandler public static Item oreBerries; //Tool modifiers - public static ModElectric modE; - public static ModFlux modF; - public static ModLapis modL; + public static ModFlux modFlux; + public static ModLapis modLapis; + public static ModAttack modAttack; //Wearables public static Item glove; @@ -989,9 +990,9 @@ void registerItems () GameRegistry.registerItem(bootsWood, "bootsWood"); exoGoggles = new ExoArmor(PHConstruct.exoGoggles, EnumArmorPart.HELMET, "exosuit").setUnlocalizedName("tconstruct.exoGoggles"); - exoChest = new ExoArmor(PHConstruct.exoChest, EnumArmorPart.CHESTPLATE, "exosuit").setUnlocalizedName("tconstruct.exoChest"); - exoPants = new ExoArmor(PHConstruct.exoPants, EnumArmorPart.LEGGINGS, "exosuit").setUnlocalizedName("tconstruct.exoPants"); - exoShoes = new ExoArmor(PHConstruct.exoShoes, EnumArmorPart.BOOTS, "exosuit").setUnlocalizedName("tconstruct.exoShoes"); + exoChest = new ExoArmor(PHConstruct.exoChest, EnumArmorPart.CHEST, "exosuit").setUnlocalizedName("tconstruct.exoChest"); + exoPants = new ExoArmor(PHConstruct.exoPants, EnumArmorPart.PANTS, "exosuit").setUnlocalizedName("tconstruct.exoPants"); + exoShoes = new ExoArmor(PHConstruct.exoShoes, EnumArmorPart.SHOES, "exosuit").setUnlocalizedName("tconstruct.exoShoes"); String[] materialStrings = { "paperStack", "greenSlimeCrystal", "searedBrick", "ingotCobalt", "ingotArdite", "ingotManyullyn", "mossBall", "lavaCrystal", "necroticBone", "ingotCopper", "ingotTin", "ingotAluminum", "rawAluminum", "ingotBronze", "ingotAluminumBrass", "ingotAlumite", "ingotSteel", "blueSlimeCrystal", "ingotObsidian", "nuggetIron", "nuggetCopper", @@ -1245,16 +1246,29 @@ private void addRecipesForCraftingTable () GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(materials, 1, 25), patSurround, 'm', "nuggetGold", '#', new ItemStack(Item.silk))); // Silky Jewel Recipes GameRegistry.addRecipe(new ItemStack(materials, 1, 26), " c ", "cec", " c ", 'c', new ItemStack(materials, 1, 25), 'e', new ItemStack(Item.emerald)); - // Wooden Armor Recipes - GameRegistry.addRecipe(new ShapedOreRecipe(helmetWood, new Object[] { "www", "w w", 'w', "logWood" })); - GameRegistry.addRecipe(new ShapedOreRecipe(chestplateWood, new Object[] { "w w", "www", "www", 'w', "logWood" })); - GameRegistry.addRecipe(new ShapedOreRecipe(leggingsWood, new Object[] { "www", "w w", "w w", 'w', "logWood" })); - GameRegistry.addRecipe(new ShapedOreRecipe(bootsWood, new Object[] { "w w", "w w", 'w', "logWood" })); - //Exosuit recipes, bronze = 14 - /*exoGoggles = new ExoArmor(PHConstruct.exoGoggles, EnumArmorPart.HELMET, "exosuit").setUnlocalizedName("tconstruct.exoGoggles"); - exoChest = new ExoArmor(PHConstruct.exoChest, EnumArmorPart.CHESTPLATE, "exosuit").setUnlocalizedName("tconstruct.exoChest"); - exoPants = new ExoArmor(PHConstruct.exoPants, EnumArmorPart.LEGGINGS, "exosuit").setUnlocalizedName("tconstruct.exoPants"); - exoShoes = new ExoArmor(PHConstruct.exoShoes, EnumArmorPart.BOOTS, "exosuit").setUnlocalizedName("tconstruct.exoShoes");*/ + // Armor Recipes + Object[] helm = new String[] { "www", "w w" }; + Object[] chest = new String[] { "w w", "www", "www" }; + Object[] pants = new String[] { "www", "w w", "w w" }; + Object[] shoes = new String[] { "w w", "w w" }; + GameRegistry.addRecipe(new ShapedOreRecipe(helmetWood, helm, 'w', "logWood")); + GameRegistry.addRecipe(new ShapedOreRecipe(chestplateWood, chest, 'w', "logWood")); + GameRegistry.addRecipe(new ShapedOreRecipe(leggingsWood, pants, 'w', "logWood")); + GameRegistry.addRecipe(new ShapedOreRecipe(bootsWood, shoes, 'w', "logWood")); + + ItemStack exoGoggleStack = new ItemStack(exoGoggles); + ItemStack exoChestStack = new ItemStack(exoChest); + ItemStack exoPantsStack = new ItemStack(exoPants); + ItemStack exoShoesStack = new ItemStack(exoShoes); + ToolBuilder.instance.addArmorTag(exoGoggleStack); + ToolBuilder.instance.addArmorTag(exoChestStack); + ToolBuilder.instance.addArmorTag(exoPantsStack); + ToolBuilder.instance.addArmorTag(exoShoesStack); + GameRegistry.addShapedRecipe(exoGoggleStack, helm, 'w', new ItemStack(largePlate, 1, 14)); + GameRegistry.addShapedRecipe(exoChestStack, chest, 'w', new ItemStack(largePlate, 1, 14)); + GameRegistry.addShapedRecipe(exoPantsStack, pants, 'w', new ItemStack(largePlate, 1, 14)); + GameRegistry.addShapedRecipe(exoShoesStack, shoes, 'w', new ItemStack(largePlate, 1, 14)); + // Metal conversion Recipes GameRegistry.addRecipe(new ItemStack(metalBlock, 1, 3), patBlock, '#', new ItemStack(materials, 1, 9)); // Copper GameRegistry.addRecipe(new ItemStack(metalBlock, 1, 5), patBlock, '#', new ItemStack(materials, 1, 10)); // Tin @@ -1559,66 +1573,57 @@ private void addRecipesForToolBuilder () tb.registerToolMod(new ModDurability(new ItemStack[] { diamond }, 0, 500, 0f, 3, "Diamond", "\u00a7bDurability +500", "\u00a7b")); tb.registerToolMod(new ModDurability(new ItemStack[] { new ItemStack(Item.emerald) }, 1, 0, 0.5f, 2, "Emerald", "\u00a72Durability +50%", "\u00a72")); - modE = new ModElectric(); - tb.registerToolMod(modE); - modF = new ModFlux(); - tb.registerToolMod(modF); + modFlux = new ModFlux(); + tb.registerToolMod(modFlux); ItemStack redstoneItem = new ItemStack(Item.redstone); ItemStack redstoneBlock = new ItemStack(Block.blockRedstone); - tb.registerToolMod(new ModRedstone(new ItemStack[] { redstoneItem }, 2, 1)); - tb.registerToolMod(new ModRedstone(new ItemStack[] { redstoneItem, redstoneItem }, 2, 2)); - tb.registerToolMod(new ModRedstone(new ItemStack[] { redstoneBlock }, 2, 9)); - tb.registerToolMod(new ModRedstone(new ItemStack[] { redstoneItem, redstoneBlock }, 2, 10)); - tb.registerToolMod(new ModRedstone(new ItemStack[] { redstoneBlock, redstoneBlock }, 2, 18)); + tb.registerToolMod(new ModRedstone(2, new ItemStack[] { redstoneItem, redstoneBlock }, new int[] { 1, 9 })); ItemStack lapisItem = new ItemStack(Item.dyePowder, 1, 4); ItemStack lapisBlock = new ItemStack(Block.blockLapis); - modL = new ModLapis(new ItemStack[] { lapisItem }, 10, 1); - tb.registerToolMod(modL); - tb.registerToolMod(new ModLapis(new ItemStack[] { lapisItem, lapisItem }, 10, 2)); - tb.registerToolMod(new ModLapis(new ItemStack[] { lapisBlock }, 10, 9)); - tb.registerToolMod(new ModLapis(new ItemStack[] { lapisItem, lapisBlock }, 10, 10)); - tb.registerToolMod(new ModLapis(new ItemStack[] { lapisBlock, lapisBlock }, 10, 18)); - - tb.registerToolMod(new ModInteger(new ItemStack[] { new ItemStack(materials, 1, 6) }, 4, "Moss", 3, "\u00a72", "Auto-Repair")); + this.modLapis = new ModLapis(10, new ItemStack[] { lapisItem, lapisBlock }, new int[] { 1, 9 }); + tb.registerToolMod(this.modLapis); + + tb.registerToolMod(new ModInteger(new ItemStack[] { new ItemStack(this.materials, 1, 6) }, 4, "Moss", 3, "\u00a72", "Auto-Repair")); ItemStack blazePowder = new ItemStack(Item.blazePowder); - tb.registerToolMod(new ModBlaze(new ItemStack[] { blazePowder }, 7, 1)); - tb.registerToolMod(new ModBlaze(new ItemStack[] { blazePowder, blazePowder }, 7, 2)); - tb.registerToolMod(new ModAutoSmelt(new ItemStack[] { new ItemStack(materials, 1, 7) }, 6, "Lava", "\u00a74", "Auto-Smelt")); - tb.registerToolMod(new ModInteger(new ItemStack[] { new ItemStack(materials, 1, 8) }, 8, "Necrotic", 1, "\u00a78", "Life Steal")); - - ItemStack quartzItem = new ItemStack(Item.netherQuartz); - ItemStack quartzBlock = new ItemStack(Block.blockNetherQuartz, 1, Short.MAX_VALUE); - tb.registerToolMod(new ModAttack("Quartz", new ItemStack[] { quartzItem }, 11, 1)); - tb.registerToolMod(new ModAttack("Quartz", new ItemStack[] { quartzItem, quartzItem }, 11, 2)); - tb.registerToolMod(new ModAttack("Quartz", new ItemStack[] { quartzBlock }, 11, 4)); - tb.registerToolMod(new ModAttack("Quartz", new ItemStack[] { quartzItem, quartzBlock }, 11, 5)); - tb.registerToolMod(new ModAttack("Quartz", new ItemStack[] { quartzBlock, quartzBlock }, 11, 8)); + tb.registerToolMod(new ModBlaze(7, new ItemStack[] { blazePowder }, new int[] { 1 })); + tb.registerToolMod(new ModAutoSmelt(new ItemStack[] { new ItemStack(this.materials, 1, 7) }, 6, "Lava", "\u00a74", "Auto-Smelt")); + tb.registerToolMod(new ModInteger(new ItemStack[] { new ItemStack(this.materials, 1, 8) }, 8, "Necrotic", 1, "\u00a78", "Life Steal")); + + this.modAttack = new ModAttack("Quartz", 11, new ItemStack[] { new ItemStack(Item.netherQuartz), new ItemStack(Block.blockNetherQuartz, 1, Short.MAX_VALUE) }, new int[] { 1, 4 }); + tb.registerToolMod(this.modAttack); tb.registerToolMod(new ModExtraModifier(new ItemStack[] { diamond, new ItemStack(Block.blockGold) }, "Tier1Free")); + tb.registerToolMod(new ModExtraModifier(new ItemStack[] { new ItemStack(Block.blockDiamond), new ItemStack(Item.appleGold, 1, 1) }, "Tier1.5Free")); tb.registerToolMod(new ModExtraModifier(new ItemStack[] { new ItemStack(Item.netherStar) }, "Tier2Free")); - ItemStack silkyJewel = new ItemStack(materials, 1, 26); + ItemStack silkyJewel = new ItemStack(this.materials, 1, 26); tb.registerToolMod(new ModButtertouch(new ItemStack[] { silkyJewel }, 12)); ItemStack piston = new ItemStack(Block.pistonBase); - tb.registerToolMod(new ModPiston(new ItemStack[] { piston }, 3, 1)); - tb.registerToolMod(new ModPiston(new ItemStack[] { piston, piston }, 3, 2)); + tb.registerToolMod(new ModPiston(3, new ItemStack[] { piston }, new int[] { 1 })); tb.registerToolMod(new ModInteger(new ItemStack[] { new ItemStack(Block.obsidian), new ItemStack(Item.enderPearl) }, 13, "Beheading", 1, "\u00a7d", "Beheading")); - ItemStack holySoil = new ItemStack(craftedSoil, 1, 4); - tb.registerToolMod(new ModSmite("Smite", new ItemStack[] { holySoil }, 14, 1)); - tb.registerToolMod(new ModSmite("Smite", new ItemStack[] { holySoil, holySoil }, 14, 2)); + ItemStack holySoil = new ItemStack(this.craftedSoil, 1, 4); + tb.registerToolMod(new ModSmite("Smite", 14, new ItemStack[] { holySoil }, new int[] { 1 })); ItemStack spidereyeball = new ItemStack(Item.fermentedSpiderEye); - tb.registerToolMod(new ModAntiSpider("Anti-Spider", new ItemStack[] { spidereyeball }, 15, 1)); - tb.registerToolMod(new ModAntiSpider("Anti-Spider", new ItemStack[] { spidereyeball, spidereyeball }, 15, 2)); + tb.registerToolMod(new ModAntiSpider("Anti-Spider", 15, new ItemStack[] { spidereyeball }, new int[] { 1 })); - ItemStack obsidianPlate = new ItemStack(largePlate, 1, 6); + ItemStack obsidianPlate = new ItemStack(this.largePlate, 1, 6); tb.registerToolMod(new ModReinforced(new ItemStack[] { obsidianPlate }, 16, 1)); + EnumSet allArmors = EnumSet.of(EnumArmorPart.HELMET, EnumArmorPart.CHEST, EnumArmorPart.PANTS, EnumArmorPart.SHOES); + EnumSet chest = EnumSet.of(EnumArmorPart.CHEST); + tb.registerArmorMod(new AModMoveSpeed(0, allArmors, new ItemStack[] { redstoneItem, redstoneBlock }, new int[] { 1, 9 }, false)); + tb.registerArmorMod(new AModKnockbackResistance(1, allArmors, new ItemStack[] { new ItemStack(Item.ingotGold), new ItemStack(Block.blockGold) }, new int[] { 1, 9 }, false)); + tb.registerArmorMod(new AModHealthBoost(2, allArmors, new ItemStack[] { new ItemStack(heartCanister, 1, 2) }, new int[] { 2 }, true)); + tb.registerArmorMod(new AModDamageBoost(3, allArmors, new ItemStack[] { new ItemStack(Item.diamond), new ItemStack(Block.blockDiamond) }, new int[] { 1, 9 }, false, 3, 0.05)); + tb.registerArmorMod(new AModDamageBoost(4, chest, new ItemStack[] { new ItemStack(Block.blockNetherQuartz, 1, Short.MAX_VALUE) }, new int[] { 1 }, true, 5, 1)); + tb.registerArmorMod(new AModProtection(5, allArmors, new ItemStack[] { new ItemStack(largePlate, 1, 2) }, new int[] { 2 } )); + TConstructRegistry.registerActiveToolMod(new TActiveOmniMod()); } @@ -2295,40 +2300,18 @@ public void modIntegration () ItemStack batHardened = GameRegistry.findItemStack("ThermalExpansion", "capacitorHardened", 1); if (batHardened != null) { - modF.batteries.add(batHardened); + modFlux.batteries.add(batHardened); } ItemStack basicCell = GameRegistry.findItemStack("ThermalExpansion", "cellBasic", 1); if (basicCell != null) { - modF.batteries.add(basicCell); + modFlux.batteries.add(basicCell); } if (batHardened != null) TConstructClientRegistry.registerManualModifier("fluxmod", ironpick.copy(), (ItemStack) batHardened); if (basicCell != null) TConstructClientRegistry.registerManualModifier("fluxmod2", ironpick.copy(), (ItemStack) basicCell); - /* IC2 */ - - //ItemStack reBattery = ic2.api.item.Items.getItem("reBattery"); - Object reBattery = getStaticItem("reBattery", "ic2.core.Ic2Items"); - if (reBattery != null) - { - modE.batteries.add((ItemStack) reBattery); - } - //ItemStack chargedReBattery = ic2.api.item.Items.getItem("chargedReBattery"); - Object chargedReBattery = getStaticItem("chargedReBattery", "ic2.core.Ic2Items"); - if (chargedReBattery != null) - { - modE.batteries.add((ItemStack) chargedReBattery); - } - //ItemStack electronicCircuit = ic2.api.item.Items.getItem("electronicCircuit"); - Object electronicCircuit = getStaticItem("electronicCircuit", "ic2.core.Ic2Items"); - if (electronicCircuit != null) - modE.circuits.add((ItemStack) electronicCircuit); - - if (chargedReBattery != null && electronicCircuit != null) - TConstructClientRegistry.registerManualModifier("electricmod", ironpick.copy(), (ItemStack) chargedReBattery, (ItemStack) electronicCircuit); - /* Thaumcraft */ Object obj = getStaticItem("itemResource", "thaumcraft.common.config.ConfigItems"); if (obj != null) diff --git a/src/tconstruct/common/TProxyCommon.java b/src/tconstruct/common/TProxyCommon.java index f8ec6605ce3..8ceff4bab63 100644 --- a/src/tconstruct/common/TProxyCommon.java +++ b/src/tconstruct/common/TProxyCommon.java @@ -52,6 +52,7 @@ public Object getServerGuiElement (int ID, EntityPlayer player, World world, int else if (ID < 100) { TileEntity tile = world.getBlockTileEntity(x, y, z); + System.out.println(tile instanceof InventoryLogic); if (tile != null && tile instanceof InventoryLogic) { return ((InventoryLogic) tile).getGuiContainer(player.inventory, world, x, y, z); diff --git a/src/tconstruct/inventory/CraftingStationContainer.java b/src/tconstruct/inventory/CraftingStationContainer.java index 68b525e687a..c73ad4206d9 100644 --- a/src/tconstruct/inventory/CraftingStationContainer.java +++ b/src/tconstruct/inventory/CraftingStationContainer.java @@ -7,16 +7,21 @@ import net.minecraft.inventory.InventoryCrafting; import net.minecraft.inventory.Slot; import net.minecraft.inventory.SlotCrafting; +import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.item.crafting.CraftingManager; import net.minecraft.world.World; import tconstruct.blocks.logic.CraftingStationLogic; +import tconstruct.library.armor.ArmorCore; +import tconstruct.library.crafting.ToolBuilder; +import tconstruct.library.tools.ToolCore; public class CraftingStationContainer extends Container { /** The crafting matrix inventory (3x3). */ public InventoryCrafting craftMatrix;// = new InventoryCrafting(this, 3, 3); public IInventory craftResult;// = new InventoryCraftResult(); + private CraftingStationLogic logic; private World worldObj; private int posX; private int posY; @@ -28,6 +33,7 @@ public CraftingStationContainer(InventoryPlayer inventorplayer, CraftingStationL this.posX = x; this.posY = y; this.posZ = z; + this.logic = logic; craftMatrix = new InventoryCraftingStation(this, 3, 3, logic); craftResult = new InventoryCraftingStationResult(logic); @@ -58,12 +64,71 @@ public CraftingStationContainer(InventoryPlayer inventorplayer, CraftingStationL this.addSlotToContainer(new Slot(inventorplayer, column, 8 + column * 18, 142)); } + //Side inventory + if (logic.chest != null) + { + IInventory chest = logic.chest.get(); + IInventory doubleChest = logic.doubleChest == null ? null : logic.doubleChest.get(); + int count = 0; + for (column = 0; column < 9; column++) + { + for (row = 0; row < 6; row++) + { + int value = count < 27 ? count : count - 27; + this.addSlotToContainer(new Slot(count < 27 ? chest : doubleChest, value, -108 + row * 18, 19 + column * 18)); + count++; + if (count >= 27 && doubleChest == null) + break; + } + if (count >= 27 && doubleChest == null) + break; + } + } + this.onCraftMatrixChanged(this.craftMatrix); } public void onCraftMatrixChanged (IInventory par1IInventory) { - this.craftResult.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(this.craftMatrix, this.worldObj)); + ItemStack tool = modifyTool(); + if (tool != null) + this.craftResult.setInventorySlotContents(0, tool); + else + this.craftResult.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(this.craftMatrix, this.worldObj)); + } + + public ItemStack modifyTool () + { + ItemStack input = craftMatrix.getStackInSlot(4); + if (input != null) + { + Item item = input.getItem(); + if (item instanceof ToolCore) + { + ItemStack[] slots = new ItemStack[8]; + for (int i = 0; i < 4; i++) + { + slots[i] = craftMatrix.getStackInSlot(i); + slots[i + 4] = craftMatrix.getStackInSlot(i + 5); + } + ItemStack output = ToolBuilder.instance.modifyTool(input, slots, ""); + if (output != null) + return output; + } + else if (item instanceof ArmorCore) + { + ItemStack[] slots = new ItemStack[8]; + for (int i = 0; i < 4; i++) + { + slots[i] = craftMatrix.getStackInSlot(i); + slots[i + 4] = craftMatrix.getStackInSlot(i + 5); + } + ItemStack output = ToolBuilder.instance.modifyArmor(input, slots, ""); + if (output != null) + return output; + } + } + return null; } public void onContainerClosed (EntityPlayer par1EntityPlayer) diff --git a/src/tconstruct/items/OreBerries.java b/src/tconstruct/items/OreBerries.java index 4acdd9e60b8..09e38166574 100644 --- a/src/tconstruct/items/OreBerries.java +++ b/src/tconstruct/items/OreBerries.java @@ -53,7 +53,7 @@ public ItemStack onItemRightClick (ItemStack stack, World world, EntityPlayer pl { if (stack.getItemDamage() == 5) { - EntityXPOrb entity = new EntityXPOrb(world, player.posX, player.posY + 1, player.posZ, itemRand.nextInt(4) + 3); + EntityXPOrb entity = new EntityXPOrb(world, player.posX, player.posY + 1, player.posZ, itemRand.nextInt(14) + 6); spawnEntity(player.posX, player.posY + 1, player.posZ, entity, world, player); if (!player.capabilities.isCreativeMode) stack.stackSize--; diff --git a/src/tconstruct/items/armor/ExoArmor.java b/src/tconstruct/items/armor/ExoArmor.java index 61e5a610e30..a9af7f502f5 100644 --- a/src/tconstruct/items/armor/ExoArmor.java +++ b/src/tconstruct/items/armor/ExoArmor.java @@ -5,13 +5,19 @@ import com.google.common.collect.Multimap; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + import net.minecraft.client.renderer.texture.IconRegister; import net.minecraft.creativetab.CreativeTabs; import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.SharedMonsterAttributes; import net.minecraft.entity.ai.attributes.AttributeModifier; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.*; +import net.minecraft.util.DamageSource; import tconstruct.library.TConstructRegistry; import tconstruct.library.armor.ArmorCore; import tconstruct.library.armor.EnumArmorPart; @@ -19,10 +25,6 @@ public class ExoArmor extends ArmorCore { String textureName; - protected static final UUID speed = UUID.fromString("CB3F55A9-629C-4F38-A497-9C13A33DB5CF"); - protected static final UUID attack = UUID.fromString("CB3F55A9-629C-4F38-A497-9C13A33DB5CE"); - protected static final UUID health = UUID.fromString("CB3F55A9-629C-4F38-A497-9C13A33DB5CD"); - protected static final UUID knockback = UUID.fromString("CB3F55A9-629C-4F38-A497-9C13A33DB5CC"); public ExoArmor(int id, EnumArmorPart part, String texture) { super(id, 0, part); @@ -43,31 +45,36 @@ public String getArmorTexture (ItemStack stack, Entity entity, int slot, int lay return "tinker:textures/armor/" + textureName + "_" + layer + ".png"; } + @Override + public void damageArmor (EntityLivingBase entity, ItemStack stack, DamageSource source, int damage, int slot) + { + //Deimplemented for now + } + + @SideOnly(Side.CLIENT) public void getSubItems (int par1, CreativeTabs par2CreativeTabs, List par3List) { ItemStack armor = new ItemStack(par1, 1, 0); NBTTagCompound baseTag = new NBTTagCompound(); NBTTagList list = new NBTTagList(); - list.appendTag(getAttributeTag("generic.attackDamage", "ExoAttack", 10.0, true, knockback)); - list.appendTag(getAttributeTag("generic.movementSpeed", "ExoSpeed", 1.5, false, speed)); - list.appendTag(getAttributeTag("generic.maxHealth", "ExoHealth", 10.0, true, health)); - list.appendTag(getAttributeTag("generic.knockbackResistance", "ExoKnockback", 0.5, false, knockback)); + NBTTagCompound armorTag = new NBTTagCompound(); + armorTag.setInteger("Modifiers", 30); + baseTag.setTag(SET_NAME, armorTag); - baseTag.setTag("AttributeModifiers", list); armor.setTagCompound(baseTag); par3List.add(armor); } - private NBTTagCompound getAttributeTag(String attributeType, String modifierName, double amount, boolean flat, UUID uuid) + @SideOnly(Side.CLIENT) + public void addInformation (ItemStack stack, EntityPlayer player, List list, boolean par4) { - NBTTagCompound knockbackTag = new NBTTagCompound(); - knockbackTag.setString("AttributeName", attributeType); - knockbackTag.setString("Name", modifierName); - knockbackTag.setDouble("Amount", amount); - knockbackTag.setInteger("Operation", flat ? 0 : 1);//0 = flat increase, 1 = % increase - knockbackTag.setLong("UUIDMost", uuid.getMostSignificantBits()); - knockbackTag.setLong("UUIDLeast", uuid.getLeastSignificantBits()); - return knockbackTag; + if (!stack.hasTagCompound()) + return; + + NBTTagCompound tag = stack.getTagCompound().getCompoundTag(SET_NAME); + double protection = tag.getDouble("protection"); + if (protection > 0) + list.add("\u00a7aProtection: "+protection+"%"); } } diff --git a/src/tconstruct/library/armor/ArmorCore.java b/src/tconstruct/library/armor/ArmorCore.java index 6f8bf87db10..7b190a70cb1 100644 --- a/src/tconstruct/library/armor/ArmorCore.java +++ b/src/tconstruct/library/armor/ArmorCore.java @@ -2,11 +2,16 @@ import net.minecraft.block.BlockDispenser; import net.minecraft.dispenser.IBehaviorDispenseItem; -import net.minecraft.entity.*; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.item.*; +import net.minecraft.item.EnumArmorMaterial; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.DamageSource; +import net.minecraft.util.MathHelper; import net.minecraft.world.World; import net.minecraftforge.common.ISpecialArmor; @@ -50,6 +55,11 @@ public ItemStack onItemRightClick (ItemStack par1ItemStack, World par2World, Ent @Override public ArmorProperties getProperties (EntityLivingBase player, ItemStack armor, DamageSource source, double damage, int slot) { + if (player.worldObj.isRemote) + { + return new ArmorProperties(0, 0, baseProtection); + } + NBTTagCompound tags = armor.getTagCompound(); if (tags == null) @@ -58,15 +68,28 @@ public ArmorProperties getProperties (EntityLivingBase player, ItemStack armor, } NBTTagCompound data = tags.getCompoundTag(SET_NAME); - - return new ArmorProperties(0, data.getInteger("damageReduction") / damage, data.getInteger("maxAbsorb")); + double amount = (data.getInteger("defense") / damage) + (data.getDouble("protection") / 100); + if (source.isUnblockable()) + amount = 0; + clamp_double(amount, 0, 1); + return new ArmorProperties(0, amount, 100); + } + + public static double clamp_double (double par0, double par1, double par2) + { + return par0 < par1 ? par1 : (par0 > par2 ? par2 : par0); } @Override public int getArmorDisplay (EntityPlayer player, ItemStack armor, int slot) { - return armor.getTagCompound() != null && armor.getTagCompound().getCompoundTag(SET_NAME) != null ? armor.getTagCompound().getCompoundTag(SET_NAME).getInteger("maxAbsorb") - : this.baseProtection; + if (!armor.hasTagCompound()) + return this.baseProtection; + NBTTagCompound armorTag = armor.getTagCompound().getCompoundTag(SET_NAME); + double amount = armorTag.getDouble("protection") / 4; + if (amount > 0 && amount < 1) + amount = 1; + return (int) (Math.floor(amount)); } @Override @@ -81,14 +104,13 @@ public void damageArmor (EntityLivingBase entity, ItemStack stack, DamageSource stack.setTagCompound(tags); data = new NBTTagCompound(); tags.setCompoundTag(SET_NAME, data); - data.setInteger("damageReduction", baseProtection); - data.setInteger("maxAbsorb", baseProtection); + data.setDouble("damageReduction", baseProtection); } data = tags.getCompoundTag(SET_NAME); int dmg = data.getInteger("Damage"); dmg += damage; - data.setInteger("Damage", dmg); + data.setDouble("Damage", dmg); } // Vanilla overrides diff --git a/src/tconstruct/library/armor/ArmorMod.java b/src/tconstruct/library/armor/ArmorMod.java new file mode 100644 index 00000000000..bdb7aa85ac1 --- /dev/null +++ b/src/tconstruct/library/armor/ArmorMod.java @@ -0,0 +1,54 @@ +package tconstruct.library.armor; + +import java.util.EnumSet; +import java.util.UUID; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import tconstruct.library.tools.ToolMod; + +public abstract class ArmorMod extends ToolMod +{ + protected final EnumSet armorTypes; + + public ArmorMod(int effect, String dataKey, EnumSet armorTypes, ItemStack[] items) + { + super(items, effect, dataKey); + this.armorTypes = armorTypes; + } + + @Override + protected boolean canModify (ItemStack armor, ItemStack[] input) + { + ArmorCore item = (ArmorCore) armor.getItem(); + if (armorTypes.contains(item.armorPart)) + { + NBTTagCompound tags = armor.getTagCompound().getCompoundTag(getTagName()); + return tags.getInteger("Modifiers") > 0; + } + return false; + } + + @Override + protected String getTagName () + { + return "TinkerArmor"; + } + + public boolean validArmorType (ArmorCore armor) + { + return true; + } + + protected NBTTagCompound getAttributeTag(String attributeType, String modifierName, double amount, boolean flat, UUID uuid) + { + NBTTagCompound tag = new NBTTagCompound(); + tag.setString("AttributeName", attributeType); + tag.setString("Name", modifierName); + tag.setDouble("Amount", amount); + tag.setInteger("Operation", flat ? 0 : 1);//0 = flat increase, 1 = % increase + tag.setLong("UUIDMost", uuid.getMostSignificantBits()); + tag.setLong("UUIDLeast", uuid.getLeastSignificantBits()); + return tag; + } +} diff --git a/src/tconstruct/library/armor/EnumArmorPart.java b/src/tconstruct/library/armor/EnumArmorPart.java index daccd220452..17c8bbc0b77 100644 --- a/src/tconstruct/library/armor/EnumArmorPart.java +++ b/src/tconstruct/library/armor/EnumArmorPart.java @@ -3,7 +3,7 @@ public enum EnumArmorPart { - HELMET(0), CHESTPLATE(1), LEGGINGS(2), BOOTS(3); + HELMET(0), CHEST(1), PANTS(2), SHOES(3); private final int partID; diff --git a/src/tconstruct/library/crafting/ToolBuilder.java b/src/tconstruct/library/crafting/ToolBuilder.java index fe330787902..53d846b0745 100644 --- a/src/tconstruct/library/crafting/ToolBuilder.java +++ b/src/tconstruct/library/crafting/ToolBuilder.java @@ -5,19 +5,20 @@ import java.util.HashMap; import java.util.List; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.Event.Result; import tconstruct.library.TConstructRegistry; +import tconstruct.library.armor.ArmorMod; import tconstruct.library.event.ToolCraftEvent; import tconstruct.library.tools.ToolCore; import tconstruct.library.tools.ToolMaterial; import tconstruct.library.tools.ToolMod; import tconstruct.library.util.IToolPart; -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraftforge.common.MinecraftForge; -import net.minecraftforge.event.Event.Result; - public class ToolBuilder { public static ToolBuilder instance = new ToolBuilder(); @@ -26,6 +27,7 @@ public class ToolBuilder public List combos = new ArrayList(); public HashMap modifiers = new HashMap(); public List toolMods = new ArrayList(); + public List armorMods = new ArrayList(); /* Build tools */ public static void addNormalToolRecipe (ToolCore output, Item head, Item handle) @@ -356,6 +358,7 @@ else if (event.getResult() == Result.ALLOW) return tool; } + @Deprecated public ItemStack modifyTool (ItemStack input, ItemStack topSlot, ItemStack bottomSlot, ItemStack extraStack, String name) { if (extraStack != null) @@ -392,6 +395,80 @@ public ItemStack modifyTool (ItemStack input, ItemStack topSlot, ItemStack botto else return null; } + + public ItemStack modifyTool (ItemStack input, ItemStack[] slots, String name) + { + ItemStack tool = input.copy(); + NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + tags.removeTag("Built"); + + boolean built = false; + for (ToolMod mod : toolMods) + { + if (mod.matches(slots, tool)) + { + built = true; + mod.addMatchingEffect(tool); + mod.modify(slots, tool); + } + } + + tags = tool.getTagCompound(); + if (name != null && !name.equals("") && !tags.hasKey("display")) + { + tags.setCompoundTag("display", new NBTTagCompound()); + tags.getCompoundTag("display").setString("Name", "\u00A7f" + name); + } + + if (built) + return tool; + else + return null; + } + + public ItemStack modifyArmor (ItemStack input, ItemStack[] slots, String name) + { + ItemStack armor = input.copy(); + if (!armor.hasTagCompound()) + addArmorTag(input); + NBTTagCompound tags = armor.getTagCompound().getCompoundTag("TinkerArmor"); + tags.removeTag("Built"); + + boolean built = false; + for (ArmorMod mod : armorMods) + { + if (mod.matches(slots, armor)) + { + built = true; + mod.addMatchingEffect(armor); + mod.modify(slots, armor); + } + } + + tags = armor.getTagCompound(); + if (name != null && !name.equals("") && !tags.hasKey("display")) + { + tags.setCompoundTag("display", new NBTTagCompound()); + tags.getCompoundTag("display").setString("Name", "\u00A7f" + name); + } + + if (built) + return armor; + else + return null; + } + + public void addArmorTag (ItemStack armor) //Not sure if temporary or not + { + NBTTagCompound baseTag = new NBTTagCompound(); + NBTTagList list = new NBTTagList(); + + NBTTagCompound armorTag = new NBTTagCompound(); + armorTag.setInteger("Modifiers", 30); + baseTag.setTag("TinkerArmor", armorTag); + + armor.setTagCompound(baseTag); + } int buildReinforced (ToolMaterial headMat, ToolMaterial handleMat, ToolMaterial accessoryMat, ToolMaterial extraMat) { @@ -439,6 +516,15 @@ float buildShoddy (ToolMaterial headMat, ToolMaterial handleMat, ToolMaterial ac public static void registerToolMod (ToolMod mod) { + if (mod == null) + throw new NullPointerException("Tool modifier cannot be null."); instance.toolMods.add(mod); } + + public static void registerArmorMod(ArmorMod mod) + { + if (mod == null) + throw new NullPointerException("Armor modifier cannot be null."); + instance.armorMods.add(mod); + } } diff --git a/src/tconstruct/library/tools/ToolMod.java b/src/tconstruct/library/tools/ToolMod.java index 9932c2e7732..c7aa82a55ca 100644 --- a/src/tconstruct/library/tools/ToolMod.java +++ b/src/tconstruct/library/tools/ToolMod.java @@ -17,7 +17,6 @@ public abstract class ToolMod public ToolMod(ItemStack[] items, int effect, String dataKey) { - //recipeItems = items; List itemstacks = new ArrayList(); for (int iter = 0; iter < items.length; iter++) itemstacks.add(items[iter]); @@ -71,6 +70,11 @@ public boolean matches (ItemStack[] input, ItemStack tool) return list.isEmpty(); } + protected String getTagName () + { + return "InfiTool"; + } + /** * * @param tool Tool to compare against @@ -79,7 +83,7 @@ public boolean matches (ItemStack[] input, ItemStack tool) protected boolean canModify (ItemStack tool, ItemStack[] input) { - NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); return tags.getInteger("Modifiers") > 0; } @@ -92,7 +96,7 @@ protected boolean canModify (ItemStack tool, ItemStack[] input) public void addMatchingEffect (ItemStack tool) { - NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); if (tags.hasKey("Effect6") || tags.hasKey(key)) return; @@ -124,7 +128,7 @@ else if (tags.hasKey("Effect1")) protected int addModifierTip (ItemStack tool, String modifierTip) { - NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); int tipNum = 0; while (true) { @@ -142,7 +146,7 @@ protected int addModifierTip (ItemStack tool, String modifierTip) protected int addToolTip (ItemStack tool, String tooltip, String modifierTip) { - NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); int tipNum = 0; while (true) { @@ -206,4 +210,20 @@ public boolean validType (ToolCore tool) { return true; } + + public boolean areItemsEquivalent (ItemStack stack1, ItemStack stack2) + { + if (stack1.itemID != stack2.itemID) + return false; + return ItemStack.areItemStackTagsEqual(stack1, stack2); + } + + public boolean areItemStacksEquivalent (ItemStack stack1, ItemStack stack2) + { + if (stack1.itemID != stack2.itemID) + return false; + if (stack1.getItemDamage() != stack2.getItemDamage()) + return false; + return ItemStack.areItemStackTagsEqual(stack1, stack2); + } } diff --git a/src/tconstruct/modifiers/ModElectric.java b/src/tconstruct/modifiers/ModElectric.java deleted file mode 100644 index 309be061208..00000000000 --- a/src/tconstruct/modifiers/ModElectric.java +++ /dev/null @@ -1,87 +0,0 @@ -package tconstruct.modifiers; - -import ic2.api.item.IElectricItem; - -import java.util.ArrayList; - -import tconstruct.library.tools.ToolCore; - -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; - -/* IC2 support */ - -public class ModElectric extends ModBoolean -{ - public ArrayList circuits = new ArrayList(); - public ArrayList batteries = new ArrayList(); - - public ModElectric() - { - super(new ItemStack[0], 9, "Electric", "\u00a7e", ""); - } - - @Override - public boolean matches (ItemStack[] input, ItemStack tool) - { - if (input[0] == null || input[1] == null) - return false; - - boolean circuit = false; - boolean battery = false; - - for (ItemStack stack : circuits) - { - if (stack.isItemEqual(input[0]) || stack.isItemEqual(input[1])) - circuit = true; - } - - for (ItemStack stack : batteries) - { - if (stack.itemID == input[0].itemID && input[0].getItem() instanceof IElectricItem) - { - battery = true; - } - if (stack.itemID == input[1].itemID && input[1].getItem() instanceof IElectricItem) - { - battery = true; - } - } - return circuit && battery && canModify(tool, input); - } - - /*@Override - protected boolean canModify (ItemStack tool, ItemStack[] input) - { - NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); - if (!tags.hasKey(key)) - return tags.getInteger("Modifiers") > 0; - - return false; - }*/ - - @Override - public void modify (ItemStack[] input, ItemStack tool) - { - NBTTagCompound tags = tool.getTagCompound(); - - if (!tags.hasKey(key)) - { - tags.setBoolean(key, true); - - int modifiers = tags.getCompoundTag("InfiTool").getInteger("Modifiers"); - modifiers -= 1; - tags.getCompoundTag("InfiTool").setInteger("Modifiers", modifiers); - int charge = 0; - if (input[0].getItem() instanceof IElectricItem && input[0].hasTagCompound()) - charge = input[0].getTagCompound().getInteger("charge"); - if (input[1].getItem() instanceof IElectricItem && input[1].hasTagCompound()) - charge = input[1].getTagCompound().getInteger("charge"); - tags.setInteger("charge", charge); - tags.setInteger(key, 1); - addModifierTip(tool, "\u00a7eElectric"); - ToolCore toolcore = (ToolCore) tool.getItem(); - tool.setItemDamage(1 + (toolcore.getMaxCharge(tool) - charge) * (tool.getMaxDamage() - 1) / toolcore.getMaxCharge(tool)); - } - } -} diff --git a/src/tconstruct/modifiers/armor/AModDamageBoost.java b/src/tconstruct/modifiers/armor/AModDamageBoost.java new file mode 100644 index 00000000000..92fb133758b --- /dev/null +++ b/src/tconstruct/modifiers/armor/AModDamageBoost.java @@ -0,0 +1,98 @@ +package tconstruct.modifiers.armor; + +import java.util.EnumSet; +import java.util.UUID; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import tconstruct.library.armor.ArmorCore; +import tconstruct.library.armor.EnumArmorPart; + +//TODO: Condense attribute modifiers into one class +public class AModDamageBoost extends ArmorModTypeFilter +{ + final boolean modifierType; + final int modifyAmount; + final double scaleAmount; + + public AModDamageBoost(int effect, EnumSet armorTypes, ItemStack[] items, int[] values, boolean type, int modifiers, double scale) + { + super(effect, "ExoAttack" + (type ? "Percent" : "Flat"), armorTypes, items, values); + this.modifierType = type; + this.modifyAmount = modifiers; + this.scaleAmount = scale; + } + + @Override + protected boolean canModify (ItemStack tool, ItemStack[] input) + { + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); + int amount = matchingAmount(input) * modifyAmount; + return tags.getInteger("Modifiers") >= amount; + } + + @Override + public void modify (ItemStack[] input, ItemStack armor) + { + NBTTagCompound baseTag = armor.getTagCompound(); + NBTTagCompound armorTag = armor.getTagCompound().getCompoundTag(getTagName()); + + int modifiers = armorTag.getInteger("Modifiers"); + modifiers -= matchingAmount(input) * modifyAmount; + armorTag.setInteger("Modifiers", modifiers); + + int amount = matchingAmount(input); + if (armorTag.hasKey(key)) + { + amount += armorTag.getInteger(key); + } + armorTag.setInteger(key, amount); + + NBTTagList attributes; + if (baseTag.hasKey("AttributeModifiers")) + { + attributes = baseTag.getTagList("AttributeModifiers"); + for (int iter = 0; iter < attributes.tagCount(); iter++) + { + NBTTagCompound tag = (NBTTagCompound) attributes.tagAt(iter); + if (tag.getString("AttributeName").equals("generic.attackDamage")) + { + attributes.removeTag(iter); + } + } + } + else + { + attributes = new NBTTagList(); + baseTag.setTag("AttributeModifiers", attributes); + } + attributes.appendTag(getAttributeTag("generic.attackDamage", key, amount * scaleAmount, modifierType, getUUIDFromItem(armor))); + } + + private static final UUID headScale = UUID.fromString("8d39e761-c100-4f81-853d-12dc8b424c10"); + private static final UUID chestScale = UUID.fromString("8d39e761-c100-4f81-853d-12dc8b424c11"); + private static final UUID pantsScale = UUID.fromString("8d39e761-c100-4f81-853d-12dc8b424c12"); + private static final UUID shoesScale = UUID.fromString("8d39e761-c100-4f81-853d-12dc8b424c13"); + private static final UUID headFlat = UUID.fromString("8d39e761-c100-4f81-853d-12dc8b424c14"); + private static final UUID chestFlat = UUID.fromString("8d39e761-c100-4f81-853d-12dc8b424c15"); + private static final UUID pantsFlat = UUID.fromString("8d39e761-c100-4f81-853d-12dc8b424c16"); + private static final UUID shoesFlat = UUID.fromString("8d39e761-c100-4f81-853d-12dc8b424c17"); + + UUID getUUIDFromItem (ItemStack stack) + { + ArmorCore item = (ArmorCore) stack.getItem(); + switch (item.armorPart) + { + case HELMET: + return modifierType ? headScale : headFlat; + case CHEST: + return modifierType ? chestScale : chestFlat; + case PANTS: + return modifierType ? pantsScale : pantsFlat; + case SHOES: + return modifierType ? shoesScale : pantsFlat; + } + return null; + } +} diff --git a/src/tconstruct/modifiers/armor/AModHealthBoost.java b/src/tconstruct/modifiers/armor/AModHealthBoost.java new file mode 100644 index 00000000000..ac49608bd00 --- /dev/null +++ b/src/tconstruct/modifiers/armor/AModHealthBoost.java @@ -0,0 +1,89 @@ +package tconstruct.modifiers.armor; + +import java.util.EnumSet; +import java.util.UUID; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import tconstruct.library.armor.ArmorCore; +import tconstruct.library.armor.EnumArmorPart; + +//TODO: Condense attribute modifiers into one class +public class AModHealthBoost extends ArmorModTypeFilter +{ + final boolean modifierType; + final int modifyAmount = 3; + + public AModHealthBoost(int effect, EnumSet armorTypes, ItemStack[] items, int[] values, boolean type) + { + super(effect, "ExoHealth" + (type ? "Percent" : "Flat"), armorTypes, items, values); + this.modifierType = type; + } + + @Override + protected boolean canModify (ItemStack tool, ItemStack[] input) + { + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); + int amount = matchingItems(input)*modifyAmount; + return tags.getInteger("Modifiers") >= amount; + } + + @Override + public void modify (ItemStack[] input, ItemStack armor) + { + NBTTagCompound baseTag = armor.getTagCompound(); + NBTTagCompound armorTag = armor.getTagCompound().getCompoundTag(getTagName()); + + int modifiers = armorTag.getInteger("Modifiers"); + modifiers -= matchingAmount(input)*modifyAmount; + armorTag.setInteger("Modifiers", modifiers); + + int amount = matchingAmount(input); + if (armorTag.hasKey(key)) + { + amount += armorTag.getInteger(key); + } + armorTag.setInteger(key, amount); + + NBTTagList attributes; + if (baseTag.hasKey("AttributeModifiers")) + { + attributes = baseTag.getTagList("AttributeModifiers"); + for (int iter = 0; iter < attributes.tagCount(); iter++) + { + NBTTagCompound tag = (NBTTagCompound) attributes.tagAt(iter); + if (tag.getString("AttributeName").equals("generic.maxHealth")) + attributes.removeTag(iter); + } + } + else + { + attributes = new NBTTagList(); + baseTag.setTag("AttributeModifiers", attributes); + } + attributes.appendTag(getAttributeTag("generic.maxHealth", key, amount, modifierType, getUUIDFromItem(armor))); + } + + private static final UUID head = UUID.fromString("a2eac357-cae3-4a8f-994c-a8bcbbd6dab8"); + private static final UUID chest = UUID.fromString("a2eac357-cae3-4a8f-994c-a8bcbbd6dab9"); + private static final UUID pants = UUID.fromString("a2eac357-cae3-4a8f-994c-a8bcbbd6daba"); + private static final UUID shoes = UUID.fromString("a2eac357-cae3-4a8f-994c-a8bcbbd6dabb"); + + UUID getUUIDFromItem (ItemStack stack) + { + ArmorCore item = (ArmorCore) stack.getItem(); + switch (item.armorPart) + { + case HELMET: + return head; + case CHEST: + return chest; + case PANTS: + return pants; + case SHOES: + return shoes; + } + return null; + } +} diff --git a/src/tconstruct/modifiers/armor/AModKnockbackResistance.java b/src/tconstruct/modifiers/armor/AModKnockbackResistance.java new file mode 100644 index 00000000000..6a53a9fc2f3 --- /dev/null +++ b/src/tconstruct/modifiers/armor/AModKnockbackResistance.java @@ -0,0 +1,89 @@ +package tconstruct.modifiers.armor; + +import java.util.EnumSet; +import java.util.UUID; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import tconstruct.library.armor.ArmorCore; +import tconstruct.library.armor.EnumArmorPart; + +//TODO: Condense attribute modifiers into one class +public class AModKnockbackResistance extends ArmorModTypeFilter +{ + final boolean modifierType; + final int modifyAmount = 2; + + public AModKnockbackResistance(int effect, EnumSet armorTypes, ItemStack[] items, int[] values, boolean type) + { + super(effect, "ExoKnockback" + (type ? "Percent" : "Flat"), armorTypes, items, values); + this.modifierType = type; + } + + @Override + protected boolean canModify (ItemStack tool, ItemStack[] input) + { + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); + int amount = matchingItems(input) * modifyAmount; + return tags.getInteger("Modifiers") >= amount; + } + + @Override + public void modify (ItemStack[] input, ItemStack armor) + { + NBTTagCompound baseTag = armor.getTagCompound(); + NBTTagCompound armorTag = armor.getTagCompound().getCompoundTag(getTagName()); + + int modifiers = armorTag.getInteger("Modifiers"); + modifiers -= matchingAmount(input) * modifyAmount; + armorTag.setInteger("Modifiers", modifiers); + + int amount = matchingAmount(input); + if (armorTag.hasKey(key)) + { + amount += armorTag.getInteger(key); + } + armorTag.setInteger(key, amount); + + NBTTagList attributes; + if (baseTag.hasKey("AttributeModifiers")) + { + attributes = baseTag.getTagList("AttributeModifiers"); + for (int iter = 0; iter < attributes.tagCount(); iter++) + { + NBTTagCompound tag = (NBTTagCompound) attributes.tagAt(iter); + if (tag.getString("AttributeName").equals("generic.knockbackResistance")) + attributes.removeTag(iter); + } + } + else + { + attributes = new NBTTagList(); + baseTag.setTag("AttributeModifiers", attributes); + } + attributes.appendTag(getAttributeTag("generic.knockbackResistance", key, amount*0.01, modifierType, getUUIDFromItem(armor))); + } + + private static final UUID head = UUID.fromString("4188779d-69d4-487c-b307-c4c182522c44"); + private static final UUID chest = UUID.fromString("4188779d-69d4-487c-b307-c4c182522c45"); + private static final UUID pants = UUID.fromString("4188779d-69d4-487c-b307-c4c182522c46"); + private static final UUID shoes = UUID.fromString("4188779d-69d4-487c-b307-c4c182522c47"); + + UUID getUUIDFromItem (ItemStack stack) + { + ArmorCore item = (ArmorCore) stack.getItem(); + switch (item.armorPart) + { + case HELMET: + return head; + case CHEST: + return chest; + case PANTS: + return pants; + case SHOES: + return shoes; + } + return null; + } +} diff --git a/src/tconstruct/modifiers/armor/AModMoveSpeed.java b/src/tconstruct/modifiers/armor/AModMoveSpeed.java new file mode 100644 index 00000000000..3b9be565469 --- /dev/null +++ b/src/tconstruct/modifiers/armor/AModMoveSpeed.java @@ -0,0 +1,88 @@ +package tconstruct.modifiers.armor; + +import java.util.EnumSet; +import java.util.UUID; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import tconstruct.library.armor.ArmorCore; +import tconstruct.library.armor.EnumArmorPart; + +//TODO: Condense attribute modifiers into one class +public class AModMoveSpeed extends ArmorModTypeFilter +{ + final boolean modifierType; + + public AModMoveSpeed(int effect, EnumSet armorTypes, ItemStack[] items, int[] values, boolean type) + { + super(effect, "ExoSpeed" + (type ? "Percent" : "Flat"), armorTypes, items, values); + this.modifierType = type; + } + + @Override + protected boolean canModify (ItemStack tool, ItemStack[] input) + { + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); + int amount = matchingAmount(input); + return tags.getInteger("Modifiers") >= amount; + } + + @Override + public void modify (ItemStack[] input, ItemStack armor) + { + NBTTagCompound baseTag = armor.getTagCompound(); + NBTTagCompound armorTag = armor.getTagCompound().getCompoundTag(getTagName()); + + int modifiers = armorTag.getInteger("Modifiers"); + modifiers -= matchingAmount(input); + armorTag.setInteger("Modifiers", modifiers); + + int amount = matchingAmount(input); + if (armorTag.hasKey(key)) + { + amount += armorTag.getInteger(key); + } + armorTag.setInteger(key, amount); + + NBTTagList attributes; + if (baseTag.hasKey("AttributeModifiers")) + { + attributes = baseTag.getTagList("AttributeModifiers"); + for (int iter = 0; iter < attributes.tagCount(); iter++) + { + NBTTagCompound tag = (NBTTagCompound) attributes.tagAt(iter); + if (tag.getString("AttributeName").equals("generic.movementSpeed")) + attributes.removeTag(iter); + } + } + else + { + attributes = new NBTTagList(); + baseTag.setTag("AttributeModifiers", attributes); + } + attributes.appendTag(getAttributeTag("generic.movementSpeed", key, amount / 100d, modifierType, getUUIDFromItem(armor))); + } + + private static final UUID head = UUID.fromString("2ba6c8ae-4a19-49c6-aab4-ca3a5eb7c730"); + private static final UUID chest = UUID.fromString("2ba6c8ae-4a19-49c6-aab4-ca3a5eb7c731"); + private static final UUID pants = UUID.fromString("2ba6c8ae-4a19-49c6-aab4-ca3a5eb7c732"); + private static final UUID shoes = UUID.fromString("2ba6c8ae-4a19-49c6-aab4-ca3a5eb7c733"); + + UUID getUUIDFromItem (ItemStack stack) + { + ArmorCore item = (ArmorCore) stack.getItem(); + switch (item.armorPart) + { + case HELMET: + return head; + case CHEST: + return chest; + case PANTS: + return pants; + case SHOES: + return shoes; + } + return null; + } +} diff --git a/src/tconstruct/modifiers/armor/AModProtection.java b/src/tconstruct/modifiers/armor/AModProtection.java new file mode 100644 index 00000000000..7dc32eec572 --- /dev/null +++ b/src/tconstruct/modifiers/armor/AModProtection.java @@ -0,0 +1,43 @@ +package tconstruct.modifiers.armor; + +import java.util.EnumSet; +import java.util.UUID; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import tconstruct.library.armor.ArmorCore; +import tconstruct.library.armor.EnumArmorPart; + +public class AModProtection extends ArmorModTypeFilter +{ + int modifyAmount = 3; + public AModProtection(int effect, EnumSet armorTypes, ItemStack[] items, int[] values) + { + super(effect, "ExoProtection", armorTypes, items, values); + } + + @Override + protected boolean canModify (ItemStack tool, ItemStack[] input) + { + NBTTagCompound tags = tool.getTagCompound().getCompoundTag(getTagName()); + int amount = matchingItems(input) * modifyAmount; + return tags.getInteger("Modifiers") >= amount; + } + + @Override + public void modify (ItemStack[] input, ItemStack armor) + { + NBTTagCompound baseTag = armor.getTagCompound(); + NBTTagCompound armorTag = armor.getTagCompound().getCompoundTag(getTagName()); + + int modifiers = armorTag.getInteger("Modifiers"); + modifiers -= matchingItems(input) * modifyAmount; + armorTag.setInteger("Modifiers", modifiers); + + int amount = matchingAmount(input); + double absorb = armorTag.getDouble("protection"); + absorb += amount; + armorTag.setDouble("protection", absorb); + } +} diff --git a/src/tconstruct/modifiers/armor/ArmorModTypeFilter.java b/src/tconstruct/modifiers/armor/ArmorModTypeFilter.java new file mode 100644 index 00000000000..c7ddc83f501 --- /dev/null +++ b/src/tconstruct/modifiers/armor/ArmorModTypeFilter.java @@ -0,0 +1,119 @@ +package tconstruct.modifiers.armor; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.List; + +import net.minecraft.item.ItemStack; +import tconstruct.library.armor.ArmorMod; +import tconstruct.library.armor.EnumArmorPart; + +public abstract class ArmorModTypeFilter extends ArmorMod +{ + public final List increase; + + public ArmorModTypeFilter(int effect, String dataKey, EnumSet armorTypes, ItemStack[] items, int[] values) + { + super(effect, dataKey, armorTypes, items); + assert items.length == values.length : "Itemstacks and their values for armor modifiers must be the same length"; + this.increase = new ArrayList(); + for (int i = 0; i < values.length; i++) + { + increase.add(values[i]); + } + } + + /** Checks to see if the inputs match the stored items + * Note: Filters types, doesn't care about amount + * + * @param input The ItemStacks to compare against + * @param tool Item to modify, used for restrictions + * @return Whether the recipe matches the input + */ + @Override + public boolean matches (ItemStack[] input, ItemStack tool) + { + if (!canModify(tool, input)) + return false; + + boolean minimumMatch = false; + for (ItemStack inputStack : input) + { + if (inputStack == null) + continue; + + boolean match = false; + for (Object check : stacks) + { + ItemStack stack = (ItemStack) check; + if (stack.getItemDamage() == Short.MAX_VALUE) + { + if (this.areItemsEquivalent(inputStack, stack)) + match = true; + } + else + { + if (this.areItemStacksEquivalent(inputStack, stack)) + match = true; + } + } + if (!match) + return false; + + minimumMatch = true; + } + return minimumMatch; + } + + public int matchingAmount (ItemStack[] input) + { + int amount = 0; + for (ItemStack inputStack : input) + { + if (inputStack == null) + continue; + else + { + for (int iter = 0; iter < stacks.size(); iter++) + { + ItemStack stack = (ItemStack) stacks.get(iter); + if (stack.getItemDamage() == Short.MAX_VALUE) + { + if (this.areItemsEquivalent(inputStack, stack)) + amount += increase.get(iter); + } + else + { + if (this.areItemStacksEquivalent(inputStack, stack)) + amount += increase.get(iter); + } + } + } + } + return amount; + } + + public int matchingItems (ItemStack[] input) + { + int amount = 0; + for (ItemStack inputStack : input) + { + if (inputStack != null) + amount++; + } + return amount; + } + + /** Adds a new itemstack to the list for increases + * + * @param stack ItemStack to compare against + * @param amount Amount to increase + */ + public void addStackToMatchList (ItemStack stack, int amount) + { + if (stack == null) + throw new NullPointerException("ItemStack added to " + this.getClass().getSimpleName() + " cannot be null."); + stacks.add(stack); + increase.add(amount); + } +} diff --git a/src/tconstruct/modifiers/ModAntiSpider.java b/src/tconstruct/modifiers/tools/ModAntiSpider.java similarity index 87% rename from src/tconstruct/modifiers/ModAntiSpider.java rename to src/tconstruct/modifiers/tools/ModAntiSpider.java index 189127ed8af..97719286a49 100644 --- a/src/tconstruct/modifiers/ModAntiSpider.java +++ b/src/tconstruct/modifiers/tools/ModAntiSpider.java @@ -1,22 +1,20 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import tconstruct.library.tools.ToolMod; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; -public class ModAntiSpider extends ToolMod +public class ModAntiSpider extends ToolModTypeFilter { String tooltipName; - int increase; int max = 4; String guiType; - public ModAntiSpider(String type, ItemStack[] items, int effect, int inc) + public ModAntiSpider(String type, int effect, ItemStack[] items, int[] values) { - super(items, effect, "ModAntiSpider"); + super(effect, "ModAntiSpider", items, values); tooltipName = "\u00a72Bane of Arthropods"; guiType = type; - increase = inc; } @Override @@ -27,7 +25,7 @@ protected boolean canModify (ItemStack tool, ItemStack[] input) return tags.getInteger("Modifiers") > 0; int keyPair[] = tags.getIntArray(key); - if (keyPair[0] + increase <= keyPair[1]) + if (keyPair[0] + matchingAmount(input) <= keyPair[1]) return true; else if (keyPair[0] == keyPair[1]) @@ -41,6 +39,7 @@ else if (keyPair[0] == keyPair[1]) public void modify (ItemStack[] input, ItemStack tool) { NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + int increase = matchingAmount(input); if (tags.hasKey(key)) { int[] keyPair = tags.getIntArray(key); diff --git a/src/tconstruct/modifiers/ModAttack.java b/src/tconstruct/modifiers/tools/ModAttack.java similarity index 86% rename from src/tconstruct/modifiers/ModAttack.java rename to src/tconstruct/modifiers/tools/ModAttack.java index bc00ee4d451..28e6f61929d 100644 --- a/src/tconstruct/modifiers/ModAttack.java +++ b/src/tconstruct/modifiers/tools/ModAttack.java @@ -1,27 +1,23 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import java.util.Arrays; import java.util.List; -import tconstruct.library.tools.ToolCore; -import tconstruct.library.tools.ToolMod; - import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; +import tconstruct.library.tools.ToolCore; -public class ModAttack extends ToolMod +public class ModAttack extends ToolModTypeFilter { String tooltipName; - int increase; int max = 72; String guiType; - public ModAttack(String type, ItemStack[] items, int effect, int inc) + public ModAttack(String type, int effect, ItemStack[] items, int[] value) { - super(items, effect, "ModAttack"); + super(effect, "ModAttack", items, value); tooltipName = "\u00a7fSharpness"; guiType = type; - increase = inc; } @Override @@ -36,14 +32,13 @@ protected boolean canModify (ItemStack tool, ItemStack[] input) return tags.getInteger("Modifiers") > 0; int keyPair[] = tags.getIntArray(key); - if (keyPair[0] + increase <= keyPair[1]) + if (keyPair[0] + matchingAmount(input) <= keyPair[1]) return true; else if (keyPair[0] == keyPair[1]) return tags.getInteger("Modifiers") > 0; - else - return false; + return false; } @Override @@ -58,6 +53,7 @@ public void modify (ItemStack[] input, ItemStack tool) amount = 36; int[] keyPair = tags.getIntArray(key); + int increase = matchingAmount(input); int leftToBoost = amount - (keyPair[0] % amount); if (increase >= leftToBoost) @@ -90,6 +86,7 @@ public void modify (ItemStack[] input, ItemStack tool) int modifiers = tags.getInteger("Modifiers"); modifiers -= 1; tags.setInteger("Modifiers", modifiers); + int increase = matchingAmount(input); String modName = "\u00a7f" + guiType + " (" + increase + "/" + max + ")"; int tooltipIndex = addToolTip(tool, tooltipName, modName); int[] keyPair = new int[] { increase, max, tooltipIndex }; @@ -112,8 +109,6 @@ void updateModTag (ItemStack tool, int[] keys) public boolean validType (ToolCore tool) { return true; - /*List list = Arrays.asList(tool.toolCategories()); - return list.contains("melee") || list.contains("harvest") || list.contains("ammo");*/ } public boolean nerfType (ToolCore tool) diff --git a/src/tconstruct/modifiers/ModAutoSmelt.java b/src/tconstruct/modifiers/tools/ModAutoSmelt.java similarity index 94% rename from src/tconstruct/modifiers/ModAutoSmelt.java rename to src/tconstruct/modifiers/tools/ModAutoSmelt.java index 6d1d86c0b33..c640c7683ed 100644 --- a/src/tconstruct/modifiers/ModAutoSmelt.java +++ b/src/tconstruct/modifiers/tools/ModAutoSmelt.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; diff --git a/src/tconstruct/modifiers/ModBlaze.java b/src/tconstruct/modifiers/tools/ModBlaze.java similarity index 89% rename from src/tconstruct/modifiers/ModBlaze.java rename to src/tconstruct/modifiers/tools/ModBlaze.java index bea3683e61c..fedb3cb835b 100644 --- a/src/tconstruct/modifiers/ModBlaze.java +++ b/src/tconstruct/modifiers/tools/ModBlaze.java @@ -1,25 +1,21 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import java.util.Arrays; import java.util.List; -import tconstruct.library.tools.ToolCore; -import tconstruct.library.tools.ToolMod; - import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; +import tconstruct.library.tools.ToolCore; -public class ModBlaze extends ToolMod +public class ModBlaze extends ToolModTypeFilter { String tooltipName; - int increase; int max; - public ModBlaze(ItemStack[] items, int effect, int inc) + public ModBlaze(int effect, ItemStack[] items, int[] values) { - super(items, effect, "Blaze"); + super(effect, "Blaze", items, values); tooltipName = "\u00a76Fiery"; - increase = inc; max = 25; } @@ -35,7 +31,7 @@ protected boolean canModify (ItemStack tool, ItemStack[] input) return tags.getInteger("Modifiers") > 0; int keyPair[] = tags.getIntArray(key); - if (keyPair[0] + increase <= keyPair[1]) + if (keyPair[0] + matchingAmount(input) <= keyPair[1]) return true; else if (keyPair[0] == keyPair[1]) @@ -49,6 +45,7 @@ else if (keyPair[0] == keyPair[1]) public void modify (ItemStack[] input, ItemStack tool) { NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + int increase = matchingAmount(input); if (tags.hasKey(key)) { int[] keyPair = tags.getIntArray(key); diff --git a/src/tconstruct/modifiers/ModBoolean.java b/src/tconstruct/modifiers/tools/ModBoolean.java similarity index 97% rename from src/tconstruct/modifiers/ModBoolean.java rename to src/tconstruct/modifiers/tools/ModBoolean.java index cf8a22ed6b3..19998f9bf0c 100644 --- a/src/tconstruct/modifiers/ModBoolean.java +++ b/src/tconstruct/modifiers/tools/ModBoolean.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import tconstruct.library.tools.ToolMod; import net.minecraft.item.ItemStack; diff --git a/src/tconstruct/modifiers/ModButtertouch.java b/src/tconstruct/modifiers/tools/ModButtertouch.java similarity index 99% rename from src/tconstruct/modifiers/ModButtertouch.java rename to src/tconstruct/modifiers/tools/ModButtertouch.java index e4b4039677c..685b7fcbe6d 100644 --- a/src/tconstruct/modifiers/ModButtertouch.java +++ b/src/tconstruct/modifiers/tools/ModButtertouch.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import java.util.Arrays; import java.util.Iterator; diff --git a/src/tconstruct/modifiers/ModDurability.java b/src/tconstruct/modifiers/tools/ModDurability.java similarity index 98% rename from src/tconstruct/modifiers/ModDurability.java rename to src/tconstruct/modifiers/tools/ModDurability.java index 48c7824e501..52e30aa8f42 100644 --- a/src/tconstruct/modifiers/ModDurability.java +++ b/src/tconstruct/modifiers/tools/ModDurability.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; diff --git a/src/tconstruct/modifiers/ModExtraModifier.java b/src/tconstruct/modifiers/tools/ModExtraModifier.java similarity index 96% rename from src/tconstruct/modifiers/ModExtraModifier.java rename to src/tconstruct/modifiers/tools/ModExtraModifier.java index d8a2d3958c3..f560ad0eb4c 100644 --- a/src/tconstruct/modifiers/ModExtraModifier.java +++ b/src/tconstruct/modifiers/tools/ModExtraModifier.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import tconstruct.library.tools.ToolMod; import net.minecraft.item.ItemStack; diff --git a/src/tconstruct/modifiers/ModFlux.java b/src/tconstruct/modifiers/tools/ModFlux.java similarity index 96% rename from src/tconstruct/modifiers/ModFlux.java rename to src/tconstruct/modifiers/tools/ModFlux.java index e271a8d2c32..171b92b2c2a 100644 --- a/src/tconstruct/modifiers/ModFlux.java +++ b/src/tconstruct/modifiers/tools/ModFlux.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import cofh.api.energy.IEnergyContainerItem; @@ -18,7 +18,7 @@ public class ModFlux extends ModBoolean public ModFlux() { - super(new ItemStack[0], 17, "Flux", "\u00a7e", ""); + super(new ItemStack[0], 9, "Flux", "\u00a7e", ""); } @Override diff --git a/src/tconstruct/modifiers/ModInteger.java b/src/tconstruct/modifiers/tools/ModInteger.java similarity index 97% rename from src/tconstruct/modifiers/ModInteger.java rename to src/tconstruct/modifiers/tools/ModInteger.java index b7ad5e261d6..3ad27ccd1eb 100644 --- a/src/tconstruct/modifiers/ModInteger.java +++ b/src/tconstruct/modifiers/tools/ModInteger.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import tconstruct.library.tools.ToolMod; import net.minecraft.item.ItemStack; diff --git a/src/tconstruct/modifiers/ModLapis.java b/src/tconstruct/modifiers/tools/ModLapis.java similarity index 95% rename from src/tconstruct/modifiers/ModLapis.java rename to src/tconstruct/modifiers/tools/ModLapis.java index 1ac6b3fe0c0..5614d2dc87d 100644 --- a/src/tconstruct/modifiers/ModLapis.java +++ b/src/tconstruct/modifiers/tools/ModLapis.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import java.util.Arrays; import java.util.Iterator; @@ -15,17 +15,15 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; -public class ModLapis extends ToolMod +public class ModLapis extends ToolModTypeFilter { String tooltipName; - int increase; int max = 450; - public ModLapis(ItemStack[] items, int effect, int inc) + public ModLapis(int effect, ItemStack[] items, int[] values) { - super(items, effect, "Lapis"); + super(effect, "Lapis", items, values); tooltipName = "\u00a79Luck"; - increase = inc; } @Override @@ -44,7 +42,7 @@ protected boolean canModify (ItemStack tool, ItemStack[] input) return tags.getInteger("Modifiers") > 0; int keyPair[] = tags.getIntArray(key); - if (keyPair[0] + increase <= max) + if (keyPair[0] + matchingAmount(input) <= max) return true; else return false; @@ -68,6 +66,7 @@ public void modify (ItemStack[] input, ItemStack tool) tags.setInteger("Modifiers", modifiers); } + int increase = matchingAmount(input); int keyPair[] = tags.getIntArray(key); keyPair[0] += increase; tags.setIntArray(key, keyPair); diff --git a/src/tconstruct/modifiers/ModPiston.java b/src/tconstruct/modifiers/tools/ModPiston.java similarity index 89% rename from src/tconstruct/modifiers/ModPiston.java rename to src/tconstruct/modifiers/tools/ModPiston.java index 473a3efac08..1f766873930 100644 --- a/src/tconstruct/modifiers/ModPiston.java +++ b/src/tconstruct/modifiers/tools/ModPiston.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import java.util.Arrays; import java.util.List; @@ -9,18 +9,15 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; -public class ModPiston extends ToolMod +public class ModPiston extends ToolModTypeFilter { String tooltipName; - int increase; - int max; + int max = 10; - public ModPiston(ItemStack[] items, int effect, int inc) + public ModPiston(int effect, ItemStack[] items, int[] values) { - super(items, effect, "Piston"); + super(effect, "Piston", items, values); tooltipName = "\u00a77Knockback"; - increase = inc; - max = 10; } @Override @@ -35,7 +32,7 @@ protected boolean canModify (ItemStack tool, ItemStack[] input) return tags.getInteger("Modifiers") > 0; int keyPair[] = tags.getIntArray(key); - if (keyPair[0] + increase <= keyPair[1]) + if (keyPair[0] + matchingAmount(input) <= keyPair[1]) return true; else if (keyPair[0] == keyPair[1]) @@ -49,6 +46,7 @@ else if (keyPair[0] == keyPair[1]) public void modify (ItemStack[] input, ItemStack tool) { NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + int increase = matchingAmount(input); if (tags.hasKey(key)) { int[] keyPair = tags.getIntArray(key); diff --git a/src/tconstruct/modifiers/ModPotion.java b/src/tconstruct/modifiers/tools/ModPotion.java similarity index 95% rename from src/tconstruct/modifiers/ModPotion.java rename to src/tconstruct/modifiers/tools/ModPotion.java index da8010b3b7e..cc2581fc17b 100644 --- a/src/tconstruct/modifiers/ModPotion.java +++ b/src/tconstruct/modifiers/tools/ModPotion.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import tconstruct.library.tools.ToolMod; import net.minecraft.item.Item; diff --git a/src/tconstruct/modifiers/ModRedstone.java b/src/tconstruct/modifiers/tools/ModRedstone.java similarity index 91% rename from src/tconstruct/modifiers/ModRedstone.java rename to src/tconstruct/modifiers/tools/ModRedstone.java index 89c8ab68d2f..8b0ae93d1ab 100644 --- a/src/tconstruct/modifiers/ModRedstone.java +++ b/src/tconstruct/modifiers/tools/ModRedstone.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import java.util.Arrays; import java.util.List; @@ -9,18 +9,15 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; -public class ModRedstone extends ToolMod +public class ModRedstone extends ToolModTypeFilter { String tooltipName; - int increase; - int max; + int max = 50; - public ModRedstone(ItemStack[] items, int effect, int inc) + public ModRedstone(int effect, ItemStack[] items, int[] values) { - super(items, effect, "Redstone"); + super(effect, "Redstone", items, values); tooltipName = "\u00a74Haste"; - increase = inc; - max = 50; } @Override @@ -35,7 +32,7 @@ protected boolean canModify (ItemStack tool, ItemStack[] input) return tags.getInteger("Modifiers") > 0; int keyPair[] = tags.getIntArray(key); - if (keyPair[0] + increase <= keyPair[1]) + if (keyPair[0] + matchingAmount(input) <= keyPair[1]) return true; else if (keyPair[0] == keyPair[1]) @@ -50,6 +47,7 @@ public void modify (ItemStack[] input, ItemStack tool) { NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); int[] keyPair; + int increase = matchingAmount(input); if (tags.hasKey(key)) { keyPair = tags.getIntArray(key); diff --git a/src/tconstruct/modifiers/ModReinforced.java b/src/tconstruct/modifiers/tools/ModReinforced.java similarity index 98% rename from src/tconstruct/modifiers/ModReinforced.java rename to src/tconstruct/modifiers/tools/ModReinforced.java index 600f662f523..757c57d2c53 100644 --- a/src/tconstruct/modifiers/ModReinforced.java +++ b/src/tconstruct/modifiers/tools/ModReinforced.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; diff --git a/src/tconstruct/modifiers/ModRepair.java b/src/tconstruct/modifiers/tools/ModRepair.java similarity index 99% rename from src/tconstruct/modifiers/ModRepair.java rename to src/tconstruct/modifiers/tools/ModRepair.java index d0bf97ccd9f..b92f54d44f0 100644 --- a/src/tconstruct/modifiers/ModRepair.java +++ b/src/tconstruct/modifiers/tools/ModRepair.java @@ -1,4 +1,4 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; diff --git a/src/tconstruct/modifiers/ModSmite.java b/src/tconstruct/modifiers/tools/ModSmite.java similarity index 87% rename from src/tconstruct/modifiers/ModSmite.java rename to src/tconstruct/modifiers/tools/ModSmite.java index e6df65fc843..2ad76919ac7 100644 --- a/src/tconstruct/modifiers/ModSmite.java +++ b/src/tconstruct/modifiers/tools/ModSmite.java @@ -1,22 +1,19 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; -import tconstruct.library.tools.ToolMod; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; -public class ModSmite extends ToolMod +public class ModSmite extends ToolModTypeFilter { String tooltipName; - int increase; int max = 36; String tagName; - public ModSmite(String type, ItemStack[] items, int effect, int inc) + public ModSmite(String type, int effect, ItemStack[] items, int[] values) { - super(items, effect, "ModSmite"); + super(effect, "ModSmite", items, values); tooltipName = "\u00a7eSmite"; tagName = type; - increase = inc; } @Override @@ -27,7 +24,7 @@ protected boolean canModify (ItemStack tool, ItemStack[] input) return tags.getInteger("Modifiers") > 0; int keyPair[] = tags.getIntArray(key); - if (keyPair[0] + increase <= keyPair[1]) + if (keyPair[0] + matchingAmount(input) <= keyPair[1]) return true; else if (keyPair[0] == keyPair[1]) @@ -41,6 +38,7 @@ else if (keyPair[0] == keyPair[1]) public void modify (ItemStack[] input, ItemStack tool) { NBTTagCompound tags = tool.getTagCompound().getCompoundTag("InfiTool"); + int increase = matchingAmount(input); if (tags.hasKey(key)) { int[] keyPair = tags.getIntArray(key); diff --git a/src/tconstruct/modifiers/TActiveOmniMod.java b/src/tconstruct/modifiers/tools/TActiveOmniMod.java similarity index 97% rename from src/tconstruct/modifiers/TActiveOmniMod.java rename to src/tconstruct/modifiers/tools/TActiveOmniMod.java index 798ad874d0f..edd37116ad9 100644 --- a/src/tconstruct/modifiers/TActiveOmniMod.java +++ b/src/tconstruct/modifiers/tools/TActiveOmniMod.java @@ -1,15 +1,7 @@ -package tconstruct.modifiers; +package tconstruct.modifiers.tools; -import java.util.Arrays; -import java.util.List; import java.util.Random; -import tconstruct.common.TContent; -import tconstruct.library.ActiveToolMod; -import tconstruct.library.tools.AbilityHelper; -import tconstruct.library.tools.ToolCore; -import tconstruct.util.config.PHConstruct; - import net.minecraft.block.Block; import net.minecraft.enchantment.Enchantment; import net.minecraft.enchantment.EnchantmentHelper; @@ -25,6 +17,11 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.MathHelper; import net.minecraft.world.World; +import tconstruct.common.TContent; +import tconstruct.library.ActiveToolMod; +import tconstruct.library.tools.AbilityHelper; +import tconstruct.library.tools.ToolCore; +import tconstruct.util.config.PHConstruct; public class TActiveOmniMod extends ActiveToolMod { @@ -55,7 +52,7 @@ public boolean beforeBlockBreak (ToolCore tool, ItemStack stack, int x, int y, i { if (entity instanceof EntityPlayer && ((EntityPlayer) entity).capabilities.isCreativeMode) return false; - TContent.modL.midStreamModify(stack, tool); + TContent.modLapis.midStreamModify(stack, tool); NBTTagCompound tags = stack.getTagCompound().getCompoundTag("InfiTool"); World world = entity.worldObj; @@ -151,7 +148,7 @@ else if (f < 1.0F) @Override public int baseAttackDamage (int earlyModDamage, int damage, ToolCore tool, NBTTagCompound tags, NBTTagCompound toolTags, ItemStack stack, EntityLivingBase player, Entity entity) { - TContent.modL.midStreamModify(stack, tool); + TContent.modLapis.midStreamModify(stack, tool); return 0; } diff --git a/src/tconstruct/modifiers/tools/ToolModTypeFilter.java b/src/tconstruct/modifiers/tools/ToolModTypeFilter.java new file mode 100644 index 00000000000..d09c0a4b8cd --- /dev/null +++ b/src/tconstruct/modifiers/tools/ToolModTypeFilter.java @@ -0,0 +1,106 @@ +package tconstruct.modifiers.tools; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.item.ItemStack; +import tconstruct.library.tools.ToolMod; + +public abstract class ToolModTypeFilter extends ToolMod +{ + public final List increase; + + public ToolModTypeFilter(int effect, String dataKey, ItemStack[] items, int[] values) + { + super(items, effect, dataKey); + assert items.length == values.length : "Itemstacks and their values for tool modifiers must be the same length"; + this.increase = new ArrayList(); + for (int i = 0; i < values.length; i++) + { + increase.add(values[i]); + } + } + + /** Checks to see if the inputs match the stored items + * Note: Filters types, doesn't care about amount + * + * @param input The ItemStacks to compare against + * @param tool Item to modify, used for restrictions + * @return Whether the recipe matches the input + */ + @Override + public boolean matches (ItemStack[] input, ItemStack tool) + { + if (!canModify(tool, input)) + return false; + + boolean minimumMatch = false; + for (ItemStack inputStack : input) + { + if (inputStack == null) + continue; + + boolean match = false; + for (Object check : stacks) + { + ItemStack stack = (ItemStack) check; + if (stack.getItemDamage() == Short.MAX_VALUE) + { + if (this.areItemsEquivalent(inputStack, stack)) + match = true; + } + else + { + if (this.areItemStacksEquivalent(inputStack, stack)) + match = true; + } + } + if (!match) + return false; + + minimumMatch = true; + } + return minimumMatch; + } + + public int matchingAmount (ItemStack[] input) + { + int amount = 0; + for (ItemStack inputStack : input) + { + if (inputStack == null) + continue; + else + { + for (int iter = 0; iter < stacks.size(); iter++) + { + ItemStack stack = (ItemStack) stacks.get(iter); + if (stack.getItemDamage() == Short.MAX_VALUE) + { + if (this.areItemsEquivalent(inputStack, stack)) + amount += increase.get(iter); + } + else + { + if (this.areItemStacksEquivalent(inputStack, stack)) + amount += increase.get(iter); + } + } + } + } + return amount; + } + + /** Adds a new itemstack to the list for increases + * + * @param stack ItemStack to compare against + * @param amount Amount to increase + */ + public void addStackToMatchList (ItemStack stack, int amount) + { + if (stack == null) + throw new NullPointerException("ItemStack added to " + this.getClass().getSimpleName() + " cannot be null."); + stacks.add(stack); + increase.add(amount); + } +} diff --git a/src/tconstruct/util/TEventHandler.java b/src/tconstruct/util/TEventHandler.java index e0feab50067..51457333bed 100644 --- a/src/tconstruct/util/TEventHandler.java +++ b/src/tconstruct/util/TEventHandler.java @@ -40,25 +40,19 @@ import net.minecraftforge.event.entity.player.PlayerInteractEvent; import net.minecraftforge.event.entity.player.PlayerInteractEvent.Action; import net.minecraftforge.oredict.OreDictionary.OreRegisterEvent; -import tconstruct.TConstruct; -import tconstruct.achievements.TAchievements; -import tconstruct.blocks.LiquidMetalFinite; -import tconstruct.blocks.TankAirBlock; -import tconstruct.common.TContent; -import tconstruct.items.tools.FryingPan; -import tconstruct.library.TConstructRegistry; -import tconstruct.library.crafting.ToolBuilder; -import tconstruct.library.event.PartBuilderEvent; -import tconstruct.library.event.ToolCraftEvent; -import tconstruct.library.tools.ArrowMaterial; -import tconstruct.library.tools.BowMaterial; -import tconstruct.library.tools.BowstringMaterial; -import tconstruct.library.tools.FletchingMaterial; -import tconstruct.library.tools.ToolCore; -import tconstruct.library.tools.Weapon; -import tconstruct.modifiers.ModAttack; -import tconstruct.util.config.PHConstruct; -import tconstruct.util.player.TPlayerStats; + +import tconstruct.*; +import tconstruct.achievements.*; +import tconstruct.blocks.*; +import tconstruct.common.*; +import tconstruct.items.tools.*; +import tconstruct.library.*; +import tconstruct.library.crafting.*; +import tconstruct.library.event.*; +import tconstruct.library.tools.*; +import tconstruct.modifiers.*; +import tconstruct.util.config.*; +import tconstruct.util.player.*; public class TEventHandler { @@ -533,20 +527,14 @@ public void bonemealEvent (BonemealEvent event) @ForgeSubscribe public void registerOre (OreRegisterEvent evt) { - if (evt.Name == "battery") - TConstruct.content.modE.batteries.add(evt.Ore); - - else if (evt.Name == "basicCircuit") - TConstruct.content.modE.circuits.add(evt.Ore); - - else if (evt.Name == "crystalQuartz") + if (evt.Name == "crystalQuartz") { - ToolBuilder.instance.registerToolMod(new ModAttack("Quartz", new ItemStack[] { evt.Ore }, 11, 2)); + TContent.modAttack.addStackToMatchList(evt.Ore, 2); } else if (evt.Name == "crystalCerusQuartz") { - ToolBuilder.instance.registerToolMod(new ModAttack("Quartz", new ItemStack[] { evt.Ore }, 11, 24)); + TContent.modAttack.addStackToMatchList(evt.Ore, 24); } }