2014-09-17 13:17:33 +02:00
|
|
|
package com.massivecraft.factions.entity;
|
|
|
|
|
2014-10-13 11:42:40 +02:00
|
|
|
import java.util.Collection;
|
2014-09-17 13:17:33 +02:00
|
|
|
import java.util.HashSet;
|
2014-10-13 11:42:40 +02:00
|
|
|
import java.util.Iterator;
|
|
|
|
import java.util.Map.Entry;
|
2014-09-17 13:17:33 +02:00
|
|
|
import java.util.Set;
|
|
|
|
|
|
|
|
import org.bukkit.ChatColor;
|
|
|
|
import org.bukkit.entity.Player;
|
|
|
|
|
|
|
|
import com.massivecraft.factions.EconomyParticipator;
|
|
|
|
import com.massivecraft.factions.Factions;
|
|
|
|
import com.massivecraft.factions.Lang;
|
|
|
|
import com.massivecraft.factions.Perm;
|
|
|
|
import com.massivecraft.factions.Rel;
|
|
|
|
import com.massivecraft.factions.RelationParticipator;
|
2014-10-13 11:42:40 +02:00
|
|
|
import com.massivecraft.factions.event.EventFactionsChunkChangeType;
|
|
|
|
import com.massivecraft.factions.event.EventFactionsChunksChange;
|
2014-10-21 07:48:42 +02:00
|
|
|
import com.massivecraft.factions.event.EventFactionsDisband;
|
2014-09-17 13:17:33 +02:00
|
|
|
import com.massivecraft.factions.event.EventFactionsMembershipChange;
|
2014-10-06 13:08:34 +02:00
|
|
|
import com.massivecraft.factions.event.EventFactionsRemovePlayerMillis;
|
2014-09-17 13:17:33 +02:00
|
|
|
import com.massivecraft.factions.event.EventFactionsMembershipChange.MembershipChangeReason;
|
|
|
|
import com.massivecraft.factions.util.RelationUtil;
|
|
|
|
import com.massivecraft.massivecore.mixin.Mixin;
|
|
|
|
import com.massivecraft.massivecore.ps.PS;
|
|
|
|
import com.massivecraft.massivecore.ps.PSFormatHumanSpace;
|
|
|
|
import com.massivecraft.massivecore.store.SenderEntity;
|
|
|
|
import com.massivecraft.massivecore.util.IdUtil;
|
|
|
|
import com.massivecraft.massivecore.util.MUtil;
|
|
|
|
import com.massivecraft.massivecore.util.Txt;
|
|
|
|
|
|
|
|
|
|
|
|
public class MPlayer extends SenderEntity<MPlayer> implements EconomyParticipator
|
|
|
|
{
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// META
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public static MPlayer get(Object oid)
|
|
|
|
{
|
|
|
|
return MPlayerColl.get().get(oid);
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// OVERRIDE: ENTITY
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public MPlayer load(MPlayer that)
|
|
|
|
{
|
2014-10-06 13:08:34 +02:00
|
|
|
this.setLastActivityMillis(that.lastActivityMillis);
|
2014-09-17 13:17:33 +02:00
|
|
|
this.setFactionId(that.factionId);
|
|
|
|
this.setRole(that.role);
|
|
|
|
this.setTitle(that.title);
|
|
|
|
this.setPowerBoost(that.powerBoost);
|
|
|
|
this.setPower(that.power);
|
|
|
|
this.setMapAutoUpdating(that.mapAutoUpdating);
|
|
|
|
this.setUsingAdminMode(that.usingAdminMode);
|
|
|
|
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean isDefault()
|
|
|
|
{
|
2014-10-06 13:08:34 +02:00
|
|
|
// Last activity millis is data we use for clearing out inactive players. So it does not in itself make the player data worth keeping.
|
2014-09-17 13:17:33 +02:00
|
|
|
if (this.hasFaction()) return false;
|
|
|
|
// Role means nothing without a faction.
|
|
|
|
// Title means nothing without a faction.
|
2014-10-06 13:08:34 +02:00
|
|
|
if (this.hasPowerBoost()) return false;
|
2014-09-17 13:17:33 +02:00
|
|
|
if (this.getPowerRounded() != (int) Math.round(MConf.get().defaultPlayerPower)) return false;
|
2014-10-06 13:08:34 +02:00
|
|
|
// if (this.isMapAutoUpdating()) return false; // Just having an auto updating map is not in itself reason enough for database storage.
|
2014-09-17 13:17:33 +02:00
|
|
|
if (this.isUsingAdminMode()) return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void postAttach(String id)
|
|
|
|
{
|
|
|
|
// If inited ...
|
|
|
|
if (!Factions.get().isDatabaseInitialized()) return;
|
|
|
|
|
|
|
|
// ... update the index.
|
|
|
|
Faction faction = this.getFaction();
|
2014-09-17 13:29:58 +02:00
|
|
|
faction.mplayers.add(this);
|
2014-09-17 13:17:33 +02:00
|
|
|
|
|
|
|
//Factions.get().log(Txt.parse("<g>postAttach added <h>%s <i>aka <h>%s <i>to <h>%s <i>aka <h>%s<i>.", id, Mixin.getDisplayName(id), faction.getId(), faction.getName()));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void preDetach(String id)
|
|
|
|
{
|
|
|
|
// If inited ...
|
|
|
|
if (!Factions.get().isDatabaseInitialized()) return;
|
|
|
|
|
|
|
|
// ... update the index.
|
|
|
|
Faction faction = this.getFaction();
|
2014-09-17 13:29:58 +02:00
|
|
|
faction.mplayers.remove(this);
|
2014-09-17 13:17:33 +02:00
|
|
|
|
|
|
|
//Factions.get().log(Txt.parse("<b>preDetach removed <h>%s <i>aka <h>%s <i>to <h>%s <i>aka <h>%s<i>.", id, Mixin.getDisplayName(id), faction.getId(), faction.getName()));
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELDS: RAW
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// In this section of the source code we place the field declarations only.
|
|
|
|
// Each field has it's own section further down since just the getter and setter logic takes up quite some place.
|
|
|
|
|
2014-10-06 13:08:34 +02:00
|
|
|
// The last known time of explicit player activity, such as login or logout.
|
|
|
|
// Null means "unknown" (as opposed to "never played on the server").
|
|
|
|
// The player might have been active very recently but we could lack that data.
|
|
|
|
// The reason being this data field was added in a version upgrade and has not been around for forever.
|
|
|
|
private Long lastActivityMillis = null;
|
|
|
|
|
2014-09-17 13:17:33 +02:00
|
|
|
// This is a foreign key.
|
|
|
|
// Each player belong to a faction.
|
2014-09-17 13:33:09 +02:00
|
|
|
// Null means default.
|
2014-09-17 13:17:33 +02:00
|
|
|
private String factionId = null;
|
|
|
|
|
|
|
|
// What role does the player have in the faction?
|
2014-09-17 13:33:09 +02:00
|
|
|
// Null means default.
|
2014-09-17 13:17:33 +02:00
|
|
|
private Rel role = null;
|
|
|
|
|
|
|
|
// What title does the player have in the faction?
|
|
|
|
// The title is just for fun. It's not connected to any game mechanic.
|
|
|
|
// The player title is similar to the faction description.
|
|
|
|
//
|
|
|
|
// Question: Can the title contain chat colors?
|
|
|
|
// Answer: Yes but in such case the policy is that they already must be parsed using Txt.parse.
|
|
|
|
// If the title contains raw markup, such as "<white>" instead of "§f" it will not be parsed and "<white>" will be displayed.
|
|
|
|
//
|
|
|
|
// Null means the player has no title.
|
|
|
|
private String title = null;
|
|
|
|
|
|
|
|
// Player usually do not have a powerboost. It defaults to 0.
|
|
|
|
// The powerBoost is a custom increase/decrease to default and maximum power.
|
|
|
|
// Note that player powerBoost and faction powerBoost are very similar.
|
|
|
|
private Double powerBoost = null;
|
|
|
|
|
|
|
|
// Each player has an individual power level.
|
|
|
|
// The power level for online players is occasionally updated by a recurring task and the power should stay the same for offline players.
|
|
|
|
// For that reason the value is to be considered correct when you pick it. Do not call the power update method.
|
2014-09-17 13:33:09 +02:00
|
|
|
// Null means default.
|
2014-09-17 13:17:33 +02:00
|
|
|
private Double power = null;
|
|
|
|
|
|
|
|
// Has this player requested an auto-updating ascii art map?
|
|
|
|
// Null means false
|
|
|
|
private Boolean mapAutoUpdating = null;
|
|
|
|
|
|
|
|
// Is this player using admin mode?
|
|
|
|
// Null means false
|
|
|
|
private Boolean usingAdminMode = null;
|
|
|
|
|
2014-09-17 13:29:58 +02:00
|
|
|
// The id for the faction this player is currently autoclaiming for.
|
2014-09-17 13:17:33 +02:00
|
|
|
// Null means the player isn't auto claiming.
|
2014-10-08 06:38:26 +02:00
|
|
|
// NOTE: This field will not be saved to the database ever.
|
2014-09-17 13:17:33 +02:00
|
|
|
private transient Faction autoClaimFaction = null;
|
|
|
|
public Faction getAutoClaimFaction() { return this.autoClaimFaction; }
|
|
|
|
public void setAutoClaimFaction(Faction autoClaimFaction) { this.autoClaimFaction = autoClaimFaction; }
|
|
|
|
|
2014-10-08 06:38:26 +02:00
|
|
|
// Does the player have /f seechunk activated?
|
|
|
|
// NOTE: This field will not be saved to the database ever.
|
|
|
|
private transient boolean seeingChunk = false;
|
|
|
|
public boolean isSeeingChunk() { return this.seeingChunk; }
|
|
|
|
public void setSeeingChunk(boolean seeingChunk) { this.seeingChunk = seeingChunk; }
|
|
|
|
|
2014-09-17 13:17:33 +02:00
|
|
|
// -------------------------------------------- //
|
|
|
|
// CORE UTILITIES
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public void resetFactionData()
|
|
|
|
{
|
|
|
|
// The default neutral faction
|
|
|
|
this.setFactionId(null);
|
|
|
|
this.setRole(null);
|
|
|
|
this.setTitle(null);
|
|
|
|
this.setAutoClaimFaction(null);
|
|
|
|
}
|
|
|
|
|
2014-10-06 13:08:34 +02:00
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELD: lastActivityMillis
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
// Raw: Using only what we have stored
|
|
|
|
|
|
|
|
public Long getLastActivityMillisRaw()
|
|
|
|
{
|
|
|
|
return this.lastActivityMillis;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setLastActivityMillis(Long lastActivityMillis)
|
|
|
|
{
|
|
|
|
// Clean input
|
|
|
|
Long target = lastActivityMillis;
|
|
|
|
|
|
|
|
// Detect Nochange
|
|
|
|
if (MUtil.equals(this.lastActivityMillis, target)) return;
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
this.lastActivityMillis = target;
|
|
|
|
|
|
|
|
// Mark as changed
|
|
|
|
this.changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setLastActivityMillis()
|
|
|
|
{
|
|
|
|
this.setLastActivityMillis(System.currentTimeMillis());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finer: Using our raw data but also underlying system as fallback
|
|
|
|
|
|
|
|
public Long getLastActivityMillis()
|
|
|
|
{
|
|
|
|
Long ret = this.getLastActivityMillisRaw();
|
|
|
|
if (ret != null) return ret;
|
|
|
|
return Mixin.getLastPlayed(this);
|
|
|
|
}
|
|
|
|
|
2014-09-17 13:17:33 +02:00
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELD: factionId
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public String getDefaultFactionId()
|
|
|
|
{
|
|
|
|
return MConf.get().defaultPlayerFactionId;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This method never returns null
|
|
|
|
public String getFactionId()
|
|
|
|
{
|
|
|
|
if (this.factionId == null) return this.getDefaultFactionId();
|
|
|
|
return this.factionId;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This method never returns null
|
|
|
|
public Faction getFaction()
|
|
|
|
{
|
|
|
|
Faction ret = Faction.get(this.getFactionId());
|
|
|
|
if (ret == null) ret = Faction.get(MConf.get().defaultPlayerFactionId);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean hasFaction()
|
|
|
|
{
|
2014-10-01 22:00:08 +02:00
|
|
|
return !this.getFactionId().equals(Factions.ID_NONE);
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// This setter is so long because it search for default/null case and takes care of updating the faction member index
|
|
|
|
public void setFactionId(String factionId)
|
|
|
|
{
|
|
|
|
// Clean input
|
|
|
|
String target = factionId;
|
|
|
|
|
|
|
|
// Detect Nochange
|
|
|
|
if (MUtil.equals(this.factionId, target)) return;
|
|
|
|
|
|
|
|
// Get the raw old value
|
|
|
|
String oldFactionId = this.factionId;
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
this.factionId = target;
|
|
|
|
|
|
|
|
// Must be attached and initialized
|
|
|
|
if (!this.attached()) return;
|
|
|
|
if (!Factions.get().isDatabaseInitialized()) return;
|
|
|
|
|
|
|
|
if (oldFactionId == null) oldFactionId = this.getDefaultFactionId();
|
|
|
|
|
|
|
|
// Update index
|
|
|
|
Faction oldFaction = Faction.get(oldFactionId);
|
|
|
|
Faction faction = this.getFaction();
|
|
|
|
|
2014-09-17 13:29:58 +02:00
|
|
|
if (oldFaction != null) oldFaction.mplayers.remove(this);
|
|
|
|
if (faction != null) faction.mplayers.add(this);
|
2014-09-17 13:17:33 +02:00
|
|
|
|
|
|
|
String oldFactionIdDesc = "NULL";
|
|
|
|
String oldFactionNameDesc = "NULL";
|
|
|
|
if (oldFaction != null)
|
|
|
|
{
|
|
|
|
oldFactionIdDesc = oldFaction.getId();
|
|
|
|
oldFactionNameDesc = oldFaction.getName();
|
|
|
|
}
|
|
|
|
String factionIdDesc = "NULL";
|
|
|
|
String factionNameDesc = "NULL";
|
|
|
|
if (faction != null)
|
|
|
|
{
|
|
|
|
factionIdDesc = faction.getId();
|
|
|
|
factionNameDesc = faction.getName();
|
|
|
|
}
|
|
|
|
|
|
|
|
Factions.get().log(Txt.parse("<i>setFactionId moved <h>%s <i>aka <h>%s <i>from <h>%s <i>aka <h>%s <i>to <h>%s <i>aka <h>%s<i>.", this.getId(), this.getDisplayName(IdUtil.getConsole()), oldFactionIdDesc, oldFactionNameDesc, factionIdDesc, factionNameDesc));
|
|
|
|
|
|
|
|
// Mark as changed
|
|
|
|
this.changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setFaction(Faction faction)
|
|
|
|
{
|
|
|
|
this.setFactionId(faction.getId());
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELD: role
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public Rel getDefaultRole()
|
|
|
|
{
|
|
|
|
return MConf.get().defaultPlayerRole;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Rel getRole()
|
|
|
|
{
|
|
|
|
if (this.role == null) return this.getDefaultRole();
|
|
|
|
return this.role;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setRole(Rel role)
|
|
|
|
{
|
|
|
|
// Clean input
|
|
|
|
Rel target = role;
|
|
|
|
|
|
|
|
// Detect Nochange
|
|
|
|
if (MUtil.equals(this.role, target)) return;
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
this.role = target;
|
|
|
|
|
|
|
|
// Mark as changed
|
|
|
|
this.changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELD: title
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public boolean hasTitle()
|
|
|
|
{
|
|
|
|
return this.title != null;
|
|
|
|
}
|
|
|
|
|
|
|
|
public String getTitle()
|
|
|
|
{
|
|
|
|
if (this.hasTitle()) return this.title;
|
|
|
|
return Lang.PLAYER_NOTITLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setTitle(String title)
|
|
|
|
{
|
|
|
|
// Clean input
|
|
|
|
String target = title;
|
|
|
|
if (target != null)
|
|
|
|
{
|
|
|
|
target = target.trim();
|
|
|
|
if (target.length() == 0)
|
|
|
|
{
|
|
|
|
target = null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// NOTE: That we parse the title here is considered part of the 1.8 --> 2.0 migration.
|
|
|
|
// This should be removed once the migration phase is considered to be over.
|
|
|
|
if (target != null)
|
|
|
|
{
|
|
|
|
target = Txt.parse(target);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Detect Nochange
|
|
|
|
if (MUtil.equals(this.title, target)) return;
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
this.title = target;
|
|
|
|
|
|
|
|
// Mark as changed
|
|
|
|
this.changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELD: powerBoost
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public double getPowerBoost()
|
|
|
|
{
|
|
|
|
Double ret = this.powerBoost;
|
|
|
|
if (ret == null) ret = 0D;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setPowerBoost(Double powerBoost)
|
|
|
|
{
|
|
|
|
// Clean input
|
|
|
|
Double target = powerBoost;
|
|
|
|
if (target == null || target == 0) target = null;
|
|
|
|
|
|
|
|
// Detect Nochange
|
|
|
|
if (MUtil.equals(this.powerBoost, target)) return;
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
this.powerBoost = target;
|
|
|
|
|
|
|
|
// Mark as changed
|
|
|
|
this.changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean hasPowerBoost()
|
|
|
|
{
|
|
|
|
return this.getPowerBoost() != 0D;
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELD: power
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
// MIXIN: RAW
|
|
|
|
|
|
|
|
public double getPowerMaxUniversal()
|
|
|
|
{
|
|
|
|
return Factions.get().getPowerMixin().getMaxUniversal(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
public double getPowerMax()
|
|
|
|
{
|
|
|
|
return Factions.get().getPowerMixin().getMax(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
public double getPowerMin()
|
|
|
|
{
|
|
|
|
return Factions.get().getPowerMixin().getMin(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
public double getPowerPerHour()
|
|
|
|
{
|
|
|
|
return Factions.get().getPowerMixin().getPerHour(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
public double getPowerPerDeath()
|
|
|
|
{
|
|
|
|
return Factions.get().getPowerMixin().getPerDeath(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
// MIXIN: FINER
|
|
|
|
|
|
|
|
public double getLimitedPower(double power)
|
|
|
|
{
|
|
|
|
power = Math.max(power, this.getPowerMin());
|
|
|
|
power = Math.min(power, this.getPowerMax());
|
|
|
|
|
|
|
|
return power;
|
|
|
|
}
|
|
|
|
|
|
|
|
public int getPowerMaxRounded()
|
|
|
|
{
|
|
|
|
return (int) Math.round(this.getPowerMax());
|
|
|
|
}
|
|
|
|
|
|
|
|
public int getPowerMinRounded()
|
|
|
|
{
|
|
|
|
return (int) Math.round(this.getPowerMin());
|
|
|
|
}
|
|
|
|
|
|
|
|
public int getPowerMaxUniversalRounded()
|
|
|
|
{
|
|
|
|
return (int) Math.round(this.getPowerMaxUniversal());
|
|
|
|
}
|
|
|
|
|
|
|
|
// RAW
|
|
|
|
|
|
|
|
public double getDefaultPower()
|
|
|
|
{
|
|
|
|
return MConf.get().defaultPlayerPower;
|
|
|
|
}
|
|
|
|
|
|
|
|
public double getPower()
|
|
|
|
{
|
|
|
|
Double ret = this.power;
|
|
|
|
if (ret == null) ret = this.getDefaultPower();
|
|
|
|
ret = this.getLimitedPower(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setPower(Double power)
|
|
|
|
{
|
|
|
|
// Clean input
|
|
|
|
Double target = power;
|
|
|
|
|
|
|
|
// Detect Nochange
|
|
|
|
if (MUtil.equals(this.power, target)) return;
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
this.power = target;
|
|
|
|
|
|
|
|
// Mark as changed
|
|
|
|
this.changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
// FINER
|
|
|
|
|
|
|
|
public int getPowerRounded()
|
|
|
|
{
|
|
|
|
return (int) Math.round(this.getPower());
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELD: mapAutoUpdating
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public boolean isMapAutoUpdating()
|
|
|
|
{
|
|
|
|
if (this.mapAutoUpdating == null) return false;
|
|
|
|
if (this.mapAutoUpdating == false) return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setMapAutoUpdating(Boolean mapAutoUpdating)
|
|
|
|
{
|
|
|
|
// Clean input
|
|
|
|
Boolean target = mapAutoUpdating;
|
2014-09-17 16:15:33 +02:00
|
|
|
if (MUtil.equals(target, false)) target = null;
|
2014-09-17 13:17:33 +02:00
|
|
|
|
|
|
|
// Detect Nochange
|
|
|
|
if (MUtil.equals(this.mapAutoUpdating, target)) return;
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
this.mapAutoUpdating = target;
|
|
|
|
|
|
|
|
// Mark as changed
|
|
|
|
this.changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// FIELD: usingAdminMode
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public boolean isUsingAdminMode()
|
|
|
|
{
|
|
|
|
if (this.usingAdminMode == null) return false;
|
|
|
|
if (this.usingAdminMode == false) return false;
|
|
|
|
|
|
|
|
// Deactivate admin mode if we don't have permissions for it.
|
|
|
|
if (this.getSender() != null && !Perm.ADMIN.has(this.getSender(), false))
|
|
|
|
{
|
|
|
|
this.setUsingAdminMode(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setUsingAdminMode(Boolean usingAdminMode)
|
|
|
|
{
|
|
|
|
// Clean input
|
|
|
|
Boolean target = usingAdminMode;
|
2014-09-17 16:15:33 +02:00
|
|
|
if (MUtil.equals(target, false)) target = null;
|
2014-09-17 13:17:33 +02:00
|
|
|
|
|
|
|
// Detect Nochange
|
|
|
|
if (MUtil.equals(this.usingAdminMode, target)) return;
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
this.usingAdminMode = target;
|
|
|
|
|
|
|
|
// Mark as changed
|
|
|
|
this.changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// TITLE, NAME, FACTION NAME AND CHAT
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public String getFactionName()
|
|
|
|
{
|
|
|
|
Faction faction = this.getFaction();
|
|
|
|
if (faction.isNone()) return "";
|
|
|
|
return faction.getName();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Base concatenations:
|
|
|
|
|
|
|
|
public String getNameAndSomething(String color, String something)
|
|
|
|
{
|
|
|
|
String ret = "";
|
|
|
|
ret += color;
|
|
|
|
ret += this.getRole().getPrefix();
|
|
|
|
if (something != null && something.length() > 0)
|
|
|
|
{
|
|
|
|
ret += something;
|
|
|
|
ret += " ";
|
|
|
|
ret += color;
|
|
|
|
}
|
|
|
|
ret += this.getName();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
public String getNameAndFactionName()
|
|
|
|
{
|
|
|
|
return this.getNameAndSomething("", this.getFactionName());
|
|
|
|
}
|
|
|
|
|
|
|
|
public String getNameAndTitle(String color)
|
|
|
|
{
|
|
|
|
if (this.hasTitle())
|
|
|
|
{
|
|
|
|
return this.getNameAndSomething(color, this.getTitle());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return this.getNameAndSomething(color, null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Colored concatenations:
|
|
|
|
// These are used in information messages
|
|
|
|
|
|
|
|
public String getNameAndTitle(Faction faction)
|
|
|
|
{
|
|
|
|
return this.getNameAndTitle(this.getColorTo(faction).toString());
|
|
|
|
}
|
2014-09-17 13:29:58 +02:00
|
|
|
public String getNameAndTitle(MPlayer mplayer)
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-09-17 13:29:58 +02:00
|
|
|
return this.getNameAndTitle(this.getColorTo(mplayer).toString());
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// RELATION AND RELATION COLORS
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String describeTo(RelationParticipator observer, boolean ucfirst)
|
|
|
|
{
|
|
|
|
return RelationUtil.describeThatToMe(this, observer, ucfirst);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String describeTo(RelationParticipator observer)
|
|
|
|
{
|
|
|
|
return RelationUtil.describeThatToMe(this, observer);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Rel getRelationTo(RelationParticipator observer)
|
|
|
|
{
|
|
|
|
return RelationUtil.getRelationOfThatToMe(this, observer);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Rel getRelationTo(RelationParticipator observer, boolean ignorePeaceful)
|
|
|
|
{
|
|
|
|
return RelationUtil.getRelationOfThatToMe(this, observer, ignorePeaceful);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public ChatColor getColorTo(RelationParticipator observer)
|
|
|
|
{
|
|
|
|
return RelationUtil.getColorOfThatToMe(this, observer);
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// HEALTH
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public void heal(int amnt)
|
|
|
|
{
|
|
|
|
Player player = this.getPlayer();
|
|
|
|
if (player == null)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
player.setHealth(player.getHealth() + amnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// TERRITORY
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public boolean isInOwnTerritory()
|
|
|
|
{
|
|
|
|
PS ps = Mixin.getSenderPs(this.getId());
|
|
|
|
if (ps == null) return false;
|
|
|
|
return BoardColl.get().getFactionAt(ps) == this.getFaction();
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean isInEnemyTerritory()
|
|
|
|
{
|
|
|
|
PS ps = Mixin.getSenderPs(this.getId());
|
|
|
|
if (ps == null) return false;
|
|
|
|
return BoardColl.get().getFactionAt(ps).getRelationTo(this) == Rel.ENEMY;
|
|
|
|
}
|
|
|
|
|
2014-10-06 13:08:34 +02:00
|
|
|
// -------------------------------------------- //
|
|
|
|
// INACTIVITY TIMEOUT
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public long getRemovePlayerMillis(boolean async)
|
|
|
|
{
|
|
|
|
EventFactionsRemovePlayerMillis event = new EventFactionsRemovePlayerMillis(async, this);
|
|
|
|
event.run();
|
|
|
|
return event.getMillis();
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean considerRemovePlayerMillis(boolean async)
|
|
|
|
{
|
|
|
|
// This may or may not be required.
|
|
|
|
// Some users have been reporting a loop issue with the same player detaching over and over again.
|
|
|
|
// Maybe skipping ahead if the player is detached will solve the issue.
|
|
|
|
if (this.detached()) return false;
|
|
|
|
|
|
|
|
// Get the last activity millis.
|
|
|
|
// Null means "unknown" in which case we does nothing.
|
|
|
|
Long lastActivityMillis = this.getLastActivityMillis();
|
|
|
|
if (lastActivityMillis == null) return false;
|
|
|
|
|
|
|
|
// Consider
|
|
|
|
long toleranceMillis = this.getRemovePlayerMillis(async);
|
|
|
|
if (System.currentTimeMillis() - lastActivityMillis <= toleranceMillis) return false;
|
|
|
|
|
|
|
|
// Inform
|
|
|
|
if (MConf.get().logFactionLeave || MConf.get().logFactionKick)
|
|
|
|
{
|
|
|
|
Factions.get().log("Player " + this.getName() + " was auto-removed due to inactivity.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Apply
|
|
|
|
|
|
|
|
// Promote a new leader if required.
|
|
|
|
if (this.getRole() == Rel.LEADER)
|
|
|
|
{
|
|
|
|
Faction faction = this.getFaction();
|
|
|
|
if (faction != null)
|
|
|
|
{
|
|
|
|
this.getFaction().promoteNewLeader();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
this.leave();
|
|
|
|
this.detach();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-09-17 13:17:33 +02:00
|
|
|
// -------------------------------------------- //
|
|
|
|
// ACTIONS
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public void leave()
|
|
|
|
{
|
|
|
|
Faction myFaction = this.getFaction();
|
|
|
|
|
2014-10-07 12:30:44 +02:00
|
|
|
boolean permanent = myFaction.getFlag(MFlag.getFlagPermanent());
|
2014-09-17 13:17:33 +02:00
|
|
|
|
2014-09-17 13:29:58 +02:00
|
|
|
if (myFaction.getMPlayers().size() > 1)
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
|
|
|
if (!permanent && this.getRole() == Rel.LEADER)
|
|
|
|
{
|
|
|
|
msg("<b>You must give the leader role to someone else first.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!MConf.get().canLeaveWithNegativePower && this.getPower() < 0)
|
|
|
|
{
|
|
|
|
msg("<b>You cannot leave until your power is positive.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Event
|
|
|
|
EventFactionsMembershipChange membershipChangeEvent = new EventFactionsMembershipChange(this.getSender(), this, myFaction, MembershipChangeReason.LEAVE);
|
|
|
|
membershipChangeEvent.run();
|
|
|
|
if (membershipChangeEvent.isCancelled()) return;
|
|
|
|
|
|
|
|
if (myFaction.isNormal())
|
|
|
|
{
|
2014-09-17 13:29:58 +02:00
|
|
|
for (MPlayer mplayer : myFaction.getMPlayersWhereOnline(true))
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-09-17 13:29:58 +02:00
|
|
|
mplayer.msg("%s<i> left %s<i>.", this.describeTo(mplayer, true), myFaction.describeTo(mplayer));
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (MConf.get().logFactionLeave)
|
|
|
|
{
|
|
|
|
Factions.get().log(this.getName()+" left the faction: "+myFaction.getName());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
this.resetFactionData();
|
|
|
|
|
2014-09-17 13:29:58 +02:00
|
|
|
if (myFaction.isNormal() && !permanent && myFaction.getMPlayers().isEmpty())
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-10-21 07:48:42 +02:00
|
|
|
EventFactionsDisband eventFactionsDisband = new EventFactionsDisband(this.getSender(), myFaction);
|
|
|
|
eventFactionsDisband.run();
|
|
|
|
if ( ! eventFactionsDisband.isCancelled())
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-10-21 07:48:42 +02:00
|
|
|
// Remove this faction
|
|
|
|
this.msg("%s <i>was disbanded since you were the last player.", myFaction.describeTo(this, true));
|
|
|
|
if (MConf.get().logFactionDisband)
|
|
|
|
{
|
|
|
|
Factions.get().log("The faction "+myFaction.getName()+" ("+myFaction.getId()+") was disbanded due to the last player ("+this.getName()+") leaving.");
|
|
|
|
}
|
|
|
|
myFaction.detach();
|
|
|
|
}
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-13 11:42:40 +02:00
|
|
|
// NEW
|
|
|
|
public boolean tryClaim(Faction newFaction, Collection<PS> pss)
|
2014-10-14 08:56:07 +02:00
|
|
|
{
|
|
|
|
return this.tryClaim(newFaction, pss, null, null);
|
|
|
|
}
|
|
|
|
public boolean tryClaim(Faction newFaction, Collection<PS> pss, String formatOne, String formatMany)
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-10-13 11:42:40 +02:00
|
|
|
// Args
|
2014-10-14 08:56:07 +02:00
|
|
|
if (formatOne == null) formatOne = "<h>%s<i> %s <h>%d <i>chunk %s<i>.";
|
|
|
|
if (formatMany == null) formatMany = "<h>%s<i> %s <h>%d <i>chunks near %s<i>.";
|
|
|
|
|
2014-10-13 11:42:40 +02:00
|
|
|
if (newFaction == null) throw new NullPointerException("newFaction");
|
2014-09-17 13:17:33 +02:00
|
|
|
|
2014-10-13 11:42:40 +02:00
|
|
|
if (pss == null) throw new NullPointerException("pss");
|
|
|
|
final Set<PS> chunks = PS.getDistinctChunks(pss);
|
2014-09-17 13:17:33 +02:00
|
|
|
|
2014-10-07 17:08:40 +02:00
|
|
|
// NoChange
|
2014-10-13 11:42:40 +02:00
|
|
|
// We clean the chunks further by removing what does not change.
|
|
|
|
// This is also very suggested cleaning of EventFactionsChunksChange input.
|
|
|
|
Iterator<PS> iter = chunks.iterator();
|
|
|
|
while (iter.hasNext())
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-10-13 11:42:40 +02:00
|
|
|
PS chunk = iter.next();
|
|
|
|
Faction oldFaction = BoardColl.get().getFactionAt(chunk);
|
|
|
|
if (newFaction == oldFaction) iter.remove();
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
2014-10-13 11:42:40 +02:00
|
|
|
if (chunks.isEmpty())
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-10-13 11:42:40 +02:00
|
|
|
msg("%s<i> already owns this land.", newFaction.describeTo(this, true));
|
|
|
|
return true;
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Event
|
2014-10-13 11:42:40 +02:00
|
|
|
// NOTE: We listen to this event ourselves at LOW.
|
|
|
|
// NOTE: That is where we apply the standard checks.
|
|
|
|
EventFactionsChunksChange event = new EventFactionsChunksChange(this.getSender(), chunks, newFaction);
|
2014-09-17 13:17:33 +02:00
|
|
|
event.run();
|
|
|
|
if (event.isCancelled()) return false;
|
2014-10-13 11:42:40 +02:00
|
|
|
|
2014-09-17 13:17:33 +02:00
|
|
|
// Apply
|
2014-10-13 11:42:40 +02:00
|
|
|
for (PS chunk : chunks)
|
|
|
|
{
|
|
|
|
BoardColl.get().setFactionAt(chunk, newFaction);
|
|
|
|
}
|
2014-09-17 13:17:33 +02:00
|
|
|
|
|
|
|
// Inform
|
2014-10-13 11:42:40 +02:00
|
|
|
for (Entry<Faction, Set<PS>> entry : event.getOldFactionChunks().entrySet())
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-10-13 11:42:40 +02:00
|
|
|
final Faction oldFaction = entry.getKey();
|
|
|
|
final Set<PS> oldChunks = entry.getValue();
|
|
|
|
final PS oldChunk = oldChunks.iterator().next();
|
|
|
|
final Set<MPlayer> informees = getClaimInformees(this, oldFaction, newFaction);
|
|
|
|
final EventFactionsChunkChangeType type = EventFactionsChunkChangeType.get(oldFaction, newFaction, this.getFaction());
|
|
|
|
|
|
|
|
String chunkString = oldChunk.toString(PSFormatHumanSpace.get());
|
|
|
|
String typeString = type.past;
|
|
|
|
|
|
|
|
for (MPlayer informee : informees)
|
|
|
|
{
|
2014-10-14 08:56:07 +02:00
|
|
|
informee.msg((oldChunks.size() == 1 ? formatOne : formatMany), this.describeTo(informee, true), typeString, oldChunks.size(), chunkString);
|
2014-10-13 11:42:40 +02:00
|
|
|
informee.msg(" <h>%s<i> --> <h>%s", oldFaction.describeTo(informee, true), newFaction.describeTo(informee, true));
|
|
|
|
}
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
2014-10-13 11:42:40 +02:00
|
|
|
|
|
|
|
// Success
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------------- //
|
|
|
|
// UTIL
|
|
|
|
// -------------------------------------------- //
|
|
|
|
|
|
|
|
public static Set<MPlayer> getClaimInformees(MPlayer msender, Faction... factions)
|
|
|
|
{
|
|
|
|
Set<MPlayer> ret = new HashSet<MPlayer>();
|
|
|
|
|
|
|
|
ret.add(msender);
|
|
|
|
|
|
|
|
for (Faction faction : factions)
|
2014-09-17 13:17:33 +02:00
|
|
|
{
|
2014-10-13 11:42:40 +02:00
|
|
|
if (faction.isNormal())
|
|
|
|
{
|
|
|
|
ret.addAll(faction.getMPlayers());
|
|
|
|
}
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
2014-10-13 11:42:40 +02:00
|
|
|
|
2014-09-17 13:17:33 +02:00
|
|
|
if (MConf.get().logLandClaims)
|
|
|
|
{
|
2014-10-13 11:42:40 +02:00
|
|
|
ret.add(MPlayer.get(IdUtil.getConsole()));
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
|
|
|
|
2014-10-13 11:42:40 +02:00
|
|
|
return ret;
|
2014-09-17 13:17:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|