Factions/src/com/massivecraft/factions/Faction.java

924 lines
21 KiB
Java
Raw Normal View History

2011-07-18 22:06:02 +02:00
package com.massivecraft.factions;
2011-02-06 13:36:11 +01:00
import java.util.*;
import java.util.Map.Entry;
2011-02-06 13:36:11 +01:00
import org.bukkit.Bukkit;
2011-02-06 13:36:11 +01:00
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
2011-02-06 13:36:11 +01:00
import org.bukkit.entity.Player;
2011-07-18 22:06:02 +02:00
2011-10-12 17:25:01 +02:00
import com.massivecraft.factions.iface.EconomyParticipator;
import com.massivecraft.factions.iface.RelationParticipator;
import com.massivecraft.factions.integration.Econ;
import com.massivecraft.factions.integration.SpoutFeatures;
2011-07-18 22:06:02 +02:00
import com.massivecraft.factions.util.*;
import com.massivecraft.mcore.mixin.Mixin;
import com.massivecraft.mcore.ps.PS;
import com.massivecraft.mcore.store.Entity;
import com.massivecraft.mcore.util.MUtil;
import com.massivecraft.mcore.util.SenderUtil;
import com.massivecraft.mcore.xlib.gson.annotations.SerializedName;
2011-02-06 13:36:11 +01:00
2013-04-12 15:10:11 +02:00
public class Faction extends Entity<Faction> implements EconomyParticipator
{
// -------------------------------------------- //
// META
// -------------------------------------------- //
public static Faction get(Object oid)
{
return FactionColl.get().get(oid);
}
// -------------------------------------------- //
// OVERRIDE: ENTITY
// -------------------------------------------- //
@Override
public Faction load(Faction that)
{
2013-04-11 12:32:38 +02:00
this.tag = that.tag;
this.setDescription(that.description);
2013-04-17 12:08:30 +02:00
this.home = that.home;
this.setPowerBoost(that.powerBoost);
this.cape = that.cape;
this.open = that.open;
this.setInvitedPlayerIds(that.invitedPlayerIds);
this.setRelationWishes(that.relationWish);
this.setFlags(that.flagOverrides);
this.setPerms(that.permOverrides);
return this;
2013-04-12 08:56:26 +02:00
}
// -------------------------------------------- //
// 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 even the getter and setter logic takes up quite some place.
// TODO: The faction "tag" could/should also have been called "name".
// The actual faction id looks something like "54947df8-0e9e-4471-a2f9-9af509fb5889" and that is not too easy to remember for humans.
// Thus we make use of a name. Since the id is used in all foreign key situations changing the name is fine.
private String tag = null;
2013-04-17 12:08:30 +02:00
// Factions can optionally set a description for themselves.
// This description can for example be seen in territorial alerts.
private String description = null;
2013-04-17 12:08:30 +02:00
// Factions can optionally set a home location.
// If they do their members can teleport there using /f home
private PS home = null;
// Factions usually do not have a powerboost. It defaults to 0.
// The powerBoost is a custom increase/decrease to default and maximum power.
private Double powerBoost = null;
// The cape field is used by the Spout integration features.
// It's the URL to the faction cape.
private String cape = null;
// Can anyone join the Faction?
// If the faction is open they can.
// If the faction is closed an invite is required.
private Boolean open = null;
2013-04-17 12:08:30 +02:00
// This is the ids of the invited players.
// They are actually "senderIds" since you can invite "@console" to your faction.
@SerializedName("invites")
private Set<String> invitedPlayerIds = null;
2013-04-17 12:08:30 +02:00
// The keys in this map are factionIds.
private Map<String, Rel> relationWish = null;
2011-03-23 17:39:56 +01:00
// The flag overrides are modifications to the default values.
private Map<FFlag, Boolean> flagOverrides = null;
// The perm overrides are modifications to the default values.
private Map<FPerm, Set<Rel>> permOverrides = null;
2011-10-23 20:50:49 +02:00
// -------------------------------------------- //
// CONSTRUCT
// -------------------------------------------- //
public Faction()
{
New "peaceful" status for factions which can only be set by server admins/moderators. Members of peaceful factions cannot deal or receive PvP damage (unless in a war zone which has friendly fire enabled), cannot claim land from another faction and likewise can't have their land claimed, and cannot be considered as ally or enemy of any other faction. Faction admins and moderators of peaceful factions can enable/disable all explosions inside their faction's territory at will. The main purpose of this is to provide a way for more peaceful players who don't want to take part in faction wars (or just want to take a break from them) to still have fun on the server. It is also meant to allow groups of players to make protected buildings, monuments, grand constructions, and so forth without having to worry about another faction destroying them. New conf.json settings: "peacefulTerritoryDisablePVP" (default true) prevents PvP damage for anyone inside a peaceful faction's territory "peacefulTerritoryDisableMonsters" (default false) provides protection against monsters spawning or attacking inside a peaceful faction's territory "peacefulMembersDisablePowerLoss" (default true) which keeps members of peaceful factions from suffering power loss when they die. New commands: /f peaceful [faction tag] - toggle the indicated faction's "peaceful" status /f noboom - enable/disable explosions inside your faction's territory; only available to faction admin and faction moderators for peaceful factions New permission nodes: factions.setPeaceful - ability to use the /f peaceful command (admins) factions.peacefulExplosionToggle - ability to use /f noboom (everyone)
2011-08-05 10:50:47 +02:00
}
// -------------------------------------------- //
// FIELD: id
// -------------------------------------------- //
// FINER
public boolean isNone()
{
return this.getId().equals(Const.FACTIONID_NONE);
}
public boolean isNormal()
{
return ! this.isNone();
}
// This is the bank account id used by external money-plugins
@Override
public String getAccountId()
{
String accountId = "faction-"+this.getId();
// We need to override the default money given to players.
if ( ! Econ.hasAccount(accountId))
{
Econ.setBalance(accountId, 0);
}
return accountId;
}
// -------------------------------------------- //
// FIELD: tag
// -------------------------------------------- //
// TODO: Rename tag --> name ?
// RAW
public String getTag()
{
String ret = this.tag;
if (ConfServer.factionTagForceUpperCase)
{
ret = ret.toUpperCase();
}
return ret;
}
public void setTag(String str)
{
if (ConfServer.factionTagForceUpperCase)
{
str = str.toUpperCase();
}
this.tag = str;
this.changed();
}
// FINER
public String getComparisonTag()
{
return MiscUtil.getComparisonString(this.getTag());
}
public String getTag(String prefix)
{
return prefix + this.getTag();
}
public String getTag(RelationParticipator observer)
{
if (observer == null) return getTag();
return this.getTag(this.getColorTo(observer).toString());
}
// -------------------------------------------- //
// FIELD: description
// -------------------------------------------- //
2011-10-23 20:50:49 +02:00
// RAW
public boolean hasDescription()
{
return this.description != null;
2011-03-23 17:39:56 +01:00
}
public String getDescription()
{
if (this.hasDescription()) return this.description;
return Lang.FACTION_NODESCRIPTION;
}
public void setDescription(String description)
{
if (description != null)
{
description = description.trim();
// This code should be kept for a while to clean out the previous default text that was actually stored in the database.
if (description.length() == 0 || description.equalsIgnoreCase("Default faction description :("))
{
description = null;
}
}
this.description = description;
this.changed();
2011-03-23 17:39:56 +01:00
}
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
// FIELD: home
// -------------------------------------------- //
2011-03-22 17:20:21 +01:00
2013-04-17 12:08:30 +02:00
public PS getHome()
2011-10-12 17:25:01 +02:00
{
2013-04-17 12:08:30 +02:00
this.verifyHomeIsValid();
return this.home;
2011-10-12 17:25:01 +02:00
}
2013-04-17 12:08:30 +02:00
public void verifyHomeIsValid()
2011-10-12 17:25:01 +02:00
{
2013-04-17 12:08:30 +02:00
if (this.isValidHome(this.home)) return;
this.home = null;
msg("<b>Your faction home has been un-set since it is no longer in your territory.");
}
public boolean isValidHome(PS ps)
{
if (ps == null) return true;
if (!ConfServer.homesMustBeInClaimedTerritory) return true;
if (BoardColl.get().getFactionAt(ps) == this) return true;
return false;
}
public boolean hasHome()
{
return this.getHome() != null;
}
public void setHome(PS home)
{
this.home = home;
2011-10-12 17:25:01 +02:00
}
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
// FIELD: powerBoost
// -------------------------------------------- //
// RAW
2013-04-17 12:08:30 +02:00
public double getPowerBoost()
2011-10-12 17:25:01 +02:00
{
2013-04-17 12:08:30 +02:00
Double ret = this.powerBoost;
if (ret == null) ret = 0D;
return ret;
2011-10-12 17:25:01 +02:00
}
2013-04-17 12:08:30 +02:00
public void setPowerBoost(Double powerBoost)
2011-10-12 17:25:01 +02:00
{
2013-04-17 12:08:30 +02:00
if (powerBoost == null || powerBoost == 0)
{
2013-04-17 12:08:30 +02:00
powerBoost = null;
}
2013-04-17 12:08:30 +02:00
this.powerBoost = powerBoost;
this.changed();
2011-10-12 17:25:01 +02:00
}
2013-04-17 12:08:30 +02:00
// -------------------------------------------- //
// FIELD: cape
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
public String getCape()
2011-10-12 17:25:01 +02:00
{
2013-04-17 12:08:30 +02:00
return cape;
2011-10-12 17:25:01 +02:00
}
2013-04-17 12:08:30 +02:00
public void setCape(String cape)
{
2013-04-17 12:08:30 +02:00
this.cape = cape;
SpoutFeatures.updateCape(this, null);
2011-03-22 17:20:21 +01:00
}
2013-04-17 12:08:30 +02:00
// -------------------------------------------- //
// FIELD: open
// -------------------------------------------- //
2011-03-22 17:20:21 +01:00
2013-04-17 12:08:30 +02:00
public boolean isOpen()
{
2013-04-17 12:08:30 +02:00
Boolean ret = this.open;
if (ret == null) ret = ConfServer.newFactionsDefaultOpen;
return ret;
}
2013-04-17 12:08:30 +02:00
public void setOpen(Boolean open)
{
2013-04-17 12:08:30 +02:00
this.open = open;
this.changed();
}
// -------------------------------------------- //
// FIELD: invitedPlayerIds
// -------------------------------------------- //
// RAW
public TreeSet<String> getInvitedPlayerIds()
{
TreeSet<String> ret = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
if (this.invitedPlayerIds != null) ret.addAll(this.invitedPlayerIds);
return ret;
}
public void setInvitedPlayerIds(Collection<String> invitedPlayerIds)
{
if (invitedPlayerIds == null || invitedPlayerIds.isEmpty())
{
this.invitedPlayerIds = null;
}
else
{
TreeSet<String> target = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
for (String invitedPlayerId : invitedPlayerIds)
{
target.add(invitedPlayerId.toLowerCase());
}
this.invitedPlayerIds = target;
}
this.changed();
}
// FINER
public boolean isInvited(String playerId)
{
return this.getInvitedPlayerIds().contains(playerId);
}
public boolean isInvited(FPlayer fplayer)
{
return this.isInvited(fplayer.getId());
}
public boolean invite(String playerId)
{
TreeSet<String> invitedPlayerIds = this.getInvitedPlayerIds();
if (invitedPlayerIds.add(playerId.toLowerCase()))
{
this.setInvitedPlayerIds(invitedPlayerIds);
return true;
}
return false;
}
public void invite(FPlayer fplayer)
{
this.invite(fplayer.getId());
}
public boolean deinvite(String playerId)
{
TreeSet<String> invitedPlayerIds = this.getInvitedPlayerIds();
if (invitedPlayerIds.remove(playerId.toLowerCase()))
{
this.setInvitedPlayerIds(invitedPlayerIds);
return true;
}
return false;
}
public void deinvite(FPlayer fplayer)
{
this.deinvite(fplayer.getId());
}
2013-04-17 12:08:30 +02:00
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
// FIELD: relationWish
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
// RAW
2013-04-17 12:08:30 +02:00
public Map<String, Rel> getRelationWishes()
{
2013-04-17 12:08:30 +02:00
Map<String, Rel> ret = new LinkedHashMap<String, Rel>();
if (this.relationWish != null) ret.putAll(this.relationWish);
return ret;
}
2013-04-17 12:08:30 +02:00
public void setRelationWishes(Map<String, Rel> relationWishes)
{
2013-04-17 12:08:30 +02:00
if (relationWishes == null || relationWishes.isEmpty())
{
this.relationWish = null;
}
else
{
this.relationWish = relationWishes;
}
this.changed();
}
2013-04-17 12:08:30 +02:00
// FINER
2013-04-17 12:08:30 +02:00
public Rel getRelationWish(String factionId)
{
2013-04-17 12:08:30 +02:00
Rel ret = this.getRelationWishes().get(factionId);
if (ret == null) ret = Rel.NEUTRAL;
return ret;
}
2013-04-17 12:08:30 +02:00
public Rel getRelationWish(Faction faction)
{
2013-04-17 12:08:30 +02:00
return this.getRelationWish(faction.getId());
}
2013-04-17 12:08:30 +02:00
public void setRelationWish(String factionId, Rel rel)
{
2013-04-17 12:08:30 +02:00
Map<String, Rel> relationWishes = this.getRelationWishes();
if (rel == null || rel == Rel.NEUTRAL)
{
relationWishes.remove(factionId);
}
else
{
relationWishes.put(factionId, rel);
}
this.setRelationWishes(relationWishes);
}
2013-04-17 12:08:30 +02:00
public void setRelationWish(Faction faction, Rel rel)
{
2013-04-17 12:08:30 +02:00
this.setRelationWish(faction.getId(), rel);
}
2013-04-17 12:08:30 +02:00
// TODO: What is this and where is it used?
2013-04-17 12:08:30 +02:00
public Map<Rel, List<String>> getFactionTagsPerRelation(RelationParticipator rp)
{
2013-04-17 12:08:30 +02:00
return getFactionTagsPerRelation(rp, false);
}
2013-04-17 12:08:30 +02:00
// onlyNonNeutral option provides substantial performance boost on large servers for listing only non-neutral factions
public Map<Rel, List<String>> getFactionTagsPerRelation(RelationParticipator rp, boolean onlyNonNeutral)
{
2013-04-17 12:08:30 +02:00
Map<Rel, List<String>> ret = new HashMap<Rel, List<String>>();
for (Rel rel : Rel.values())
{
2013-04-17 12:08:30 +02:00
ret.put(rel, new ArrayList<String>());
}
2013-04-17 12:08:30 +02:00
for (Faction faction : FactionColl.get().getAll())
{
Rel relation = faction.getRelationTo(this);
if (onlyNonNeutral && relation == Rel.NEUTRAL) continue;
ret.get(relation).add(faction.getTag(rp));
}
return ret;
}
// -------------------------------------------- //
// FIELD: flagOverrides
// -------------------------------------------- //
// RAW
public Map<FFlag, Boolean> getFlags()
{
Map<FFlag, Boolean> ret = new LinkedHashMap<FFlag, Boolean>();
for (FFlag fflag : FFlag.values())
{
ret.put(fflag, fflag.getDefault());
}
if (this.flagOverrides != null)
{
for (Entry<FFlag, Boolean> entry : this.flagOverrides.entrySet())
{
ret.put(entry.getKey(), entry.getValue());
}
}
return ret;
}
public void setFlags(Map<FFlag, Boolean> flags)
{
Map<FFlag, Boolean> target = new LinkedHashMap<FFlag, Boolean>();
if (flags != null)
{
target.putAll(flags);
}
Iterator<Entry<FFlag, Boolean>> iter = target.entrySet().iterator();
while (iter.hasNext())
{
Entry<FFlag, Boolean> entry = iter.next();
if (entry.getKey().getDefault() == entry.getValue())
{
iter.remove();
}
}
if (target == null || target.isEmpty())
{
this.flagOverrides = null;
}
else
{
this.flagOverrides = target;
}
this.changed();
}
// FINER
public boolean getFlag(FFlag flag)
{
return this.getFlags().get(flag);
}
public void setFlag(FFlag flag, boolean value)
{
Map<FFlag, Boolean> flags = this.getFlags();
flags.put(flag, value);
this.setFlags(flags);
}
// -------------------------------------------- //
// FIELD: permOverrides
// -------------------------------------------- //
// RAW
public Map<FPerm, Set<Rel>> getPerms()
{
Map<FPerm, Set<Rel>> ret = new LinkedHashMap<FPerm, Set<Rel>>();
for (FPerm fperm : FPerm.values())
{
ret.put(fperm, fperm.getDefault());
}
if (this.permOverrides != null)
{
for (Entry<FPerm, Set<Rel>> entry : this.permOverrides.entrySet())
{
ret.put(entry.getKey(), new LinkedHashSet<Rel>(entry.getValue()));
}
}
return ret;
}
public void setPerms(Map<FPerm, Set<Rel>> perms)
{
Map<FPerm, Set<Rel>> target = new LinkedHashMap<FPerm, Set<Rel>>();
if (perms != null)
{
for (Entry<FPerm, Set<Rel>> entry : perms.entrySet())
{
target.put(entry.getKey(), new LinkedHashSet<Rel>(entry.getValue()));
}
}
Iterator<Entry<FPerm, Set<Rel>>> iter = target.entrySet().iterator();
while (iter.hasNext())
{
Entry<FPerm, Set<Rel>> entry = iter.next();
if (entry.getKey().getDefault().equals(entry.getValue()))
{
iter.remove();
}
}
if (target == null || target.isEmpty())
{
this.permOverrides = null;
}
else
{
this.permOverrides = target;
}
this.changed();
}
// FINER
public Set<Rel> getPermittedRelations(FPerm perm)
{
return this.getPerms().get(perm);
}
public void setPermittedRelations(FPerm perm, Set<Rel> rels)
{
Map<FPerm, Set<Rel>> perms = this.getPerms();
perms.put(perm, rels);
this.setPerms(perms);
}
public void setPermittedRelations(FPerm perm, Rel... rels)
{
Set<Rel> temp = new HashSet<Rel>();
temp.addAll(Arrays.asList(rels));
this.setPermittedRelations(perm, temp);
}
public void setRelationPermitted(FPerm perm, Rel rel, boolean permitted)
{
Map<FPerm, Set<Rel>> perms = this.getPerms();
Set<Rel> rels = perms.get(perm);
if (permitted)
{
rels.add(rel);
}
else
{
rels.remove(rel);
}
this.setPerms(perms);
}
// -------------------------------------------- //
// OVERRIDE: RelationParticipator
// -------------------------------------------- //
@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);
}
// -------------------------------------------- //
// POWER
// -------------------------------------------- //
// TODO: Implement a has enough feature.
public double getPower()
{
if (this.getFlag(FFlag.INFPOWER))
2011-10-22 18:12:15 +02:00
{
2011-10-23 20:50:49 +02:00
return 999999;
2011-10-22 18:12:15 +02:00
}
double ret = 0;
for (FPlayer fplayer : this.getFPlayers())
{
2011-03-23 12:00:38 +01:00
ret += fplayer.getPower();
2011-02-06 13:36:11 +01:00
}
2013-04-09 13:15:25 +02:00
if (ConfServer.powerFactionMax > 0 && ret > ConfServer.powerFactionMax)
{
2013-04-09 13:15:25 +02:00
ret = ConfServer.powerFactionMax;
}
return ret + this.getPowerBoost();
2011-02-06 13:36:11 +01:00
}
public double getPowerMax()
{
if (this.getFlag(FFlag.INFPOWER))
2011-10-22 18:12:15 +02:00
{
2011-10-23 20:50:49 +02:00
return 999999;
2011-10-22 18:12:15 +02:00
}
double ret = 0;
for (FPlayer fplayer : this.getFPlayers())
{
2011-03-23 12:00:38 +01:00
ret += fplayer.getPowerMax();
2011-02-06 13:36:11 +01:00
}
2013-04-09 13:15:25 +02:00
if (ConfServer.powerFactionMax > 0 && ret > ConfServer.powerFactionMax)
{
2013-04-09 13:15:25 +02:00
ret = ConfServer.powerFactionMax;
}
return ret + this.getPowerBoost();
2011-02-06 13:36:11 +01:00
}
public int getPowerRounded()
{
2011-02-06 13:36:11 +01:00
return (int) Math.round(this.getPower());
}
public int getPowerMaxRounded()
{
2011-02-06 13:36:11 +01:00
return (int) Math.round(this.getPowerMax());
}
public int getLandCount()
{
return BoardColl.get().getCount(this);
2011-02-06 13:36:11 +01:00
}
public int getLandCountInWorld(String worldName)
{
return BoardColl.get().get(worldName).getCount(this);
}
public boolean hasLandInflation()
{
return this.getLandCount() > this.getPowerRounded();
2011-02-06 13:36:11 +01:00
}
// -------------------------------------------- //
// FOREIGN KEYS: FPLAYERS
// -------------------------------------------- //
// TODO: With this approach null must be used as default always.
// TODO: Take a moment and reflect upon the consequenses eeeeeeh...
// TODO: This one may be to slow after all :/ Thus I must maintain an index.
protected transient List<FPlayer> fplayers = null;
public void reindexFPlayers()
{
this.fplayers = new ArrayList<FPlayer>();
String factionId = this.getId();
if (factionId == null) return;
2013-04-12 08:56:26 +02:00
for (FPlayer fplayer : FPlayerColl.get().getAll())
{
if (!MUtil.equals(factionId, fplayer.getFactionId())) continue;
this.fplayers.add(fplayer);
2011-02-06 13:36:11 +01:00
}
}
public List<FPlayer> getFPlayers()
{
return new ArrayList<FPlayer>(this.fplayers);
}
public List<FPlayer> getFPlayersWhereOnline(boolean online)
{
List<FPlayer> ret = this.getFPlayers();
Iterator<FPlayer> iter = ret.iterator();
while (iter.hasNext())
{
FPlayer fplayer = iter.next();
if (fplayer.isOnline() != online)
{
iter.remove();
}
}
2011-02-06 13:36:11 +01:00
return ret;
}
public List<FPlayer> getFPlayersWhereRole(Rel role)
{
List<FPlayer> ret = this.getFPlayers();
Iterator<FPlayer> iter = ret.iterator();
while (iter.hasNext())
{
FPlayer fplayer = iter.next();
if (fplayer.getRole() != role)
{
iter.remove();
}
2011-02-06 13:36:11 +01:00
}
return ret;
}
public FPlayer getLeader()
{
List<FPlayer> ret = this.getFPlayers();
Iterator<FPlayer> iter = ret.iterator();
while (iter.hasNext())
{
FPlayer fplayer = iter.next();
if (fplayer.getRole() == Rel.LEADER)
{
return fplayer;
}
}
return null;
}
public List<CommandSender> getOnlineCommandSenders()
2011-10-22 17:42:13 +02:00
{
List<CommandSender> ret = new ArrayList<CommandSender>();
for (CommandSender player : SenderUtil.getOnlineSenders())
2011-10-22 17:42:13 +02:00
{
FPlayer fplayer = FPlayerColl.get().get(player);
if (fplayer.getFaction() != this) continue;
ret.add(player);
2011-02-06 13:36:11 +01:00
}
return ret;
}
public List<Player> getOnlinePlayers()
{
List<Player> ret = new ArrayList<Player>();
for (Player player : Bukkit.getOnlinePlayers())
{
2013-04-12 08:56:26 +02:00
FPlayer fplayer = FPlayerColl.get().get(player);
if (fplayer.getFaction() != this) continue;
ret.add(player);
2011-02-06 13:36:11 +01:00
}
return ret;
}
// used when current leader is about to be removed from the faction; promotes new leader, or disbands faction if no other members left
public void promoteNewLeader()
{
if ( ! this.isNormal()) return;
2013-04-09 13:15:25 +02:00
if (this.getFlag(FFlag.PERMANENT) && ConfServer.permanentFactionsDisableLeaderPromotion) return;
FPlayer oldLeader = this.getLeader();
// get list of officers, or list of normal members if there are no officers
List<FPlayer> replacements = this.getFPlayersWhereRole(Rel.OFFICER);
if (replacements == null || replacements.isEmpty())
{
replacements = this.getFPlayersWhereRole(Rel.MEMBER);
}
if (replacements == null || replacements.isEmpty())
{ // faction leader is the only member; one-man faction
if (this.getFlag(FFlag.PERMANENT))
{
if (oldLeader != null)
{
oldLeader.setRole(Rel.MEMBER);
}
return;
}
// no members left and faction isn't permanent, so disband it
2013-04-09 13:15:25 +02:00
if (ConfServer.logFactionDisband)
{
Factions.get().log("The faction "+this.getTag()+" ("+this.getId()+") has been disbanded since it has no members left.");
}
2013-04-12 08:56:26 +02:00
for (FPlayer fplayer : FPlayerColl.get().getAllOnline())
{
fplayer.msg("The faction %s<i> was disbanded.", this.getTag(fplayer));
}
this.detach();
}
else
{ // promote new faction leader
if (oldLeader != null)
{
oldLeader.setRole(Rel.MEMBER);
}
replacements.get(0).setRole(Rel.LEADER);
this.msg("<i>Faction leader <h>%s<i> has been removed. %s<i> has been promoted as the new faction leader.", oldLeader == null ? "" : oldLeader.getName(), replacements.get(0).getName());
Factions.get().log("Faction "+this.getTag()+" ("+this.getId()+") leader was removed. Replacement leader: "+replacements.get(0).getName());
}
}
// -------------------------------------------- //
// MESSAGES
// -------------------------------------------- //
// These methods are simply proxied in from the Mixin.
2013-04-10 10:32:04 +02:00
// CONVENIENCE SEND MESSAGE
public boolean sendMessage(String message)
{
return Mixin.message(new FactionEqualsPredictate(this), message);
}
public boolean sendMessage(String... messages)
{
return Mixin.message(new FactionEqualsPredictate(this), messages);
2011-02-06 13:36:11 +01:00
}
public boolean sendMessage(Collection<String> messages)
{
return Mixin.message(new FactionEqualsPredictate(this), messages);
}
// CONVENIENCE MSG
public boolean msg(String msg)
{
return Mixin.msg(new FactionEqualsPredictate(this), msg);
2011-02-06 13:36:11 +01:00
}
public boolean msg(String msg, Object... args)
{
return Mixin.msg(new FactionEqualsPredictate(this), msg, args);
}
public boolean msg(Collection<String> msgs)
{
return Mixin.msg(new FactionEqualsPredictate(this), msgs);
}
2011-03-18 17:33:23 +01:00
2011-02-06 13:36:11 +01:00
}