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

873 lines
20 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.ps.PS;
import com.massivecraft.mcore.store.Entity;
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);
this.open = that.open;
this.setInvitedPlayerIds(that.invitedPlayerIds);
this.setRelationWishes(that.relationWish);
2013-04-11 12:32:38 +02:00
this.home = that.home;
this.cape = that.cape;
this.setPowerBoost(that.powerBoost);
this.setFlags(that.flagOverrides);
2013-04-11 12:32:38 +02:00
this.permOverrides = that.permOverrides;
return this;
2013-04-12 08:56:26 +02:00
}
// -------------------------------------------- //
// FIELDS: RAW
// -------------------------------------------- //
// TODO
// 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;
private String description = null;
private Boolean open = null;
@SerializedName("invites")
private Set<String> invitedPlayerIds = null;
private Map<String, Rel> relationWish = null;
2011-03-23 17:39:56 +01:00
private PS home = null;
// The cape field is a URL used by the Spout integration features.
private String cape = null;
// The powerBoost is a custom increase/decrease to default and max power for this faction.
private Double powerBoost = null;
// The flag overrides are the modifications to the default values
private Map<FFlag, Boolean> flagOverrides;
2011-10-23 20:50:49 +02:00
// FIELDS: Permission <-> Groups management
2011-10-24 01:37:51 +02:00
private Map<FPerm, Set<Rel>> permOverrides; // Contains the modifications to the default values
public Set<Rel> getPermittedRelations(FPerm perm)
{
Set<Rel> ret = this.permOverrides.get(perm);
if (ret == null) ret = perm.getDefault();
return ret;
}
2012-05-09 06:29:52 +02:00
/*
public void addPermittedRelation(FPerm perm, Rel rel)
{
Set<Rel> newPermittedRelations = EnumSet.noneOf(Rel.class);
newPermittedRelations.addAll(this.getPermittedRelations(perm));
newPermittedRelations.add(rel);
this.setPermittedRelations(perm, newPermittedRelations);
}
public void removePermittedRelation(FPerm perm, Rel rel)
{
Set<Rel> newPermittedRelations = EnumSet.noneOf(Rel.class);
newPermittedRelations.addAll(this.getPermittedRelations(perm));
newPermittedRelations.remove(rel);
this.setPermittedRelations(perm, newPermittedRelations);
2012-05-09 06:29:52 +02:00
}*/
public void setRelationPermitted(FPerm perm, Rel rel, boolean permitted)
{
Set<Rel> newPermittedRelations = EnumSet.noneOf(Rel.class);
newPermittedRelations.addAll(this.getPermittedRelations(perm));
if (permitted)
{
newPermittedRelations.add(rel);
}
else
{
newPermittedRelations.remove(rel);
}
this.setPermittedRelations(perm, newPermittedRelations);
}
public void setPermittedRelations(FPerm perm, Set<Rel> rels)
{
if (perm.getDefault().equals(rels))
{
this.permOverrides.remove(perm);
return;
}
this.permOverrides.put(perm, rels);
}
public void setPermittedRelations(FPerm perm, Rel... rels)
{
Set<Rel> temp = new HashSet<Rel>();
temp.addAll(Arrays.asList(rels));
this.setPermittedRelations(perm, temp);
}
2011-10-23 20:50:49 +02:00
2011-10-22 18:12:15 +02:00
// -------------------------------------------- //
// CONSTRUCT
// -------------------------------------------- //
public Faction()
{
this.flagOverrides = new LinkedHashMap<FFlag, Boolean>();
2011-10-24 01:37:51 +02:00
this.permOverrides = new LinkedHashMap<FPerm, Set<Rel>>();
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
}
// -------------------------------------------- //
// FIELD: open
// -------------------------------------------- //
2011-03-22 17:20:21 +01:00
public boolean isOpen()
2011-10-12 17:25:01 +02:00
{
Boolean ret = this.open;
if (ret == null) ret = ConfServer.newFactionsDefaultOpen;
return ret;
2011-10-12 17:25:01 +02:00
}
public void setOpen(Boolean open)
2011-10-12 17:25:01 +02:00
{
this.open = open;
this.changed();
2011-10-12 17:25:01 +02:00
}
// -------------------------------------------- //
// FIELD: relationWish
// -------------------------------------------- //
// RAW
public Map<String, Rel> getRelationWishes()
2011-10-12 17:25:01 +02:00
{
Map<String, Rel> ret = new LinkedHashMap<String, Rel>();
if (this.relationWish != null) ret.putAll(this.relationWish);
return ret;
2011-10-12 17:25:01 +02:00
}
public void setRelationWishes(Map<String, Rel> relationWishes)
2011-10-12 17:25:01 +02:00
{
if (relationWishes == null || relationWishes.isEmpty())
{
this.relationWish = null;
}
else
{
this.relationWish = relationWishes;
}
this.changed();
2011-10-12 17:25:01 +02:00
}
// FINER
public Rel getRelationWish(String factionId)
2011-10-12 17:25:01 +02:00
{
Rel ret = this.getRelationWishes().get(factionId);
if (ret == null) ret = Rel.NEUTRAL;
return ret;
2011-10-12 17:25:01 +02:00
}
public Rel getRelationWish(Faction faction)
{
return this.getRelationWish(faction.getId());
2011-03-22 17:20:21 +01:00
}
public void setRelationWish(String factionId, Rel rel)
{
Map<String, Rel> relationWishes = this.getRelationWishes();
if (rel == null || rel == Rel.NEUTRAL)
{
relationWishes.remove(factionId);
}
else
{
relationWishes.put(factionId, rel);
2011-03-22 17:20:21 +01:00
}
this.setRelationWishes(relationWishes);
2011-03-22 17:20:21 +01:00
}
public void setRelationWish(Faction faction, Rel rel)
{
this.setRelationWish(faction.getId(), rel);
}
// TODO: What is this and where is it used?
2011-11-24 16:53:59 +01:00
public Map<Rel, List<String>> getFactionTagsPerRelation(RelationParticipator rp)
{
return getFactionTagsPerRelation(rp, false);
}
// 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)
{
Map<Rel, List<String>> ret = new HashMap<Rel, List<String>>();
for (Rel rel : Rel.values())
{
ret.put(rel, new ArrayList<String>());
}
for (Faction faction : FactionColl.get().getAll())
{
Rel relation = faction.getRelationTo(this);
if (onlyNonNeutral && relation == Rel.NEUTRAL) continue;
2011-11-24 16:53:59 +01:00
ret.get(relation).add(faction.getTag(rp));
}
return ret;
}
// -------------------------------------------- //
// 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());
}
// -------------------------------------------- //
// FIELD: home
// -------------------------------------------- //
// TODO: Checkery is a bit weird?
public PS getHome()
{
this.verifyHomeIsValid();
return this.home;
}
public void verifyHomeIsValid()
{
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;
}
// -------------------------------------------- //
// FIELD: cape
// -------------------------------------------- //
public String getCape()
{
return cape;
}
public void setCape(String cape)
{
this.cape = cape;
SpoutFeatures.updateCape(this, null);
}
// -------------------------------------------- //
// FIELD: powerBoost
// -------------------------------------------- //
// RAW
public double getPowerBoost()
{
Double ret = this.powerBoost;
if (ret == null) ret = 0D;
return ret;
}
public void setPowerBoost(Double powerBoost)
{
if (powerBoost == null || powerBoost == 0)
{
powerBoost = null;
}
this.powerBoost = powerBoost;
this.changed();
}
// -------------------------------------------- //
// 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);
}
// -------------------------------------------- //
// RELATION AND 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);
}
2011-10-24 03:02:25 +02:00
// TODO: Implement a has enough feature.
// -------------------------------------------- //
// POWER
// -------------------------------------------- //
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.powerBoost;
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.powerBoost;
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
}
// -------------------------------------------- //
// FPLAYERS
// -------------------------------------------- //
public List<FPlayer> getFPlayers()
{
List<FPlayer> ret = new ArrayList<FPlayer>();
2013-04-12 08:56:26 +02:00
for (FPlayer fplayer : FPlayerColl.get().getAll())
{
if (fplayer.getFaction() != this) continue;
ret.add(fplayer);
2011-02-06 13:36:11 +01:00
}
return ret;
}
public List<FPlayer> getFPlayersWhereOnline(boolean online)
{
List<FPlayer> ret = new ArrayList<FPlayer>();
for (FPlayer fplayer : FPlayerColl.get().getAll())
{
if (fplayer.getFaction() != this) continue;
if (fplayer.isOnline() != online) continue;
ret.add(fplayer);
}
2011-02-06 13:36:11 +01:00
return ret;
}
public List<FPlayer> getFPlayersWhereRole(Rel role)
{
List<FPlayer> ret = new ArrayList<FPlayer>();
for (FPlayer fplayer : FPlayerColl.get().getAll())
{
if (fplayer.getFaction() != this) continue;
if (fplayer.getRole() != role) continue;
ret.add(fplayer);
2011-02-06 13:36:11 +01:00
}
return ret;
}
public FPlayer getLeader()
{
for (FPlayer fplayer : FPlayerColl.get().getAll())
{
if (fplayer.getFaction() != this) continue;
if (fplayer.getRole() != Rel.LEADER) continue;
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 SenderEntity class using a for loop.
2013-04-10 10:32:04 +02:00
// CONVENIENCE SEND MESSAGE
public boolean sendMessage(String message)
{
for (FPlayer fplayer : this.getFPlayers())
{
fplayer.sendMessage(message);
}
2013-04-12 08:56:26 +02:00
return true;
}
public boolean sendMessage(String... messages)
{
for (FPlayer fplayer : this.getFPlayers())
{
fplayer.sendMessage(messages);
2011-02-06 13:36:11 +01:00
}
return true;
2011-02-06 13:36:11 +01:00
}
public boolean sendMessage(Collection<String> messages)
{
for (FPlayer fplayer : this.getFPlayers())
{
2011-03-22 17:20:21 +01:00
fplayer.sendMessage(messages);
2011-02-06 13:36:11 +01:00
}
return true;
}
// CONVENIENCE MSG
public boolean msg(String msg)
{
for (FPlayer fplayer : this.getFPlayers())
{
fplayer.msg(msg);
}
return true;
2011-02-06 13:36:11 +01:00
}
public boolean msg(String msg, Object... args)
{
for (FPlayer fplayer : this.getFPlayers())
{
fplayer.msg(msg, args);
}
return true;
}
public boolean msg(Collection<String> msgs)
{
for (FPlayer fplayer : this.getFPlayers())
{
fplayer.msg(msgs);
}
return true;
}
2011-03-18 17:33:23 +01:00
2011-02-06 13:36:11 +01:00
}