Debug commands

Not fully tested. The ones tested do work, though.

src/main/java/WayofTime/bloodmagic/BloodMagic.java

@@ -2,16 +2,14 @@ package WayofTime.bloodmagic;
 
 import java.io.File;
 
+import WayofTime.bloodmagic.command.CommandBloodMagic;
 import lombok.Getter;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.item.Item;
 import net.minecraft.launchwrapper.Launch;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.SidedProxy;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLInterModComms;
-import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.event.*;
 import net.minecraftforge.fml.common.network.NetworkRegistry;
 import WayofTime.bloodmagic.api.Constants;
 import WayofTime.bloodmagic.api.util.helper.LogHelper;
@@ -105,6 +103,11 @@ public class BloodMagic
         proxy.postInit();
     }
 
+    @Mod.EventHandler
+    public void serverStarting(FMLServerStartingEvent event) {
+        event.registerServerCommand(new CommandBloodMagic());
+    }
+
     @Mod.EventHandler
     public void onIMCRecieved(FMLInterModComms.IMCEvent event)
     {

src/main/java/WayofTime/bloodmagic/command/CommandBloodMagic.java

@@ -0,0 +1,66 @@
+package WayofTime.bloodmagic.command;
+
+import WayofTime.bloodmagic.command.sub.SubCommandBind;
+import WayofTime.bloodmagic.command.sub.SubCommandHelp;
+import WayofTime.bloodmagic.command.sub.SubCommandNetwork;
+import WayofTime.bloodmagic.command.sub.SubCommandOrb;
+import WayofTime.bloodmagic.util.helper.TextHelper;
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.util.ChatComponentText;
+
+import java.util.*;
+
+public class CommandBloodMagic extends CommandBase {
+
+    private final List<String> aliases = new ArrayList<String>();
+    private final Map<String, ISubCommand> subCommands = new HashMap<String, ISubCommand>();
+
+    public CommandBloodMagic() {
+        aliases.add("BloodMagic");
+        aliases.add("bloodmagic");
+        aliases.add("bloodMagic");
+        aliases.add("bm");
+
+        subCommands.put("help", new SubCommandHelp(this));
+        subCommands.put("network", new SubCommandNetwork(this));
+        subCommands.put("bind", new SubCommandBind(this));
+        subCommands.put("orb", new SubCommandOrb(this));
+    }
+
+    @Override
+    public String getCommandName() {
+        return "/bloodmagic";
+    }
+
+    @Override
+    public int getRequiredPermissionLevel() {
+        return 3;
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender commandSender) {
+        return getCommandName() + " help";
+    }
+
+    @Override
+    public List<String> getCommandAliases() {
+        return aliases;
+    }
+
+    @Override
+    public void processCommand(ICommandSender commandSender, String[] args) {
+        if (args.length > 0 && subCommands.containsKey(args[0])) {
+
+            ISubCommand subCommand = subCommands.get(args[0]);
+            String[] subArgs = Arrays.copyOfRange(args, 1, args.length);
+            subCommand.processSubCommand(commandSender, subArgs);
+        } else {
+            commandSender.addChatMessage(new ChatComponentText(TextHelper.localizeEffect("commands.error.unknown")));
+        }
+    }
+
+    public Map<String, ISubCommand> getSubCommands() {
+        return subCommands;
+    }
+}

src/main/java/WayofTime/bloodmagic/command/ISubCommand.java

@@ -0,0 +1,17 @@
+package WayofTime.bloodmagic.command;
+
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+
+public interface ISubCommand {
+
+    String getSubCommandName();
+
+    ICommand getParentCommand();
+
+    String getArgUsage(ICommandSender commandSender);
+
+    String getHelpText();
+
+    void processSubCommand(ICommandSender commandSender, String[] args);
+}

src/main/java/WayofTime/bloodmagic/command/SubCommandBase.java

@@ -0,0 +1,86 @@
+package WayofTime.bloodmagic.command;
+
+import WayofTime.bloodmagic.util.helper.TextHelper;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.PlayerNotFoundException;
+import net.minecraft.command.PlayerSelector;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StatCollector;
+
+import java.util.Locale;
+
+public abstract class SubCommandBase implements ISubCommand {
+
+    private ICommand parent;
+    private String name;
+
+    public SubCommandBase(ICommand parent, String name) {
+        this.parent = parent;
+        this.name = name;
+    }
+
+    @Override
+    public String getSubCommandName() {
+        return name;
+    }
+
+    @Override
+    public ICommand getParentCommand() {
+        return parent;
+    }
+
+    @Override
+    public void processSubCommand(ICommandSender commandSender, String[] args) {
+
+        if (args.length == 0 && !getSubCommandName().equals("help"))
+            displayErrorString(commandSender, String.format(StatCollector.translateToLocal("commands.format.error"), capitalizeFirstLetter(getSubCommandName()), getArgUsage(commandSender)));
+
+        if (isBounded(0, 2, args.length) && args[0].equals("help"))
+            displayHelpString(commandSender, String.format(StatCollector.translateToLocal("commands.format.help"), capitalizeFirstLetter(getSubCommandName()), getHelpText()));
+    }
+
+    protected EntityPlayerMP getCommandSenderAsPlayer(ICommandSender commandSender) throws PlayerNotFoundException{
+        if (commandSender instanceof EntityPlayerMP)
+            return (EntityPlayerMP)commandSender;
+        else
+            throw new PlayerNotFoundException(StatCollector.translateToLocal("commands.error.arg.player.missing"));
+    }
+
+    protected EntityPlayerMP getPlayer(ICommandSender commandSender, String playerName) throws PlayerNotFoundException {
+        EntityPlayerMP entityplayermp = PlayerSelector.matchOnePlayer(commandSender, playerName);
+
+        if (entityplayermp != null)
+            return entityplayermp;
+        else {
+            entityplayermp = MinecraftServer.getServer().getConfigurationManager().getPlayerByUsername(playerName);
+
+            if (entityplayermp == null)
+                throw new PlayerNotFoundException();
+            else
+                return entityplayermp;
+        }
+    }
+
+    protected String capitalizeFirstLetter(String toCapital) {
+        return String.valueOf(toCapital.charAt(0)).toUpperCase(Locale.ENGLISH) + toCapital.substring(1);
+    }
+
+    protected boolean isBounded(int low, int high, int given) {
+        return given > low && given < high;
+    }
+
+    protected void displayHelpString(ICommandSender commandSender, String display, Object ... info) {
+        commandSender.addChatMessage(new ChatComponentText(TextHelper.localizeEffect(display, info)));
+    }
+
+    protected void displayErrorString(ICommandSender commandSender, String display, Object ... info) {
+        commandSender.addChatMessage(new ChatComponentText(TextHelper.localizeEffect(display, info)));
+    }
+
+    protected void displaySuccessString(ICommandSender commandSender, String display, Object ... info) {
+        commandSender.addChatMessage(new ChatComponentText(TextHelper.localizeEffect(display, info)));
+    }
+}

src/main/java/WayofTime/bloodmagic/command/sub/SubCommandBind.java

@@ -0,0 +1,85 @@
+package WayofTime.bloodmagic.command.sub;
+
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.api.iface.IBindable;
+import WayofTime.bloodmagic.api.util.helper.BindableHelper;
+import WayofTime.bloodmagic.api.util.helper.PlayerHelper;
+import WayofTime.bloodmagic.command.SubCommandBase;
+import WayofTime.bloodmagic.util.helper.TextHelper;
+import com.google.common.base.Strings;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.PlayerNotFoundException;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.ChatComponentTranslation;
+
+public class SubCommandBind extends SubCommandBase {
+
+    public SubCommandBind(ICommand parent) {
+        super(parent, "bind");
+    }
+
+    @Override
+    public String getArgUsage(ICommandSender commandSender) {
+        return TextHelper.localizeEffect("commands.bind.usage");
+    }
+
+    @Override
+    public String getHelpText() {
+        return TextHelper.localizeEffect("commands.bind.help");
+    }
+
+    @Override
+    public void processSubCommand(ICommandSender commandSender, String[] args) {
+        super.processSubCommand(commandSender, args);
+
+        if (commandSender.getEntityWorld().isRemote)
+            return;
+
+        try {
+            EntityPlayer player = getCommandSenderAsPlayer(commandSender);
+            String playerName = player.getName();
+            String uuid = PlayerHelper.getUUIDFromPlayer(player).toString();
+            ItemStack held = player.getHeldItem();
+            boolean bind = true;
+
+            if (held != null && held.getItem() instanceof IBindable) {
+                if (args.length > 0) {
+
+                    if (args[0].equalsIgnoreCase("help"))
+                        return;
+
+                    if (isBoolean(args[0])) {
+                        bind = Boolean.parseBoolean(args[0]);
+
+                        if (args.length > 2)
+                            playerName = args[1];
+                    } else {
+                        playerName = args[0];
+                        uuid = PlayerHelper.getUUIDFromPlayer(getPlayer(commandSender, playerName)).toString();
+                    }
+                }
+
+                if (bind) {
+                    BindableHelper.setItemOwnerName(held, playerName);
+                    BindableHelper.setItemOwnerUUID(held, uuid);
+                    commandSender.addChatMessage(new ChatComponentTranslation("commands.bind.success"));
+                } else {
+                    if (!Strings.isNullOrEmpty(((IBindable) held.getItem()).getOwnerUUID(held))) {
+                        held.getTagCompound().removeTag(Constants.NBT.OWNER_UUID);
+                        held.getTagCompound().removeTag(Constants.NBT.OWNER_NAME);
+                        commandSender.addChatMessage(new ChatComponentTranslation("commands.bind.remove.success"));
+                    }
+                }
+            }
+        } catch (PlayerNotFoundException e) {
+            commandSender.addChatMessage(new ChatComponentText(TextHelper.localizeEffect("commands.error.404")));
+        }
+    }
+
+    private boolean isBoolean(String string) {
+        return string.equalsIgnoreCase("true") || string.equalsIgnoreCase("false");
+    }
+}

src/main/java/WayofTime/bloodmagic/command/sub/SubCommandHelp.java

@@ -0,0 +1,38 @@
+package WayofTime.bloodmagic.command.sub;
+
+import WayofTime.bloodmagic.command.CommandBloodMagic;
+import WayofTime.bloodmagic.command.ISubCommand;
+import WayofTime.bloodmagic.command.SubCommandBase;
+import WayofTime.bloodmagic.util.helper.TextHelper;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StatCollector;
+
+public class SubCommandHelp extends SubCommandBase {
+
+    public SubCommandHelp(ICommand parent) {
+        super(parent, "help");
+    }
+
+    @Override
+    public String getArgUsage(ICommandSender commandSender) {
+        return StatCollector.translateToLocal("commands.help.usage");
+    }
+
+    @Override
+    public String getHelpText() {
+        return StatCollector.translateToLocal("commands.help.help");
+    }
+
+    @Override
+    public void processSubCommand(ICommandSender commandSender, String[] args) {
+        super.processSubCommand(commandSender, args);
+
+        if (args.length > 0)
+            return;
+
+        for (ISubCommand subCommand : ((CommandBloodMagic)getParentCommand()).getSubCommands().values())
+            commandSender.addChatMessage(new ChatComponentText(TextHelper.localizeEffect("commands.format.help", capitalizeFirstLetter(subCommand.getSubCommandName()), subCommand.getArgUsage(commandSender))));
+    }
+}

src/main/java/WayofTime/bloodmagic/command/sub/SubCommandNetwork.java

@@ -0,0 +1,179 @@
+package WayofTime.bloodmagic.command.sub;
+
+import WayofTime.bloodmagic.api.network.SoulNetwork;
+import WayofTime.bloodmagic.api.util.helper.NetworkHelper;
+import WayofTime.bloodmagic.api.util.helper.PlayerHelper;
+import WayofTime.bloodmagic.command.SubCommandBase;
+import WayofTime.bloodmagic.util.Utils;
+import WayofTime.bloodmagic.util.helper.TextHelper;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.PlayerNotFoundException;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StatCollector;
+
+import java.util.Locale;
+
+public class SubCommandNetwork extends SubCommandBase {
+
+    public SubCommandNetwork(ICommand parent) {
+        super(parent, "network");
+    }
+
+    @Override
+    public String getArgUsage(ICommandSender commandSender) {
+        return StatCollector.translateToLocal("commands.network.usage");
+    }
+
+    @Override
+    public String getHelpText() {
+        return StatCollector.translateToLocal("commands.network.help");
+    }
+
+    @Override
+    public void processSubCommand(ICommandSender commandSender, String[] args) {
+        super.processSubCommand(commandSender, args);
+
+        if (args.length > 0) {
+
+            if (args[0].equalsIgnoreCase("help"))
+                return;
+
+            try {
+                String givenName = commandSender.getName();
+                EntityPlayer player = getPlayer(commandSender, givenName);
+
+                if (args.length > 1) {
+                    givenName = args[1];
+                    player = getPlayer(commandSender, givenName);
+                }
+
+                SoulNetwork network = NetworkHelper.getSoulNetwork(player);
+                boolean displayHelp = isBounded(0, 2, args.length);
+
+                try {
+                    switch (ValidCommands.valueOf(args[0].toUpperCase(Locale.ENGLISH))) {
+                        case SYPHON: {
+                            if (displayHelp) {
+                                displayHelpString(commandSender, ValidCommands.SYPHON.help);
+                                break;
+                            }
+
+                            if (args.length == 3) {
+                                if (Utils.isInteger(args[2])) {
+                                    int amount = Integer.parseInt(args[2]);
+                                    NetworkHelper.syphonAndDamage(NetworkHelper.getSoulNetwork(player), player, amount);
+                                    displaySuccessString(commandSender, "commands.network.syphon.success", amount, givenName);
+                                } else {
+                                    displayErrorString(commandSender, "commands.error.arg.invalid");
+                                }
+                            } else {
+                                displayErrorString(commandSender, "commands.error.arg.missing");
+                            }
+
+                            break;
+                        }
+                        case ADD: {
+                            if (displayHelp) {
+                                displayHelpString(commandSender, ValidCommands.ADD.help);
+                                break;
+                            }
+
+                            if (args.length == 3) {
+                                if (Utils.isInteger(args[2])) {
+                                    int amount = Integer.parseInt(args[2]);
+                                    int maxOrb = NetworkHelper.getMaximumForTier(network.getOrbTier());
+                                    displaySuccessString(commandSender, "commands.network.add.success", network.addLifeEssence(amount, maxOrb), givenName);
+                                } else {
+                                    displayErrorString(commandSender, "commands.error.arg.invalid");
+                                }
+                            } else {
+                                displayErrorString(commandSender, "commands.error.arg.missing");
+                            }
+
+                            break;
+                        }
+                        case SET: {
+                            if (displayHelp) {
+                                displayHelpString(commandSender, ValidCommands.SET.help);
+                                break;
+                            }
+
+                            if (args.length == 3) {
+                                if (Utils.isInteger(args[2])) {
+                                    int amount = Integer.parseInt(args[2]);
+                                    network.setCurrentEssence(amount);
+                                    displaySuccessString(commandSender, "commands.network.set.success", givenName, amount);
+                                } else {
+                                    displayErrorString(commandSender, "commands.error.arg.invalid");
+                                }
+                            } else {
+                                displayErrorString(commandSender, "commands.error.arg.missing");
+                            }
+
+                            break;
+                        }
+                        case GET: {
+                            if (displayHelp) {
+                                displayHelpString(commandSender, ValidCommands.GET.help);
+                                break;
+                            }
+
+                            if (args.length > 1)
+                                commandSender.addChatMessage(new ChatComponentText(TextHelper.localizeEffect("message.divinationsigil.currentessence", network.getCurrentEssence())));
+
+                            break;
+                        }
+                        case FILL: {
+                            if (displayHelp) {
+                                displayHelpString(commandSender, ValidCommands.FILL.help, Integer.MAX_VALUE);
+                                break;
+                            }
+
+                            if (args.length > 1) {
+                                network.setCurrentEssence(Integer.MAX_VALUE);
+                                displaySuccessString(commandSender, "commands.network.fill.success", givenName);
+                            }
+
+                            break;
+                        }
+                        case CAP: {
+                            if (displayHelp) {
+                                displayHelpString(commandSender, ValidCommands.CAP.help);
+                                break;
+                            }
+
+                            if (args.length > 1) {
+                                int maxOrb = NetworkHelper.getMaximumForTier(network.getOrbTier());
+                                network.setCurrentEssence(maxOrb);
+                                displaySuccessString(commandSender, "commands.network.cap.success", givenName);
+                            }
+
+                            break;
+                        }
+                    }
+                } catch (IllegalArgumentException e) {
+                    displayErrorString(commandSender, "commands.error.404");
+                }
+            } catch (PlayerNotFoundException e) {
+                displayErrorString(commandSender, "commands.error.404");
+            }
+        }
+    }
+
+    private enum ValidCommands {
+        SYPHON("commands.network.syphon.help"),
+        ADD("commands.network.add.help"),
+        SET("commands.network.set.help"),
+        GET("commands.network.get.help"),
+        FILL("commands.network.fill.help"),
+        CAP("commands.network.cap.help");
+
+        public String help;
+
+        ValidCommands(String help) {
+            this.help = help;
+        }
+    }
+}

src/main/java/WayofTime/bloodmagic/command/sub/SubCommandOrb.java

@@ -0,0 +1,108 @@
+package WayofTime.bloodmagic.command.sub;
+
+import WayofTime.bloodmagic.api.network.SoulNetwork;
+import WayofTime.bloodmagic.api.util.helper.NetworkHelper;
+import WayofTime.bloodmagic.api.util.helper.PlayerHelper;
+import WayofTime.bloodmagic.command.SubCommandBase;
+import WayofTime.bloodmagic.util.Utils;
+import WayofTime.bloodmagic.util.helper.TextHelper;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.PlayerNotFoundException;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StatCollector;
+
+import java.util.Locale;
+
+public class SubCommandOrb extends SubCommandBase {
+
+    public SubCommandOrb(ICommand parent) {
+        super(parent, "orb");
+    }
+
+    @Override
+    public String getArgUsage(ICommandSender commandSender) {
+        return StatCollector.translateToLocal("commands.orb.usage");
+    }
+
+    @Override
+    public String getHelpText() {
+        return StatCollector.translateToLocal("commands.orb.help");
+    }
+
+    @Override
+    public void processSubCommand(ICommandSender commandSender, String[] args) {
+        super.processSubCommand(commandSender, args);
+
+        if (args.length > 0) {
+
+            if (args[0].equalsIgnoreCase("help"))
+                return;
+
+            try {
+                String givenName = commandSender.getName();
+
+                if (args.length > 1)
+                    givenName = args[1];
+
+                EntityPlayer player = getPlayer(commandSender, givenName);
+                String uuid = PlayerHelper.getUUIDFromPlayer(player).toString();
+                SoulNetwork network = NetworkHelper.getSoulNetwork(uuid);
+
+                boolean displayHelp = isBounded(0, 2, args.length);
+
+                try {
+                    switch (ValidCommands.valueOf(args[0].toUpperCase(Locale.ENGLISH))) {
+                        case SET: {
+                            if (displayHelp) {
+                                displayHelpString(commandSender, ValidCommands.SET.help);
+                                break;
+                            }
+
+                            if (args.length == 3) {
+                                if (Utils.isInteger(args[2])) {
+                                    int amount = Integer.parseInt(args[2]);
+                                    network.setOrbTier(amount);
+                                    displaySuccessString(commandSender, "commands.success");
+                                } else {
+                                    displayErrorString(commandSender, "commands.error.arg.invalid");
+                                }
+                            } else {
+                                displayErrorString(commandSender, "commands.error.arg.missing");
+                            }
+
+                            break;
+                        }
+                        case GET: {
+                            if (displayHelp) {
+                                displayHelpString(commandSender, ValidCommands.GET.help);
+                                break;
+                            }
+
+                            if (args.length > 1)
+                                commandSender.addChatMessage(new ChatComponentText(TextHelper.localizeEffect("message.orb.currenttier", network.getOrbTier())));
+
+                            break;
+                        }
+                    }
+                } catch (IllegalArgumentException e) {
+                    displayErrorString(commandSender, "commands.error.404");
+                }
+            } catch (PlayerNotFoundException e) {
+                displayErrorString(commandSender, "commands.error.404");
+            }
+        }
+    }
+
+    private enum ValidCommands {
+        SET("commands.orb.set.help"),
+        GET("commands.orb.get.help");
+
+        public String help;
+
+        ValidCommands(String help) {
+            this.help = help;
+        }
+    }
+}

src/main/resources/assets/bloodmagic/lang/en_US.lang

@@ -385,6 +385,64 @@ chat.BloodMagic.livingArmour.upgrade.poisonRemove=You are starting to feel bette
 chat.BloodMagic.livingArmour.upgrade.grimReaper=&6A shadowy force pulls you from the brink of death!
 chat.BloodMagic.livingArmour.newUpgrade=&4Upgrade acquired!
 
+# Commands
+commands.error.arg.invalid=Invalid arguments
+commands.error.arg.missing=Not enough arguments
+commands.error.arg.player.missing=You must specify which player you wish to perform this action on.
+commands.error.404=Command not found!
+commands.error.unknown=Unknown command!
+commands.error.perm=You do not have permission to use this command.
+
+commands.success=Executed successfully
+
+commands.format.help=%s - %s
+commands.format.error=%s - %s
+
+commands.help.usage=/bloodmagic help
+commands.help.help=Displays the help information for the "/bloodmagic" command.
+
+commands.network.usage=/bloodmagic network [syphon|add|get|fill|cap] player [amount]
+commands.network.help=LP network utilities
+commands.network.syphon.help=Removes the given amount of LP from the given player's LP network.
+commands.network.syphon.success=Successfully syphoned %d LP from %s.
+commands.network.add.help=Adds the given amount of LP to the given player's LP network. Follows standard LP gain rules.
+commands.network.add.success=Successfully added %d LP to %s's LP network.
+commands.network.set.help=Sets the given player's LP to the given amount.
+commands.network.set.success=Successfully set %s's LP network to %d LP.
+commands.network.get.help=Returns the amount of LP in the given player's LP network.
+commands.network.fill.help=Fills the given player's LP network to %d.
+commands.network.fill.success=Successfully filled %s's LP network.
+commands.network.cap.help=Fills the given player's LP network to the max that their highest Blood Orb can store.
+commands.network.cap.success=Successfully capped off %s's LP network.
+
+commands.bind.usage=/bloodmagic bind [true|false] [player]
+commands.bind.help=Attempts to (un)bind the currently held item.
+commands.bind.success=Binding successful
+commands.bind.remove.success=Unbinding successful
+
+commands.orb.usage=/bloodmagic orb [set|get] player [tier]
+commands.orb.help=Used to set or get the Player's max Blood Orb tier.
+
+commands.bind.usage=/bind <player>
+commands.bind.success=Item successfully bound!
+commands.bind.failed.noPlayer=There is no player specified
+commands.bind.failed.alreadyBound=Item is already bound; use /unbind to unbind it
+commands.bind.failed.notBindable=Item cannot be bound
+commands.unbind.usage=/unbind
+commands.unbind.success=Item successfully unbound!
+commands.unbind.failed.notBindable=Item cannot be unbound
+commands.soulnetwork.usage=/soulnetwork <player> <add|subtract|fill|empty|get> [amount]
+commands.soulnetwork.add.success=Successfully added %dLP to %s's Soul Network!
+commands.soulnetwork.subtract.success=Successfully subtracted %dLP from %s's Soul Network!
+commands.soulnetwork.fill.success=Successfully filled %s's Soul Network!
+commands.soulnetwork.empty.success=Successfully emptied %s's Soul Network!
+commands.soulnetwork.get.success=There is %dLP in %s's Soul Network!
+commands.soulnetwork.noPlayer=There is no player specified
+commands.soulnetwork.noCommand=There is no command specified
+commands.soulnetwork.notACommand=That is not a valid command
+commands.soulnetwork.fillMax.success=Successfully filled %s's Soul Network to their orb max!
+commands.soulnetwork.create.success=Successfully created %s's Soul Network (Orb tier: %d)
+
 # JustEnoughItems
 jei.BloodMagic.recipe.altar=Blood Altar
 jei.BloodMagic.recipe.binding=Alchemy Array (Binding)