Smelting!

src/main/java/com/gmail/nossr50/skills/SkillCommand.java

@@ -60,8 +60,11 @@ public abstract class SkillCommand implements CommandExecutor {
         permissionsCheck();
 
         player.sendMessage(LocaleLoader.getString("Skills.Header", new Object[] { LocaleLoader.getString(skillString + ".SkillName") }));
-        player.sendMessage(LocaleLoader.getString("Commands.XPGain", new Object[] { LocaleLoader.getString("Commands.XPGain." + skillString) }));
-        player.sendMessage(LocaleLoader.getString("Effects.Level", new Object[] { profile.getSkillLevel(skill), profile.getSkillXpLevel(skill), profile.getXpToLevel(skill) }));
+
+        if (!skill.isChildSkill()) {
+            player.sendMessage(LocaleLoader.getString("Commands.XPGain", new Object[] { LocaleLoader.getString("Commands.XPGain." + skillString) }));
+            player.sendMessage(LocaleLoader.getString("Effects.Level", new Object[] { profile.getSkillLevel(skill), profile.getSkillXpLevel(skill), profile.getXpToLevel(skill) }));
+        }
 
         if (effectsHeaderPermissions()) {
             player.sendMessage(LocaleLoader.getString("Skills.Header", new Object[] { LocaleLoader.getString("Effects.Effects") }));

src/main/java/com/gmail/nossr50/skills/SkillManager.java

@@ -19,6 +19,13 @@ public abstract class SkillManager {
         this.skillLevel = profile.getSkillLevel(skill);
         this.activationChance = Misc.calculateActivationChance(Permissions.lucky(player, skill));
     }
+    
+    public SkillManager(Player player, SkillType child, SkillType parent1, SkillType parent2) {
+        this.player = player;
+        this.profile = Users.getProfile(player);
+        this.skillLevel = (profile.getSkillLevel(parent1) / 4) + (profile.getSkillLevel(parent2) / 4); //TODO: Make this cleaner somehow
+        this.activationChance = Misc.calculateActivationChance(Permissions.lucky(player, child));
+    }
 
     public Player getPlayer() {
         return player;

src/main/java/com/gmail/nossr50/skills/SkillType.java

@@ -16,6 +16,7 @@ public enum SkillType {
     HERBALISM(AbilityType.GREEN_TERRA, Config.getInstance().getLevelCapHerbalism(), ToolType.HOE, Config.getInstance().getFormulaMultiplierHerbalism()),
     MINING(AbilityType.SUPER_BREAKER, Config.getInstance().getLevelCapMining(), ToolType.PICKAXE, Config.getInstance().getFormulaMultiplierMining()),
     REPAIR(Config.getInstance().getLevelCapRepair(), Config.getInstance().getFormulaMultiplierRepair()),
+    SMELTING(Config.getInstance().getLevelCapSmelting(), 0),
     SWORDS(AbilityType.SERRATED_STRIKES, Config.getInstance().getLevelCapSwords(), ToolType.SWORD, Config.getInstance().getFormulaMultiplierSwords()),
     TAMING(Config.getInstance().getLevelCapTaming(), Config.getInstance().getFormulaMultiplierTaming()),
     UNARMED(AbilityType.BERSERK, Config.getInstance().getLevelCapUnarmed(), ToolType.FISTS, Config.getInstance().getFormulaMultiplierUnarmed()),
@@ -142,4 +143,14 @@ public enum SkillType {
     public int getSkillLevel(Player player) {
         return Users.getProfile(player).getSkillLevel(this);
     }
+
+    public boolean isChildSkill() {
+        switch (this) {
+        case SMELTING:
+            return true;
+
+        default:
+            return false;
+        }
+    }
 }

src/main/java/com/gmail/nossr50/skills/herbalism/Herbalism.java

@@ -580,6 +580,8 @@ public class Herbalism {
                 else {
                     item = new ItemStack(Material.APPLE);
                 }
+
+                mcMMO.placeStore.setFalse(block);
                 break;
 
             case FLOWER_POT:

src/main/java/com/gmail/nossr50/skills/mining/Mining.java

@@ -96,7 +96,7 @@ public class Mining {
         case EMERALD_ORE:
             xp += config.getMiningXPEmeraldOre();
             break;
-
+            
         default:
             if (ModChecks.isCustomMiningBlock(block)) {
                 xp += ModChecks.getCustomBlock(block).getXpGain();

src/main/java/com/gmail/nossr50/skills/smelting/FluxMiningEventHandler.java

@@ -0,0 +1,59 @@
+package com.gmail.nossr50.skills.smelting;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.mining.Mining;
+import com.gmail.nossr50.util.Misc;
+
+public class FluxMiningEventHandler {
+    private SmeltingManager manager;
+    private BlockBreakEvent event;
+    private Block block;
+
+    protected FluxMiningEventHandler(SmeltingManager manager, BlockBreakEvent event) {
+        this.manager = manager;
+        this.event = event;
+        this.block = event.getBlock();
+    }
+
+    protected void processDrops() {
+        ItemStack item = null;
+
+        switch (block.getType()) {
+        case IRON_ORE:
+            item = new ItemStack(Material.IRON_INGOT);
+            break;
+
+        case GOLD_ORE:
+            item = new ItemStack(Material.GOLD_INGOT);
+            break;
+
+        default:
+            break;
+        }
+
+        if (item == null) {
+            return;
+        }
+
+        Location location = block.getLocation();
+        int chance = (int) ((Mining.doubleDropsMaxChance / Mining.doubleDropsMaxLevel) * (Misc.skillCheck(manager.getProfile().getSkillLevel(SkillType.MINING), Mining.doubleDropsMaxLevel)));
+        Misc.dropItem(location, item);
+        Misc.randomDropItem(location, item, chance);
+    }
+
+    protected void eventCancellationAndProcessing() {
+        event.setCancelled(true);
+        block.setType(Material.AIR);
+    }
+
+    protected void sendAbilityMessage() {
+        manager.getPlayer().sendMessage(LocaleLoader.getString("Smelting.FluxMining.Success"));
+    }
+}

src/main/java/com/gmail/nossr50/skills/smelting/FuelEfficiencyEventHandler.java

@@ -0,0 +1,23 @@
+package com.gmail.nossr50.skills.smelting;
+
+import org.bukkit.event.inventory.FurnaceBurnEvent;
+
+public class FuelEfficiencyEventHandler {
+    private SmeltingManager manager;
+    private FurnaceBurnEvent event;
+    private double burnModifier;
+
+    protected FuelEfficiencyEventHandler(SmeltingManager manager, FurnaceBurnEvent event) {
+        this.manager = manager;
+        this.event = event;
+    }
+
+    protected void calculateBurnModifier() {
+        this.burnModifier = 1 + ((manager.getSkillLevel() / Smelting.burnModifierMaxLevel) * Smelting.burnTimeMultiplier);
+    }
+
+    protected void modifyBurnTime() {
+        int burnTime = event.getBurnTime();
+        event.setBurnTime((int)(burnTime * burnModifier));
+    }
+}

src/main/java/com/gmail/nossr50/skills/smelting/SmeltResourceEventHandler.java

@@ -0,0 +1,79 @@
+package com.gmail.nossr50.skills.smelting;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.FurnaceSmeltEvent;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.PlayerProfile;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
+import com.gmail.nossr50.util.Misc;
+
+public class SmeltResourceEventHandler {
+    private SmeltingManager manager;
+    private FurnaceSmeltEvent event;
+
+    protected int skillModifier;
+
+    protected SmeltResourceEventHandler(SmeltingManager manager, FurnaceSmeltEvent event) {
+        this.manager = manager;
+        this.event = event;
+    }
+
+    protected void calculateSkillModifier() {
+        this.skillModifier = Misc.skillCheck(manager.getSkillLevel(), Smelting.secondSmeltMaxLevel);
+    }
+
+    protected void handleXPGain() {
+        Player player = manager.getPlayer();
+        PlayerProfile profile = manager.getProfile();
+        Material sourceType = event.getSource().getType();
+        int xp = 0;
+
+        switch (sourceType) {
+        case COAL_ORE:
+            xp = Config.getInstance().getSmeltingXPCoal();
+            break;
+
+        case GLOWING_REDSTONE_ORE:
+        case REDSTONE_ORE:
+            xp = Config.getInstance().getSmeltingXPRedstone();
+            break;
+
+        case IRON_ORE:
+            xp = Config.getInstance().getSmeltingXPIron();
+            break;
+
+        case GOLD_ORE:
+            xp = Config.getInstance().getSmeltingXPGold();
+            break;
+
+        case DIAMOND_ORE:
+            xp = Config.getInstance().getSmeltingXPDiamond();
+            break;
+
+        case LAPIS_ORE:
+            xp = Config.getInstance().getSmeltingXPLapis();
+            break;
+
+        case EMERALD_ORE:
+            xp = Config.getInstance().getSmeltingXPEmerald();
+            break;
+
+        default:
+            break;
+        }
+
+        Skills.xpProcessing(player, profile, SkillType.MINING, xp / 2);
+        Skills.xpProcessing(player, profile, SkillType.REPAIR, xp / 2);
+    }
+
+    protected void handleBonusSmelts() {
+        ItemStack result = event.getResult();
+
+        result.setAmount(result.getAmount() + 1);
+        event.setResult(result);
+    }
+}

src/main/java/com/gmail/nossr50/skills/smelting/Smelting.java

@@ -0,0 +1,18 @@
+package com.gmail.nossr50.skills.smelting;
+
+public class Smelting {
+    public static int burnModifierMaxLevel = 1000;
+    public static double burnTimeMultiplier = 3.0;
+
+    public static double secondSmeltMaxChance = 100;
+    public static int secondSmeltMaxLevel = 1000;
+
+    public static int fluxMiningUnlockLevel = 200;
+    public static double fluxMiningChance = 33.0;
+
+    public static int vanillaXPBoostRank1Level = 100;
+    public static int vanillaXPBoostRank2Level = 300;
+    public static int vanillaXPBoostRank3Level = 500;
+    public static int vanillaXPBoostRank4Level = 700;
+    public static int vanillaXPBoostRank5Level = 900;
+}

src/main/java/com/gmail/nossr50/skills/smelting/SmeltingCommand.java

@@ -0,0 +1,134 @@
+package com.gmail.nossr50.skills.smelting;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class SmeltingCommand extends SkillCommand {
+    private String burnTimeModifier;
+    private String secondSmeltChance;
+    private String secondSmeltChanceLucky;
+    private String fluxMiningChance;
+    private String fluxMiningChanceLucky;
+    private String vanillaXPModifier;
+
+    private boolean canFuelEfficiency;
+    private boolean canSecondSmelt;
+    private boolean canFluxMine;
+    private boolean canVanillaXPBoost;
+
+    public SmeltingCommand() {
+        super(SkillType.SMELTING);
+        this.skillValue = (profile.getSkillLevel(SkillType.MINING) / 4) + (profile.getSkillLevel(SkillType.REPAIR) / 4); //TODO: Make this cleaner somehow
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //FUEL EFFICIENCY
+        burnTimeModifier = String.valueOf(1 + ((skillValue / Smelting.burnModifierMaxLevel) * Smelting.burnTimeMultiplier));
+
+        //SECOND SMELT
+        String[] secondSmeltStrings = calculateAbilityDisplayValues(Smelting.secondSmeltMaxLevel, Smelting.secondSmeltMaxChance);
+        secondSmeltChance = secondSmeltStrings[0];
+        secondSmeltChanceLucky = secondSmeltStrings[1];
+
+        //FLUX MINING
+        String[] fluxMiningStrings = calculateAbilityDisplayValues(Smelting.fluxMiningChance);
+        fluxMiningChance = fluxMiningStrings[0];
+        fluxMiningChanceLucky = fluxMiningStrings[1];
+
+        //VANILLA XP BOOST
+        if (skillValue >= Smelting.vanillaXPBoostRank5Level) {
+            vanillaXPModifier = "6";
+        }
+        else if (skillValue >= Smelting.vanillaXPBoostRank4Level) {
+            vanillaXPModifier = "5";
+        }
+        else if (skillValue >= Smelting.vanillaXPBoostRank3Level) {
+            vanillaXPModifier = "4";
+        }
+        else if (skillValue >= Smelting.vanillaXPBoostRank2Level) {
+            vanillaXPModifier = "3";
+        }
+        else {
+            vanillaXPModifier = "2";
+        }
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canFuelEfficiency = Permissions.fuelEfficiency(player);
+        canSecondSmelt = Permissions.secondSmelt(player);
+        canFluxMine = Permissions.fluxMining(player);
+        canVanillaXPBoost = Permissions.smeltingVanillaXPBoost(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canFluxMine || canFuelEfficiency || canSecondSmelt || canVanillaXPBoost;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canFuelEfficiency) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Smelting.Effect.0"), LocaleLoader.getString("Smelting.Effect.1") }));
+        }
+
+        if (canSecondSmelt) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Smelting.Effect.2"), LocaleLoader.getString("Smelting.Effect.3") }));
+        }
+
+        if (canVanillaXPBoost) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Smelting.Effect.4"), LocaleLoader.getString("Smelting.Effect.5") }));
+        }
+
+        if (canFluxMine) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Smelting.Effect.6"), LocaleLoader.getString("Smelting.Effect.7") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canFluxMine || canFuelEfficiency || canSecondSmelt || canVanillaXPBoost;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canFuelEfficiency) {
+            player.sendMessage(LocaleLoader.getString("Smelting.Ability.FuelEfficiency", new Object[] { burnTimeModifier }));
+        }
+
+        if (canSecondSmelt) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Smelting.Ability.SecondSmelt", new Object[] { secondSmeltChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { secondSmeltChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Smelting.Ability.SecondSmelt", new Object[] { secondSmeltChance }));
+            }
+        }
+
+        if (canVanillaXPBoost) {
+            if (skillValue < Smelting.vanillaXPBoostRank1Level) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Smelting.Ability.Locked.0", new Object[] { Smelting.vanillaXPBoostRank1Level } ) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Smelting.Ability.VanillaXPBoost", new Object[] { vanillaXPModifier }));
+            }
+        }
+
+        if (canFluxMine) {
+            if (skillValue < Smelting.fluxMiningUnlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Smelting.Ability.Locked.1", new Object[] { Smelting.fluxMiningUnlockLevel } ) }));
+            }
+            else if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Smelting.Ability.FluxMining", new Object[] { fluxMiningChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { fluxMiningChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Smelting.Ability.FluxMining", new Object[] { fluxMiningChance }));
+            }
+        }
+    }
+}

