package tconstruct.weaponry; import net.minecraft.init.Items; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; import net.minecraft.nbt.NBTTagString; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.StatCollector; import net.minecraftforge.event.entity.EntityJoinWorldEvent; import cpw.mods.fml.common.eventhandler.Event; import cpw.mods.fml.common.eventhandler.EventPriority; import cpw.mods.fml.common.eventhandler.SubscribeEvent; import cpw.mods.fml.common.gameevent.PlayerEvent; import tconstruct.armor.player.TPlayerStats; import tconstruct.library.TConstructRegistry; import tconstruct.library.crafting.PatternBuilder; import tconstruct.library.crafting.ToolBuilder; import tconstruct.library.entity.ProjectileBase; import tconstruct.library.event.PartBuilderEvent; import tconstruct.library.event.SmelteryCastEvent; import tconstruct.library.event.ToolBuildEvent; import tconstruct.library.event.ToolCraftEvent; import tconstruct.library.tools.AbilityHelper; import tconstruct.library.tools.ArrowMaterial; import tconstruct.library.tools.BowMaterial; import tconstruct.library.tools.BowstringMaterial; import tconstruct.library.tools.CustomMaterial; import tconstruct.library.tools.DualMaterialToolPart; import tconstruct.library.tools.FletchingMaterial; import tconstruct.library.tools.FletchlingLeafMaterial; import tconstruct.library.tools.ToolCore; import tconstruct.library.tools.ToolMaterial; import tconstruct.library.util.IToolPart; import tconstruct.library.weaponry.ArrowShaftMaterial; import tconstruct.library.weaponry.BowBaseAmmo; import tconstruct.library.weaponry.IAmmo; import tconstruct.library.weaponry.ProjectileWeapon; import tconstruct.tools.TinkerTools; import tconstruct.util.config.PHConstruct; import tconstruct.weaponry.ammo.ArrowAmmo; import tconstruct.weaponry.ammo.BoltAmmo; import tconstruct.weaponry.weapons.Crossbow; import tconstruct.weaponry.weapons.LongBow; import tconstruct.weaponry.weapons.ShortBow; public class WeaponryHandler { @SubscribeEvent public void onCrafting(PlayerEvent.ItemCraftedEvent event) { Item item = event.crafting.getItem(); if (!event.player.worldObj.isRemote) { if (item == Item.getItemFromBlock(TinkerTools.toolStationWood)) { if (!PHConstruct.beginnerBook) { return; } TPlayerStats stats = TPlayerStats.get(event.player); if (!stats.weaponryManual) { stats.weaponryManual = true; AbilityHelper.spawnItemAtPlayer(event.player, new ItemStack(TinkerTools.manualBook, 1, 4)); } } } } // Provides ammo-items with the necessary NBT @SubscribeEvent public void onAmmoCrafted(ToolCraftEvent.NormalTool event) { if (!(event.tool instanceof IAmmo)) return; NBTTagCompound tags = event.toolTag.getCompoundTag("InfiTool"); // calculate its stats if (event.tool instanceof ArrowAmmo) { // arrows work like this: // the head is responsible for the damage, but also adds weight // the shaft defines how fragile the arrow is, and also adds to the weight a bit. But mostly the fragility. // the fletching defines the accuracy of the arrow and adds a bit breakchance. Mostly there for the // durability modifier because availability // Shortbows work better with lighter arrows // while Longbows require a bit heavier arrows, the lighter the arrow the more impact the accuracy has // otherwise // summa sumarum: heavier arrows fall faster (less range) but accuracy has less impact // the materials ToolMaterial head = TConstructRegistry.getMaterial(tags.getInteger("Head")); ArrowMaterial arrow = TConstructRegistry.getArrowMaterial(tags.getInteger("Head")); ArrowShaftMaterial shaft = (ArrowShaftMaterial) TConstructRegistry .getCustomMaterial(tags.getInteger("Handle"), ArrowShaftMaterial.class); FletchingMaterial fletching = (FletchingMaterial) TConstructRegistry .getCustomMaterial(tags.getInteger("Accessory"), FletchingMaterial.class); // todo: fix leaf fletching if (fletching == null) fletching = (FletchingMaterial) TConstructRegistry .getCustomMaterial(tags.getInteger("Accessory"), FletchlingLeafMaterial.class); // invalid materials if (arrow == null || shaft == null || fletching == null) { event.setResult(Event.Result.DENY); return; } int durability = (int) ((float) head.durability() * shaft.durabilityModifier * fletching.durabilityModifier); float weight = arrow.mass + shaft.weight; float accuracy = fletching.accuracy; float breakChance = shaft.fragility * arrow.breakChance + fletching.breakChance; setAmmoData(tags, durability, weight, breakChance, accuracy, head.shoddy(), head.reinforced()); // Blaze shafts give fiery if (tags.getInteger("Handle") == 3) { tags.setInteger("Fiery", 5); } // arrows get only 2 modifiers (so one less) by default int mods = Math.max(0, tags.getInteger("Modifiers") - 1); tags.setInteger("Modifiers", mods); } else if (event.tool instanceof BoltAmmo) { // bolts work like ammos, but have more weight as they have 2 main materials // Crossbows work better with heavier bolts // the materials ToolMaterial headMat = TConstructRegistry.getMaterial(tags.getInteger("Head")); ToolMaterial coreMat = TConstructRegistry.getMaterial(tags.getInteger("Handle")); ArrowMaterial head = TConstructRegistry.getArrowMaterial(tags.getInteger("Head")); ArrowMaterial core = TConstructRegistry.getArrowMaterial(tags.getInteger("Handle")); FletchingMaterial fletching = (FletchingMaterial) TConstructRegistry .getCustomMaterial(tags.getInteger("Accessory"), FletchingMaterial.class); // todo: fix leaf fletching if (fletching == null) fletching = (FletchingMaterial) TConstructRegistry .getCustomMaterial(tags.getInteger("Accessory"), FletchlingLeafMaterial.class); // invalid materials if (head == null || core == null || fletching == null) { event.setResult(Event.Result.DENY); return; } int durability = (int) ((float) headMat.durability() * coreMat.handleDurability() * fletching.durabilityModifier); float weight = head.mass + core.mass * 1.5f; float accuracy = (100f + fletching.accuracy) / 2f; float breakChance = (fletching.breakChance * 2 + 0.15f * core.breakChance) * head.breakChance / 2f; float shoddy = (headMat.shoddy() + coreMat.shoddy()) / 2f; int reinforced = Math.max(headMat.reinforced(), coreMat.reinforced()); setAmmoData(tags, durability, weight, breakChance, accuracy, shoddy, reinforced); int mods = Math.max(0, tags.getInteger("Modifiers") - 1); tags.setInteger("Modifiers", mods); } // now that durability has been handled... // fill the ammo full and at the same time provide the missing NBT tag IAmmo ammoItem = (IAmmo) event.tool; tags.setInteger("Ammo", ammoItem.getMaxAmmo(tags)); } @SubscribeEvent public void onProjectileWeaponCrafted(ToolCraftEvent.NormalTool event) { if (!(event.tool instanceof ProjectileWeapon)) return; NBTTagCompound tags = event.toolTag.getCompoundTag("InfiTool"); ProjectileWeapon weapon = (ProjectileWeapon) event.tool; int drawSpeed; float flightSpeed; BowMaterial top; BowMaterial bottom; BowstringMaterial string; boolean enchanted; if (event.tool instanceof BowBaseAmmo) { top = TConstructRegistry.getBowMaterial(tags.getInteger("Head")); bottom = TConstructRegistry.getBowMaterial(tags.getInteger("Accessory")); string = (BowstringMaterial) TConstructRegistry .getCustomMaterial(tags.getInteger("Handle"), BowstringMaterial.class); // some materials seem to be incompatible if (top == null || bottom == null || string == null) { event.setResult(Event.Result.DENY); return; } drawSpeed = (int) ((top.drawspeed + bottom.drawspeed) / 2f * string.drawspeedModifier); flightSpeed = (top.flightSpeedMax + bottom.flightSpeedMax) / 2 * string.flightSpeedModifier; // SHORT bows have a SHORTER windup because they're SHORT. hahahaha.... get it? if (event.tool instanceof ShortBow) { drawSpeed *= 0.9; } // longbows have LONGER drawspeed. LOGIC! if (event.tool instanceof LongBow) { drawSpeed *= 1.8f; flightSpeed *= 1.5f; } // enchanted bowstring enchanted = tags.getInteger("Handle") == 1; } else if (event.tool instanceof Crossbow) { top = TConstructRegistry.getBowMaterial(tags.getInteger("Head")); string = (BowstringMaterial) TConstructRegistry .getCustomMaterial(tags.getInteger("Accessory"), BowstringMaterial.class); // some materials seem to be incompatible if (top == null || string == null) { event.setResult(Event.Result.DENY); return; } drawSpeed = (int) ((float) top.drawspeed * string.drawspeedModifier); flightSpeed = (top.flightSpeedMax * string.flightSpeedModifier); // crossbows are more efficient the higher the base drawspeed is. So the higher the drawspeed, the more // bonus you get drawSpeed *= 2.5f; drawSpeed -= drawSpeed * 0.25f; // crossbows are stronk flightSpeed *= 1.5; // enchanted bowstring enchanted = tags.getInteger("Accessory") == 1; } else return; // enchanted fabric if (enchanted) { int modifiers = tags.getInteger("Modifiers"); modifiers += 1; tags.setInteger("Modifiers", modifiers); } tags.setInteger("DrawSpeed", drawSpeed); tags.setInteger("BaseDrawSpeed", drawSpeed); // used to calculate correct speed increase with redstone modifier tags.setFloat("FlightSpeed", flightSpeed); } // arrows use custom materials. But we don't allow the creation of those items // we therefore replace the items with their toolpart counterparts here @SubscribeEvent public void buildArrow(ToolBuildEvent event) { if (event.headStack == null || event.handleStack == null || event.accessoryStack == null) return; // are we building an arrow? CustomMaterial mat = TConstructRegistry.getCustomMaterial(event.handleStack, ArrowShaftMaterial.class); if (mat == null) return; Item extra = event.extraStack != null ? event.extraStack.getItem() : null; ToolCore tool = ToolBuilder.instance.getMatchingRecipe( event.headStack.getItem(), mat.craftingItem.getItem(), event.accessoryStack.getItem(), extra); // it's an arrow! if (tool == TinkerWeaponry.arrowAmmo) event.handleStack = mat.craftingItem.copy(); } // bolts require special treatment because of their dual-material cores @SubscribeEvent public void buildBolt(ToolBuildEvent event) { if (event.headStack == null || event.handleStack == null) return; if (event.headStack.getItem() != TinkerWeaponry.partBolt) return; // is the bolt already split into 2 items? if (event.accessoryStack != null && event.headStack.getItem() == TinkerWeaponry.partBolt && event.handleStack.getItem() == TinkerWeaponry.partBolt && event.accessoryStack.getItem() == TinkerWeaponry.fletching) return; // split the bolt into its two parts ItemStack bolt1 = event.headStack.copy(); ItemStack bolt2 = event.headStack; ItemStack fletching = event.handleStack; // set the correct material on the 2nd part DualMaterialToolPart dualPart = (DualMaterialToolPart) bolt2.getItem(); bolt1.setItemDamage(dualPart.getMaterialID2(bolt1)); // update the part positions xX event.headStack = bolt1; event.handleStack = bolt2; event.accessoryStack = fletching; } private void setAmmoData(NBTTagCompound tags, int durability, float weight, float breakChance, float accuracy, float shoddy, int reinforced) { tags.setInteger("TotalDurability", durability); tags.setInteger("BaseDurability", durability); tags.setFloat("Mass", weight); tags.setFloat("BreakChance", breakChance); tags.setFloat("Accuracy", accuracy); tags.setFloat("Shoddy", shoddy); // we could actually always set this to 0 since it has zero impact on ammo tags.setInteger("Unbreaking", reinforced); } @SubscribeEvent public void weaponryPartCrafted(PartBuilderEvent.NormalPart event) { if (event.pattern == null) return; // weaponry part if (event.pattern.getItem() == TinkerWeaponry.woodPattern) { // crossbow or bow limb if (event.pattern.getItemDamage() == 1 || event.pattern.getItemDamage() == 3) { // only allow crafting if the material has bow stats PatternBuilder.ItemKey key = PatternBuilder.instance.getItemKey(event.material); if (key == null) return; PatternBuilder.MaterialSet ms = PatternBuilder.instance.materialSets.get(key.key); if (ms == null) return; if (TConstructRegistry.getBowMaterial(ms.materialID) == null) event.setResult(Event.Result.DENY); } } // arrow stats, still in tool if (event.pattern.getItem() == TinkerTools.woodPattern && event.pattern.getItemDamage() == 25) { // only allow crafting if the material has bow stats PatternBuilder.ItemKey key = PatternBuilder.instance.getItemKey(event.material); if (key == null) return; PatternBuilder.MaterialSet ms = PatternBuilder.instance.materialSets.get(key.key); if (ms == null) return; if (TConstructRegistry.getArrowMaterial(ms.materialID) == null) event.setResult(Event.Result.DENY); } } @SubscribeEvent public void weaponryPartCast(SmelteryCastEvent.CastingTable event) { if (event.recipe == null || event.recipe.output == null) return; if (!(event.recipe.output.getItem() instanceof IToolPart)) return; // get material for the output int mat = ((IToolPart) event.recipe.output.getItem()).getMaterialID(event.recipe.output); // arrowhead if (event.recipe.output.getItem() == TinkerWeaponry.arrowhead) if (TConstructRegistry.getArrowMaterial(mat) == null) event.setResult(Event.Result.DENY); // crossbow/bowlimb if (event.recipe.output.getItem() == TinkerWeaponry.partBowLimb || event.recipe.output.getItem() == TinkerWeaponry.partCrossbowLimb) if (TConstructRegistry.getBowMaterial(mat) == null) event.setResult(Event.Result.DENY); } // high priority because we want to do these checks on unmodified stacks @SubscribeEvent(priority = EventPriority.HIGH) public void boneanaParts(ToolBuildEvent event) { if (event.headStack == null || event.handleStack == null || event.accessoryStack != null || event.extraStack != null) return; // golden carrot + bone if (event.headStack.getItem() == Items.golden_carrot && event.handleStack.getItem() == Items.bone) { // golden carrot must be named banana if (!event.headStack.hasTagCompound() || !event.headStack.getTagCompound().hasKey("display") || !event.headStack.getTagCompound().getCompoundTag("display").hasKey("Name") || !event.headStack.getTagCompound().getCompoundTag("display").getString("Name") .equalsIgnoreCase("banana")) return; event.name = '\u2400' + "Bonæna"; // the \u2400 is a non-printable unicode character so you can't just type // it event.headStack = new ItemStack(TinkerTools.swordBlade, 1, TinkerTools.MaterialID.Bone); event.handleStack = new ItemStack(TinkerTools.toolRod, 1, TinkerTools.MaterialID.Bone); event.accessoryStack = new ItemStack(TinkerTools.wideGuard, 1, TinkerTools.MaterialID.Bone); } } @SubscribeEvent(priority = EventPriority.HIGH) public void boneanaBuilding(ToolCraftEvent.NormalTool event) { // is it a boneana? if (!event.toolTag.hasKey("display")) return; final NBTTagCompound display = event.toolTag.getCompoundTag("display"); if ("\u00A7f\u2400Bonæna".equals(display.getString("Name"))) { // set correct name display.setString("Name", EnumChatFormatting.YELLOW + "Bonæna"); // lore! NBTTagList lore = new NBTTagList(); lore.appendTag(new NBTTagString(StatCollector.translateToLocal("tool.boneana.lore"))); display.setTag("Lore", lore); // let's polish it up a bit! NBTTagCompound tag = event.toolTag.getCompoundTag("InfiTool"); tag.setBoolean("Special", true); tag.setInteger("Attack", 4); tag.setInteger("TotalDurability", 600); tag.setInteger("BaseDurability", 600); tag.setFloat("Shoddy", -2.0f); tag.setInteger("MiningSpeed", 1); tag.setInteger("HarvestLevel", 0); tag.setInteger("Modifiers", 0); ItemStack weapon = new ItemStack(TinkerWeaponry.boneana); weapon.setTagCompound(event.toolTag); event.overrideResult(weapon); event.setResult(Event.Result.ALLOW); } } @SubscribeEvent public void entityJoin(EntityJoinWorldEvent event) { // This prevents invalid projectiles to be created // This can happen because of ID remaps. if (event.entity instanceof ProjectileBase) { ProjectileBase projectile = (ProjectileBase) event.entity; if (projectile.returnStack == null || !(projectile.returnStack.getItem() instanceof ToolCore)) event.setCanceled(true); } } }