MicrozCommand.java

package com.multimote.microz.utils;

import com.multimote.microz.Core;
import com.multimote.microz.data.GlobalData;
import com.multimote.microz.entity.CorpseEntity;
import com.multimote.microz.entity.living.FastZombie;
import com.multimote.microz.entity.living.npc.NpcBase;
import com.multimote.microz.handlers.packet.DescrWorldDataPacket;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.command.WrongUsageException;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;

import java.util.Arrays;
import java.util.List;

/**
 * Created by MultiMote on 13.10.2014.
 */
public class MicrozCommand extends CommandBase {

    @Override
    public String getCommandName() {
        return "microz";
    }

    @Override
    public List getCommandAliases() {
        return Arrays.asList("mz");
    }

    @Override
    public int getRequiredPermissionLevel() {
        return 2;
    }

    @Override
    public String getCommandUsage(ICommandSender sender) {
        return "no gaems";
    }

    @Override
    public void processCommand(ICommandSender sender, String[] args) {
        if (args.length < 1) {
            this.printHelp(sender);
        } else {
            if (args[0].equals("--help")) {
                this.printHelp(sender);
            } else if (args[0].equals("man")) {
                if (args.length > 1) this.printHelp(args[1], sender);
            } else if (args[0].equals("removedead") && sender.getEntityWorld() != null) {
                this.removeEntities(CorpseEntity.class, sender.getEntityWorld());
            } else if (args[0].equals("removezombies") && sender.getEntityWorld() != null) {
                this.removeEntities(FastZombie.class, sender.getEntityWorld());
            } else if (args[0].equals("removenpc") && sender.getEntityWorld() != null) {
                this.removeEntities(NpcBase.class, sender.getEntityWorld());
            } else if (args[0].equals("worldborder") && sender.getEntityWorld() != null) {
                this.handleWBcmd(sender, args);
            } else if (args[0].equals("blowout") && sender.getEntityWorld() != null) {
                this.handleBlowoutCmd(sender, args);
            }
        }
    }

    private void checkPlayer(ICommandSender sender){
        if(!(sender instanceof EntityPlayer)){
            throw new CommandException("noplayer");
        }
    }

    private void handleBlowoutCmd(ICommandSender sender, String[] args) {
        if(args.length>1){
            if(args[1].equals("start")){
                if(GlobalData.blowoutsDimension == sender.getEntityWorld().provider.dimensionId){
                    Core.blowout.startBlowout(sender.getEntityWorld());
                }else throw new CommandException("wrongdim");
            }else if(args[1].equals("stop")){
                Core.blowout.stopBlowout();
            }else if(args[1].equals("startafter")){
                if(GlobalData.blowoutsDimension == sender.getEntityWorld().provider.dimensionId){
                    if(args.length > 2){
                        Core.blowout.setNextBlowoutTime(parseIntWithMin(sender, args[2], 0) * 20);
                    }
                }else throw new CommandException("wrongdim");

            }else if(this.isTrue(args[1])){
                GlobalData.blowouts = true;
                NBTConf.writeGlobalConf();
            }else if(this.isFalse(args[1])){
                Core.blowout.stopBlowout();
                GlobalData.blowouts = false;
                NBTConf.writeGlobalConf();
            }else if(args[1].equals("length") || args[1].equals("len")){
                if(args.length > 2){
                    GlobalData.blowoutLength = parseIntWithMin(sender, args[2], 0);
                    NBTConf.writeGlobalConf();
                }
            }else if(args[1].equals("dimension") || args[1].equals("dim")){
                if(args.length > 2){
                    if(args[2].equals("this"))
                    GlobalData.blowoutsDimension = sender.getEntityWorld().provider.dimensionId;
                    else
                    GlobalData.blowoutsDimension = parseIntWithMin(sender, args[2], 0);

                    NBTConf.writeGlobalConf();
                }
            }else if(args[1].equals("delay")){
                if(args.length > 2){
                    GlobalData.blowoutsDelay = parseIntWithMin(sender, args[2], 0) * 20;
                    NBTConf.writeGlobalConf();
                }
            }else if(args[1].equals("messages")){
                if(args.length > 2){
                    if(this.isTrue(args[2])){
                        GlobalData.sendBlowoutMessage = true;
                        NBTConf.writeGlobalConf();
                    }else if(this.isFalse(args[2])){
                        GlobalData.sendBlowoutMessage = false;
                        NBTConf.writeGlobalConf();
                    }else throw new CommandException("truefalse");
                }
            }
        }
    }

