diff --git a/src/generated/resources/.cache/cache b/src/generated/resources/.cache/cache index d94080a9..d938ef2c 100644 --- a/src/generated/resources/.cache/cache +++ b/src/generated/resources/.cache/cache @@ -56,7 +56,7 @@ e6d9cf699667aaa47efff37b2b033895dee29c15 assets/bloodmagic/blockstates/waterritu 42f26f715bddd16c069f9b51e3767b36477c8908 assets/bloodmagic/blockstates/woodtilepath.json 3c6ce233dae6c1307d9016406c324bbe844b4e1e assets/bloodmagic/blockstates/wornstonebrickpath.json d59655f12d1724b73b77c373fb6864fcff69db12 assets/bloodmagic/blockstates/wornstonetilepath.json -6db439502b9bb27666e8297b8e3b7a63f78dc967 assets/bloodmagic/lang/en_us.json +c220fc49d1981be98283901bf1b50702f5c021cd assets/bloodmagic/lang/en_us.json 34445195b9f2459475cde53454bc8e37d32865d7 assets/bloodmagic/models/block/accelerationrune.json bcdbccc49d4509571be6988762ab87126275a4c8 assets/bloodmagic/models/block/airritualstone.json adf6c0b1e25451609486dc8c8cfbd9cf0f8c67f4 assets/bloodmagic/models/block/alchemicalreactionchamber.json @@ -312,6 +312,7 @@ db0f63198089161b8d4ecfb1ec8a45f7dc5ba83d assets/bloodmagic/models/item/soulaxe.j ad010d9680cd748bd04c8fc36262c236f7d90105 assets/bloodmagic/models/item/soulgemlesser.json b49e7f34913e32ccb68eeb6f6c196ff6b209f482 assets/bloodmagic/models/item/soulgempetty.json c873e91c70eef9ad4c39aeb2fe8b9aa16a26cccd assets/bloodmagic/models/item/soulpickaxe.json +5682770badd4dbc1ae533de0ce0f9a7cd0b2aeea assets/bloodmagic/models/item/soulscythe.json bde2befafc97fd89a428dfa3f39fc970e9a3ae29 assets/bloodmagic/models/item/soulshovel.json f8db155d49b0f2c37504bac46a8974d4bf90db3e assets/bloodmagic/models/item/soulsnare.json fe2b201007c974229509f6900c6eb8b03d158b0a assets/bloodmagic/models/item/soulsword.json @@ -361,6 +362,11 @@ cebb0537b96480ac99314840a45107108b1bbc3a assets/bloodmagic/models/item/variants/ 37144adb7eb312c66a3567faeb3ece5aeef76e70 assets/bloodmagic/models/item/variants/soulpickaxe_destructive.json e09d7927fdb84c372d36b290e3c69f728c922675 assets/bloodmagic/models/item/variants/soulpickaxe_steadfast.json bec6cecf74db6a32fb5890b0596ddb7e2bf2daef assets/bloodmagic/models/item/variants/soulpickaxe_vengeful.json +a1fa69851bf9bb7022a25c0bef26fd44633616e2 assets/bloodmagic/models/item/variants/soulscythe.json +7c97bf4b12fc39cbe100d0e54e6b1b53a592c771 assets/bloodmagic/models/item/variants/soulscythe_corrosive.json +ad9c84341af3f0e90cdb206f39fbf4c2e589c52a assets/bloodmagic/models/item/variants/soulscythe_destructive.json +00b631dc41ee04264a91fe9a9e0b5660daf9fbc5 assets/bloodmagic/models/item/variants/soulscythe_steadfast.json +379922deb3b4e352763b335c01d4d66bfc531218 assets/bloodmagic/models/item/variants/soulscythe_vengeful.json 501142d1ff49eaf663e9a2044da17b8b5a25e361 assets/bloodmagic/models/item/variants/soulshovel.json f65e2a2d4f0cae6c3dc986274c2dee0f1773cfb2 assets/bloodmagic/models/item/variants/soulshovel_corrosive.json 6c6b04b81358bb82b4d127fc621190dc2804fd45 assets/bloodmagic/models/item/variants/soulshovel_destructive.json @@ -625,6 +631,7 @@ a222d09abf1ea61feb684f2ac23d011c2034f526 data/bloodmagic/recipes/soulforge/reage 4a4340f334c51beaacb77fd201298ad94b71e79c data/bloodmagic/recipes/soulforge/sanguine_reverter.json 799c9b83373966f70bbd6777cdae0ff2ff89fd84 data/bloodmagic/recipes/soulforge/sentientaxe.json 6d94372ffffbe36ca91ed2a5e46991bff896726c data/bloodmagic/recipes/soulforge/sentientpickaxe.json +6b47831e5c2f3033b6706706d810fa96d8abebd6 data/bloodmagic/recipes/soulforge/sentientscythe.json 6dcced40126f950b85f868aa04c77e90b71b69f2 data/bloodmagic/recipes/soulforge/sentientshovel.json 7e281841a2953c1284d332c2bbf75097f8128241 data/bloodmagic/recipes/soulforge/sentientsword.json c4102a1573e632d0b9f894353b0d522a51a7c65e data/bloodmagic/recipes/soulforge/steadfast_crystal_block.json diff --git a/src/generated/resources/assets/bloodmagic/lang/en_us.json b/src/generated/resources/assets/bloodmagic/lang/en_us.json index 75fa0670..739326b8 100644 --- a/src/generated/resources/assets/bloodmagic/lang/en_us.json +++ b/src/generated/resources/assets/bloodmagic/lang/en_us.json @@ -144,6 +144,7 @@ "item.bloodmagic.soulgemlesser": "Lesser Tartaric Gem", "item.bloodmagic.soulgempetty": "Petty Tartaric Gem", "item.bloodmagic.soulpickaxe": "Sentient Pickaxe", + "item.bloodmagic.soulscythe": "Sentient Scythe", "item.bloodmagic.soulshovel": "Sentient Shovel", "item.bloodmagic.soulsnare": "Soul Snare", "item.bloodmagic.soulsword": "Sentient Sword", diff --git a/src/generated/resources/assets/bloodmagic/models/item/soulscythe.json b/src/generated/resources/assets/bloodmagic/models/item/soulscythe.json new file mode 100644 index 00000000..54c81982 --- /dev/null +++ b/src/generated/resources/assets/bloodmagic/models/item/soulscythe.json @@ -0,0 +1,34 @@ +{ + "overrides": [ + { + "predicate": { + "bloodmagic:type": 0.0 + }, + "model": "bloodmagic:item/variants/soulscythe" + }, + { + "predicate": { + "bloodmagic:type": 1.0 + }, + "model": "bloodmagic:item/variants/soulscythe_corrosive" + }, + { + "predicate": { + "bloodmagic:type": 2.0 + }, + "model": "bloodmagic:item/variants/soulscythe_destructive" + }, + { + "predicate": { + "bloodmagic:type": 3.0 + }, + "model": "bloodmagic:item/variants/soulscythe_vengeful" + }, + { + "predicate": { + "bloodmagic:type": 4.0 + }, + "model": "bloodmagic:item/variants/soulscythe_steadfast" + } + ] +} \ No newline at end of file diff --git a/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe.json b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe.json new file mode 100644 index 00000000..c6ada5af --- /dev/null +++ b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe.json @@ -0,0 +1,6 @@ +{ + "parent": "minecraft:item/handheld", + "textures": { + "layer0": "bloodmagic:item/soulscythe" + } +} \ No newline at end of file diff --git a/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_corrosive.json b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_corrosive.json new file mode 100644 index 00000000..9da5186f --- /dev/null +++ b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_corrosive.json @@ -0,0 +1,6 @@ +{ + "parent": "minecraft:item/handheld", + "textures": { + "layer0": "bloodmagic:item/soulscythe_corrosive" + } +} \ No newline at end of file diff --git a/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_destructive.json b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_destructive.json new file mode 100644 index 00000000..a9e5999b --- /dev/null +++ b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_destructive.json @@ -0,0 +1,6 @@ +{ + "parent": "minecraft:item/handheld", + "textures": { + "layer0": "bloodmagic:item/soulscythe_destructive" + } +} \ No newline at end of file diff --git a/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_steadfast.json b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_steadfast.json new file mode 100644 index 00000000..9a8e1765 --- /dev/null +++ b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_steadfast.json @@ -0,0 +1,6 @@ +{ + "parent": "minecraft:item/handheld", + "textures": { + "layer0": "bloodmagic:item/soulscythe_steadfast" + } +} \ No newline at end of file diff --git a/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_vengeful.json b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_vengeful.json new file mode 100644 index 00000000..e0a42699 --- /dev/null +++ b/src/generated/resources/assets/bloodmagic/models/item/variants/soulscythe_vengeful.json @@ -0,0 +1,6 @@ +{ + "parent": "minecraft:item/handheld", + "textures": { + "layer0": "bloodmagic:item/soulscythe_vengeful" + } +} \ No newline at end of file diff --git a/src/generated/resources/data/bloodmagic/recipes/soulforge/sentientscythe.json b/src/generated/resources/data/bloodmagic/recipes/soulforge/sentientscythe.json new file mode 100644 index 00000000..77c85c8b --- /dev/null +++ b/src/generated/resources/data/bloodmagic/recipes/soulforge/sentientscythe.json @@ -0,0 +1,15 @@ +{ + "type": "bloodmagic:soulforge", + "input0": { + "item": "bloodmagic:soulgempetty" + }, + "input1": { + "item": "minecraft:iron_hoe" + }, + "output": { + "item": "bloodmagic:soulscythe", + "nbt": "{Damage:0}" + }, + "minimumDrain": 0.0, + "drain": 0.0 +} \ No newline at end of file diff --git a/src/main/java/wayoftime/bloodmagic/client/ClientEvents.java b/src/main/java/wayoftime/bloodmagic/client/ClientEvents.java index 1ad86927..422cf4df 100644 --- a/src/main/java/wayoftime/bloodmagic/client/ClientEvents.java +++ b/src/main/java/wayoftime/bloodmagic/client/ClientEvents.java @@ -79,6 +79,7 @@ public class ClientEvents registerMultiWillTool(BloodMagicItems.SENTIENT_AXE.get()); registerMultiWillTool(BloodMagicItems.SENTIENT_PICKAXE.get()); registerMultiWillTool(BloodMagicItems.SENTIENT_SHOVEL.get()); + registerMultiWillTool(BloodMagicItems.SENTIENT_SCYTHE.get()); registerMultiWillTool(BloodMagicItems.PETTY_GEM.get()); registerMultiWillTool(BloodMagicItems.LESSER_GEM.get()); registerMultiWillTool(BloodMagicItems.COMMON_GEM.get()); diff --git a/src/main/java/wayoftime/bloodmagic/common/data/GeneratorItemModels.java b/src/main/java/wayoftime/bloodmagic/common/data/GeneratorItemModels.java index 70e010b6..0f2a9a83 100644 --- a/src/main/java/wayoftime/bloodmagic/common/data/GeneratorItemModels.java +++ b/src/main/java/wayoftime/bloodmagic/common/data/GeneratorItemModels.java @@ -81,6 +81,7 @@ public class GeneratorItemModels extends ItemModelProvider registerDemonTool(BloodMagicItems.SENTIENT_AXE.get()); registerDemonTool(BloodMagicItems.SENTIENT_PICKAXE.get()); registerDemonTool(BloodMagicItems.SENTIENT_SHOVEL.get()); + registerDemonTool(BloodMagicItems.SENTIENT_SCYTHE.get()); registerSacrificialKnife(BloodMagicItems.SACRIFICIAL_DAGGER.get()); registerCustomFullTexture(BloodMagicBlocks.MIMIC.get(), "solidopaquemimic"); diff --git a/src/main/java/wayoftime/bloodmagic/common/data/GeneratorLanguage.java b/src/main/java/wayoftime/bloodmagic/common/data/GeneratorLanguage.java index eacefad8..3ffc4aa2 100644 --- a/src/main/java/wayoftime/bloodmagic/common/data/GeneratorLanguage.java +++ b/src/main/java/wayoftime/bloodmagic/common/data/GeneratorLanguage.java @@ -425,6 +425,7 @@ public class GeneratorLanguage extends LanguageProvider addItem(BloodMagicItems.SENTIENT_AXE, "Sentient Axe"); addItem(BloodMagicItems.SENTIENT_PICKAXE, "Sentient Pickaxe"); addItem(BloodMagicItems.SENTIENT_SHOVEL, "Sentient Shovel"); + addItem(BloodMagicItems.SENTIENT_SCYTHE, "Sentient Scythe"); addItem(BloodMagicItems.WEAK_ACTIVATION_CRYSTAL, "Weak Activation Crystal"); addItem(BloodMagicItems.AWAKENED_ACTIVATION_CRYSTAL, "Awakened Activation Crystal"); diff --git a/src/main/java/wayoftime/bloodmagic/common/item/BloodMagicItems.java b/src/main/java/wayoftime/bloodmagic/common/item/BloodMagicItems.java index 869fdb16..bc80ed56 100644 --- a/src/main/java/wayoftime/bloodmagic/common/item/BloodMagicItems.java +++ b/src/main/java/wayoftime/bloodmagic/common/item/BloodMagicItems.java @@ -173,6 +173,7 @@ public class BloodMagicItems public static final RegistryObject SENTIENT_AXE = ITEMS.register("soulaxe", () -> new ItemSentientAxe()); public static final RegistryObject SENTIENT_PICKAXE = ITEMS.register("soulpickaxe", () -> new ItemSentientPickaxe()); public static final RegistryObject SENTIENT_SHOVEL = ITEMS.register("soulshovel", () -> new ItemSentientShovel()); + public static final RegistryObject SENTIENT_SCYTHE = ITEMS.register("soulscythe", () -> new ItemSentientScythe()); public static final RegistryObject RAW_CRYSTAL_BLOCK_ITEM = ITEMS.register("rawdemoncrystal", () -> new BlockItem(BloodMagicBlocks.RAW_CRYSTAL_BLOCK.get(), new Item.Properties().group(BloodMagic.TAB))); public static final RegistryObject CORROSIVE_CRYSTAL_BLOCK_ITEM = ITEMS.register("corrosivedemoncrystal", () -> new BlockItem(BloodMagicBlocks.CORROSIVE_CRYSTAL_BLOCK.get(), new Item.Properties().group(BloodMagic.TAB))); diff --git a/src/main/java/wayoftime/bloodmagic/common/item/ItemSentientScythe.java b/src/main/java/wayoftime/bloodmagic/common/item/ItemSentientScythe.java new file mode 100644 index 00000000..930507ad --- /dev/null +++ b/src/main/java/wayoftime/bloodmagic/common/item/ItemSentientScythe.java @@ -0,0 +1,831 @@ +package wayoftime.bloodmagic.common.item; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.UUID; + +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Multimap; + +import net.minecraft.block.BlockState; +import net.minecraft.client.util.ITooltipFlag; +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.entity.CreatureAttribute; +import net.minecraft.entity.Entity; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.ai.attributes.Attribute; +import net.minecraft.entity.ai.attributes.AttributeModifier; +import net.minecraft.entity.ai.attributes.Attributes; +import net.minecraft.entity.monster.IMob; +import net.minecraft.entity.monster.SlimeEntity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.inventory.EquipmentSlotType; +import net.minecraft.item.HoeItem; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.network.play.server.SEntityVelocityPacket; +import net.minecraft.particles.ParticleTypes; +import net.minecraft.potion.EffectInstance; +import net.minecraft.potion.Effects; +import net.minecraft.stats.Stats; +import net.minecraft.util.ActionResult; +import net.minecraft.util.DamageSource; +import net.minecraft.util.EntityPredicates; +import net.minecraft.util.Hand; +import net.minecraft.util.SoundEvents; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.MathHelper; +import net.minecraft.util.math.vector.Vector3d; +import net.minecraft.util.text.ITextComponent; +import net.minecraft.util.text.TranslationTextComponent; +import net.minecraft.world.Difficulty; +import net.minecraft.world.World; +import net.minecraft.world.server.ServerWorld; +import net.minecraftforge.api.distmarker.Dist; +import net.minecraftforge.api.distmarker.OnlyIn; +import wayoftime.bloodmagic.BloodMagic; +import wayoftime.bloodmagic.api.compat.EnumDemonWillType; +import wayoftime.bloodmagic.api.compat.IDemonWill; +import wayoftime.bloodmagic.api.compat.IDemonWillWeapon; +import wayoftime.bloodmagic.api.compat.IMultiWillTool; +import wayoftime.bloodmagic.util.Constants; +import wayoftime.bloodmagic.util.helper.NBTHelper; +import wayoftime.bloodmagic.will.PlayerDemonWillHandler; + +public class ItemSentientScythe extends HoeItem implements IDemonWillWeapon, IMultiWillTool +{ + public static int[] soulBracket = new int[] { 16, 60, 200, 400, 1000 }; + public static double[] defaultDamageAdded = new double[] { 0.5, 1, 1.5, 2, 2.5 }; + public static double[] destructiveDamageAdded = new double[] { 2, 3, 4, 5, 6 }; + public static double[] vengefulDamageAdded = new double[] { 0, 0.5, 1, 1.5, 2 }; + public static double[] steadfastDamageAdded = new double[] { 0, 0.5, 1, 1.5, 2 }; + public static double[] defaultDigSpeedAdded = new double[] { 1, 1.5, 2, 3, 4 }; + public static double[] soulDrainPerSwing = new double[] { 0.05, 0.1, 0.2, 0.4, 0.75 }; + public static double[] soulDrop = new double[] { 2, 4, 7, 10, 13 }; + public static double[] staticDrop = new double[] { 1, 1, 2, 3, 3 }; + + public static double[] healthBonus = new double[] { 0, 0, 0, 0, 0 }; // TODO: Think of implementing this later + public static double[] vengefulAttackSpeed = new double[] { -3, -2.8, -2.7, -2.6, -2.5 }; + public static double[] destructiveAttackSpeed = new double[] { -3.1, -3.1, -3.2, -3.3, -3.3 }; + + public static int[] absorptionTime = new int[] { 200, 300, 400, 500, 600 }; + + public static double maxAbsorptionHearts = 10; + + public static int[] poisonTime = new int[] { 25, 50, 60, 80, 100 }; + public static int[] poisonLevel = new int[] { 0, 0, 0, 1, 1 }; + + public static double[] movementSpeed = new double[] { 0.05, 0.1, 0.15, 0.2, 0.25 }; + + public final double baseAttackDamage = 4; + public final double baseAttackSpeed = -3; + private static Map hitMap = new HashMap(); + + public ItemSentientScythe() + { + super(BMItemTier.SENTIENT, 8, -3.1f, new Item.Properties().maxDamage(520).group(BloodMagic.TAB)); +// super(RegistrarBloodMagicItems.SOUL_TOOL_MATERIAL, 8.0F, 3.1F); + } + + @Override + public float getDestroySpeed(ItemStack stack, BlockState state) + { + float value = super.getDestroySpeed(stack, state); + if (value > 1) + { + return (float) (value + getDigSpeedOfSword(stack)); + } else + { + return value; + } + } + + public void recalculatePowers(ItemStack stack, World world, PlayerEntity player) + { + EnumDemonWillType type = PlayerDemonWillHandler.getLargestWillType(player); + double soulsRemaining = PlayerDemonWillHandler.getTotalDemonWill(type, player); + this.setCurrentType(stack, soulsRemaining > 0 ? type : EnumDemonWillType.DEFAULT); + int level = getLevel(stack, soulsRemaining); + + double drain = level >= 0 ? soulDrainPerSwing[level] : 0; + double extraDamage = getExtraDamage(type, level); + + setDrainOfActivatedSword(stack, drain); + setDamageOfActivatedSword(stack, baseAttackDamage + extraDamage); + setStaticDropOfActivatedSword(stack, level >= 0 ? staticDrop[level] : 1); + setDropOfActivatedSword(stack, level >= 0 ? soulDrop[level] : 0); + setAttackSpeedOfSword(stack, level >= 0 ? getAttackSpeed(type, level) : baseAttackSpeed); + setHealthBonusOfSword(stack, level >= 0 ? getHealthBonus(type, level) : 0); + setSpeedOfSword(stack, level >= 0 ? getMovementSpeed(type, level) : 0); + setDigSpeedOfSword(stack, level >= 0 ? getDigSpeed(type, level) : 0); + } + + public double getExtraDamage(EnumDemonWillType type, int willBracket) + { + if (willBracket < 0) + { + return 0; + } + + switch (type) + { + case CORROSIVE: + case DEFAULT: + return defaultDamageAdded[willBracket]; + case DESTRUCTIVE: + return destructiveDamageAdded[willBracket]; + case VENGEFUL: + return vengefulDamageAdded[willBracket]; + case STEADFAST: + return steadfastDamageAdded[willBracket]; + } + + return 0; + } + + public double getAttackSpeed(EnumDemonWillType type, int willBracket) + { + switch (type) + { + case VENGEFUL: + return vengefulAttackSpeed[willBracket]; + case DESTRUCTIVE: + return destructiveAttackSpeed[willBracket]; + default: + return -2.9; + } + } + + public double getHealthBonus(EnumDemonWillType type, int willBracket) + { + switch (type) + { + case STEADFAST: + return healthBonus[willBracket]; + default: + return 0; + } + } + + public double getMovementSpeed(EnumDemonWillType type, int willBracket) + { + switch (type) + { + case VENGEFUL: + return movementSpeed[willBracket]; + default: + return 0; + } + } + + public double getDigSpeed(EnumDemonWillType type, int willBracket) + { + switch (type) + { + case VENGEFUL: +// return movementSpeed[willBracket]; + default: + return defaultDigSpeedAdded[willBracket]; + } + } + +// public void onLeftClickAir(ItemStack stack, LivingEntity attacker) +// { +// if (attacker instanceof PlayerEntity) +// { +// PlayerEntity attackerPlayer = (PlayerEntity) attacker; +// this.recalculatePowers(stack, attackerPlayer.getEntityWorld(), attackerPlayer); +// EnumDemonWillType type = this.getCurrentType(stack); +// double will = PlayerDemonWillHandler.getTotalDemonWill(type, attackerPlayer); +// int willBracket = this.getLevel(stack, will); +// +// this.recalculatePowers(stack, attacker.world, attackerPlayer); +// +//// applyEffectToEntity(type, willBracket, target, attackerPlayer); +// +// attackEntitiesInAreaExcludingEntity(stack, attackerPlayer, type, willBracket); +// } +// } + + @Override + public boolean onEntitySwing(ItemStack stack, LivingEntity attacker) + { + if (attacker instanceof PlayerEntity) + { + PlayerEntity attackerPlayer = (PlayerEntity) attacker; + this.recalculatePowers(stack, attackerPlayer.getEntityWorld(), attackerPlayer); + EnumDemonWillType type = this.getCurrentType(stack); + double will = PlayerDemonWillHandler.getTotalDemonWill(type, attackerPlayer); + int willBracket = this.getLevel(stack, will); + + this.recalculatePowers(stack, attacker.world, attackerPlayer); + +// applyEffectToEntity(type, willBracket, target, attackerPlayer); + + attackEntitiesInAreaExcludingEntity(stack, attackerPlayer, type, willBracket, null); + } + return false; + } + + public void attackEntitiesInAreaExcludingEntity(ItemStack stack, PlayerEntity attacker, EnumDemonWillType type, int willBracket, LivingEntity attackedEntity) + { +// System.out.println("Is client: " + attacker.world.isRemote); + double verticalRange = 2; + double horizontalRange = 2; + double range = 2; + + AxisAlignedBB aabb = null; + List list = null; + + if (attackedEntity != null) + { + aabb = attackedEntity.getBoundingBox().expand(horizontalRange, verticalRange, horizontalRange); + list = attacker.world.getEntitiesInAABBexcluding(attackedEntity, aabb, EntityPredicates.IS_ALIVE); + } else + { + Vector3d eyeVec = attacker.getEyePosition(1).add(attacker.getLookVec().scale(range)); + aabb = new AxisAlignedBB(eyeVec.getX() - horizontalRange, eyeVec.getY() - verticalRange, eyeVec.getZ() - horizontalRange, eyeVec.getX() + horizontalRange, eyeVec.getY() + verticalRange, eyeVec.getZ() + horizontalRange); +// List list = attacker.world.getEntitiesInAABBexcluding(attacker, aabb, EntityPredicates.IS_ALIVE); + list = attacker.world.getEntitiesInAABBexcluding(attacker, aabb, EntityPredicates.IS_ALIVE); + } + + list = attacker.world.getEntitiesWithinAABB(LivingEntity.class, aabb); + + // TODO: check if we actually hit something first, 'kay? + float f = (float) attacker.getAttributeValue(Attributes.ATTACK_DAMAGE); + + float f2 = attacker.getCooledAttackStrength(0.5F); +// float f2 = 1; + f = f * (0.2F + f2 * f2 * 0.8F); + attacker.resetCooldown(); +// f *= 5; + + boolean flag1 = false; + int i = 0; + i = i + EnchantmentHelper.getKnockbackModifier(attacker); + boolean flag = f2 > 0.9F; + + if (attacker.isSprinting() && flag) + { + attacker.world.playSound((PlayerEntity) null, attacker.getPosX(), attacker.getPosY(), attacker.getPosZ(), SoundEvents.ENTITY_PLAYER_ATTACK_KNOCKBACK, attacker.getSoundCategory(), 1.0F, 1.0F); + ++i; + flag1 = true; + } + + boolean didHit = false; + boolean strongAttackHit = false; + boolean weakAttackHit = false; + boolean noDamageHit = false; + + for (Entity targetEntity : list) + { + if (targetEntity.equals(attacker)) + { + continue; + } + + if (!net.minecraftforge.common.ForgeHooks.onPlayerAttackTarget(attacker, targetEntity)) + continue; + if (targetEntity.canBeAttackedWithItem()) + { + if (!targetEntity.hitByEntity(attacker)) + { + float f1; + if (targetEntity instanceof LivingEntity) + { + f1 = EnchantmentHelper.getModifierForCreature(stack, ((LivingEntity) targetEntity).getCreatureAttribute()); + } else + { + f1 = EnchantmentHelper.getModifierForCreature(stack, CreatureAttribute.UNDEFINED); + } + + f1 = f1 * f2; + + if (f > 0.0F || f1 > 0.0F) + { + boolean flag2 = flag && attacker.fallDistance > 0.0F && !attacker.isOnGround() && !attacker.isOnLadder() && !attacker.isInWater() && !attacker.isPotionActive(Effects.BLINDNESS) && !attacker.isPassenger() && targetEntity instanceof LivingEntity; + flag2 = flag2 && !attacker.isSprinting(); + net.minecraftforge.event.entity.player.CriticalHitEvent hitResult = net.minecraftforge.common.ForgeHooks.getCriticalHit(attacker, targetEntity, flag2, flag2 + ? 1.5F + : 1.0F); + flag2 = hitResult != null; + if (flag2) + { + f *= hitResult.getDamageModifier(); + } + + f = f + f1; + boolean flag3 = false; + double d0 = (double) (attacker.distanceWalkedModified - attacker.prevDistanceWalkedModified); + + float f4 = 0.0F; + boolean flag4 = false; + int j = EnchantmentHelper.getFireAspectModifier(attacker); + if (targetEntity instanceof LivingEntity) + { + f4 = ((LivingEntity) targetEntity).getHealth(); + if (j > 0 && !targetEntity.isBurning()) + { + flag4 = true; + targetEntity.setFire(1); + } + } + + Vector3d vector3d = targetEntity.getMotion(); + boolean flag5 = targetEntity.attackEntityFrom(DamageSource.causePlayerDamage(attacker), f); + + if (flag5) + { + didHit = true; + if (i > 0) + { + if (targetEntity instanceof LivingEntity) + { + ((LivingEntity) targetEntity).applyKnockback((float) i * 0.5F, (double) MathHelper.sin(attacker.rotationYaw * ((float) Math.PI / 180F)), (double) (-MathHelper.cos(attacker.rotationYaw * ((float) Math.PI / 180F)))); + } else + { + targetEntity.addVelocity((double) (-MathHelper.sin(attacker.rotationYaw * ((float) Math.PI / 180F)) * (float) i * 0.5F), 0.1D, (double) (MathHelper.cos(attacker.rotationYaw * ((float) Math.PI / 180F)) * (float) i * 0.5F)); + } + + } + +// if (flag3) +// { +// float f3 = 1.0F + EnchantmentHelper.getSweepingDamageRatio(attacker) * f; +// +// for (LivingEntity livingentity : this.world.getEntitiesWithinAABB(LivingEntity.class, targetEntity.getBoundingBox().grow(1.0D, 0.25D, 1.0D))) +// { +// if (livingentity != this && livingentity != targetEntity && !this.isOnSameTeam(livingentity) && (!(livingentity instanceof ArmorStandEntity) || !((ArmorStandEntity) livingentity).hasMarker()) && this.getDistanceSq(livingentity) < 9.0D) +// { +// livingentity.applyKnockback(0.4F, (double) MathHelper.sin(this.rotationYaw * ((float) Math.PI / 180F)), (double) (-MathHelper.cos(this.rotationYaw * ((float) Math.PI / 180F)))); +// livingentity.attackEntityFrom(DamageSource.causePlayerDamage(this), f3); +// } +// } +// +// this.world.playSound((PlayerEntity) null, this.getPosX(), this.getPosY(), this.getPosZ(), SoundEvents.ENTITY_PLAYER_ATTACK_SWEEP, this.getSoundCategory(), 1.0F, 1.0F); +// this.spawnSweepParticles(); +// } + + attacker.spawnSweepParticles(); + + if (targetEntity instanceof ServerPlayerEntity && targetEntity.velocityChanged) + { + ((ServerPlayerEntity) targetEntity).connection.sendPacket(new SEntityVelocityPacket(targetEntity)); + targetEntity.velocityChanged = false; + targetEntity.setMotion(vector3d); + } + + if (flag2) + { + attacker.onCriticalHit(targetEntity); + } + + if (!flag2 && !flag3) + { + if (flag) + { + strongAttackHit = true; + } else + { + weakAttackHit = true; + } + } + + if (f1 > 0.0F) + { + attacker.onEnchantmentCritical(targetEntity); + } + + attacker.setLastAttackedEntity(targetEntity); + if (targetEntity instanceof LivingEntity) + { + EnchantmentHelper.applyThornEnchantments((LivingEntity) targetEntity, attacker); + } + + EnchantmentHelper.applyArthropodEnchantments(attacker, targetEntity); + ItemStack itemstack1 = stack; + Entity entity = targetEntity; +// if (targetEntity instanceof EnderDragonPartEntity) +// { +// entity = ((EnderDragonPartEntity) targetEntity).dragon; +// } + + if (!attacker.world.isRemote && !itemstack1.isEmpty() && entity instanceof LivingEntity) + { + ItemStack copy = itemstack1.copy(); + itemstack1.hitEntity((LivingEntity) entity, attacker); + if (itemstack1.isEmpty()) + { + net.minecraftforge.event.ForgeEventFactory.onPlayerDestroyItem(attacker, copy, Hand.MAIN_HAND); + attacker.setHeldItem(Hand.MAIN_HAND, ItemStack.EMPTY); + } + } + + if (targetEntity instanceof LivingEntity) + { + float f5 = f4 - ((LivingEntity) targetEntity).getHealth(); + attacker.addStat(Stats.DAMAGE_DEALT, Math.round(f5 * 10.0F)); + if (j > 0) + { + targetEntity.setFire(j * 4); + } + + if (attacker.world instanceof ServerWorld && f5 > 2.0F) + { + int k = (int) ((double) f5 * 0.5D); + ((ServerWorld) attacker.world).spawnParticle(ParticleTypes.DAMAGE_INDICATOR, targetEntity.getPosX(), targetEntity.getPosYHeight(0.5D), targetEntity.getPosZ(), k, 0.1D, 0.0D, 0.1D, 0.2D); + } + } + + } else + { + noDamageHit = true; + if (flag4) + { + targetEntity.extinguish(); + } + } + } + + } + } + } + + if (didHit) + { + if (flag1) + { + attacker.setMotion(attacker.getMotion().mul(0.6D, 1.0D, 0.6D)); + attacker.setSprinting(false); + } + + attacker.addExhaustion(0.1F); + + attacker.world.playSound((PlayerEntity) null, attacker.getPosX(), attacker.getPosY(), attacker.getPosZ(), SoundEvents.ENTITY_PLAYER_ATTACK_SWEEP, attacker.getSoundCategory(), 1.0F, 1.0F); + } + + if (noDamageHit) + { + attacker.world.playSound((PlayerEntity) null, attacker.getPosX(), attacker.getPosY(), attacker.getPosZ(), SoundEvents.ENTITY_PLAYER_ATTACK_NODAMAGE, attacker.getSoundCategory(), 1.0F, 1.0F); + } + + if (strongAttackHit) + { + attacker.world.playSound((PlayerEntity) null, attacker.getPosX(), attacker.getPosY(), attacker.getPosZ(), SoundEvents.ENTITY_PLAYER_ATTACK_STRONG, attacker.getSoundCategory(), 1.0F, 1.0F); + } + if (weakAttackHit) + { + attacker.world.playSound((PlayerEntity) null, attacker.getPosX(), attacker.getPosY(), attacker.getPosZ(), SoundEvents.ENTITY_PLAYER_ATTACK_WEAK, attacker.getSoundCategory(), 1.0F, 1.0F); + } + } + + public void applyEffectToEntity(EnumDemonWillType type, int willBracket, LivingEntity target, PlayerEntity attacker) + { + switch (type) + { + case CORROSIVE: + target.addPotionEffect(new EffectInstance(Effects.WITHER, poisonTime[willBracket], poisonLevel[willBracket])); + break; + case DEFAULT: + break; + case DESTRUCTIVE: + break; + case STEADFAST: + if (!target.isAlive()) + { + float absorption = attacker.getAbsorptionAmount(); + attacker.addPotionEffect(new EffectInstance(Effects.ABSORPTION, absorptionTime[willBracket], 127)); + attacker.setAbsorptionAmount((float) Math.min(absorption + target.getMaxHealth() * 0.05f, maxAbsorptionHearts)); + } + break; + case VENGEFUL: + break; + } + } + + @Override + public boolean hitEntity(ItemStack stack, LivingEntity target, LivingEntity attacker) + { + if (super.hitEntity(stack, target, attacker)) + { + if (attacker instanceof PlayerEntity) + { + UUID id = attacker.getUniqueID(); + + PlayerEntity attackerPlayer = (PlayerEntity) attacker; + + System.out.println("Hit map: " + hitMap.containsKey(id)); + + if (hitMap.containsKey(id) && hitMap.get(id)) + { + EnumDemonWillType type = this.getCurrentType(stack); + double will = PlayerDemonWillHandler.getTotalDemonWill(type, attackerPlayer); + int willBracket = this.getLevel(stack, will); + applyEffectToEntity(type, willBracket, target, attackerPlayer); + } else + { + this.recalculatePowers(stack, attackerPlayer.getEntityWorld(), attackerPlayer); + EnumDemonWillType type = this.getCurrentType(stack); + double will = PlayerDemonWillHandler.getTotalDemonWill(type, attackerPlayer); + int willBracket = this.getLevel(stack, will); + hitMap.put(id, true); + this.attackEntitiesInAreaExcludingEntity(stack, attackerPlayer, type, willBracket, target); + hitMap.remove(id); + } + } + + return true; + } + + return false; + } + + @Override + public EnumDemonWillType getCurrentType(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + if (!tag.contains(Constants.NBT.WILL_TYPE)) + { + return EnumDemonWillType.DEFAULT; + } + + return EnumDemonWillType.valueOf(tag.getString(Constants.NBT.WILL_TYPE).toUpperCase(Locale.ENGLISH)); + } + + public void setCurrentType(ItemStack stack, EnumDemonWillType type) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putString(Constants.NBT.WILL_TYPE, type.toString()); + } + + @Override + public ActionResult onItemRightClick(World world, PlayerEntity player, Hand hand) + { + recalculatePowers(player.getHeldItem(hand), world, player); + + return super.onItemRightClick(world, player, hand); + } + + @Override + public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged) + { + return oldStack.getItem() != newStack.getItem(); + } + + private int getLevel(ItemStack stack, double soulsRemaining) + { + int lvl = -1; + for (int i = 0; i < soulBracket.length; i++) + { + if (soulsRemaining >= soulBracket[i]) + { + lvl = i; + } + } + + return lvl; + } + + @Override + @OnlyIn(Dist.CLIENT) + public void addInformation(ItemStack stack, World world, List tooltip, ITooltipFlag flag) + { + if (!stack.hasTag()) + return; + + tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.sentientAxe.desc")); + tooltip.add(new TranslationTextComponent("tooltip.bloodmagic.currentType." + getCurrentType(stack).name().toLowerCase())); + } + + @Override + public boolean onLeftClickEntity(ItemStack stack, PlayerEntity player, Entity entity) + { + recalculatePowers(stack, player.getEntityWorld(), player); + + double drain = this.getDrainOfActivatedSword(stack); + if (drain > 0) + { + EnumDemonWillType type = getCurrentType(stack); + double soulsRemaining = PlayerDemonWillHandler.getTotalDemonWill(type, player); + + if (drain > soulsRemaining) + { + return false; + } else + { + PlayerDemonWillHandler.consumeDemonWill(type, player, drain); + } + } + + return super.onLeftClickEntity(stack, player, entity); + } + + @Override + public List getRandomDemonWillDrop(LivingEntity killedEntity, LivingEntity attackingEntity, ItemStack stack, int looting) + { + List soulList = new ArrayList<>(); + + if (killedEntity.getEntityWorld().getDifficulty() != Difficulty.PEACEFUL && !(killedEntity instanceof IMob)) + { + return soulList; + } + + double willModifier = killedEntity instanceof SlimeEntity ? 0.67 : 1; + + IDemonWill soul; + + EnumDemonWillType type = this.getCurrentType(stack); + switch (type) + { + case CORROSIVE: + soul = ((IDemonWill) BloodMagicItems.MONSTER_SOUL_CORROSIVE.get()); + break; + case DESTRUCTIVE: + soul = ((IDemonWill) BloodMagicItems.MONSTER_SOUL_DESTRUCTIVE.get()); + break; + case STEADFAST: + soul = ((IDemonWill) BloodMagicItems.MONSTER_SOUL_STEADFAST.get()); + break; + case VENGEFUL: + soul = ((IDemonWill) BloodMagicItems.MONSTER_SOUL_VENGEFUL.get()); + break; + default: + soul = ((IDemonWill) BloodMagicItems.MONSTER_SOUL_RAW.get()); + break; + } + + for (int i = 0; i <= looting; i++) + { + if (i == 0 || attackingEntity.getEntityWorld().rand.nextDouble() < 0.4) + { + ItemStack soulStack = soul.createWill(willModifier * (this.getDropOfActivatedSword(stack) * attackingEntity.getEntityWorld().rand.nextDouble() + this.getStaticDropOfActivatedSword(stack)) * killedEntity.getMaxHealth() / 20d); + soulList.add(soulStack); + } + } + + return soulList; + } + + // TODO: Change attack speed. + @Override + public Multimap getAttributeModifiers(EquipmentSlotType slot, ItemStack stack) + { + Multimap multimap = HashMultimap.create(); + if (slot == EquipmentSlotType.MAINHAND) + { + multimap.put(Attributes.ATTACK_DAMAGE, new AttributeModifier(ATTACK_DAMAGE_MODIFIER, "Weapon modifier", getDamageOfActivatedSword(stack), AttributeModifier.Operation.ADDITION)); + multimap.put(Attributes.ATTACK_SPEED, new AttributeModifier(ATTACK_SPEED_MODIFIER, "Weapon modifier", this.getAttackSpeedOfSword(stack), AttributeModifier.Operation.ADDITION)); + multimap.put(Attributes.MAX_HEALTH, new AttributeModifier(new UUID(0, 31818145), "Weapon modifier", this.getHealthBonusOfSword(stack), AttributeModifier.Operation.ADDITION)); + multimap.put(Attributes.MOVEMENT_SPEED, new AttributeModifier(new UUID(0, 4218052), "Weapon modifier", this.getSpeedOfSword(stack), AttributeModifier.Operation.ADDITION)); + } + + return multimap; + } + + public double getDamageOfActivatedSword(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + return tag.getDouble(Constants.NBT.SOUL_SWORD_DAMAGE); + } + + public void setDamageOfActivatedSword(ItemStack stack, double damage) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putDouble(Constants.NBT.SOUL_SWORD_DAMAGE, damage); + } + + public double getDrainOfActivatedSword(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + return tag.getDouble(Constants.NBT.SOUL_SWORD_ACTIVE_DRAIN); + } + + public void setDrainOfActivatedSword(ItemStack stack, double drain) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putDouble(Constants.NBT.SOUL_SWORD_ACTIVE_DRAIN, drain); + } + + public double getStaticDropOfActivatedSword(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + return tag.getDouble(Constants.NBT.SOUL_SWORD_STATIC_DROP); + } + + public void setStaticDropOfActivatedSword(ItemStack stack, double drop) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putDouble(Constants.NBT.SOUL_SWORD_STATIC_DROP, drop); + } + + public double getDropOfActivatedSword(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + return tag.getDouble(Constants.NBT.SOUL_SWORD_DROP); + } + + public void setDropOfActivatedSword(ItemStack stack, double drop) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putDouble(Constants.NBT.SOUL_SWORD_DROP, drop); + } + + public double getHealthBonusOfSword(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + return tag.getDouble(Constants.NBT.SOUL_SWORD_HEALTH); + } + + public void setHealthBonusOfSword(ItemStack stack, double hp) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putDouble(Constants.NBT.SOUL_SWORD_HEALTH, hp); + } + + public double getAttackSpeedOfSword(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + return tag.getDouble(Constants.NBT.SOUL_SWORD_ATTACK_SPEED); + } + + public void setAttackSpeedOfSword(ItemStack stack, double speed) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putDouble(Constants.NBT.SOUL_SWORD_ATTACK_SPEED, speed); + } + + public double getSpeedOfSword(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + return tag.getDouble(Constants.NBT.SOUL_SWORD_SPEED); + } + + public void setSpeedOfSword(ItemStack stack, double speed) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putDouble(Constants.NBT.SOUL_SWORD_SPEED, speed); + } + + public double getDigSpeedOfSword(ItemStack stack) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + return tag.getDouble(Constants.NBT.SOUL_SWORD_DIG_SPEED); + } + + public void setDigSpeedOfSword(ItemStack stack, double speed) + { + NBTHelper.checkNBT(stack); + + CompoundNBT tag = stack.getTag(); + + tag.putDouble(Constants.NBT.SOUL_SWORD_DIG_SPEED, speed); + } +} diff --git a/src/main/java/wayoftime/bloodmagic/common/recipe/TartaricForgeRecipeProvider.java b/src/main/java/wayoftime/bloodmagic/common/recipe/TartaricForgeRecipeProvider.java index 6e1f4b6a..63bd6a20 100644 --- a/src/main/java/wayoftime/bloodmagic/common/recipe/TartaricForgeRecipeProvider.java +++ b/src/main/java/wayoftime/bloodmagic/common/recipe/TartaricForgeRecipeProvider.java @@ -30,6 +30,7 @@ public class TartaricForgeRecipeProvider implements ISubRecipeProvider TartaricForgeRecipeBuilder.tartaricForge(new ItemStack(BloodMagicItems.SENTIENT_AXE.get()), 0, 0, Ingredient.fromItems(BloodMagicItems.PETTY_GEM.get()), Ingredient.fromItems(Items.IRON_AXE)).build(consumer, BloodMagic.rl(basePath + "sentientaxe")); TartaricForgeRecipeBuilder.tartaricForge(new ItemStack(BloodMagicItems.SENTIENT_PICKAXE.get()), 0, 0, Ingredient.fromItems(BloodMagicItems.PETTY_GEM.get()), Ingredient.fromItems(Items.IRON_PICKAXE)).build(consumer, BloodMagic.rl(basePath + "sentientpickaxe")); TartaricForgeRecipeBuilder.tartaricForge(new ItemStack(BloodMagicItems.SENTIENT_SHOVEL.get()), 0, 0, Ingredient.fromItems(BloodMagicItems.PETTY_GEM.get()), Ingredient.fromItems(Items.IRON_SHOVEL)).build(consumer, BloodMagic.rl(basePath + "sentientshovel")); + TartaricForgeRecipeBuilder.tartaricForge(new ItemStack(BloodMagicItems.SENTIENT_SCYTHE.get()), 0, 0, Ingredient.fromItems(BloodMagicItems.PETTY_GEM.get()), Ingredient.fromItems(Items.IRON_HOE)).build(consumer, BloodMagic.rl(basePath + "sentientscythe")); TartaricForgeRecipeBuilder.tartaricForge(new ItemStack(BloodMagicItems.REAGENT_AIR.get()), 128, 20, Ingredient.fromItems(Items.GHAST_TEAR), Ingredient.fromTag(Tags.Items.FEATHERS), Ingredient.fromTag(Tags.Items.FEATHERS)).build(consumer, BloodMagic.rl(basePath + "reagent_air")); TartaricForgeRecipeBuilder.tartaricForge(new ItemStack(BloodMagicItems.ARCANE_ASHES.get()), 0, 0, Ingredient.fromTag(Tags.Items.DUSTS_REDSTONE), Ingredient.fromTag(Tags.Items.DYES_WHITE), Ingredient.fromTag(Tags.Items.GUNPOWDER), Ingredient.fromTag(ItemTags.COALS)).build(consumer, BloodMagic.rl(basePath + "arcaneashes")); diff --git a/src/main/java/wayoftime/bloodmagic/util/handler/event/GenericHandler.java b/src/main/java/wayoftime/bloodmagic/util/handler/event/GenericHandler.java index 2d4ed58e..653c15b9 100644 --- a/src/main/java/wayoftime/bloodmagic/util/handler/event/GenericHandler.java +++ b/src/main/java/wayoftime/bloodmagic/util/handler/event/GenericHandler.java @@ -87,6 +87,15 @@ public class GenericHandler } } + @SubscribeEvent + public void onPlayerLeftClickAir(PlayerInteractEvent.LeftClickEmpty event) + { +// if (event.getItemStack().getItem() instanceof ItemSentientScythe) +// { +// ((ItemSentientScythe) event.getItemStack().getItem()).onLeftClickAir(event.getItemStack(), event.getEntityLiving()); +// } + } + @SubscribeEvent public void onHoe(BlockToolInteractEvent event) { diff --git a/src/main/resources/assets/bloodmagic/textures/item/soulscythe.png b/src/main/resources/assets/bloodmagic/textures/item/soulscythe.png new file mode 100644 index 00000000..2adb8ae5 Binary files /dev/null and b/src/main/resources/assets/bloodmagic/textures/item/soulscythe.png differ diff --git a/src/main/resources/assets/bloodmagic/textures/item/soulscythe_corrosive.png b/src/main/resources/assets/bloodmagic/textures/item/soulscythe_corrosive.png new file mode 100644 index 00000000..79328204 Binary files /dev/null and b/src/main/resources/assets/bloodmagic/textures/item/soulscythe_corrosive.png differ diff --git a/src/main/resources/assets/bloodmagic/textures/item/soulscythe_destructive.png b/src/main/resources/assets/bloodmagic/textures/item/soulscythe_destructive.png new file mode 100644 index 00000000..adeb8589 Binary files /dev/null and b/src/main/resources/assets/bloodmagic/textures/item/soulscythe_destructive.png differ diff --git a/src/main/resources/assets/bloodmagic/textures/item/soulscythe_steadfast.png b/src/main/resources/assets/bloodmagic/textures/item/soulscythe_steadfast.png new file mode 100644 index 00000000..bdac5fbf Binary files /dev/null and b/src/main/resources/assets/bloodmagic/textures/item/soulscythe_steadfast.png differ diff --git a/src/main/resources/assets/bloodmagic/textures/item/soulscythe_vengeful.png b/src/main/resources/assets/bloodmagic/textures/item/soulscythe_vengeful.png new file mode 100644 index 00000000..9c3c04f5 Binary files /dev/null and b/src/main/resources/assets/bloodmagic/textures/item/soulscythe_vengeful.png differ