src/main/java/com/gmail/nossr50/skills/smelting/SmeltingManager.java

@@ -0,0 +1,80 @@
+package com.gmail.nossr50.skills.smelting;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.inventory.FurnaceBurnEvent;
+import org.bukkit.event.inventory.FurnaceExtractEvent;
+import org.bukkit.event.inventory.FurnaceSmeltEvent;
+
+import com.gmail.nossr50.skills.SkillManager;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.Permissions;
+
+public class SmeltingManager extends SkillManager {
+
+    public SmeltingManager(Player player) {
+        super(player, SkillType.SMELTING);
+    }
+
+    /**
+     * Increases burn time for furnace fuel.
+     *
+     * @param event The {@link FurnaceBurnEvent} to modify.
+     */
+    public void fuelEfficiency(FurnaceBurnEvent event) {
+        if (Misc.isNPC(player) || !Permissions.fuelEfficiency(player)) {
+            return;
+        }
+
+        FuelEfficiencyEventHandler eventHandler = new FuelEfficiencyEventHandler(this, event);
+        eventHandler.calculateBurnModifier();
+        eventHandler.modifyBurnTime();
+    }
+
+    public void smeltProcessing(FurnaceSmeltEvent event) {
+        if (Misc.isNPC(player)) {
+            return;
+        }
+
+        SmeltResourceEventHandler eventHandler = new SmeltResourceEventHandler(this, event);
+
+        if (Permissions.smelting(player)) {
+            eventHandler.handleXPGain();
+        }
+
+        if (!Permissions.secondSmelt(player)) {
+            return;
+        }
+
+        eventHandler.calculateSkillModifier();
+
+        double chance = (Smelting.secondSmeltMaxChance / Smelting.secondSmeltMaxLevel) * eventHandler.skillModifier;
+        if (chance > Misc.getRandom().nextInt(activationChance)) {
+            eventHandler.handleBonusSmelts();
+        }
+    }
+
+    public void fluxMining(BlockBreakEvent event) {
+        if (skillLevel < Smelting.fluxMiningUnlockLevel || !Permissions.fluxMining(player)) {
+            return;
+        }
+
+        if (Smelting.fluxMiningChance > Misc.getRandom().nextInt(activationChance)) {
+            FluxMiningEventHandler eventHandler = new FluxMiningEventHandler(this, event);
+            eventHandler.processDrops();
+            eventHandler.eventCancellationAndProcessing();
+            eventHandler.sendAbilityMessage();
+        }
+    }
+
+    public void vanillaXPBoost(FurnaceExtractEvent event) {
+        if (skillLevel < Smelting.vanillaXPBoostRank1Level || !Permissions.smeltingVanillaXPBoost(player)) {
+            return;
+        }
+
+        SmeltingVanillaXPEventHandler eventHandler = new SmeltingVanillaXPEventHandler(this, event);
+        eventHandler.calculateModifier();
+        eventHandler.modifyVanillaXP();
+    }
+}

