Version 1.0.1

.gitignore

@@ -0,0 +1,6 @@
+/bin
+.classpath
+.project
+.settings/
+.DS_Store
+

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.

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: /<command> <player>

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<String,Boolean> cursedPlayers = new HashMap<String,Boolean>(); // 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<String,Boolean> getCursedPlayers()
+	{
+		return cursedPlayers;
+	}
+
+	public void setCursedPlayers(HashMap<String,Boolean> newCursedPlayers)
+	{
+		cursedPlayers = newCursedPlayers;
+	}
+
+	public void save(HashMap<String,Boolean> 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<String,Boolean> 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<String,Boolean> if you know there's that HashMap in the file
+			return (HashMap<String,Boolean>)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.");
+	}
+
+
+}

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);
+		}
+
+	}
+
+}

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());	
+		}
+	}
+
+}

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();
+	}
+
+}