Initial implementation of merging the player statistics mod I maintain.

5 files changed, 895 insertions, 0 deletions

diff --git a/src/Java/miscutil/core/commands/CommandUptime.java b/src/Java/miscutil/core/commands/CommandUptime.java
new file mode 100644
index 0000000000..2c13257b88
--- /dev/null
+++ b/src/Java/miscutil/core/commands/CommandUptime.java
@@ -0,0 +1,164 @@
+package miscutil.core.commands;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+
+import miscutil.core.util.uptime.PlayerUptimeData;
+import miscutil.core.util.uptime.Uptime;
+import miscutil.core.util.uptime.UptimeData;
+import miscutil.core.util.uptime.UptimeLog;
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
+//import net.minecraft.server.dedicated.DedicatedServer;
+import net.minecraft.util.ChatComponentText;
+
+public class CommandUptime
+extends CommandBase
+{
+	public String getCommandName()
+	{
+		return "uptime";
+	}
+
+	public String getCommandUsage(ICommandSender sender)
+	{
+		return "/" + getCommandName() + " [player_name | reset | winners]";
+	}
+
+	@SuppressWarnings("rawtypes")
+	public List getCommandAliases()
+	{
+		return null;
+	}
+
+	public void processCommand(ICommandSender sender, String[] args)
+	{
+
+		try{
+			EntityPlayerMP player = (EntityPlayerMP)sender;
+
+
+			Uptime.updateUptime();
+			UptimeData data = Uptime.getUptimeData();
+			if (args.length == 0)
+			{
+				player.addChatMessage(new ChatComponentText("World is on day " + data.getWorldDays() + "."));
+
+				player.addChatMessage(new ChatComponentText("Server has been running for " + data.getServerOndays() + " days."));
+
+				long remainder = data.getServerUptime() / 1000L;
+				int days = (int)remainder / 86400;
+				remainder %= 86400L;
+				int hours = (int)remainder / 3600;
+				remainder %= 3600L;
+				int minutes = (int)remainder / 60;
+				remainder %= 60L;
+				int seconds = (int)remainder;
+				player.addChatMessage(new ChatComponentText("Server has been up for " + days + " days, " + hours + " hours, " + minutes + " minutes and " + seconds + " seconds."));
+			}
+			else if (args.length == 1)
+			{
+				if (args[0].equalsIgnoreCase("reset"))
+				{
+					if (player.canCommandSenderUseCommand(2, ""))
+					{
+						data.resetUptime();
+
+						@SuppressWarnings("unchecked")
+						List<EntityPlayerMP> players = net.minecraft.server.MinecraftServer.getServer().worldServers[0].playerEntities;
+						for (int t = 0; t < players.size(); t++) {
+							((EntityPlayerMP)players.get(t)).addChatMessage(new ChatComponentText("All player statistics have been reset."));
+						}
+					}
+					else
+					{
+						player.addChatMessage(new ChatComponentText("You must be an OP to use this subcommand."));
+					}
+				}
+				else if (!args[0].equalsIgnoreCase("winners"))
+				{
+					PlayerUptimeData player_data = data.getPlayerUptimeData(args[0]);
+					if (player_data != null)
+					{
+						player.addChatMessage(new ChatComponentText(args[0] + " has played for " + player_data.player_ondays + " days."));
+
+						long remainder = player_data.played_time / 1000L;
+						int days = (int)remainder / 86400;
+						remainder %= 86400L;
+						int hours = (int)remainder / 3600;
+						remainder %= 3600L;
+						int minutes = (int)remainder / 60;
+						remainder %= 60L;
+						int seconds = (int)remainder;
+						player.addChatMessage(new ChatComponentText(args[0] + " has played for " + days + " days, " + hours + " hours, " + minutes + " minutes and " + seconds + " seconds."));
+
+						Date first_joined = new Date(player_data.first_joined);
+						player.addChatMessage(new ChatComponentText(args[0] + " first joined on the " + new SimpleDateFormat("d MMM yyyy 'at' HH:mm:ss z").format(first_joined) + "."));
+
+						Date last_active = new Date(player_data.last_active);
+						player.addChatMessage(new ChatComponentText(args[0] + " was last active on the " + new SimpleDateFormat("d MMM yyyy 'at' HH:mm:ss z").format(last_active) + "."));
+						if (player_data.number_of_deaths != 0)
+						{
+							player.addChatMessage(new ChatComponentText(args[0] + " has died " + player_data.number_of_deaths + " times."));
+							Date death_date = new Date(player_data.last_death);
+							player.addChatMessage(new ChatComponentText(args[0] + " last died on the " + new SimpleDateFormat("d MMM yyyy 'at' HH:mm:ss z").format(death_date) + "."));
+
+							remainder = player_data.shortest_life / 1000L;
+							days = (int)remainder / 86400;
+							remainder %= 86400L;
+							hours = (int)remainder / 3600;
+							remainder %= 3600L;
+							minutes = (int)remainder / 60;
+							remainder %= 60L;
+							seconds = (int)remainder;
+							player.addChatMessage(new ChatComponentText(args[0] + "'s shortest life was " + days + " days, " + hours + " hours, " + minutes + " minutes and " + seconds + " seconds."));
+
+							remainder = player_data.longest_life / 1000L;
+							days = (int)remainder / 86400;
+							remainder %= 86400L;
+							hours = (int)remainder / 3600;
+							remainder %= 3600L;
+							minutes = (int)remainder / 60;
+							remainder %= 60L;
+							seconds = (int)remainder;
+							player.addChatMessage(new ChatComponentText(args[0] + "'s longest life was " + days + " days, " + hours + " hours, " + minutes + " minutes and " + seconds + " seconds."));
+						}
+						else
+						{
+							player.addChatMessage(new ChatComponentText(args[0] + " has not died yet."));
+						}
+						remainder = player_data.alive_time / 1000L;
+						days = (int)remainder / 86400;
+						remainder %= 86400L;
+						hours = (int)remainder / 3600;
+						remainder %= 3600L;
+						minutes = (int)remainder / 60;
+						remainder %= 60L;
+						seconds = (int)remainder;
+						player.addChatMessage(new ChatComponentText(args[0] + " has been alive for " + days + " days, " + hours + " hours, " + minutes + " minutes and " + seconds + " seconds."));
+					}
+					else
+					{
+						player.addChatMessage(new ChatComponentText("No uptime data exists for that player."));
+					}
+				}
+			}
+			else
+			{
+				player.addChatMessage(new ChatComponentText("Invalid usage, correct usage is /" + getCommandName() + " [player_name | all]"));
+			}
+		}
+		catch (ClassCastException e) {
+            //do something clever with the exception
+			UptimeLog.log("SEVERE", e.getMessage());
+			UptimeLog.log("WARNING", "You cannot run this command from console");
+        }
+	}
+
+	public boolean canCommandSenderUseCommand(ICommandSender sender)
+	{
+		return true;
+	}
+}
diff --git a/src/Java/miscutil/core/util/uptime/PlayerUptimeData.java b/src/Java/miscutil/core/util/uptime/PlayerUptimeData.java
new file mode 100644
index 0000000000..8049ab68a8
--- /dev/null
+++ b/src/Java/miscutil/core/util/uptime/PlayerUptimeData.java
@@ -0,0 +1,199 @@
+package miscutil.core.util.uptime;
+
+import java.util.Properties;
+
+public class PlayerUptimeData
+{
+	public long last_update;
+	public long first_joined;
+	public long last_active;
+	public long played_time;
+	public long player_lastday;
+	public int player_ondays;
+	public long this_death;
+	public long last_death;
+	public long alive_time;
+	public int number_of_deaths;
+	public long last_life;
+	public long shortest_life;
+	public long longest_life;
+	public boolean online;
+
+	public PlayerUptimeData()
+	{
+		long temp_time = System.currentTimeMillis();
+
+		this.first_joined = temp_time;
+		this.last_active = temp_time;
+		this.played_time = 0L;
+
+		this.player_lastday = temp_time;
+		this.player_ondays = 1;
+
+		this.this_death = temp_time;
+		this.last_death = temp_time;
+		this.alive_time = 0L;
+		this.number_of_deaths = 0;
+		this.last_life = 0L;
+		this.shortest_life = 0L;
+		this.longest_life = 0L;
+
+		this.online = true;
+		this.last_update = temp_time;
+	}
+
+	public PlayerUptimeData(int player_number, Properties properties)
+			throws NumberFormatException
+	{
+		long temp_time = System.currentTimeMillis();
+
+		this.first_joined = Long.valueOf(properties.getProperty("first_joined_" + player_number)).longValue();
+		this.last_active = Long.valueOf(properties.getProperty("last_active_" + player_number)).longValue();
+		this.played_time = Long.valueOf(properties.getProperty("played_time_" + player_number)).longValue();
+
+		this.player_lastday = Long.valueOf(properties.getProperty("player_lastday_" + player_number)).longValue();
+		this.player_ondays = Integer.valueOf(properties.getProperty("player_ondays_" + player_number)).intValue();
+
+		this.this_death = Long.valueOf(properties.getProperty("this_death_" + player_number)).longValue();
+		this.last_death = Long.valueOf(properties.getProperty("last_death_" + player_number)).longValue();
+		this.alive_time = Long.valueOf(properties.getProperty("alive_time_" + player_number)).longValue();
+		this.number_of_deaths = Integer.valueOf(properties.getProperty("number_of_deaths_" + player_number)).intValue();
+		this.last_life = Long.valueOf(properties.getProperty("last_life_" + player_number)).longValue();
+		this.shortest_life = Long.valueOf(properties.getProperty("shortest_life_" + player_number)).longValue();
+		this.longest_life = Long.valueOf(properties.getProperty("longest_life_" + player_number)).longValue();
+
+		this.online = false;
+		this.last_update = temp_time;
+	}
+
+	public void savePlayerUptimeData(int player_number, Properties player_properties)
+	{
+		player_properties.setProperty("first_joined_" + player_number, String.valueOf(this.first_joined));
+		player_properties.setProperty("last_active_" + player_number, String.valueOf(this.last_active));
+		player_properties.setProperty("played_time_" + player_number, String.valueOf(this.played_time));
+		player_properties.setProperty("player_lastday_" + player_number, String.valueOf(this.player_lastday));
+		player_properties.setProperty("player_ondays_" + player_number, String.valueOf(this.player_ondays));
+		player_properties.setProperty("this_death_" + player_number, String.valueOf(this.this_death));
+		player_properties.setProperty("last_death_" + player_number, String.valueOf(this.last_death));
+		player_properties.setProperty("alive_time_" + player_number, String.valueOf(this.alive_time));
+		player_properties.setProperty("number_of_deaths_" + player_number, String.valueOf(this.number_of_deaths));
+		player_properties.setProperty("last_life_" + player_number, String.valueOf(this.last_life));
+		player_properties.setProperty("shortest_life_" + player_number, String.valueOf(this.shortest_life));
+		player_properties.setProperty("longest_life_" + player_number, String.valueOf(this.longest_life));
+	}
+
+	public void playerLoggedOn()
+	{
+		long temp_time = System.currentTimeMillis();
+		if (!this.online)
+		{
+			this.last_active = temp_time;
+
+
+			this.online = true;
+		}
+		this.last_update = temp_time;
+	}
+
+	public void playerLoggedOff()
+	{
+		long temp_time = System.currentTimeMillis();
+		if (this.online)
+		{
+			this.last_active = temp_time;
+			this.played_time += temp_time - this.last_update;
+
+
+			this.alive_time += temp_time - this.last_update;
+
+
+			this.online = false;
+		}
+		this.last_update = temp_time;
+	}
+
+	public void playerDied()
+	{
+		long temp_time = System.currentTimeMillis();
+
+
+		updateUptime();
+
+
+		this.this_death = temp_time;
+		this.number_of_deaths += 1;
+
+
+		this.last_life = this.alive_time;
+		if (this.number_of_deaths == 1)
+		{
+			this.shortest_life = this.last_life;
+			this.longest_life = this.last_life;
+		}
+		else if (this.last_life < this.shortest_life)
+		{
+			this.shortest_life = this.last_life;
+		}
+		else if (this.last_life > this.longest_life)
+		{
+			this.longest_life = this.last_life;
+		}
+	}
+
+	public void playerRespawned()
+	{
+		long temp_time = System.currentTimeMillis();
+
+		this.last_active = temp_time;
+		this.played_time += temp_time - this.last_update;
+
+		this.alive_time = 0L;
+		this.last_death = this.this_death;
+
+		this.last_update = temp_time;
+	}
+
+	public void updateUptime()
+	{
+		long temp_time = System.currentTimeMillis();
+		if (this.online)
+		{
+			this.last_active = temp_time;
+			this.played_time += temp_time - this.last_update;
+
+
+			this.alive_time += temp_time - this.last_update;
+
+
+			long current_day = temp_time / 86400000L;
+			current_day *= 86400000L;
+			if (current_day > this.player_lastday)
+			{
+				this.player_ondays += 1;
+				this.player_lastday = current_day;
+			}
+		}
+		this.last_update = temp_time;
+	}
+
+	public void resetUptime()
+	{
+		long temp_time = System.currentTimeMillis();
+
+		this.played_time = 0L;
+
+		this.player_lastday = temp_time;
+		this.player_ondays = 1;
+
+		this.this_death = temp_time;
+		this.last_death = temp_time;
+		this.alive_time = 0L;
+		this.number_of_deaths = 0;
+		this.last_life = 0L;
+		this.shortest_life = 0L;
+		this.longest_life = 0L;
+
+		this.online = true;
+		this.last_update = temp_time;
+	}
+}
diff --git a/src/Java/miscutil/core/util/uptime/Uptime.java b/src/Java/miscutil/core/util/uptime/Uptime.java
new file mode 100644
index 0000000000..bd853f5b67
--- /dev/null
+++ b/src/Java/miscutil/core/util/uptime/Uptime.java
@@ -0,0 +1,288 @@
+package miscutil.core.util.uptime;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.File;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import javax.swing.Timer;
+
+import miscutil.core.commands.CommandUptime;
+import net.minecraft.command.ICommandManager;
+import net.minecraft.command.ServerCommandManager;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.world.storage.WorldInfo;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingDeathEvent;
+
+import com.google.common.io.Files;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.event.FMLServerStartingEvent;
+import cpw.mods.fml.common.event.FMLServerStoppingEvent;
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.PlayerEvent;
+
+//@Mod(modid="Uptime.MODID", name="UptimeR2", version="2", acceptableRemoteVersions = "*")
+public class Uptime {
+	public static final String MODID = "UptimeR2";
+	private static MinecraftServer server;
+	//public static CommonProxy proxy;
+	private static Timer updater;
+	private static UptimeData uptime_data;
+	private static WorldInfo world_info;
+	private File uptime_file;
+	private File uptime_backup;
+	@Mod.Instance("Uptime")
+	public static Uptime instance;
+
+	public void preInit(FMLPreInitializationEvent event)
+	{
+		UptimeLog.log("INFO", "Conjumbobulating Time Synthesis.");
+		UptimeLog.initLogger();
+	}
+
+	
+	public void init(FMLInitializationEvent event)
+	{
+		MinecraftForge.EVENT_BUS.register(this);
+		FMLCommonHandler.instance().bus().register(this);
+
+	}
+
+	
+	public void serverStarting(FMLServerStartingEvent event)
+	{
+		uptime_data = null;
+
+
+		server = MinecraftServer.getServer();
+
+
+		world_info = server.worldServers[0].getWorldInfo();
+
+
+		File minecraft_folder = server.getFile("");
+		String world_folder = server.getFolderName();
+		String file_path = minecraft_folder + "/saves/" + world_folder;
+		if (!MinecraftServer.getServer().isSinglePlayer()) {
+			file_path = minecraft_folder + "/" + world_folder;
+		}
+		this.uptime_backup = new File(file_path + "/uptime.bk");
+		this.uptime_file = new File(file_path + "/uptime.txt");
+		if (this.uptime_backup.exists())
+		{
+			FMLLog.info("Uptime: Uptime has found a backup of the uptime file, trying to restore it.", new Object[0]);
+			try
+			{
+				this.uptime_file.delete();
+				this.uptime_file.createNewFile();
+
+				Files.copy(this.uptime_backup, this.uptime_file);
+
+				uptime_data = new UptimeData(this.uptime_file, false);
+
+				FMLLog.info("Uptime: Uptime restored the backup.", new Object[0]);
+			}
+			catch (IOException ioe)
+			{
+				FMLLog.warning("Uptime: Failed to restore backup of uptime file, uptime has been reset and the backup removed.", new Object[] { ioe });
+				this.uptime_backup.delete();
+				uptime_data = new UptimeData(this.uptime_file, true);
+			}
+			catch (NumberFormatException npe)
+			{
+				FMLLog.warning("Uptime: Backup file is corrupt, uptime has been reset and the backup removed.", new Object[0]);
+				this.uptime_backup.delete();
+				uptime_data = new UptimeData(this.uptime_file, true);
+			}
+		}
+		else if (this.uptime_file.exists())
+		{
+			FMLLog.info("Uptime: Found uptime file, restoring it.", new Object[0]);
+			if (this.uptime_file.length() > 1L)
+			{
+				try
+				{
+					uptime_data = new UptimeData(this.uptime_file, false);
+				}
+				catch (NumberFormatException npe)
+				{
+					FMLLog.warning("Uptime: Uptime file is corrupt, uptime has been reset.", new Object[0]);
+					uptime_data = new UptimeData(this.uptime_file, true);
+				}
+			}
+			else
+			{
+				FMLLog.warning("Uptime: Uptime file is empty, uptime has been reset.", new Object[0]);
+				uptime_data = new UptimeData(this.uptime_file, true);
+			}
+		}
+		else
+		{
+			FMLLog.info("Uptime: No uptime or backup found, creating a new one.", new Object[0]);
+
+
+			uptime_data = new UptimeData(this.uptime_file, true);
+		}
+		updater = new Timer(60000, (ActionListener) this);
+		updater.setRepeats(true);
+		updater.start();
+
+
+		ICommandManager command_manager = server.getCommandManager();
+		ServerCommandManager server_command_manager = (ServerCommandManager)command_manager;
+		server_command_manager.registerCommand(new CommandUptime());
+
+
+		saveUptime();
+	}
+
+	
+	public void serverStopping(FMLServerStoppingEvent event)
+	{
+		UptimeLog.log("INFO", "upTime is going to stop.");
+		if (updater.isRunning())
+		{
+			updater.stop();
+			UptimeLog.log("INFO", "Saving Time Stats.");
+			saveUptime();
+		}
+	}
+
+	public static void updateUptime()
+	{
+		uptime_data.updateUptime(world_info.getWorldTime());
+	}
+
+	public static UptimeData getUptimeData()
+	{
+		return uptime_data;
+	}
+
+	private void saveUptime()
+	{
+		updateUptime();
+
+		FMLLog.finer("Uptime: Uptime is currently saving its data.", new Object[0]);
+		try
+		{
+			this.uptime_backup.delete();
+			this.uptime_backup.createNewFile();
+			Files.copy(this.uptime_file, this.uptime_backup);
+
+
+			this.uptime_file.delete();
+			this.uptime_file.createNewFile();
+
+			uptime_data.saveUptime();
+
+
+			this.uptime_backup.delete();
+		}
+		catch (IOException ioe)
+		{
+			FMLLog.warning("Uptime: Failed while perpairing to save uptime file.", new Object[] { ioe });
+		}
+		FMLLog.finer("Uptime: Uptime has finished saving it's data.", new Object[0]);
+	}
+
+	@SubscribeEvent(priority=EventPriority.NORMAL, receiveCanceled=true)
+	public void onPlayerDeath(LivingDeathEvent lde)
+	{
+		if ((lde.entity instanceof EntityPlayerMP))
+		{
+			EntityPlayerMP player = (EntityPlayerMP)lde.entity;
+
+
+			uptime_data.playerDied(player.getCommandSenderName());
+
+			updateUptime();
+
+			PlayerUptimeData player_data = uptime_data.getPlayerUptimeData(player.getCommandSenderName());
+
+
+			player.addChatMessage(new ChatComponentText("You died on day " + uptime_data.getWorldDays() + "."));
+			player.addChatMessage(new ChatComponentText("This took you " + player_data.player_ondays + " real days."));
+
+			long remainder = player_data.last_life / 1000L;
+			int days = (int)remainder / 86400;
+			remainder %= 86400L;
+			int hours = (int)remainder / 3600;
+			remainder %= 3600L;
+			int minutes = (int)remainder / 60;
+			remainder %= 60L;
+			int seconds = (int)remainder;
+			player.addChatMessage(new ChatComponentText("In-game time taken: " + days + "d " + hours + "h " + minutes + "m " + seconds + "s."));
+			if (player_data.last_life <= 10000L) {
+				player.addChatMessage(new ChatComponentText("It takes someone very special to die that quickly."));
+			} else if (player_data.last_life <= 20000L) {
+				player.addChatMessage(new ChatComponentText("It could of been worse, you could of been the idiot that died in 10 seconds."));
+			} else if (player_data.last_life <= 30000L) {
+				player.addChatMessage(new ChatComponentText("Might I advise you learn how to run away and hide, and then just stay in there, and don't come out, you'll live longer that way."));
+			} else if (player_data.last_life <= 40000L) {
+				player.addChatMessage(new ChatComponentText("My grandma could survive longer in Minecraft that then."));
+			} else if (player_data.last_life <= 50000L) {
+				player.addChatMessage(new ChatComponentText("I would taunt you, but honestly, I think what just happened speaks for itself."));
+			} else if (player_data.last_life <= 60000L) {
+				player.addChatMessage(new ChatComponentText("Well, that didn't quite go to plan did it now, dust yourself off and try again."));
+			} else if (player_data.last_life <= 120000L) {
+				player.addChatMessage(new ChatComponentText("Ohhh, you was doing so well, right up to that point at the end there when you died."));
+			}
+			if (player_data.number_of_deaths == 1)
+			{
+				player.addChatMessage(new ChatComponentText("That was your first death."));
+			}
+			else
+			{
+				Date death_date = new Date(player_data.this_death);
+				player.addChatMessage(new ChatComponentText("That was death number " + player_data.number_of_deaths + ". You last died on the " + new SimpleDateFormat("d MMM yyyy 'at' HH:mm:ss z").format(death_date) + "."));
+				if (player_data.last_life == player_data.longest_life) {
+					player.addChatMessage(new ChatComponentText("That was your longest life, congratulations."));
+				} else if (player_data.last_life == player_data.shortest_life) {
+					player.addChatMessage(new ChatComponentText("That was your shortest life, really good job there."));
+				}
+			}
+			//Log Readable stats from dying players.
+			System.out.println(player.getDisplayName() + " has died.");
+			System.out.println("In-game time taken: " + days + "d " + hours + "h " + minutes + "m " + seconds + "s.");
+			System.out.println("This took " + player_data.player_ondays + " real days.");
+			System.out.println("That was death number " + player_data.number_of_deaths + ".");
+
+		}
+	}
+
+	public void actionPerformed(ActionEvent event)
+	{
+		if (event.getSource() == updater) {
+			saveUptime();
+		}
+	}
+
+	@SubscribeEvent(priority=EventPriority.NORMAL, receiveCanceled=true)
+	public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent event)
+	{
+		uptime_data.playerLoggedOn(event.player.getCommandSenderName());
+	}
+
+	@SubscribeEvent(priority=EventPriority.NORMAL, receiveCanceled=true)
+	public void onPlayerLogout(PlayerEvent.PlayerLoggedOutEvent event)
+	{
+		uptime_data.playerLoggedOff(event.player.getCommandSenderName());
+	}
+
+	@SubscribeEvent(priority=EventPriority.NORMAL, receiveCanceled=true)
+	public void onPlayerRespawn(PlayerEvent.PlayerRespawnEvent event)
+	{
+		uptime_data.playerRespawned(event.player.getCommandSenderName());
+	}
+}
diff --git a/src/Java/miscutil/core/util/uptime/UptimeData.java b/src/Java/miscutil/core/util/uptime/UptimeData.java
new file mode 100644
index 0000000000..b6a2f4f0d1
--- /dev/null
+++ b/src/Java/miscutil/core/util/uptime/UptimeData.java
@@ -0,0 +1,206 @@
+package miscutil.core.util.uptime;
+
+import cpw.mods.fml.common.FMLLog;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Properties;
+
+public class UptimeData
+{
+	private long last_update;
+	private long server_uptime;
+	private long server_lastday;
+	private int server_ondays;
+	private long last_world_time;
+	private int world_days;
+	private HashMap<String, PlayerUptimeData> player_data;
+	private File uptime_file;
+
+	public UptimeData(File uptime_file, boolean new_world)
+			throws NumberFormatException
+	{
+		this.uptime_file = uptime_file;
+		this.player_data = new HashMap<String, PlayerUptimeData>();
+		if (new_world)
+		{
+			FMLLog.info("Uptime: No uptime file, estimating uptime from worlds total time.", new Object[0]);
+			long temp_time = System.currentTimeMillis();
+
+			long world_total_time = net.minecraft.server.MinecraftServer.getServer().worldServers[0].getWorldInfo().getWorldTotalTime();
+			this.last_update = temp_time;
+			this.server_uptime = (world_total_time * 50L);
+			this.server_lastday = temp_time;
+			this.server_ondays = ((int)(this.server_uptime / 86400000L) + 1);
+			this.last_world_time = world_total_time;
+			this.world_days = ((int)(world_total_time / 24000L) + 1);
+			try
+			{
+				uptime_file.delete();
+				uptime_file.createNewFile();
+			}
+			catch (IOException ioe)
+			{
+				FMLLog.warning("Uptime: Failed to create uptime file.", new Object[] { ioe });
+			}
+		}
+		else
+		{
+			Properties properties = new Properties();
+			try
+			{
+				FileInputStream in = new FileInputStream(uptime_file);
+				properties.load(in);
+				this.last_update = System.currentTimeMillis();
+				this.server_uptime = Long.valueOf(properties.getProperty("server_uptime")).longValue();
+				this.server_lastday = Long.valueOf(properties.getProperty("server_lastday")).longValue();
+				this.server_ondays = Integer.valueOf(properties.getProperty("server_ondays")).intValue();
+				this.last_world_time = Long.valueOf(properties.getProperty("last_world_time")).longValue();
+				this.world_days = Integer.valueOf(properties.getProperty("world_days")).intValue();
+				int players = Integer.valueOf(properties.getProperty("players")).intValue();
+				for (int t = 0; t < players; t++)
+				{
+					String player = properties.getProperty("name_" + t);
+					PlayerUptimeData new_data = new PlayerUptimeData(t, properties);
+					this.player_data.put(player, new_data);
+				}
+			}
+			catch (IOException ioe)
+			{
+				FMLLog.warning("Uptime: Failed to read to the uptime file, estimating uptime from worlds total time.", new Object[] { ioe });
+				long temp_time = System.currentTimeMillis();
+
+				long world_total_time = net.minecraft.server.MinecraftServer.getServer().worldServers[0].getWorldInfo().getWorldTotalTime();
+				this.last_update = temp_time;
+				this.server_uptime = (world_total_time * 50L);
+				this.server_lastday = temp_time;
+				this.server_ondays = ((int)(this.server_uptime / 86400000L) + 1);
+				this.last_world_time = world_total_time;
+				this.world_days = ((int)(world_total_time / 24000L) + 1);
+			}
+		}
+	}
+
+	public void saveUptime()
+	{
+		try
+		{
+			Properties properties = new Properties();
+			properties.setProperty("server_uptime", String.valueOf(this.server_uptime));
+			properties.setProperty("server_lastday", String.valueOf(this.server_lastday));
+			properties.setProperty("server_ondays", String.valueOf(this.server_ondays));
+			properties.setProperty("last_world_time", String.valueOf(this.last_world_time));
+			properties.setProperty("world_days", String.valueOf(this.world_days));
+			properties.setProperty("players", String.valueOf(this.player_data.size()));
+
+
+			int player_number = 0;
+			for (String player : this.player_data.keySet())
+			{
+				properties.setProperty("name_" + player_number, player);
+				((PlayerUptimeData)this.player_data.get(player)).savePlayerUptimeData(player_number, properties);
+				player_number++;
+			}
+			FileOutputStream out = new FileOutputStream(this.uptime_file);
+			properties.store(out, "Server Uptime");
+		}
+		catch (IOException ioe)
+		{
+			FMLLog.warning("Uptime: Failed to write to the uptime file.", new Object[] { ioe });
+		}
+	}
+
+	public void updateUptime(long current_world_time)
+	{
+		long temp_time = System.currentTimeMillis();
+		if (this.last_world_time / 24000L < current_world_time / 24000L)
+		{
+			this.world_days += 1;
+		}
+		else if (this.last_world_time > current_world_time)
+		{
+			this.world_days += 1;
+			FMLLog.info("Uptime: World time has gone backwards, assuming /time set was used and increasing world day.", new Object[0]);
+		}
+		this.last_world_time = current_world_time;
+
+
+		this.server_uptime += temp_time - this.last_update;
+
+
+		long current_day = temp_time / 86400000L;
+		current_day *= 86400000L;
+		if (current_day > this.server_lastday)
+		{
+			this.server_ondays += 1;
+			this.server_lastday = current_day;
+		}
+		for (PlayerUptimeData player : this.player_data.values()) {
+			player.updateUptime();
+		}
+		this.last_update = temp_time;
+	}
+
+	public long getServerUptime()
+	{
+		return this.server_uptime;
+	}
+
+	public int getServerOndays()
+	{
+		return this.server_ondays;
+	}
+
+	public int getWorldDays()
+	{
+		return this.world_days;
+	}
+
+	public void playerLoggedOn(String username)
+	{
+		if (this.player_data.get(username) == null) {
+			this.player_data.put(username, new PlayerUptimeData());
+		} else {
+			((PlayerUptimeData)this.player_data.get(username)).playerLoggedOn();
+		}
+	}
+
+	public void playerLoggedOff(String username)
+	{
+		if (this.player_data.get(username) != null) {
+			((PlayerUptimeData)this.player_data.get(username)).playerLoggedOff();
+		}
+	}
+
+	public void playerDied(String username)
+	{
+		if (this.player_data.get(username) != null) {
+			((PlayerUptimeData)this.player_data.get(username)).playerDied();
+		}
+	}
+
+	public void playerRespawned(String username)
+	{
+		if (this.player_data.get(username) != null) {
+			((PlayerUptimeData)this.player_data.get(username)).playerRespawned();
+		}
+	}
+
+	public PlayerUptimeData getPlayerUptimeData(String username)
+	{
+		if (this.player_data.get(username) != null) {
+			return (PlayerUptimeData)this.player_data.get(username);
+		}
+		return null;
+	}
+
+	public void resetUptime()
+	{
+		for (PlayerUptimeData player : this.player_data.values()) {
+			player.resetUptime();
+		}
+	}
+}
diff --git a/src/Java/miscutil/core/util/uptime/UptimeLog.java b/src/Java/miscutil/core/util/uptime/UptimeLog.java
new file mode 100644
index 0000000000..902bf38672
--- /dev/null
+++ b/src/Java/miscutil/core/util/uptime/UptimeLog.java
@@ -0,0 +1,38 @@
+package miscutil.core.util.uptime;
+
+import java.util.logging.Level;
+
+
+import java.util.logging.Logger;
+
+import cpw.mods.fml.common.FMLLog;
+
+public class UptimeLog {
+	
+	//UptimeLog.log("INFO", "text");
+	//(ALL, CONFIG, FINE, FINER, FINEST, INFO, OFF, SEVERE and WARNING)
+	
+	private static Logger logger = Logger.getLogger(Uptime.MODID);
+	
+	public static void initLogger() {
+		logger.setParent((Logger) FMLLog.getLogger());
+	}
+
+	public static void log(String logLevel, String message) {
+		Level logNotif;
+		if (logLevel.equals("INFO")){
+			logNotif = Level.INFO;
+		}
+		else if (logLevel.equals("WARNING")){
+			logNotif = Level.WARNING;
+		}
+		else if (logLevel.equals("SEVERE")){
+			logNotif = Level.SEVERE;
+		}
+		else {
+			logNotif = Level.CONFIG;
+		}
+		logger.log(logNotif, message);
+	}
+	
+}