Project renamed to "TAIGA: Tinkers alloying addon"

src/main/java/com/sosnitzka/taiga/traits/TraitAnalysing.java

@@ -0,0 +1,66 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.event.entity.living.LivingExperienceDropEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+
+
+public class TraitAnalysing extends AbstractTrait {
+
+    public TraitAnalysing() {
+        super("analysing", TextFormatting.GREEN);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @SubscribeEvent
+    public void onXpDrop(LivingExperienceDropEvent event) {
+        EntityPlayer player = event.getAttackingPlayer();
+        if (player != null && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), this.identifier)) {
+            event.setDroppedExperience(this.getUpdateXP(event.getDroppedExperience()));
+        }
+
+    }
+
+    @SubscribeEvent
+    public void onBlockBreak(BlockEvent.BreakEvent event) {
+        EntityPlayer player = event.getPlayer();
+        if (player != null && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), this.identifier)) {
+            event.setExpToDrop(this.getUpdateXP(event.getExpToDrop()));
+        }
+
+    }
+
+    @SubscribeEvent
+    public void onMobDrops(LivingDropsEvent event) {
+        World w = event.getEntity().getEntityWorld();
+        if (event.getSource().getEntity() instanceof EntityPlayer) {
+            EntityPlayer player = (EntityPlayer) event.getSource().getEntity();
+            if (!w.isRemote && event.getEntity() instanceof EntityMob && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), identifier)) {
+                event.getDrops().clear();
+            }
+        }
+    }
+
+    private int getUpdateXP(int xp) {
+        float exp = (float) random.nextFloat() * random.nextFloat() * random.nextFloat() * (xp + 18) * 50;
+        return Math.round(exp);
+    }
+
+    @Override
+    public void blockHarvestDrops(ItemStack tool, BlockEvent.HarvestDropsEvent event) {
+        if (random.nextFloat() < 0.85) {
+            event.getDrops().clear();
+        }
+    }
+
+}

src/main/java/com/sosnitzka/taiga/traits/TraitArcane.java

