diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..59d1bad --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +/bin +.classpath +.project +.settings/ +.DS_Store + diff --git a/README b/README index e69de29..a5f7c57 100644 --- a/README +++ b/README @@ -0,0 +1,3 @@ +This plugin for Minecraft servers running Bukkit allows admins to "curse" a player, making their lives... unpleasant. + +Note: TranslatorTester is only for testing purposes and is not important in the actual running of the plugin. \ No newline at end of file diff --git a/plugin.yml b/plugin.yml new file mode 100644 index 0000000..9541103 --- /dev/null +++ b/plugin.yml @@ -0,0 +1,9 @@ +name: Curse +main: me.hgilman.Curse.Curse +version: 1.0.1 +commands: + curse: + description: Makes the player's life... unpleasant. + permission: curse.curse + permission-message: You dont't have permission to curse someone + usage: / diff --git a/src/me/hgilman/Curse/Curse.java b/src/me/hgilman/Curse/Curse.java new file mode 100644 index 0000000..3d3729d --- /dev/null +++ b/src/me/hgilman/Curse/Curse.java @@ -0,0 +1,206 @@ +package me.hgilman.Curse; + +import java.util.HashMap; +import java.util.Random; +import java.util.logging.Logger; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.lang.String; +import org.bukkit.plugin.PluginManager; +import org.bukkit.plugin.java.JavaPlugin; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.bukkit.ChatColor; + +import me.hgilman.Curse.CurseBlockListener; + +public class Curse extends JavaPlugin { + + private HashMap cursedPlayers = new HashMap(); // The cursedPlayers hashmap. + + private final CurseBlockListener blockListener = new CurseBlockListener(this); + private final CursePlayerListener playerListener = new CursePlayerListener(this); + + Logger log = Logger.getLogger("Minecraft"); // Get the logger. + + public void onEnable() + { + log.info("Curse plugin enabling..."); + + PluginManager pm = this.getServer().getPluginManager(); + + pm.registerEvents(blockListener, this); + pm.registerEvents(playerListener, this); + + + new File("plugins/Curse").mkdir(); + File playersFile = new File("plugins/Curse/CursedPlayers.dat"); + + if(!(playersFile.exists())) + { + try + { + playersFile.createNewFile(); + } + catch (IOException ex) + { + ex.printStackTrace(); //explained below. + } + } + else + { + setCursedPlayers(load("plugins/Curse/CursedPlayers.dat")); + } + + Player[] onlinePlayers = this.getServer().getOnlinePlayers(); + for (int i = 0; i < onlinePlayers.length; i++) // For every online player... + { + if (isCursed(onlinePlayers[i])) // If the player is cursed... + { + newLightningStrike(onlinePlayers[i]); // Schedule a new lightning strike event. + } + } + + log.info("Curse plugin enabled."); + } + + public void onDisable() + { + save(getCursedPlayers(), "plugins/Curse/CursedPlayers.dat"); + + log.info("Curse plugin disabled."); + } + + public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args){ + if (sender instanceof Player) // If they're a player... + { + if (args.length == 0) // If they didn't give an arg... + { + sender.sendMessage("Error! You must specify a player."); + return false; + } + else if (this.getServer().getPlayer(args[0]) != null) // If the input matched a player... + { + + Player targetPlayer = this.getServer().getPlayer(args[0]); + + if (isCursed(targetPlayer)) // If the player is cursed... + { + uncursePlayer(targetPlayer); // Uncurse the player. + sender.sendMessage("Uncursed " + targetPlayer.getName() + "."); + + } + else // If they are not cursed. + { + cursePlayer(targetPlayer); // Curse the player. + sender.sendMessage("Cursed " + targetPlayer.getName() + "."); + } + + } + else // They gave input, but it was bad. + { + sender.sendMessage("Error! Invalid input!"); + sender.sendMessage(ChatColor.DARK_PURPLE + "Note that at this time offline players cannot be cursed."); + return false; + } + } + else + { + sender.sendMessage("This command can only be used ingame."); + return false; + } + return true; + } + + public HashMap getCursedPlayers() + { + return cursedPlayers; + } + + public void setCursedPlayers(HashMap newCursedPlayers) + { + cursedPlayers = newCursedPlayers; + } + + public void save(HashMap pluginEnabled, String path) + { + try{ + ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path)); + oos.writeObject(pluginEnabled); + oos.flush(); + oos.close(); + //Handle I/O exceptions + }catch(Exception e){ + e.printStackTrace(); + } + } + + @SuppressWarnings("unchecked") + public HashMap load(String path) + { + ObjectInputStream ois = null; + try + { + + ois = new ObjectInputStream(new FileInputStream(path)); + Object result = ois.readObject(); + ois.close(); + //you can feel free to cast result to HashMap if you know there's that HashMap in the file + return (HashMap)result; + + + } + catch(Exception e) + { + + e.printStackTrace(); + } + return null; + } + + public boolean isCursed(Player player) + { + + if (!(getCursedPlayers().containsKey(player.getName()))) // If the player was not on the list... + { + return false; + } + + else if (this.getCursedPlayers().get(player.getName()).booleanValue()) // If they're cursed... + { + return true; + } + else + { + return false; // If they're on the list but are not cursed... + } + + } + + public void cursePlayer(Player player) // Curses the player. + { + getCursedPlayers().put(player.getName(), true); + newLightningStrike(player); // Schedule a new lightning strike. + } + + public void uncursePlayer(Player player) + { + getCursedPlayers().put(player.getName(), false); // Uncurses the player. + } + + public void newLightningStrike(Player player) // Schedules a new lightningstrike effect on the player. + { + Random generator = new Random(); + int nextStrikeTicks = generator.nextInt(1200); + double nextStrikeSeconds = nextStrikeTicks / 20; + player.getServer().getScheduler().scheduleSyncDelayedTask(this, new RunnableStrikeLightningEffect(this, player), nextStrikeTicks); + log.info("Scheduled lightning strike effect for " + player.getName() + " in " + nextStrikeSeconds + " seconds."); + } + + +} diff --git a/src/me/hgilman/Curse/CurseBlockListener.java b/src/me/hgilman/Curse/CurseBlockListener.java new file mode 100644 index 0000000..0a0ecb5 --- /dev/null +++ b/src/me/hgilman/Curse/CurseBlockListener.java @@ -0,0 +1,34 @@ +package me.hgilman.Curse; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockPlaceEvent; +import org.bukkit.block.Block; +import org.bukkit.entity.Player; +import org.bukkit.Material; + + +public class CurseBlockListener implements Listener { + + public static Curse plugin; + + public CurseBlockListener(Curse instance) + { + + plugin = instance; + } + + @EventHandler + public void onBlockPlace (BlockPlaceEvent event) + { + Block placedBlock = event.getBlock(); + Player placingPlayer = event.getPlayer(); + + if (plugin.isCursed(placingPlayer)) // If the player is cursed. + { + placedBlock.setType(Material.WOOL); + } + + } + +} diff --git a/src/me/hgilman/Curse/CursePlayerListener.java b/src/me/hgilman/Curse/CursePlayerListener.java new file mode 100644 index 0000000..ae8e48c --- /dev/null +++ b/src/me/hgilman/Curse/CursePlayerListener.java @@ -0,0 +1,43 @@ +package me.hgilman.Curse; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.AsyncPlayerChatEvent; +import org.bukkit.entity.Player; +import org.bukkit.ChatColor; +import me.hgilman.Curse.CurseTranslator; + + +public class CursePlayerListener implements Listener { + + public static Curse plugin; + + public CursePlayerListener(Curse instance) + { + + plugin = instance; + } + + @EventHandler + public void onPlayerJoin (PlayerJoinEvent event) + { + Player player = event.getPlayer(); + + if(plugin.isCursed(player)) // If the player is cursed... + { + plugin.newLightningStrike(player); // Schedule a new lightning strike on them. + } + + } + + @EventHandler + public void onPlayerChat(AsyncPlayerChatEvent event) + { + if (plugin.isCursed(event.getPlayer())) // If the player in question is cursed... + { + event.setMessage(ChatColor.LIGHT_PURPLE + new CurseTranslator(event.getMessage()).getTranslation()); + } + } + +} diff --git a/src/me/hgilman/Curse/CurseTranslator.java b/src/me/hgilman/Curse/CurseTranslator.java new file mode 100644 index 0000000..6fc4f2a --- /dev/null +++ b/src/me/hgilman/Curse/CurseTranslator.java @@ -0,0 +1,64 @@ +package me.hgilman.Curse; + +import java.util.Arrays; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class CurseTranslator { + + private static char[] vowels = {'a', '', '', '', '', '', 'e', '', '', '', '', 'i', '', '', '', '', 'o', '', '', '', '', '', 'u', '', '', '', ''}; + private static char[] extendedVowels = {'a', '', '', '', '', '', 'e', '', '', '', '', 'i', '', '', '', '', 'o', '', '', '', '', '', 'u', '', '', '', '', '', 'y'}; + Matcher matcher; + private String word; + private String nonwordStuff; + private StringBuilder returnValue = new StringBuilder(); + + static { + Arrays.sort(vowels); + Arrays.sort(extendedVowels); + } + + public CurseTranslator(String text) + { + matcher = Pattern.compile("([^\\pL]+)|(\\pL+)").matcher(text); //matches all sequences of alphabetic characters preceded by + //a non-alphabetic character, I add the space to the front of + while(matcher.find()) //the text to make sure it sees the first word + { + word = matcher.group(2); + nonwordStuff = matcher.group(1); + returnValue.append((nonwordStuff != null ? nonwordStuff : "") + shifter(word)); + } + } + + private static String shifter(String text) + { + if(text == null || text.length() < 1) return ""; + // text = tokenizer.nextToken(); + // System.out.println(length); + if(Arrays.binarySearch(vowels, text.charAt(0)) >= 0) { + // System.out.println("vowel found"); + text+="yay"; + return text; + } else if(text.toLowerCase().charAt(0) == 'q' && text.toLowerCase().charAt(1) == 'u') { + text = text.substring(2); + text += "quay"; + return text; + } + int i = 1; + text += text.toLowerCase().charAt(0); + for(; Arrays.binarySearch(extendedVowels, text.charAt(i)) < 0; i++) { + //System.out.println("flag1"); + text += text.toLowerCase().charAt(i); + //System.out.println("0 pos is" + text.charAt(0)); + } + text = text.substring(i); + text+="ay"; + return text; + } + + public String getTranslation() + { + return returnValue.toString(); + } + +} diff --git a/src/me/hgilman/Curse/RunnableStrikeLightningEffect.java b/src/me/hgilman/Curse/RunnableStrikeLightningEffect.java new file mode 100644 index 0000000..2d2747d --- /dev/null +++ b/src/me/hgilman/Curse/RunnableStrikeLightningEffect.java @@ -0,0 +1,27 @@ +package me.hgilman.Curse; + +import org.bukkit.entity.Player; + +public class RunnableStrikeLightningEffect implements Runnable { + + private Curse plugin; + private Player player; + + + public RunnableStrikeLightningEffect(Curse instance, Player playerInstance) + { + plugin = instance; + player = playerInstance; + } + + public void run() + { + if(plugin.isCursed(player) && player.isOnline()) // If the player is cursed and online... + { + player.getWorld().strikeLightningEffect(player.getLocation()); // Strike the lightning effect at the player's location. + plugin.newLightningStrike(player); // Schedule a new lightning strike. + } + + } + +} diff --git a/src/me/hgilman/Curse/TranslatorTester.java b/src/me/hgilman/Curse/TranslatorTester.java new file mode 100644 index 0000000..8773398 --- /dev/null +++ b/src/me/hgilman/Curse/TranslatorTester.java @@ -0,0 +1,24 @@ +package me.hgilman.Curse; + +import java.util.Scanner; + +public class TranslatorTester { + + private static Scanner in = new Scanner(System.in); + /** + * @param args + */ + public static void main(String[] args) { + System.out.println("Translator Tester is ready"); + System.out.println("Type your input or \"!quit!\" to quit"); + String input = in.nextLine(); + while(!input.equalsIgnoreCase("!quit!")) { + System.out.println("Input: \"" + input + "\""); + CurseTranslator ct = new CurseTranslator(input); + System.out.println("Output: \"" + ct.getTranslation() + "\""); + input = in.nextLine(); + } + System.out.println("Translator Tester has been quit"); + } + +}