AlarmMessages

#### Alarm Messages ###
package me.Skill4Kill12.alarm;

import java.util.HashMap;
import java.util.logging.Logger;

import org.bukkit.Location;
import org.bukkit.plugin.PluginDescriptionFile;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;

public class AlarmMessage extends JavaPlugin{
    public final BlockListener BlockListener = new BlockListener();
    public final Logger logger = Logger.getLogger("Minecraft");
    public static AlarmMessage plugin;

    public static HashMap<Location, String> hm = new HashMap<Location, String>();

    @Override
    public void onDisable() {
        Data.Save();
        this.logger.info("[AlarmMessage] The Plugin Has Been Disabled!");
    }

    @Override
    public void onEnable() {
        PluginManager pm = getServer().getPluginManager();
        pm.registerEvents(this.BlockListener, this);
        PluginDescriptionFile pdfFile = this.getDescription();
                Data.Load();
        this.logger.info("[AlarmMessage]" + pdfFile.getName() + " Version: " + pdfFile.getVersion() + " Has Been Enabled!");
    }
}

######################################################################################################################

## Data ##

package me.Skill4Kill12.alarm;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;

import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;

public class Data {
    static File file = new File("plugins/AlarmMessage/data");
    static File folder = new File("plugins/AlarmMessage/");
    public static AlarmMessage plugin;

    @SuppressWarnings("unused")
    public static boolean Load() {
        // check if file exists;
        if (!file.exists()) {
            try {
                folder.mkdirs();
                file.createNewFile();
            } catch (IOException e) {
                return false;
            }
            return true;
        }

        // Read data!;
        try {
            BufferedReader in = new BufferedReader(new FileReader(file));
            String string;
            while ((string = in.readLine()) != null) {
                if (string != null) {
                    AlarmMessage log = new AlarmMessage();
                    log.logger.info("[AlarmMessage] Reading file");
                    stringToHashMap(string);
                }
            }
            in.close();
        } catch (IOException e) {
            AlarmMessage core = new AlarmMessage();
            core.logger.warning("Can not Load the File.");
            return false;
        }
        BufferedReader in;
        return true;
    }

    // Save data!;
    @SuppressWarnings("unused")
    public static boolean Save() {
        if (!file.exists()) {
            try {
                folder.mkdirs();
                file.createNewFile();
            } catch (IOException e) {
                return false;
            }
        }
        try {
            BufferedWriter out = new BufferedWriter(new FileWriter(file));
            @SuppressWarnings("resource")
            BufferedReader in = new BufferedReader(new FileReader(file));
            Iterator<Location> iterator = AlarmMessage.hm.keySet().iterator();
            while(iterator.hasNext()){
                Location location = iterator.next();
                String line234 = AlarmMessage.hm.get(location);
            out.write(LocationToString(location));
            out.write(" - " + line234);
            out.newLine();
        }
            out.close();
        } catch (IOException e) {
            return false;
        }
        BufferedWriter out;
        return true;

    }

    private static void stringToHashMap(String string) {
    String[] split = string.split(" - ");

        try {
            World world = Bukkit.getWorld(split[0]);
            double x = Double.parseDouble(split[1]);
            double y = Double.parseDouble(split[2]);
            double z = Double.parseDouble(split[3]);
            Location location = new Location (world, x, y, z);

            String tekst = split[4];

            AlarmMessage.hm.put(location, tekst);
        } catch (Exception e) {
            AlarmMessage lugin = new AlarmMessage();
            lugin.logger.warning("Error Converting File");
            lugin.logger.warning("Make shure that it look like (World - Double x - Double y - Double z - String)");
            lugin.logger.info("World is just a name, Doubles are cordinates, String is tekst");
            lugin.logger.info("If the file looks correct and you get the error please make a ticket, and attach your file");
        }
    }

    private static String LocationToString(Location location) {
        String world = location.getWorld().getName().trim();
        double x = location.getX();
        double y = location.getY();
        double z = location.getZ();
        String sx = Double.toString(x);
        String sy = Double.toString(y);
        String sz = Double.toString(z);
        String tekst = world + " - " + sx + " - " + sy + " - " + sz;

        return tekst;
    }
}

###################################################################################################################

## Block Listener ##

package me.Skill4Kill12.alarm;

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

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.block.Sign;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockIgniteEvent;
import org.bukkit.event.block.BlockRedstoneEvent;
import org.bukkit.event.block.SignChangeEvent;

public class BlockListener implements Listener {
    public static AlarmMessage plugin;

    @EventHandler
    public void onSignChange(SignChangeEvent event) {
        String line1 = event.getLine(0);
        String line2 = event.getLine(1);
        String line3 = event.getLine(2);
        String line4 = event.getLine(3);
        String line234 = "An Emergency Has Occured " + line2 + line3 + line4;
        Location location = event.getBlock().getLocation();
        if (!line1.equals("[Alarm]")) {
            return;
        }
        try {
            AlarmMessage.hm.put(location, line234);
            event.setLine(0, "[!Alarm!]");
        } catch (Exception e) {
            event.setLine(0, "");
            event.setLine(1, "");
            event.setLine(2, "");
            event.setLine(3, "");
            AlarmMessage alarmmessage = new AlarmMessage();
                        alarmmessage.logger.warning("Error Adding Alarm Sign Please Make A Ticket");
                        alarmmessage.logger.warning("" + e);
                }
    }

    @EventHandler
    public void onSignIgnite(BlockIgniteEvent event){
        if(AlarmMessage.hm.containsKey(event.getBlock().getLocation())){
            event.setCancelled(true);
        }
    }

    @EventHandler
    public void onSignRemove(BlockBreakEvent event){
        if(AlarmMessage.hm.containsKey(event.getBlock().getLocation())){
            AlarmMessage.hm.remove(event.getBlock().getLocation());
        }
    }

    @EventHandler
    public void onBlockPower(BlockRedstoneEvent event) {

        if (!(event.getBlock().getState() instanceof Sign)) {
            return;
        }

        Location location = event.getBlock().getLocation();
        if(AlarmMessage.hm.containsKey(location)){
            if (event.getBlock().isBlockPowered() || event.getBlock().isBlockIndirectlyPowered()) {
                List<Player> onlineplayers = Arrays.asList(Bukkit.getServer().getOnlinePlayers());
                Iterator<Player> iterator = onlineplayers.iterator();
                String string = AlarmMessage.hm.get(event.getBlock().getLocation());
            while (iterator.hasNext()) {
                Player onlineplayer = iterator.next();
                onlineplayer.sendMessage(ChatColor.RED + string);
            }
                     }
        }
    }
}