@@ -0,0 +1,42 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+public class TraitArcane extends AbstractTrait {
+
+    public TraitArcane() {
+        super("arcane", TextFormatting.DARK_PURPLE);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        int time = (int) world.getWorldTime();
+        if (random.nextFloat() <= 0.1 && isNight(time)) {
+            ToolHelper.healTool(tool, random.nextInt(15) + 1, null);
+        }
+    }
+
+    @Override
+    public void afterHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean wasCritical, boolean wasHit) {
+        int time = (int) player.getEntityWorld().getWorldTime();
+        if (random.nextFloat() <= 0.1 && isNight(time)) {
+            ToolHelper.healTool(tool, random.nextInt(15) + 1, null);
+        }
+    }
+
+
+    public boolean isNight(int time) {
+        if (time > 12500) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitBlind.java

@@ -0,0 +1,44 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.init.MobEffects;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+
+public class TraitBlind extends AbstractTrait {
+
+    public TraitBlind() {
+        super("blind", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        int time = (int) world.getWorldTime();
+        if (random.nextFloat() <= 0.05 || (random.nextFloat() <= 0.1 && isNight(time))) {
+            player.addPotionEffect(new PotionEffect(MobEffects.BLINDNESS, random.nextInt(400) + 200));
+            player.addPotionEffect(new PotionEffect(MobEffects.WEAKNESS, random.nextInt(400) + 200));
+        }
+    }
+
+    @Override
+    public void afterHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean wasCritical, boolean wasHit) {
+        int time = (int) player.getEntityWorld().getWorldTime();
+        if (random.nextFloat() <= 0.05 || (random.nextFloat() <= 0.1 && isNight(time))) {
+            player.addPotionEffect(new PotionEffect(MobEffects.BLINDNESS, random.nextInt(400) + 200));
+            player.addPotionEffect(new PotionEffect(MobEffects.WEAKNESS, random.nextInt(400) + 200));
+        }
+    }
+
+    public boolean isNight(int time) {
+        if (time > 12500) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitBright.java

@@ -0,0 +1,50 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.MobEffects;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+
+
+public class TraitBright extends AbstractTrait {
+
+    public TraitBright() {
+        super("bright", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public float damage(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, float newDamage, boolean isCritical) {
+        int time = (int) target.getEntityWorld().getWorldTime();
+        if (isDay(time)) {
+            newDamage += damage / 2f;
+        }
+        return super.damage(tool, player, target, damage, newDamage, isCritical);
+
+    }
+
+    @Override
+    public void onUpdate(ItemStack item, World world, Entity entity, int i, boolean b) {
+        if (entity instanceof EntityPlayer) {
+            EntityPlayer e = (EntityPlayer) entity;
+            if (TinkerUtil.hasTrait(TagUtil.getTagSafe(e.getHeldItemMainhand()), identifier)) {
+                e.addPotionEffect(new PotionEffect(MobEffects.GLOWING, 100));
+            }
+        }
+
+    }
+
+    public boolean isDay(int time) {
+        if (time < 12500) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitCascade.java

@@ -0,0 +1,57 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+public class TraitCascade extends AbstractTrait {
+
+    public TraitCascade() {
+        super("cascade", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        float f = random.nextFloat();
+        float b = 0.99F * calcBonus(tool);
+        if (!world.isRemote && tool.canHarvestBlock(state) && f <= b) {
+            double x, y, z, sx, sy, sz;
+            sx = x = pos.getX();
+            sy = y = pos.getY();
+            sz = z = pos.getZ();
+            for (int i = random.nextInt(ToolHelper.getCurrentDurability(tool)); i > 0; i--) {
+                int r = random.nextInt(3);
+                int d = random.nextBoolean() ? 1 : -1;
+                if (r == 0) x += d;
+                if (r == 1) y += d;
+                if (r == 2) z += d;
+                BlockPos nextBlock = new BlockPos(x, y, z);
+                if (world.getBlockState(nextBlock) == world.getBlockState(pos)) {
+                    world.destroyBlock(nextBlock, true);
+                    sx = x = nextBlock.getX();
+                    sy = y = nextBlock.getY();
+                    sz = z = nextBlock.getZ();
+                    ToolHelper.damageTool(tool, random.nextInt(2), player);
+                } else {
+                    x = sx;
+                    y = sy;
+                    z = sz;
+                }
+
+            }
+
+        }
+
+    }
+
+    private float calcBonus(ItemStack tool) {
+        int durability = ToolHelper.getCurrentDurability(tool);
+        int maxDurability = ToolHelper.getMaxDurability(tool);
+        return (0.4f) / (maxDurability - 50) * (durability) + 0.55f;
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitCurvature.java

@@ -0,0 +1,79 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+
+
+public class TraitCurvature extends AbstractTrait {
+
+
+    public TraitCurvature() {
+        super("curvature", TextFormatting.BLACK);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        if (random.nextFloat() <= 0.05 && world.provider.getDimension() != -1) {
+            teleport(player, world);
+            player.playSound(SoundEvents.ENTITY_ENDERMEN_TELEPORT, 1.0F, 1.0F);
+        }
+    }
+
+    @Override
+    public void afterHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean wasCritical, boolean wasHit) {
+        World w = player.getEntityWorld();
+        if (random.nextFloat() <= 0.1 && w.provider.getDimension() != -1) {
+            if (random.nextBoolean()) {
+                teleport(player, w);
+                target.playSound(SoundEvents.ENTITY_ENDERMEN_TELEPORT, 1.0F, 1.0F);
+            } else {
+                target.playSound(SoundEvents.ENTITY_ENDERMEN_TELEPORT, 1.0F, 1.0F);
+                teleport(target, w);
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void onMobDrops(LivingDropsEvent event) {
+        World w = event.getEntity().getEntityWorld();
+        if (event.getSource().getEntity() instanceof EntityPlayer) {
+            EntityPlayer player = (EntityPlayer) event.getSource().getEntity();
+            if (!w.isRemote && event.getEntity() instanceof EntityMob && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), identifier)) {
+                ItemStack i = new ItemStack(Items.ENDER_PEARL, random.nextInt(3));
+                event.getDrops().add(0, new EntityItem(w, event.getEntity().posX, event.getEntity().posY, event.getEntity().posZ, i));
+            }
+        }
+    }
+
+    private void teleport(EntityLivingBase e, World w) {
+        int x = e.getPosition().getX() + random.nextInt(250) - 125;
+        int y = e.getPosition().getY();
+        int z = e.getPosition().getZ() + random.nextInt(250) - 125;
+        while (w.getBlockState(new BlockPos(x, y, z)).getBlock() != Blocks.AIR) {
+            y++;
+        }
+        while (w.getBlockState(new BlockPos(x, y - 1, z)).getBlock() == Blocks.AIR) {
+            y--;
+        }
+
+        e.setPosition(x, y, z);
+    }
+
+}

src/main/java/com/sosnitzka/taiga/traits/TraitDark.java

@@ -0,0 +1,32 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+
+
+public class TraitDark extends AbstractTrait {
+
+    public TraitDark() {
+        super("dark", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public float damage(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, float newDamage, boolean isCritical) {
+        int time = (int) target.getEntityWorld().getWorldTime();
+        if (isNight(time)) {
+            newDamage += damage / 2f;
+        }
+        return super.damage(tool, player, target, damage, newDamage, isCritical);
+
+    }
+
+    public boolean isNight(int time) {
+        if (time > 12500) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitDiffuse.java

@@ -0,0 +1,67 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.event.entity.living.LivingExperienceDropEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+
+public class TraitDiffuse extends AbstractTrait {
+
+    public TraitDiffuse() {
+        super("diffuse", TextFormatting.DARK_GRAY);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @SubscribeEvent
+    public void onXpDrop(LivingExperienceDropEvent event) {
+        EntityPlayer player = event.getAttackingPlayer();
+        if (player != null && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), this.identifier)) {
+            event.setDroppedExperience(0);
+        }
+
+    }
+
+    @SubscribeEvent
+    public void onBlockBreak(BlockEvent.BreakEvent event) {
+        EntityPlayer player = event.getPlayer();
+        if (player != null && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), this.identifier)) {
+            event.setExpToDrop(this.getUpdateXP(event.getExpToDrop()));
+        }
+
+    }
+
+    @SubscribeEvent
+    public void onMobDrops(LivingDropsEvent event) {
+        World w = event.getEntity().getEntityWorld();
+        if (event.getSource().getEntity() instanceof EntityPlayer) {
+            EntityPlayer player = (EntityPlayer) event.getSource().getEntity();
+            if (!w.isRemote && event.getEntity() instanceof EntityMob && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), identifier)) {
+                event.getDrops().clear();
+            }
+        }
+    }
+
+    private int getUpdateXP(int xp) {
+        float exp = (float) random.nextFloat() * random.nextFloat() * random.nextFloat() * (xp + random.nextInt(10));
+        if (random.nextBoolean())
+            return Math.round(exp);
+        else return 0;
+    }
+
+    @Override
+    public void blockHarvestDrops(ItemStack tool, BlockEvent.HarvestDropsEvent event) {
+        if (random.nextFloat() < 0.75) {
+            event.getDrops().clear();
+        }
+    }
+
+}

src/main/java/com/sosnitzka/taiga/traits/TraitDissolving.java

@@ -0,0 +1,32 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingExperienceDropEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+
+
+public class TraitDissolving extends AbstractTrait {
+
+    public TraitDissolving() {
+        super("dissolving", TextFormatting.DARK_AQUA);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    // high chance to remove XP, low chance to double,triple or quatruple dropped Experience
+    @SubscribeEvent
+    public void onXpDrop(LivingExperienceDropEvent event) {
+        EntityPlayer player = event.getAttackingPlayer();
+        float r = random.nextFloat();
+        if (r <= 0.75 && player != null && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), this.identifier)) {
+            event.setDroppedExperience(0);
+        }
+        if (r > 0.95 && player != null && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), this.identifier)) {
+            event.setDroppedExperience(event.getDroppedExperience() * (random.nextInt(3) + 2));
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitFracture.java

@@ -0,0 +1,66 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.tools.ToolCore;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+public class TraitFracture extends AbstractTrait {
+
+    public TraitFracture() {
+        super("fracture", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        float f = random.nextFloat();
+        float b = 0.99F * calcBonus(tool);
+        if (!world.isRemote && tool.canHarvestBlock(state) && f <= b) {
+            RayTraceResult mop = ((ToolCore) tool.getItem()).rayTrace(world, (EntityPlayer) player, false);
+            if (mop == null) return;
+            for (int i = random.nextInt(9) + 1; i >= 0; i--) {
+                switch (mop.sideHit) {
+                    case UP:
+                        BlockPos next1 = new BlockPos(pos.getX(), pos.getY() - i, pos.getZ());
+                        if (tool.canHarvestBlock(world.getBlockState(next1))) world.destroyBlock(next1, true);
+                        break;
+                    case DOWN:
+                        BlockPos next2 = new BlockPos(pos.getX(), pos.getY() + i, pos.getZ());
+                        if (tool.canHarvestBlock(world.getBlockState(next2))) world.destroyBlock(next2, true);
+                        break;
+                    case WEST:
+                        BlockPos next3 = new BlockPos(pos.getX() + i, pos.getY(), pos.getZ());
+                        if (tool.canHarvestBlock(world.getBlockState(next3))) world.destroyBlock(next3, true);
+                        break;
+                    case EAST:
+                        BlockPos next4 = new BlockPos(pos.getX() - i, pos.getY(), pos.getZ());
+                        if (tool.canHarvestBlock(world.getBlockState(next4))) world.destroyBlock(next4, true);
+                        break;
+                    case SOUTH:
+                        BlockPos next5 = new BlockPos(pos.getX(), pos.getY(), pos.getZ() - i);
+                        if (tool.canHarvestBlock(world.getBlockState(next5))) world.destroyBlock(next5, true);
+                        break;
+                    case NORTH:
+                        BlockPos next6 = new BlockPos(pos.getX(), pos.getY() - i, pos.getZ() + i);
+                        if (tool.canHarvestBlock(world.getBlockState(next6))) world.destroyBlock(next6, true);
+                        break;
+                }
+            }
+            if (random.nextBoolean()) ToolHelper.damageTool(tool, random.nextInt(5), player);
+        }
+
+    }
+
+    private float calcBonus(ItemStack tool) {
+        int durability = ToolHelper.getCurrentDurability(tool);
+        int maxDurability = ToolHelper.getMaxDurability(tool);
+        return (0.4f) / (maxDurability - 50) * (durability) + 0.55f;
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitFragile.java

@@ -0,0 +1,87 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+public class TraitFragile extends AbstractTrait {
+
+    public TraitFragile() {
+        super("fragile", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        if (random.nextBoolean()) {
+            float f = random.nextFloat();
+            float b = 0.99F * calcBonus(tool);
+            if (!world.isRemote && tool.canHarvestBlock(state) && f <= b) {
+                if (random.nextBoolean()) ToolHelper.damageTool(tool, random.nextInt(3), player);
+            }
+        } else {
+            float f = random.nextFloat();
+            float b = 0.99F * calcBonus(tool);
+            if (!world.isRemote && state.getBlock() == Blocks.STONE && f <= b) {
+                double x, y, z, sx, sy, sz;
+                sx = x = pos.getX();
+                sy = y = pos.getY();
+                sz = z = pos.getZ();
+                for (int i = random.nextInt(50) + 50; i > 0; i--) {
+                    int r = random.nextInt(3);
+                    int d = random.nextBoolean() ? 1 : -1;
+                    if (r == 0) x += d;
+                    if (r == 1) y += d;
+                    if (r == 2) z += d;
+                    BlockPos nextBlock = new BlockPos(x, y, z);
+                    int tn = (int) world.getWorldTime() + 5;
+                    if (world.getBlockState(nextBlock) == world.getBlockState(pos)) {
+                        Block block = Blocks.STONE;
+                        int ib = random.nextInt(3);
+                        switch (ib) {
+                            case 0:
+                                block = Blocks.COBBLESTONE;
+                                break;
+                            case 1:
+                                block = Blocks.MOSSY_COBBLESTONE;
+                                break;
+                            case 2:
+                                block = Blocks.GRAVEL;
+                                break;
+                        }
+                        f = random.nextFloat();
+                        if (f < 0.85) {
+                            world.setBlockState(nextBlock, block.getDefaultState());
+                        } else if (f > 95) {
+                            world.destroyBlock(nextBlock, true);
+                        }
+                        sx = x = nextBlock.getX();
+                        sy = y = nextBlock.getY();
+                        sz = z = nextBlock.getZ();
+                        if (random.nextBoolean()) ToolHelper.damageTool(tool, 1, player);
+                    } else {
+                        x = sx;
+                        y = sy;
+                        z = sz;
+                    }
+
+                }
+
+            }
+
+        }
+    }
+
+
+    private float calcBonus(ItemStack tool) {
+        int durability = ToolHelper.getCurrentDurability(tool);
+        int maxDurability = ToolHelper.getMaxDurability(tool);
+        return (0.4f) / (maxDurability - 50) * (durability) + 0.55f;
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitGarishly.java

@@ -0,0 +1,80 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+import static com.sosnitzka.taiga.Items.*;
+
+public class TraitGarishly extends AbstractTrait {
+
+    public TraitGarishly() {
+        super("garishly", TextFormatting.YELLOW);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @SubscribeEvent
+    public void onMobDrops(LivingDropsEvent event) {
+        World w = event.getEntity().getEntityWorld();
+        if (event.getSource().getEntity() instanceof EntityPlayer) {
+            EntityPlayer player = (EntityPlayer) event.getSource().getEntity();
+            if (!w.isRemote && event.getEntity() instanceof EntityMob && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), identifier)) {
+
+                int r = random.nextInt(5);
+                ItemStack i = null;
+                switch (r) {
+                    case 0:
+                        i = new ItemStack(Items.BLAZE_POWDER, random.nextInt(3));
+                        break;
+                    case 1:
+                        i = new ItemStack(Items.BLAZE_ROD, random.nextInt(3));
+                        break;
+                    case 2:
+                        i = new ItemStack(glimmerstone_dust, random.nextInt(3));
+                        break;
+                    case 3:
+                        i = new ItemStack(luminar_dust, random.nextInt(3));
+                        break;
+                    case 4:
+                        i = new ItemStack(Items.COAL, random.nextInt(3));
+                        break;
+                    case 5:
+                        i = new ItemStack(lignite, random.nextInt(3));
+                        break;
+                }
+
+                event.getDrops().add(0, new EntityItem(w, event.getEntity().posX, event.getEntity().posY, event.getEntity().posZ, i));
+            }
+        }
+    }
+
+    @Override
+    public void blockHarvestDrops(ItemStack tool, BlockEvent.HarvestDropsEvent event) {
+        float r = random.nextFloat();
+        if (r > 0.5f) event.getDrops().clear();
+        else if (r < 0.1 && event.getWorld().getBlockState(event.getPos()).getMaterial() == Material.ROCK) {
+            ItemStack stack = new ItemStack(Item.getItemFromBlock(event.getWorld().getBlockState(event.getPos()).getBlock()), random.nextInt(5));
+            event.getDrops().add(0, stack);
+            ToolHelper.damageTool(tool, random.nextInt(6) + 1, event.getHarvester());
+        }
+    }
+
+
+}
+
+
+

src/main/java/com/sosnitzka/taiga/traits/TraitGlimmer.java

@@ -0,0 +1,48 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.MobEffects;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+
+public class TraitGlimmer extends AbstractTrait {
+
+
+    public TraitGlimmer() {
+        super("glimmer", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public void onUpdate(ItemStack item, World world, Entity entity, int i, boolean b) {
+        if (entity instanceof EntityPlayer) {
+            EntityPlayer e = (EntityPlayer) entity;
+            if (TinkerUtil.hasTrait(TagUtil.getTagSafe(e.getHeldItemMainhand()), identifier)) {
+                e.addPotionEffect(new PotionEffect(MobEffects.GLOWING, 100));
+            }
+        }
+
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        if (random.nextFloat() <= 0.08) {
+            player.addPotionEffect(new PotionEffect(MobEffects.NIGHT_VISION, random.nextInt(600) + 300));
+        }
+    }
+
+    @Override
+    public void afterHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean wasCritical, boolean wasHit) {
+        if (random.nextFloat() <= 0.08) {
+            player.addPotionEffect(new PotionEffect(MobEffects.NIGHT_VISION, random.nextInt(600) + 300));
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitHaunted.java

@@ -0,0 +1,44 @@
+package com.sosnitzka.taiga.traits;
+
+import com.sosnitzka.taiga.util.EntityAIPermanentPanic;
+import net.minecraft.entity.EntityCreature;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.*;
+import net.minecraft.entity.passive.*;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.common.MinecraftForge;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+
+public class TraitHaunted extends AbstractTrait {
+
+    public TraitHaunted() {
+        super("haunted", TextFormatting.DARK_GRAY);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+
+    // Just several tested Vanilla-Mobs, e.g. no ghasts, bats or skeletons
+    @Override
+    public void onHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean isCritical) {
+        int time = (int) player.getEntityWorld().getWorldTime();
+        if (random.nextFloat() <= 0.1 || (random.nextFloat() <= 0.3 && isNight(time)))
+            if (target instanceof EntityCow || target instanceof EntityZombie || target instanceof EntityWolf || target instanceof EntityPig || target instanceof EntitySpider ||
+                    target instanceof EntityVillager || target instanceof EntitySheep || target instanceof EntityEnderman || target instanceof EntityEndermite ||
+                    target instanceof EntityBlaze || target instanceof EntityWitch || target instanceof EntityHorse) {
+                ((EntityLiving) target).tasks.taskEntries.clear();
+                ((EntityLiving) target).targetTasks.taskEntries.clear();
+                ((EntityLiving) target).tasks.addTask(0, new EntityAIPermanentPanic((EntityCreature) target, target.getAIMoveSpeed() + 3.5D));
+
+            }
+    }
+
+    public boolean isNight(int time) {
+        if (time > 12500) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitHeroic.java

@@ -0,0 +1,24 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+public class TraitHeroic extends AbstractTrait {
+
+    public TraitHeroic() {
+        super("heroic", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public float damage(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, float newDamage, boolean isCritical) {
+        int durability = ToolHelper.getCurrentDurability(tool);
+        int durabilitymax = ToolHelper.getMaxDurability(tool);
+        float calc = (float) (newDamage + (newDamage / 2) / (durability * durabilitymax / (durabilitymax - durability - 1)));
+        if ((float) durability < (float) (0.10 * durabilitymax) || player.getHealth() < player.getMaxHealth() / 8 || (target.getHealth() == target.getMaxHealth() && random.nextFloat() > 0.8)) {
+            return super.damage(tool, player, target, damage, calc, isCritical);
+        } else return super.damage(tool, player, target, damage, newDamage, isCritical);
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitHollow.java

@@ -0,0 +1,56 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+
+public class TraitHollow extends AbstractTrait {
+
+    public TraitHollow() {
+        super("hollow", TextFormatting.DARK_GRAY);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+
+    @Override
+    public void onHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean isCritical) {
+        int time = (int) player.getEntityWorld().getWorldTime();
+        if (random.nextFloat() <= 0.2 || (random.nextFloat() <= 0.2 && isNight(time))) {
+            ((EntityLiving) target).setNoAI(true);
+            target.playSound(SoundEvents.ENTITY_ENDERMEN_TELEPORT, 1.0F, 1.0F);
+            if (target.getMaxHealth() < 200) {
+                target.setHealth(target.getMaxHealth() * (1.8f - random.nextFloat() * 0.4f));
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void onMobDrops(LivingDropsEvent event) {
+        World w = event.getEntity().getEntityWorld();
+        if (event.getSource().getEntity() instanceof EntityPlayer) {
+            EntityPlayer player = (EntityPlayer) event.getSource().getEntity();
+            if (!w.isRemote && random.nextFloat() <= 0.9 && event.getEntity() instanceof EntityMob && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), identifier)) {
+                event.getDrops().clear();
+            }
+        }
+    }
+
+    public boolean isNight(int time) {
+        if (time > 12500) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitInstable.java

@@ -0,0 +1,70 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+
+public class TraitInstable extends AbstractTrait {
+
+
+    public TraitInstable() {
+        super("instable", TextFormatting.DARK_RED);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        if (random.nextFloat() <= 0.03) {
+            if (!world.isRemote) {
+                if (random.nextBoolean()) {
+                    explode(world, player, pos.getX(), pos.getY(), pos.getZ());
+                } else explode(world, null, pos.getX(), pos.getY(), pos.getZ());
+            }
+            ToolHelper.damageTool(tool, 11 + random.nextInt(10), null);
+        }
+    }
+
+    @Override
+    public void afterHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean wasCritical, boolean wasHit) {
+        BlockPos pos = target.getPosition();
+        if (random.nextFloat() <= 0.04) {
+            if (!player.getEntityWorld().isRemote) {
+                if (random.nextBoolean()) {
+                    explode(player.getEntityWorld(), player, pos.getX(), pos.getY(), pos.getZ());
+                } else explode(player.getEntityWorld(), target, pos.getX(), pos.getY(), pos.getZ());
+            }
+            ToolHelper.damageTool(tool, 3 + random.nextInt(18), null);
+        }
+    }
+
+    @SubscribeEvent
+    public void onMobDrops(LivingDropsEvent event) {
+        World w = event.getEntity().getEntityWorld();
+        if (event.getSource().getEntity() instanceof EntityPlayer) {
+            EntityPlayer player = (EntityPlayer) event.getSource().getEntity();
+            if (!w.isRemote && event.getEntity() instanceof EntityMob && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), identifier)) {
+                ItemStack i = new ItemStack(Items.GUNPOWDER, random.nextInt(4));
+                event.getDrops().add(0, new EntityItem(w, event.getEntity().posX, event.getEntity().posY, event.getEntity().posZ, i));
+            }
+        }
+    }
+    private void explode(World w, Entity e, double x, double y, double z) {
+        w.newExplosion(e, x, y, z, 1.2f + random.nextFloat() * 35, random.nextBoolean(), true);
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitMelting.java

@@ -0,0 +1,32 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.event.world.BlockEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+
+/**
+ * Created by Robert on 03.06.2016.
+ */
+public class TraitMelting extends AbstractTrait {
+
+    public TraitMelting() {
+        super("melting", TextFormatting.YELLOW);
+    }
+
+    @Override
+    public void blockHarvestDrops(ItemStack tool, BlockEvent.HarvestDropsEvent event) {
+        float r = random.nextFloat();
+        Block b = event.getWorld().getBlockState(event.getPos()).getBlock();
+        if (r <= 0.01 && (b == Blocks.STONE || b == Blocks.COBBLESTONE || b == Blocks.NETHERRACK)) {
+            event.getWorld().setBlockState(event.getPos(), Blocks.LAVA.getDefaultState());
+        }
+    }
+
+
+}
+
+
+

src/main/java/com/sosnitzka/taiga/traits/TraitNatureBound.java

@@ -0,0 +1,56 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+
+public class TraitNatureBound extends AbstractTrait {
+    public static DamageSource splinter = new DamageSource("splinter").setDamageBypassesArmor();
+    private static int chance = 10;
+
+    public TraitNatureBound() {
+        super("naturebound", TextFormatting.GREEN);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @Override
+    public int onToolHeal(ItemStack tool, int amount, int newAmount, EntityLivingBase entity) {
+        // 5% less durability repaired!
+        return newAmount - amount * 5 / 100;
+    }
+
+    @Override
+    public void onUpdate(ItemStack tool, World world, Entity entity, int itemSlot, boolean isSelected) {
+        // *20 because 20 ticks in a second
+        if (!world.isRemote && entity instanceof EntityLivingBase && random.nextInt(20 * chance) == 0) {
+            ToolHelper.healTool(tool, 1, (EntityLivingBase) entity);
+        }
+
+    }
+
+    @SubscribeEvent
+    public void onBlockBreak(BlockEvent.BreakEvent e) {
+        Block b = e.getWorld().getBlockState(e.getPos()).getBlock();
+        if (random.nextFloat() <= .07 && (b == Blocks.DIRT || b == Blocks.GRASS || b == Blocks.LOG || b == Blocks.LOG2 || b == Blocks.STONE)) {
+            e.setCanceled(true);
+            e.getPlayer().playSound(SoundEvents.ENTITY_ENDERMEN_TELEPORT, 1.0F, 1.0F);
+        }
+    }
+
+
+
+
+
+}

src/main/java/com/sosnitzka/taiga/traits/TraitOrganizing.java

@@ -0,0 +1,29 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+public class TraitOrganizing extends AbstractTrait {
+
+    private static final float chance = 0.1f;
+
+    public TraitOrganizing() {
+        super("organizing", TextFormatting.GREEN);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        if (!world.isRemote && (state.getMaterial() == Material.ROCK) && random.nextFloat() < chance) {
+            world.setBlockState(pos, Blocks.LOG.getDefaultState());
+            ToolHelper.healTool(tool, random.nextInt(5), player);
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitPulverizing.java

@@ -0,0 +1,39 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+public class TraitPulverizing extends AbstractTrait {
+
+    public TraitPulverizing() {
+        super("pulverizing", TextFormatting.DARK_GRAY);
+    }
+
+    @Override
+    public void miningSpeed(ItemStack tool, PlayerEvent.BreakSpeed event) {
+        if (ToolHelper.isToolEffective2(tool, event.getState())) {
+            event.setNewSpeed((float) (event.getNewSpeed() + calcBonus(tool)));
+        }
+    }
+
+    private double calcBonus(ItemStack tool) {
+        int durability = ToolHelper.getCurrentDurability(tool);
+        int maxDurability = ToolHelper.getMaxDurability(tool);
+        float speed = ToolHelper.getMiningSpeedStat(tool);
+        tool.setItemDamage(tool.getItemDamage() + 1);
+        return speed * (maxDurability - maxDurability / 10) / (durability);
+    }
+
+
+    @Override
+    public void blockHarvestDrops(ItemStack tool, BlockEvent.HarvestDropsEvent event) {
+        if (random.nextFloat() < 0.9) {
+            event.getDrops().clear();
+        }
+    }
+
+}

src/main/java/com/sosnitzka/taiga/traits/TraitRandomize.java

@@ -0,0 +1,175 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityTNTPrimed;
+import net.minecraft.entity.monster.*;
+import net.minecraft.entity.passive.*;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+import slimeknights.tconstruct.world.entity.EntityBlueSlime;
+
+import static com.sosnitzka.taiga.Blocks.*;
+import static slimeknights.tconstruct.shared.TinkerCommons.oreArdite;
+import static slimeknights.tconstruct.shared.TinkerCommons.oreCobalt;
+
+public class TraitRandomize extends AbstractTrait {
+
+    public TraitRandomize() {
+        super("randomize", TextFormatting.DARK_RED);
+    }
+
+    @Override
+    public void miningSpeed(ItemStack tool, PlayerEvent.BreakSpeed event) {
+        if (ToolHelper.isToolEffective2(tool, event.getState())) {
+            event.setNewSpeed((float) (event.getNewSpeed() + random.nextFloat() * 2));
+        }
+    }
+
+    @Override
+    public void onHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean isCritical) {
+        if (random.nextFloat() <= .15 && target instanceof EntityLiving) {
+            World w = player.getEntityWorld();
+            Entity e = new EntityCow(w);
+            target.playSound(SoundEvents.ENTITY_ENDERMEN_TELEPORT, 1.0F, 1.0F);
+            if (!w.isRemote) {
+                int i = random.nextInt(22);
+                switch (i) {
+                    case 0:
+                        e = new EntityCow(w);
+                        break;
+                    case 1:
+                        e = new EntityPig(w);
+                        break;
+                    case 2:
+                        e = new EntityHorse(w);
+                        break;
+                    case 3:
+                        e = new EntityChicken(w);
+                        break;
+                    case 4:
+                        e = new EntityVillager(w);
+                        break;
+                    case 5:
+                        e = new EntityEnderman(w);
+                        break;
+                    case 6:
+                        e = new EntityPolarBear(w);
+                        break;
+                    case 7:
+                        e = new EntityIronGolem(w);
+                        break;
+                    case 8:
+                        e = new EntitySilverfish(w);
+                        break;
+                    case 9:
+                        e = new EntityCaveSpider(w);
+                        break;
+                    case 10:
+                        e = new EntityWolf(w);
+                        break;
+                    case 11:
+                        e = new EntityWitch(w);
+                        break;
+                    case 12:
+                        e = new EntityTNTPrimed(w);
+                        break;
+                    case 13:
+                        e = new EntityGhast(w);
+                        break;
+                    case 14:
+                        e = new EntitySpider(w);
+                        break;
+                    case 15:
+                        e = new EntitySkeleton(w);
+                        break;
+                    case 16:
+                        e = new EntityMagmaCube(w);
+                        break;
+                    case 17:
+                        e = new EntitySlime(w);
+                        break;
+                    case 18:
+                        e = new EntityBlueSlime(w);
+                        break;
+                    case 19:
+                        e = new EntityBat(w);
+                        break;
+                    case 20:
+                        e = new EntityPigZombie(w);
+                        break;
+                    case 21:
+                        e = new EntityBlaze(w);
+                        break;
+                }
+                e.setPosition(target.getPosition().getX(), target.getPosition().getY() + 0.1f, target.getPosition().getZ());
+                e.setCustomNameTag("Missingno");
+                ((EntityLiving) e).setHealth(((EntityLiving) e).getHealth() * (random.nextInt(5) + 1));
+                w.spawnEntityInWorld(e);
+                target.setDead();
+            }
+        }
+    }
+
+    @Override
+    public void blockHarvestDrops(ItemStack tool, BlockEvent.HarvestDropsEvent event) {
+        float r = random.nextFloat();
+        if (r > 0.95f) event.getDrops().clear();
+        if (event.getDrops() != null) {
+            if (r < 0.4f && (event.getDrops().get(0).getItem() == Item.getItemFromBlock(Blocks.IRON_ORE) || event.getDrops().get(0).getItem() == Item.getItemFromBlock(Blocks.GOLD_ORE))) {
+                ItemStack change = new ItemStack(Item.getItemFromBlock(Blocks.IRON_ORE));
+                int i = random.nextInt(12);
+                switch (i) {
+                    case 0:
+                        change = new ItemStack(Item.getItemFromBlock(Blocks.GOLD_ORE));
+                        break;
+                    case 1:
+                        change = new ItemStack(Item.getItemFromBlock(Blocks.REDSTONE_ORE));
+                        break;
+                    case 2:
+                        change = new ItemStack(Item.getItemFromBlock(Blocks.LAPIS_ORE));
+                        break;
+                    case 3:
+                        change = new ItemStack(Item.getItemFromBlock(Blocks.DIAMOND_ORE));
+                        break;
+                    case 4:
+                        change = new ItemStack(Item.getItemFromBlock(Blocks.QUARTZ_ORE));
+                        break;
+                    case 5:
+                        change = new ItemStack(oreCobalt.getItem());
+                        break;
+                    case 6:
+                        change = new ItemStack(oreArdite.getItem());
+                        break;
+                    case 7:
+                        change = new ItemStack(titaniteOre);
+                        break;
+                    case 8:
+                        change = new ItemStack(bismuthOre);
+                        break;
+                    case 9:
+                        change = new ItemStack(tiberiumOre);
+                        break;
+                    case 10:
+                        change = new ItemStack(eterniteOre);
+                        break;
+                    case 11:
+                        change = new ItemStack(Item.getItemFromBlock(Blocks.IRON_ORE));
+                        break;
+                }
+                event.getDrops().set(0, change);
+
+
+            }
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitResonance.java

@@ -0,0 +1,26 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+
+public class TraitResonance extends AbstractTrait {
+
+
+    public TraitResonance() {
+        super("resonance", TextFormatting.AQUA);
+    }
+
+    @Override
+    public void afterHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean wasCritical, boolean wasHit) {
+        if (random.nextFloat() <= .33) {
+            target.knockBack(target, random.nextFloat() * random.nextFloat() * 12, player.posX - target.posX, player.posZ - target.posZ);
+        }
+    }
+
+
+}
+
+
+

src/main/java/com/sosnitzka/taiga/traits/TraitReviving.java

@@ -0,0 +1,72 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityCreature;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDeathEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+
+/**
+ * Created by Robert on 03.06.2016.
+ */
+public class TraitReviving extends AbstractTrait {
+
+    public TraitReviving() {
+        super("reviving", TextFormatting.DARK_PURPLE);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @SubscribeEvent
+    public void onEntityKill(LivingDeathEvent e) {
+        BlockPos pos = e.getEntity().getPosition();
+        World w = e.getEntity().getEntityWorld();
+        if (!w.isRemote && e.getSource().getEntity() != null) {
+            if (e.getSource().getEntity() instanceof EntityPlayer && e.getEntity() instanceof EntityCreature) {
+                if (isNight((int) w.getWorldTime()) && random.nextFloat() > 0.85 && TinkerUtil.hasTrait(TagUtil.getTagSafe(((EntityPlayer) e.getSource().getEntity()).getHeldItemMainhand()), identifier)) {
+                    String name = EntityList.getEntityString(e.getEntity());
+                    Entity ent = EntityList.createEntityByName(name, w);
+                    ent.setPosition(pos.getX(), pos.getY(), pos.getZ());
+                    w.spawnEntityInWorld(ent);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        int time = (int) world.getWorldTime();
+        if (random.nextFloat() <= 0.1 && isNight(time)) {
+            ToolHelper.healTool(tool, random.nextInt(15) + 1, null);
+        }
+    }
+
+    @Override
+    public void afterHit(ItemStack tool, EntityLivingBase player, EntityLivingBase target, float damage, boolean wasCritical, boolean wasHit) {
+        int time = (int) player.getEntityWorld().getWorldTime();
+        if (random.nextFloat() <= 0.1 && isNight(time)) {
+            ToolHelper.healTool(tool, random.nextInt(15) + 1, null);
+        }
+    }
+
+
+    public boolean isNight(int time) {
+        if (time > 12500) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/com/sosnitzka/taiga/traits/TraitSlaughtering.java

@@ -0,0 +1,39 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+
+public class TraitSlaughtering extends AbstractTrait {
+
+    public TraitSlaughtering() {
+        super("slaughtering", TextFormatting.DARK_RED);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+
+    @SubscribeEvent
+    public void onMobDrops(LivingDropsEvent event) {
+        World w = event.getEntity().getEntityWorld();
+        if (event.getSource().getEntity() instanceof EntityPlayer) {
+            EntityPlayer player = (EntityPlayer) event.getSource().getEntity();
+            if (!w.isRemote && event.getEntity() instanceof EntityLiving && !(event.getEntity() instanceof EntityPlayer) && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), identifier)) {
+                Item i = event.getDrops().get(random.nextInt(event.getDrops().size())).getEntityItem().getItem();
+                if (i != null) {
+                    event.getDrops().add(new EntityItem(event.getEntity().getEntityWorld(), event.getEntity().posX, event.getEntity().posY, event.getEntity().posZ, new ItemStack(i, random.nextInt(4) + 1)));
+                }
+            }
+        }
+    }
+
+}

src/main/java/com/sosnitzka/taiga/traits/TraitSofty.java

@@ -0,0 +1,33 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+public class TraitSofty extends AbstractTrait {
+    private static final float chance = 0.2f;
+
+    public TraitSofty() {
+        super("softy", TextFormatting.AQUA);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        if (!world.isRemote && state.getMaterial() != Material.ROCK && state.getMaterial() != Material.GROUND && random.nextFloat() < chance) {
+            ToolHelper.healTool(tool, random.nextInt(10), player);
+        }
+    }
+
+
+}
+
+
+

src/main/java/com/sosnitzka/taiga/traits/TraitUncertain.java

@@ -0,0 +1,78 @@
+package com.sosnitzka.taiga.traits;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import slimeknights.tconstruct.library.traits.AbstractTrait;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.TinkerUtil;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+import static com.sosnitzka.taiga.Items.glimmerstone_dust;
+import static com.sosnitzka.taiga.Items.tiberiumShardStable;
+
+
+public class TraitUncertain extends AbstractTrait {
+
+
+    public TraitUncertain() {
+        super("uncertain", TextFormatting.RED);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @Override
+    public void afterBlockBreak(ItemStack tool, World world, IBlockState state, BlockPos pos, EntityLivingBase player, boolean wasEffective) {
+        if (random.nextFloat() <= 0.05) {
+            if (!world.isRemote) {
+                if (random.nextFloat() > 0.1f) {
+                    explode(world, player, pos.getX(), pos.getY(), pos.getZ());
+                } else explode(world, null, pos.getX(), pos.getY(), pos.getZ());
+            }
+            ToolHelper.damageTool(tool, random.nextInt(5) + 1, null);
+        }
+    }
+
+    @SubscribeEvent
+    public void onMobDrops(LivingDropsEvent event) {
+        World w = event.getEntity().getEntityWorld();
+        if (event.getSource().getEntity() instanceof EntityPlayer) {
+            EntityPlayer player = (EntityPlayer) event.getSource().getEntity();
+            if (!w.isRemote && event.getEntity() instanceof EntityMob && TinkerUtil.hasTrait(TagUtil.getTagSafe(player.getHeldItemMainhand()), identifier)) {
+                ItemStack i = new ItemStack(Items.COAL, random.nextInt(4));
+                if (random.nextBoolean()) {
+                    int r = random.nextInt(4);
+                    switch (r) {
+                        case 0:
+                            i = new ItemStack(Items.GUNPOWDER, random.nextInt(4));
+                            break;
+                        case 1:
+                            i = new ItemStack(tiberiumShardStable, random.nextInt(4));
+                            break;
+                        case 2:
+                            i = new ItemStack(tiberiumShardStable, random.nextInt(4));
+                            break;
+                        case 3:
+                            i = new ItemStack(glimmerstone_dust, random.nextInt(4));
+                            break;
+                    }
+                }
+                event.getDrops().add(0, new EntityItem(w, event.getEntity().posX, event.getEntity().posY, event.getEntity().posZ, i));
+            }
+        }
+    }
+
+    private void explode(World w, Entity e, double x, double y, double z) {
+        w.newExplosion(e, x, y, z, 1.2f + random.nextFloat() * 5, random.nextBoolean(), true);
+    }
+}