    private void handleWBcmd(ICommandSender sender, String[] args) {
        this.checkPlayer(sender);
        if (args.length > 1) {
            if (args[1].equals("setpoint")) {
                if (args.length > 2) {
                    if (args[2].equals("bottom-left")) {
                        if (args.length > 3) {
                            if (args[3].equals("here")) {
                                EntityPlayer player = ((EntityPlayer) sender);
                                MicrozHooks.setMapBottomLeftPoint(player.worldObj, MathHelper.floor_double(player.posX), MathHelper.floor_double(player.posZ));
                                NBTConf.writeWorldConfig(player.worldObj, player.worldObj.provider.dimensionId);
                                Core.packets.sendToDimension(new DescrWorldDataPacket(player.worldObj.provider.dimensionId), player.worldObj.provider.dimensionId);
                            }
                        } else if (args.length > 4) {
                            EntityPlayer player = ((EntityPlayer) sender);
                            int x = sender.getPlayerCoordinates().posX;
                            int z = sender.getPlayerCoordinates().posY;
                            x = MathHelper.floor_double(func_110666_a(sender, (double)x, args[3]));
                            z = MathHelper.floor_double(func_110666_a(sender, (double)z, args[4]));
                            MicrozHooks.setMapBottomLeftPoint(player.worldObj, x, z);
                            NBTConf.writeWorldConfig(player.worldObj, player.worldObj.provider.dimensionId);
                            Core.packets.sendToDimension(new DescrWorldDataPacket(player.worldObj.provider.dimensionId), player.worldObj.provider.dimensionId);
                        }
                    } else if (args[2].equals("top-right")) {
                        if (args.length > 3) {
                            if (args[3].equals("here")) {
                                EntityPlayer player = ((EntityPlayer) sender);
                                MicrozHooks.setMapTopRightPoint(player.worldObj, MathHelper.floor_double(player.posX), MathHelper.floor_double(player.posZ));
                                NBTConf.writeWorldConfig(player.worldObj, player.worldObj.provider.dimensionId);
                                Core.packets.sendToDimension(new DescrWorldDataPacket(player.worldObj.provider.dimensionId), player.worldObj.provider.dimensionId);
                            }
                        } else if (args.length > 4) {
                            EntityPlayer player = ((EntityPlayer) sender);
                            int x = sender.getPlayerCoordinates().posX;
                            int z = sender.getPlayerCoordinates().posY;
                            x = MathHelper.floor_double(func_110666_a(sender, (double)x, args[3]));
                            z = MathHelper.floor_double(func_110666_a(sender, (double)z, args[4]));
                            MicrozHooks.setMapTopRightPoint(player.worldObj, x, z);
                            NBTConf.writeWorldConfig(player.worldObj, player.worldObj.provider.dimensionId);
                            Core.packets.sendToDimension(new DescrWorldDataPacket(player.worldObj.provider.dimensionId), player.worldObj.provider.dimensionId);
                        }
                    }
                }
            }else if (args[1].equals("switch")) {
                if (args.length > 2) {
                    if (this.isTrue(args[2])) {
                        EntityPlayer player = ((EntityPlayer) sender);
                        MicrozHooks.switchBorder(player.worldObj, true);
                        NBTConf.writeWorldConfig(player.worldObj, player.worldObj.provider.dimensionId);
                        Core.packets.sendToDimension(new DescrWorldDataPacket(player.worldObj.provider.dimensionId), player.worldObj.provider.dimensionId);
                    }else if (this.isFalse(args[2])) {
                        EntityPlayer player = ((EntityPlayer) sender);
                        MicrozHooks.switchBorder(player.worldObj, false);
                        NBTConf.writeWorldConfig(player.worldObj, player.worldObj.provider.dimensionId);
                        Core.packets.sendToDimension(new DescrWorldDataPacket(player.worldObj.provider.dimensionId), player.worldObj.provider.dimensionId);
                    }
                }

            }else if (args[1].equals("mapname")) {
                if (args.length > 2) {
                    EntityPlayer player = ((EntityPlayer) sender);
                    MicrozHooks.setMapName(player.worldObj, args[2]);
                    NBTConf.writeWorldConfig(player.worldObj, player.worldObj.provider.dimensionId);
                    Core.packets.sendToDimension(new DescrWorldDataPacket(player.worldObj.provider.dimensionId), player.worldObj.provider.dimensionId);
                }

            }
        }
    }