src/main/java/com/gmail/nossr50/skills/smelting/SmeltingVanillaXPEventHandler.java

@@ -0,0 +1,39 @@
+package com.gmail.nossr50.skills.smelting;
+
+import org.bukkit.event.inventory.FurnaceExtractEvent;
+
+public class SmeltingVanillaXPEventHandler {
+    private SmeltingManager manager;
+    private FurnaceExtractEvent event;
+    private int xpBoostModifier;
+
+    protected SmeltingVanillaXPEventHandler(SmeltingManager manager, FurnaceExtractEvent event) {
+        this.manager = manager;
+        this.event = event;
+    }
+
+    protected void calculateModifier() {
+        int skillLevel =  manager.getSkillLevel();
+
+        if (skillLevel >= Smelting.vanillaXPBoostRank5Level) {
+            xpBoostModifier = 6;
+        }
+        else if (skillLevel >= Smelting.vanillaXPBoostRank4Level) {
+            xpBoostModifier = 5;
+        }
+        else if (skillLevel >= Smelting.vanillaXPBoostRank3Level) {
+            xpBoostModifier = 4;
+        }
+        else if (skillLevel >= Smelting.vanillaXPBoostRank2Level) {
+            xpBoostModifier = 3;
+        }
+        else {
+            xpBoostModifier = 2;
+        }
+    }
+
+    protected void modifyVanillaXP() {
+        int xp = event.getExpToDrop();
+        event.setExpToDrop(xp * xpBoostModifier);
+    }
+}