Saber-Factions/src/org/mcteam/factions/FPlayer.java

570 lines
14 KiB
Java
Raw Normal View History

2011-04-08 15:51:07 +02:00
package org.mcteam.factions;
2011-02-06 13:36:11 +01:00
import java.io.*;
2011-03-18 17:33:23 +01:00
import java.lang.reflect.Type;
2011-02-06 13:36:11 +01:00
import java.util.*;
import java.util.logging.Level;
2011-03-18 17:33:23 +01:00
import java.util.Map.Entry;
2011-02-06 13:36:11 +01:00
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
2011-04-08 15:51:07 +02:00
import org.mcteam.factions.gson.reflect.TypeToken;
import org.mcteam.factions.struct.Relation;
import org.mcteam.factions.struct.Role;
import org.mcteam.factions.util.DiscUtil;
2011-02-06 13:36:11 +01:00
/**
* Logged in players always have exactly one FPlayer instance.
* Logged out players may or may not have an FPlayer instance. They will always have one if they are part of a faction.
* This is because only players with a faction are saved to disk (in order to not waste disk space).
*
2011-03-23 12:00:38 +01:00
* The FPlayer is linked to a minecraft player using the player name.
*
* The same instance is always returned for the same player.
* This means you can use the == operator. No .equals method necessary.
*/
2011-03-18 17:33:23 +01:00
public class FPlayer {
2011-03-22 17:20:21 +01:00
// -------------------------------------------- //
// Fields
// -------------------------------------------- //
2011-03-23 12:00:38 +01:00
private static transient TreeMap<String, FPlayer> instances = new TreeMap<String, FPlayer>(String.CASE_INSENSITIVE_ORDER);
2011-03-22 17:20:21 +01:00
private static transient File file = new File(Factions.instance.getDataFolder(), "players.json");
2011-02-06 13:36:11 +01:00
2011-03-22 17:20:21 +01:00
private transient String playerName;
private transient FLocation lastStoodAt = new FLocation(); // Where did this player stand the last time we checked?
private int factionId;
private Role role;
2011-02-06 13:36:11 +01:00
private String title;
private double power;
private long lastPowerUpdateTime;
2011-03-22 20:36:33 +01:00
private long lastLoginTime;
private transient boolean mapAutoUpdating;
private boolean factionChatting;
2011-02-06 13:36:11 +01:00
2011-03-22 17:20:21 +01:00
// -------------------------------------------- //
// Construct
// -------------------------------------------- //
2011-03-18 17:33:23 +01:00
// GSON need this noarg constructor.
public FPlayer() {
2011-03-19 13:00:03 +01:00
this.resetFactionData();
this.power = this.getPowerMax();
this.lastPowerUpdateTime = System.currentTimeMillis();
2011-03-22 20:36:33 +01:00
this.lastLoginTime = System.currentTimeMillis();
2011-03-19 13:00:03 +01:00
this.mapAutoUpdating = false;
}
public void resetFactionData() {
this.factionId = 0; // The default neutral faction
this.factionChatting = false;
this.role = Role.NORMAL;
this.title = "";
2011-03-18 17:33:23 +01:00
}
2011-03-22 17:20:21 +01:00
// -------------------------------------------- //
// Minecraft Player
// -------------------------------------------- //
2011-03-18 17:33:23 +01:00
public Player getPlayer() {
return Factions.instance.getServer().getPlayer(playerName);
2011-03-18 17:33:23 +01:00
}
public String getPlayerName() {
return this.playerName;
2011-03-18 17:33:23 +01:00
}
public boolean isOnline() {
return Factions.instance.getServer().getPlayer(playerName) != null;
2011-03-18 17:33:23 +01:00
}
public boolean isOffline() {
return ! isOnline();
}
2011-03-22 17:20:21 +01:00
// -------------------------------------------- //
// Getters And Setters
// -------------------------------------------- //
public Faction getFaction() {
return Faction.get(factionId);
}
2011-03-22 19:25:11 +01:00
private int getFactionId() {
return factionId;
}
2011-03-22 17:20:21 +01:00
public void setFaction(Faction faction) {
this.factionId = faction.getId();
}
public boolean hasFaction() {
return factionId != 0;
}
public Role getRole() {
return this.role;
}
public void setRole(Role role) {
this.role = role;
}
public boolean isFactionChatting() {
if (this.factionId == 0) {
return false;
}
return factionChatting;
}
public void setFactionChatting(boolean factionChatting) {
this.factionChatting = factionChatting;
}
2011-02-06 13:36:11 +01:00
2011-03-22 20:36:33 +01:00
public long getLastLoginTime() {
return lastLoginTime;
}
public void setLastLoginTime(long lastLoginTime) {
this.lastLoginTime = lastLoginTime;
this.lastPowerUpdateTime = lastLoginTime;
2011-03-22 20:36:33 +01:00
}
2011-02-06 13:36:11 +01:00
public boolean isMapAutoUpdating() {
return mapAutoUpdating;
}
public void setMapAutoUpdating(boolean mapAutoUpdating) {
this.mapAutoUpdating = mapAutoUpdating;
}
2011-03-22 17:20:21 +01:00
public FLocation getLastStoodAt() {
return this.lastStoodAt;
}
public void setLastStoodAt(FLocation flocation) {
this.lastStoodAt = flocation;
}
//----------------------------------------------//
// Title, Name, Faction Tag and Chat
//----------------------------------------------//
// Base:
2011-02-06 13:36:11 +01:00
public String getTitle() {
2011-03-22 19:25:11 +01:00
return this.title;
2011-02-06 13:36:11 +01:00
}
public void setTitle(String title) {
this.title = title;
}
public String getName() {
return this.playerName;
}
public String getTag() {
2011-03-19 13:00:03 +01:00
if ( ! this.hasFaction()) {
return "";
}
return this.getFaction().getTag();
}
// Base concatenations:
public String getNameAndSomething(String something) {
String ret = this.role.getPrefix();
if (something.length() > 0) {
ret += something+" ";
}
ret += this.getName();
return ret;
}
public String getNameAndTitle() {
return this.getNameAndSomething(this.getTitle());
}
public String getNameAndTag() {
return this.getNameAndSomething(this.getTag());
}
// Colored concatenations:
// These are used in information messages
public String getNameAndTitle(Faction faction) {
return this.getRelationColor(faction)+this.getNameAndTitle();
}
2011-03-23 12:00:38 +01:00
public String getNameAndTitle(FPlayer fplayer) {
return this.getRelationColor(fplayer)+this.getNameAndTitle();
}
public String getNameAndTag(Faction faction) {
return this.getRelationColor(faction)+this.getNameAndTag();
}
2011-03-23 12:00:38 +01:00
public String getNameAndTag(FPlayer fplayer) {
return this.getRelationColor(fplayer)+this.getNameAndTag();
}
public String getNameAndRelevant(Faction faction) {
// Which relation?
Relation rel = this.getRelation(faction);
// For member we show title
if (rel == Relation.MEMBER) {
return rel.getColor() + this.getNameAndTitle();
}
// For non members we show tag
return rel.getColor() + this.getNameAndTag();
}
2011-03-23 12:00:38 +01:00
public String getNameAndRelevant(FPlayer fplayer) {
return getNameAndRelevant(fplayer.getFaction());
}
// Chat Tag:
// These are injected into the format of global chat messages.
public String getChatTag() {
2011-03-19 13:00:03 +01:00
if ( ! this.hasFaction()) {
return "";
}
return String.format(Conf.chatTagFormat, this.role.getPrefix()+this.getTag());
}
// Colored Chat Tag
public String getChatTag(Faction faction) {
2011-03-19 13:00:03 +01:00
if ( ! this.hasFaction()) {
return "";
}
return this.getRelation(faction).getColor()+getChatTag();
}
2011-03-23 12:00:38 +01:00
public String getChatTag(FPlayer fplayer) {
2011-03-19 13:00:03 +01:00
if ( ! this.hasFaction()) {
return "";
}
2011-03-23 12:00:38 +01:00
return this.getRelation(fplayer).getColor()+getChatTag();
}
// -------------------------------
// Relation and relation colors
// -------------------------------
public Relation getRelation(Faction faction) {
return faction.getRelation(this);
}
2011-03-23 12:00:38 +01:00
public Relation getRelation(FPlayer fplayer) {
return this.getFaction().getRelation(fplayer);
}
public ChatColor getRelationColor(Faction faction) {
return faction.getRelationColor(this);
}
2011-03-23 12:00:38 +01:00
public ChatColor getRelationColor(FPlayer fplayer) {
return this.getRelation(fplayer).getColor();
}
2011-02-06 13:36:11 +01:00
//----------------------------------------------//
// Health
//----------------------------------------------//
public void heal(int amnt) {
Player player = this.getPlayer();
if (player == null) {
return;
}
player.setHealth(player.getHealth() + amnt);
}
//----------------------------------------------//
// Power
//----------------------------------------------//
public double getPower() {
this.updatePower();
return this.power;
}
protected void alterPower(double delta) {
this.power += delta;
if (this.power > this.getPowerMax()) {
this.power = this.getPowerMax();
} else if (this.power < this.getPowerMin()) {
this.power = this.getPowerMin();
}
//Log.debug("Power of "+this.getName()+" is now: "+this.power);
2011-02-06 13:36:11 +01:00
}
public double getPowerMax() {
return Conf.powerPlayerMax;
2011-02-06 13:36:11 +01:00
}
public double getPowerMin() {
return Conf.powerPlayerMin;
2011-02-06 13:36:11 +01:00
}
public int getPowerRounded() {
return (int) Math.round(this.getPower());
}
public int getPowerMaxRounded() {
return (int) Math.round(this.getPowerMax());
}
public int getPowerMinRounded() {
return (int) Math.round(this.getPowerMin());
}
protected void updatePower() {
if (this.isOffline() && !Conf.powerRegenOffline) {
return;
}
2011-02-06 13:36:11 +01:00
long now = System.currentTimeMillis();
long millisPassed = now - this.lastPowerUpdateTime;
this.lastPowerUpdateTime = now;
int millisPerMinute = 60*1000;
this.alterPower(millisPassed * Conf.powerPerMinute / millisPerMinute);
}
public void onDeath() {
this.updatePower();
this.alterPower(-Conf.powerPerDeath);
}
//----------------------------------------------//
// Territory
//----------------------------------------------//
public boolean isInOwnTerritory() {
2011-03-22 17:20:21 +01:00
return Board.getFactionAt(new FLocation(this)) == this.getFaction();
2011-02-06 13:36:11 +01:00
}
public boolean isInOthersTerritory() {
2011-03-19 13:00:03 +01:00
int idHere = Board.getIdAt(new FLocation(this));
return idHere != 0 && idHere != this.factionId;
2011-02-06 13:36:11 +01:00
}
public void sendFactionHereMessage() {
2011-03-19 13:00:03 +01:00
Faction factionHere = Board.getFactionAt(new FLocation(this));
String msg = Conf.colorSystem+" ~ "+factionHere.getTag(this);
2011-03-23 17:39:56 +01:00
if (factionHere.getDescription().length() > 0) {
msg += " - "+factionHere.getDescription();
}
2011-02-06 13:36:11 +01:00
this.sendMessage(msg);
}
2011-03-22 20:36:33 +01:00
// -------------------------------
// Actions
// -------------------------------
public void leave() {
Faction myFaction = this.getFaction();
if (this.getRole() == Role.ADMIN && myFaction.getFPlayers().size() > 1) {
sendMessage("You must give the admin role to someone else first.");
return;
}
if (!Conf.CanLeaveWithNegativePower && this.getPower() < 0) {
sendMessage("You cannot leave until your power is positive.");
return;
}
if (myFaction.isNormal()) {
myFaction.sendMessage(this.getNameAndRelevant(myFaction) + Conf.colorSystem + " left your faction.");
}
2011-03-22 20:36:33 +01:00
this.resetFactionData();
if (myFaction.isNormal() && myFaction.getFPlayers().size() == 0) {
2011-03-22 20:36:33 +01:00
// Remove this faction
for (FPlayer fplayer : FPlayer.getAllOnline()) {
fplayer.sendMessage("The faction "+myFaction.getTag(fplayer)+Conf.colorSystem+" was disbanded.");
}
Faction.delete(myFaction.getId());
}
}
2011-03-22 17:20:21 +01:00
// -------------------------------------------- //
// Messages
// -------------------------------------------- //
public void sendMessage(String message) {
if (this.getPlayer() != null)
this.getPlayer().sendMessage(Conf.colorSystem + message);
2011-02-06 13:36:11 +01:00
}
2011-03-22 17:20:21 +01:00
public void sendMessage(List<String> messages) {
for(String message : messages) {
this.sendMessage(message);
}
}
2011-03-22 17:20:21 +01:00
2011-03-18 17:33:23 +01:00
// -------------------------------------------- //
2011-03-19 13:00:03 +01:00
// Get and search
2011-03-18 17:33:23 +01:00
// -------------------------------------------- //
2011-03-23 12:00:38 +01:00
// You should use this one to be sure you do not spell the player name wrong.
public static FPlayer get(Player player) {
return get(player.getName());
}
private static FPlayer get(String playerName) {
if (instances.containsKey(playerName)) {
return instances.get(playerName);
2011-03-18 17:33:23 +01:00
}
2011-03-22 19:25:11 +01:00
FPlayer vplayer = new FPlayer();
vplayer.playerName = playerName;
instances.put(playerName, vplayer);
2011-03-18 17:33:23 +01:00
return vplayer;
}
2011-03-19 13:00:03 +01:00
public static Set<FPlayer> getAllOnline() {
Set<FPlayer> fplayers = new HashSet<FPlayer>();
for (Player player : Factions.instance.getServer().getOnlinePlayers()) {
fplayers.add(FPlayer.get(player));
}
return fplayers;
}
public static Collection<FPlayer> getAll() {
return instances.values();
}
public static FPlayer find(String playername) {
for (Entry<String, FPlayer> entry : instances.entrySet()) {
if (entry.getKey().equalsIgnoreCase(playername)) {
return entry.getValue();
}
}
return null;
}
2011-03-18 17:33:23 +01:00
// -------------------------------------------- //
// Persistance
// -------------------------------------------- //
public boolean shouldBeSaved() {
return this.factionId != 0;
}
public static boolean save() {
2011-03-22 22:31:04 +01:00
//Factions.log("Saving players to disk");
2011-03-18 17:33:23 +01:00
2011-03-23 12:00:38 +01:00
// We only wan't to save the players with non default values
Map<String, FPlayer> playersToSave = new HashMap<String, FPlayer>();
2011-03-18 17:33:23 +01:00
for (Entry<String, FPlayer> entry : instances.entrySet()) {
if (entry.getValue().shouldBeSaved()) {
2011-03-23 12:00:38 +01:00
playersToSave.put(entry.getKey(), entry.getValue());
2011-03-18 17:33:23 +01:00
}
}
try {
2011-03-23 12:00:38 +01:00
DiscUtil.write(file, Factions.gson.toJson(playersToSave));
} catch (Exception e) {
2011-03-18 17:33:23 +01:00
e.printStackTrace();
Factions.log("Failed to save the players to disk.");
2011-03-18 17:33:23 +01:00
return false;
}
return true;
}
public static boolean load() {
2011-03-23 12:00:38 +01:00
Factions.log("Loading players from disk");
2011-03-18 17:33:23 +01:00
if ( ! file.exists()) {
if ( ! loadOld())
Factions.log("No players to load from disk. Creating new file.");
2011-03-18 17:33:23 +01:00
save();
return true;
}
try {
Type type = new TypeToken<Map<String, FPlayer>>(){}.getType();
Map<String, FPlayer> instancesFromFile = Factions.gson.fromJson(DiscUtil.read(file), type);
2011-03-23 12:00:38 +01:00
instances.clear();
instances.putAll(instancesFromFile);
} catch (Exception e) {
2011-03-18 17:33:23 +01:00
e.printStackTrace();
Factions.log("Failed to load the players from disk.");
2011-03-18 17:33:23 +01:00
return false;
}
fillPlayernames();
return true;
}
public static void fillPlayernames() {
for(Entry<String, FPlayer> entry : instances.entrySet()) {
entry.getValue().playerName = entry.getKey();
2011-03-18 17:33:23 +01:00
}
}
2011-03-22 19:25:11 +01:00
public static void clean() {
for (FPlayer fplayer : instances.values()) {
if ( ! Faction.exists(fplayer.getFactionId())) {
Factions.log("Reset faction data (invalid faction) for player "+fplayer.getName());
fplayer.resetFactionData();
}
}
2011-03-22 20:36:33 +01:00
}
public static void autoLeaveOnInactivityRoutine() {
long now = System.currentTimeMillis();
2011-03-23 17:39:56 +01:00
double toleranceMillis = Conf.autoLeaveAfterDaysOfInactivity * 24 * 60 * 60 * 1000;
2011-03-22 20:36:33 +01:00
for (FPlayer fplayer : FPlayer.getAll()) {
if (now - fplayer.getLastLoginTime() > toleranceMillis) {
fplayer.leave();
}
}
}
private static boolean loadOld() {
File folderFollower = new File(Factions.instance.getDataFolder(), "follower");
if ( ! folderFollower.isDirectory())
return false;
Factions.log("Players file doesn't exist, attempting to load old pre-1.1 data.");
String ext = ".json";
class jsonFileFilter implements FileFilter {
@Override
public boolean accept(File file) {
return (file.getName().toLowerCase().endsWith(".json") && file.isFile());
}
}
File[] jsonFiles = folderFollower.listFiles(new jsonFileFilter());
for (File jsonFile : jsonFiles) {
// Extract the name from the filename. The name is filename minus ".json"
String name = jsonFile.getName();
name = name.substring(0, name.length() - ext.length());
try {
FPlayer follower = Factions.gson.fromJson(DiscUtil.read(jsonFile), FPlayer.class);
follower.playerName = name;
follower.lastLoginTime = System.currentTimeMillis();
instances.put(follower.playerName, follower);
Factions.log("loaded pre-1.1 follower "+name);
} catch (Exception e) {
e.printStackTrace();
Factions.log(Level.WARNING, "failed to load follower "+name);
}
}
return true;
}
2011-02-06 13:36:11 +01:00
}