    private void printHelp(String cmd, ICommandSender sender) {
        if (cmd.equals("man")) {
            sender.addChatMessage(new ChatComponentText("man <arg>"));
        }if (cmd.equals("blowout")) {
            sender.addChatMessage(new ChatComponentText(EnumChatFormatting.GRAY + "blowout <on/off>"+ EnumChatFormatting.WHITE +" - enables or disables blowout globally."));
            sender.addChatMessage(new ChatComponentText(EnumChatFormatting.GRAY + "blowout <start/stop>"+ EnumChatFormatting.WHITE +" - starts or stops blowout in current world."));
            sender.addChatMessage(new ChatComponentText(EnumChatFormatting.GRAY + "blowout <n> <seconds>"+ EnumChatFormatting.WHITE +" - starts blowout after n seconds."));
            sender.addChatMessage(new ChatComponentText("Configuration:"));
            sender.addChatMessage(new ChatComponentText(EnumChatFormatting.GRAY + "blowout delay <n>"+ EnumChatFormatting.WHITE +" - set delay per blowouts for n seconds."));
            sender.addChatMessage(new ChatComponentText(EnumChatFormatting.GRAY + "blowout length <n>"+ EnumChatFormatting.WHITE +" - set blowout length for n seconds."));
            sender.addChatMessage(new ChatComponentText(EnumChatFormatting.GRAY + "blowout dimension <n/here>"+ EnumChatFormatting.WHITE +" - set blowout dimension to n dimension / player dimension."));
            sender.addChatMessage(new ChatComponentText(EnumChatFormatting.GRAY + "blowout messages <on/off>"+ EnumChatFormatting.WHITE +" - switch blowout chat messages."));
        } else throw new CommandException("There is no manual for " + cmd);
    }

    private void printHelp(ICommandSender sender) {
       sender.addChatMessage(new ChatComponentText("Available args:"));
       sender.addChatMessage(new ChatComponentText("removedead, removezombies, removenpc, blowout"));
       sender.addChatMessage(new ChatComponentText(EnumChatFormatting.WHITE + "Enter" + EnumChatFormatting.GRAY + " /mz man <arg> " + EnumChatFormatting.WHITE + "for help."));
    }

    private boolean removeEntities(Class eclass, World world) {
        if (world == null) return false;
        List entities = world.loadedEntityList;
        for (Object obj : entities) {
            if (obj instanceof Entity && eclass.isAssignableFrom(obj.getClass())) ((Entity) obj).setDead();
        }
        return true;
    }


    private boolean isTrue(String arg){
        return  arg.equals("on") || arg.equals("true") || arg.equals("enable");
    }

    private boolean isFalse(String arg){
        return  arg.equals("off") || arg.equals("false") || arg.equals("disable");
    }

    /**
     * Adds the strings available in this command to the given list of tab completion options.
     */
   /* @Override
    public List addTabCompletionOptions(ICommandSender sender, String[] args)
    {
        return args.length != 1 && args.length != 2 ? null : getListOfStringsMatchingLastWord(args, MinecraftServer.getServer().getAllUsernames());
    }*/

    /**
     * Return whether the specified command parameter index is a username parameter.
     */
    /*@Override
    public boolean isUsernameIndex(String[] args, int index)
    {
        return index == 0;
    }*/
}