SnowGrowCommands.java

package musaddict.snowgrow;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

import musaddict.snowgrow.SnowGrow;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

public class SnowGrowCommands implements CommandExecutor{
    private SnowGrow plugin;
    public HashMap<String, int[]> playerSnow = new HashMap<String, int[]>();

    public SnowGrowCommands(SnowGrow plugin) {
        this.plugin = plugin;
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] arg) {
        String s = "[" + sender.getName() + "] /" + command.getName();
        for (int i = 0; i < arg.length; i++) s += " " + arg[i];
        System.out.println(s);

        if (arg.length == 2) {
            if (arg[0].equals("enable") || arg[0].equals("disable")) {
                World world = Bukkit.getServer().getWorld(arg[1]);

                if (world == null) {
                    sender.sendMessage(ChatColor.AQUA + arg[1] + ChatColor.RED + " cannot be found."); //Bad world name

                    return true;
                }

                if (arg[0].equals("enable")) {
                    if(sender.isOp() || sender.hasPermission("sg.world.enable")){
                        if (SnowGrow.worldData.list.contains(world)) {
                            sender.sendMessage(ChatColor.AQUA + arg[1] + ChatColor.GRAY + " is already enabled. Did you mean '/snow disable'?"); //Already exists
                        }
                        else {
                            SnowGrow.worldData.list.add(world);
                            sender.sendMessage(ChatColor.AQUA + arg[1] + ChatColor.GREEN + " is now hooked into weather!"); //World added to auto-grow list
                        }
                    }
                    else{
                        sender.sendMessage(ChatColor.RED + "You do not have permission to enable snow.");
                    }
                }
                else if (arg[0].equals("disable")) {
                    if(sender.isOp() || sender.hasPermission("sg.world.disable")){
                        if (SnowGrow.worldData.list.contains(world)) {
                            SnowGrow.worldData.list.remove(world);
                            sender.sendMessage(ChatColor.AQUA + arg[1] + ChatColor.GRAY + " is unhooked from weather."); //Removed
                        }
                        else {
                            sender.sendMessage(ChatColor.AQUA + arg[1] + ChatColor.GRAY + " is already disabled. Did you mean '/snow enable'?"); //World not in auto-grow list
                        }
                    }
                    else{
                        sender.sendMessage(ChatColor.RED + "You do not have permission to disable snow.");
                    }
                }

                return true;
            }
            else {
                Player player = (Player)sender;
                if(player.isOp() || player.hasPermission("sg.snow")){
                    if (playerSnow.containsKey(player.getName())) {
                        player.sendMessage(ChatColor.RED + "It is already snowing.");
                        player.sendMessage(ChatColor.GRAY + "/snow stop");
                        return true;
                    }

                    int radius = Integer.parseInt(arg[0]);
                    int maxRange = plugin.getConfig().getInt("command-snow.max-range");
                    int maxTime = plugin.getConfig().getInt("command-snow.max-time");
                    int time = Integer.parseInt(arg[1]);

                    if (time > maxTime && maxTime > -1) {
                        player.sendMessage(ChatColor.AQUA + (time + "") + ChatColor.RED + " seconds is too long.");
                        player.sendMessage(ChatColor.GRAY + "Please use " + ChatColor.AQUA + maxTime + ChatColor.GRAY + " or less.");
                        return true;
                    }

                    if (radius > maxRange && maxRange > -1) {
                        player.sendMessage(ChatColor.AQUA + (radius + "") + ChatColor.RED + " meters is too long.");
                        player.sendMessage(ChatColor.GRAY + "Please use " + ChatColor.AQUA + maxRange + ChatColor.GRAY + " or less.");
                        return true;
                    }

                    int min = time / 60, sec = time % 60;

                    boolean circular = true;
                    if (arg.length == 3)
                        if (arg[2].equals("sq"))
                            circular = false;

                    player.sendMessage(ChatColor.GRAY + "You let it snow for " + ChatColor.AQUA + min + ChatColor.GRAY + " minutes and "+ ChatColor.AQUA + sec + ChatColor.GRAY + " seconds.");

                    int taskID1 = plugin.getServer().getScheduler().scheduleSyncRepeatingTask(plugin, new SnowGrowSchedule(plugin, getAffectedBlocks(player.getLocation().getBlock().getRelative(BlockFace.DOWN), radius, circular), true), 20L, (long) (plugin.getConfig().getInt("command-snow.growth-delay") * 20L));
                    int taskID2 = plugin.getServer().getScheduler().scheduleAsyncRepeatingTask(plugin, new RemainingTime(player, time), (30 * 20L), (30 * 20L));
                    int stopID = plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new StopTasks(player, new int[] {taskID1, taskID2}), time * 20L);
                    playerSnow.put(player.getName(), new int[] {stopID, taskID1, taskID2});
                    return true;
                } else {
                    player.sendMessage(ChatColor.RED + "You do not have permission to start snow.");
                    return true;
                }
            }
        }
        if (arg.length == 1){
            if (arg[0].equals("stop")){
                Player player = (Player)sender;
                if(player.isOp() || player.hasPermission("sg.stop")){

                    if (playerSnow.containsKey(player.getName())) {
                        new StopTasks(player, playerSnow.get(player.getName())).run(); //Runs instantly, no need to delay with a scheduler
                    }
                    else {
                        player.sendMessage(ChatColor.GRAY + "There was no snow to stop."); //Wasn't snowing (for this player)
                    }
                    //stop both tasks
                    return true;
                }else {
                    player.sendMessage(ChatColor.RED + "You do not have permission to stop snow.");
                    return true;
                }
            }else if(arg[0].equals("help")){
                Player player = (Player)sender;
                player.sendMessage(ChatColor.GRAY + "------------------" + ChatColor.AQUA + "SnowGrow" + ChatColor.GRAY + "------------------");
                player.sendMessage(ChatColor.AQUA + "/snow [enable/disable] [world] " + ChatColor.GRAY + "- Hooks into weather."); //TODO: Make this sound better/shorten
                player.sendMessage(ChatColor.AQUA + "/snow [radius] [time] (sq) " + ChatColor.GRAY + " - Add \"sq\" for square radius."); //TODO: add 3rd arg for square selection (circle by default)" +
                player.sendMessage(ChatColor.AQUA + "/snow stop " + ChatColor.GRAY + " - Stops snow growth by you.");
                player.sendMessage(ChatColor.GRAY + "-----------------" + SnowGrow.info.getVersion() + "----------------");
                player.sendMessage("");
                player.sendMessage(ChatColor.GRAY + "Written by:" + ChatColor.GOLD + " Musaddict" + ChatColor.GRAY + "," + ChatColor.GOLD + " Feed_Dante");
                return true;
            }else{
                return false;
            }

        }

        return false;
    }

    public class RemainingTime implements Runnable { //This is now thread safe
        private Player player;
        private int remainder;

        public RemainingTime(Player player, int remainder) {
            this.player = player;
            this.remainder = remainder;
        }

        public void run() {
            if(remainder > 30){
                remainder = remainder - 30;
                int min = remainder / 60, sec = remainder % 60;
                player.sendMessage(ChatColor.GRAY + "Remaining time: " + ChatColor.AQUA + min + ChatColor.GRAY + " minutes " + ChatColor.AQUA + sec + ChatColor.GRAY + " seconds.");
            }
        }
    }

    public class StopTasks implements Runnable { //This is now thread safe
        private Player player;
        private int[] tasks;

        public StopTasks(Player player, int[] tasks) {
            this.player = player;
            this.tasks = tasks;
        }

        public void run() {
            if (tasks == null) {
                player.sendMessage("tasks is null");
                return;
            }
            for (int task : tasks) {
                plugin.getServer().getScheduler().cancelTask(task);
            }
            player.sendMessage(ChatColor.GRAY + "It has stopped snowing.");
            playerSnow.remove(player.getName());
        }
    }

    //blocks to ignore when placing snow
    public static List<Material> NotAllowed = Arrays.asList(new Material[] {
            Material.TORCH,
            Material.FIRE,
            Material.WATER,
            Material.STATIONARY_WATER,
            Material.ICE,
            Material.REDSTONE_WIRE,
            Material.REDSTONE_TORCH_ON,
            Material.REDSTONE_TORCH_OFF,
            Material.VINE,
            Material.WATER_LILY,
            Material.LAVA,
            Material.STATIONARY_LAVA,
            Material.WHEAT,
            Material.STEP,
            Material.COBBLESTONE_STAIRS,
            Material.WOOD_STAIRS,
            Material.BRICK_STAIRS,
            Material.NETHER_BRICK_STAIRS,
            Material.FENCE,
            Material.FENCE_GATE,
            Material.SUGAR_CANE_BLOCK,
            Material.CROPS}); //Needs more, too lazy

    public static List<Material> ToReplace = Arrays.asList(new Material[] {
        Material.SNOW,
        Material.LONG_GRASS,
        Material.DEAD_BUSH,
        Material.RED_ROSE,
        Material.YELLOW_FLOWER});

    private ArrayList<Location> getAffectedBlocks(Block sourceBlock, int radius, boolean circular)
    {
        ArrayList<Location> affectedBlocks = new ArrayList<Location>();
        double sourceX = sourceBlock.getX(), sourceY = sourceBlock.getY(), sourceZ = sourceBlock.getZ();

        sourceX += (sourceX >= 0)? 0.5 : -0.5;
        sourceY += (sourceY >= 0)? 0.5 : -0.5;
        sourceZ += (sourceZ >= 0)? 0.5 : -0.5;

        double minX = sourceX - radius,
            maxX = sourceX + radius,
            minY = sourceY - radius,
            maxY = sourceY + radius,
            minZ = sourceZ - radius,
            maxZ = sourceZ + radius;

        double radSQ = Math.pow(radius, 2);

        Block temp = null;

        for (double x = minX; x < maxX; x++)
        {
            for (double z = minZ; z < maxZ; z++)
            {
                if (circular) {
                    double coord = (Math.pow((x - sourceX), 2) + Math.pow((z - sourceZ), 2));

                    if (coord >= radSQ) //Make sure the block is within our circle.
                        continue; //If not, go to the next one.
                }

                int highesyBlockY = sourceBlock.getWorld().getHighestBlockYAt((int) x, (int) z); //Gets the highest non-air coordinate at the given coordinates

                temp = sourceBlock.getWorld().getBlockAt((int) x, highesyBlockY, (int) z);

                while (temp.getType() == Material.AIR) //For some reason getHighestBlockYAt sometimes returns a block that has air beneath it.
                    temp = temp.getRelative(BlockFace.DOWN);

                //if (highesyBlockY < maxY && highesyBlockY > minY)
                if (temp.getY() < maxY && temp.getY() > minY)
                {
                    //blocks to replace with snow
                    if (ToReplace.contains(temp.getType()))
                        affectedBlocks.add(temp.getLocation());
                    else if (!NotAllowed.contains(temp.getType()))
                        affectedBlocks.add(temp.getRelative(BlockFace.UP).getLocation());
                }
            }
        }

        return affectedBlocks;
    }
}