2013-04-22 09:37:53 +02:00
package com.massivecraft.factions.entity ;
2011-02-06 13:36:11 +01:00
2013-04-22 09:37:53 +02:00
import com.massivecraft.factions.Factions ;
2017-03-24 22:59:44 +01:00
import com.massivecraft.factions.FactionsIndex ;
2017-03-15 18:22:17 +01:00
import com.massivecraft.factions.FactionsParticipator ;
2013-04-22 09:37:53 +02:00
import com.massivecraft.factions.Rel ;
import com.massivecraft.factions.RelationParticipator ;
2017-04-06 22:32:52 +02:00
import com.massivecraft.factions.Selector ;
import com.massivecraft.factions.SelectorType ;
import com.massivecraft.factions.cmd.CmdFactions ;
import com.massivecraft.factions.cmd.type.TypeFaction ;
import com.massivecraft.factions.cmd.type.TypeMPlayer ;
import com.massivecraft.factions.cmd.type.TypeRel ;
import com.massivecraft.factions.cmd.type.TypeSelector ;
2017-03-24 14:29:26 +01:00
import com.massivecraft.factions.predicate.PredicateCommandSenderFaction ;
import com.massivecraft.factions.predicate.PredicateMPlayerRole ;
2016-01-25 09:49:43 +01:00
import com.massivecraft.factions.util.MiscUtil ;
import com.massivecraft.factions.util.RelationUtil ;
2016-03-15 20:43:54 +01:00
import com.massivecraft.massivecore.collections.MassiveList ;
2017-03-25 00:47:01 +01:00
import com.massivecraft.massivecore.collections.MassiveMap ;
2014-11-13 11:41:21 +01:00
import com.massivecraft.massivecore.collections.MassiveMapDef ;
2017-03-25 00:47:01 +01:00
import com.massivecraft.massivecore.collections.MassiveSet ;
2017-04-06 22:32:52 +02:00
import com.massivecraft.massivecore.collections.MassiveSetDef ;
import com.massivecraft.massivecore.command.type.Type ;
2016-05-13 12:32:05 +02:00
import com.massivecraft.massivecore.mixin.MixinMessage ;
2014-06-04 14:02:23 +02:00
import com.massivecraft.massivecore.money.Money ;
2017-04-06 22:32:52 +02:00
import com.massivecraft.massivecore.mson.Mson ;
2016-02-03 05:06:49 +01:00
import com.massivecraft.massivecore.predicate.Predicate ;
2017-01-20 09:32:23 +01:00
import com.massivecraft.massivecore.predicate.PredicateAnd ;
import com.massivecraft.massivecore.predicate.PredicateVisibleTo ;
2014-06-04 14:02:23 +02:00
import com.massivecraft.massivecore.ps.PS ;
import com.massivecraft.massivecore.store.Entity ;
2017-04-20 11:05:56 +02:00
import com.massivecraft.massivecore.store.EntityInternalMap ;
2016-01-25 09:49:43 +01:00
import com.massivecraft.massivecore.store.SenderColl ;
2014-06-04 14:02:23 +02:00
import com.massivecraft.massivecore.util.IdUtil ;
import com.massivecraft.massivecore.util.MUtil ;
import com.massivecraft.massivecore.util.Txt ;
2017-03-24 13:05:58 +01:00
import org.bukkit.ChatColor ;
import org.bukkit.command.CommandSender ;
import org.bukkit.entity.Player ;
import java.util.Collection ;
2017-05-01 21:15:25 +02:00
import java.util.Comparator ;
2017-03-24 13:05:58 +01:00
import java.util.Iterator ;
import java.util.List ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Set ;
2011-02-06 13:36:11 +01:00
2017-03-15 18:22:17 +01:00
public class Faction extends Entity < Faction > implements FactionsParticipator
2011-10-08 22:03:44 +02:00
{
2017-03-24 14:29:26 +01:00
// -------------------------------------------- //
// CONSTANTS
// -------------------------------------------- //
public static final transient String NODESCRIPTION = Txt . parse ( " <em><silver>no description set " ) ;
public static final transient String NOMOTD = Txt . parse ( " <em><silver>no message of the day set " ) ;
2013-04-11 12:22:35 +02:00
// -------------------------------------------- //
// META
// -------------------------------------------- //
2013-04-12 09:47:43 +02:00
public static Faction get ( Object oid )
2013-04-11 12:22:35 +02:00
{
2014-09-17 13:17:33 +02:00
return FactionColl . get ( ) . get ( oid ) ;
2013-04-12 09:47:43 +02:00
}
2013-04-11 12:22:35 +02:00
// -------------------------------------------- //
// OVERRIDE: ENTITY
// -------------------------------------------- //
2013-04-12 09:47:43 +02:00
@Override
2013-04-11 12:22:35 +02:00
public Faction load ( Faction that )
{
2013-04-24 19:01:17 +02:00
this . setName ( that . name ) ;
2013-04-17 08:49:43 +02:00
this . setDescription ( that . description ) ;
2014-10-02 16:12:16 +02:00
this . setMotd ( that . motd ) ;
2013-04-25 10:51:11 +02:00
this . setCreatedAtMillis ( that . createdAtMillis ) ;
2013-04-24 18:22:52 +02:00
this . setHome ( that . home ) ;
2013-04-17 12:08:30 +02:00
this . setPowerBoost ( that . powerBoost ) ;
2017-04-20 11:05:56 +02:00
this . invitations . load ( that . invitations ) ;
2013-04-25 08:34:10 +02:00
this . setRelationWishes ( that . relationWishes ) ;
2014-10-02 11:45:06 +02:00
this . setFlagIds ( that . flags ) ;
2014-10-02 14:02:07 +02:00
this . setPermIds ( that . perms ) ;
2017-04-06 22:32:52 +02:00
this . factionBans . load ( that . factionBans ) ;
2013-04-11 12:22:35 +02:00
return this ;
2013-04-12 08:56:26 +02:00
}
2013-06-18 09:07:05 +02:00
@Override
public void preDetach ( String id )
{
2017-03-25 00:47:01 +01:00
if ( ! this . isLive ( ) ) return ;
2014-10-01 22:00:08 +02:00
2016-01-24 20:07:09 +01:00
// NOTE: Existence check is required for compatibility with some plugins.
// If they have money ...
if ( Money . exists ( this ) )
{
// ... remove it.
Money . set ( this , null , 0 ) ;
}
2013-06-18 09:07:05 +02:00
}
2017-04-20 11:05:56 +02:00
// -------------------------------------------- //
// VERSION
// -------------------------------------------- //
2017-04-06 22:32:52 +02:00
public int version = 2 ;
2017-04-20 11:05:56 +02:00
2013-04-11 12:22:35 +02:00
// -------------------------------------------- //
// FIELDS: RAW
// -------------------------------------------- //
2013-04-17 10:22:51 +02:00
// In this section of the source code we place the field declarations only.
2013-04-17 15:30:21 +02:00
// Each field has it's own section further down since just the getter and setter logic takes up quite some place.
2013-04-11 12:22:35 +02:00
2013-04-17 10:22:51 +02:00
// 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.
2013-04-24 19:01:17 +02:00
// Null should never happen. The name must not be null.
private String name = null ;
2013-04-11 12:22:35 +02:00
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.
2013-04-24 14:42:52 +02:00
// Null means the faction has no description.
2013-04-17 10:22:51 +02:00
private String description = null ;
2011-10-08 22:03:44 +02:00
2014-10-02 16:12:16 +02:00
// Factions can optionally set a message of the day.
// This message will be shown when logging on to the server.
// Null means the faction has no motd
private String motd = null ;
2013-04-25 10:51:11 +02:00
// We store the creation date for the faction.
// It can be displayed on info pages etc.
private long createdAtMillis = System . currentTimeMillis ( ) ;
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
2013-04-24 14:42:52 +02:00
// Null means the faction has no home.
2013-04-17 12:08:30 +02:00
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.
2013-04-24 14:42:52 +02:00
// Null means the faction has powerBoost (0).
2013-04-17 12:08:30 +02:00
private Double powerBoost = null ;
// Can anyone join the Faction?
// If the faction is open they can.
// If the faction is closed an invite is required.
2014-09-17 13:33:09 +02:00
// Null means default.
2014-10-02 11:45:06 +02:00
// private Boolean open = null;
2011-03-22 18:48:09 +01:00
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.
2013-04-24 14:42:52 +02:00
// Null means no one is invited
2017-04-20 11:05:56 +02:00
private EntityInternalMap < Invitation > invitations = new EntityInternalMap < > ( this , Invitation . class ) ;
2013-04-17 10:22:51 +02:00
2013-04-17 12:08:30 +02:00
// The keys in this map are factionIds.
2013-04-24 14:42:52 +02:00
// Null means no special relation whishes.
2017-03-24 14:03:29 +01:00
private MassiveMapDef < String , Rel > relationWishes = new MassiveMapDef < > ( ) ;
2011-03-23 17:39:56 +01:00
2013-04-17 13:16:22 +02:00
// The flag overrides are modifications to the default values.
2014-09-17 13:33:09 +02:00
// Null means default.
2017-03-24 14:03:29 +01:00
private MassiveMapDef < String , Boolean > flags = new MassiveMapDef < > ( ) ;
2011-10-23 23:17:02 +02:00
2013-04-17 13:16:22 +02:00
// The perm overrides are modifications to the default values.
2014-09-17 13:33:09 +02:00
// Null means default.
2017-04-06 22:32:52 +02:00
private MassiveMapDef < String , Set < String > > perms = new MassiveMapDef < > ( ) ;
// The perm blacklist of which selectors are not allowed in any way.
private EntityInternalMap < FactionBan > factionBans = new EntityInternalMap < > ( this , FactionBan . class ) ;
2011-10-23 20:50:49 +02:00
2013-04-11 12:22:35 +02:00
// -------------------------------------------- //
2013-04-17 10:22:51 +02:00
// FIELD: id
2013-04-11 12:22:35 +02:00
// -------------------------------------------- //
2013-04-17 10:22:51 +02:00
// FINER
2013-04-11 12:22:35 +02:00
2013-04-17 10:22:51 +02:00
public boolean isNone ( )
2013-04-11 12:22:35 +02:00
{
2014-10-01 22:00:08 +02:00
return this . getId ( ) . equals ( Factions . ID_NONE ) ;
2013-04-17 10:22:51 +02:00
}
public boolean isNormal ( )
{
return ! this . isNone ( ) ;
}
// -------------------------------------------- //
2013-04-24 19:01:17 +02:00
// FIELD: name
2013-04-17 10:22:51 +02:00
// -------------------------------------------- //
// RAW
2015-11-06 02:10:29 +01:00
@Override
2013-04-24 19:01:17 +02:00
public String getName ( )
2013-04-11 12:22:35 +02:00
{
2013-04-24 19:01:17 +02:00
String ret = this . name ;
2013-04-24 16:40:35 +02:00
2014-09-17 13:17:33 +02:00
if ( MConf . get ( ) . factionNameForceUpperCase )
2013-04-11 12:22:35 +02:00
{
2013-04-17 10:22:51 +02:00
ret = ret . toUpperCase ( ) ;
2013-04-11 12:22:35 +02:00
}
2013-04-24 16:40:35 +02:00
2013-04-17 10:22:51 +02:00
return ret ;
2013-04-11 12:22:35 +02:00
}
2013-04-25 08:34:10 +02:00
public void setName ( String name )
2013-04-11 12:22:35 +02:00
{
2013-04-25 08:34:10 +02:00
// Clean input
String target = name ;
// Detect Nochange
if ( MUtil . equals ( this . name , target ) ) return ;
2013-04-24 16:40:35 +02:00
2013-04-25 08:34:10 +02:00
// Apply
this . name = target ;
// Mark as changed
2013-04-17 10:22:51 +02:00
this . changed ( ) ;
2013-04-11 12:22:35 +02:00
}
2013-04-17 10:22:51 +02:00
// FINER
2013-04-11 12:22:35 +02:00
2013-04-24 19:01:17 +02:00
public String getComparisonName ( )
2013-04-11 12:22:35 +02:00
{
2013-04-24 19:01:17 +02:00
return MiscUtil . getComparisonString ( this . getName ( ) ) ;
2013-04-11 12:22:35 +02:00
}
2013-04-24 19:01:17 +02:00
public String getName ( String prefix )
2013-04-11 12:22:35 +02:00
{
2013-04-24 19:01:17 +02:00
return prefix + this . getName ( ) ;
2013-04-11 12:22:35 +02:00
}
2013-04-17 10:22:51 +02:00
2013-04-24 19:01:17 +02:00
public String getName ( RelationParticipator observer )
2013-04-17 10:22:51 +02:00
{
2013-04-24 19:01:17 +02:00
if ( observer = = null ) return getName ( ) ;
return this . getName ( this . getColorTo ( observer ) . toString ( ) ) ;
2013-04-17 10:22:51 +02:00
}
2013-04-17 08:49:43 +02:00
// -------------------------------------------- //
2013-04-17 10:22:51 +02:00
// FIELD: description
2013-04-17 08:49:43 +02:00
// -------------------------------------------- //
2011-10-23 20:50:49 +02:00
2013-04-17 10:22:51 +02:00
// RAW
public boolean hasDescription ( )
2011-10-08 22:03:44 +02:00
{
2013-04-17 10:22:51 +02:00
return this . description ! = null ;
2011-03-23 17:39:56 +01:00
}
2013-04-17 10:22:51 +02:00
public String getDescription ( )
2011-10-08 22:03:44 +02:00
{
2017-05-09 10:59:38 +02:00
return this . description ;
2013-04-17 10:22:51 +02:00
}
public void setDescription ( String description )
{
2013-04-25 08:34:10 +02:00
// Clean input
2017-04-21 20:12:41 +02:00
String target = clean ( description ) ;
2013-04-25 08:34:10 +02:00
// Detect Nochange
if ( MUtil . equals ( this . description , target ) ) return ;
// Apply
this . description = target ;
// Mark as changed
2013-04-17 10:22:51 +02:00
this . changed ( ) ;
2011-03-23 17:39:56 +01:00
}
2017-05-09 10:59:38 +02:00
// FINER
public String getDescriptionDesc ( )
{
String motd = this . getDescription ( ) ;
if ( motd = = null ) motd = NODESCRIPTION ;
return motd ;
}
2014-10-02 16:12:16 +02:00
// -------------------------------------------- //
// FIELD: motd
// -------------------------------------------- //
// RAW
public boolean hasMotd ( )
{
return this . motd ! = null ;
}
public String getMotd ( )
{
2017-05-09 10:59:38 +02:00
return this . motd ;
2014-10-02 16:12:16 +02:00
}
2017-04-21 20:12:41 +02:00
public void setMotd ( String motd )
2014-10-02 16:12:16 +02:00
{
// Clean input
2017-04-21 20:12:41 +02:00
String target = clean ( motd ) ;
2014-10-02 16:12:16 +02:00
// Detect Nochange
if ( MUtil . equals ( this . motd , target ) ) return ;
// Apply
this . motd = target ;
// Mark as changed
this . changed ( ) ;
}
// FINER
2017-05-09 10:59:38 +02:00
public String getMotdDesc ( )
{
return getMotdDesc ( this . getMotd ( ) ) ;
}
private static String getMotdDesc ( String motd )
{
if ( motd = = null ) motd = NOMOTD ;
return motd ;
}
2016-03-15 20:43:54 +01:00
public List < Object > getMotdMessages ( )
2014-10-02 16:12:16 +02:00
{
2016-03-15 20:43:54 +01:00
// Create
List < Object > ret = new MassiveList < > ( ) ;
// Fill
Object title = this . getName ( ) + " - Message of the Day " ;
title = Txt . titleize ( title ) ;
ret . add ( title ) ;
2017-05-09 10:59:38 +02:00
String motd = Txt . parse ( " <i> " ) + this . getMotdDesc ( ) ;
2016-03-15 20:43:54 +01:00
ret . add ( motd ) ;
ret . add ( " " ) ;
// Return
return ret ;
2014-10-02 16:12:16 +02:00
}
2013-04-25 10:51:11 +02:00
// -------------------------------------------- //
// FIELD: createdAtMillis
// -------------------------------------------- //
public long getCreatedAtMillis ( )
{
return this . createdAtMillis ;
}
public void setCreatedAtMillis ( long createdAtMillis )
{
// Clean input
long target = createdAtMillis ;
// Detect Nochange
if ( MUtil . equals ( this . createdAtMillis , createdAtMillis ) ) return ;
// Apply
this . createdAtMillis = target ;
// Mark as changed
this . changed ( ) ;
}
2013-04-17 08:49:43 +02:00
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
// FIELD: home
2013-04-17 08:49:43 +02:00
// -------------------------------------------- //
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 ;
2015-11-30 20:18:16 +01:00
this . changed ( ) ;
2013-04-17 12:08:30 +02:00
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 ;
2014-09-17 13:17:33 +02:00
if ( ! MConf . get ( ) . homesMustBeInClaimedTerritory ) return true ;
if ( BoardColl . get ( ) . getFactionAt ( ps ) = = this ) return true ;
2013-04-17 12:08:30 +02:00
return false ;
}
public boolean hasHome ( )
{
return this . getHome ( ) ! = null ;
}
public void setHome ( PS home )
{
2013-04-25 08:34:10 +02:00
// Clean input
PS target = home ;
// Detect Nochange
if ( MUtil . equals ( this . home , target ) ) return ;
// Apply
this . home = target ;
// Mark as changed
2013-04-24 18:22:52 +02:00
this . changed ( ) ;
2011-10-12 17:25:01 +02:00
}
2013-04-17 10:22:51 +02:00
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
// FIELD: powerBoost
2013-04-17 10:22:51 +02:00
// -------------------------------------------- //
// RAW
2017-03-15 18:22:17 +01:00
@Override
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 ;
2013-04-17 10:22:51 +02:00
return ret ;
2011-10-12 17:25:01 +02:00
}
2017-03-15 18:22:17 +01:00
@Override
2013-04-17 12:08:30 +02:00
public void setPowerBoost ( Double powerBoost )
2011-10-12 17:25:01 +02:00
{
2013-04-25 08:34:10 +02:00
// 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
2013-04-17 10:22:51 +02:00
this . changed ( ) ;
2011-10-12 17:25:01 +02:00
}
2013-04-17 12:08:30 +02:00
// -------------------------------------------- //
// FIELD: open
// -------------------------------------------- //
2011-03-22 17:20:21 +01:00
2014-11-13 11:41:21 +01:00
// Nowadays this is a flag!
@Deprecated
2013-04-23 14:00:18 +02:00
public boolean isDefaultOpen ( )
{
2014-11-13 11:41:21 +01:00
return MFlag . getFlagOpen ( ) . isStandard ( ) ;
2013-04-23 14:00:18 +02:00
}
2014-11-13 11:41:21 +01:00
@Deprecated
2013-04-17 12:08:30 +02:00
public boolean isOpen ( )
2013-04-17 10:22:51 +02:00
{
2014-11-13 11:41:21 +01:00
return this . getFlag ( MFlag . getFlagOpen ( ) ) ;
2013-04-17 10:22:51 +02:00
}
2014-11-13 11:41:21 +01:00
@Deprecated
2013-04-25 11:00:17 +02:00
public void setOpen ( Boolean open )
2011-11-24 16:27:14 +01:00
{
2014-11-13 11:41:21 +01:00
MFlag flag = MFlag . getFlagOpen ( ) ;
if ( open = = null ) open = flag . isStandard ( ) ;
this . setFlag ( flag , open ) ;
}
2011-11-24 16:27:14 +01:00
2013-04-17 10:22:51 +02:00
// -------------------------------------------- //
// FIELD: invitedPlayerIds
// -------------------------------------------- //
// RAW
2017-04-20 11:05:56 +02:00
public EntityInternalMap < Invitation > getInvitations ( ) { return this . invitations ; }
2013-04-17 10:22:51 +02:00
// FINER
public boolean isInvited ( String playerId )
{
2017-04-20 11:05:56 +02:00
return this . getInvitations ( ) . containsKey ( playerId ) ;
2013-04-17 10:22:51 +02:00
}
2014-09-17 13:29:58 +02:00
public boolean isInvited ( MPlayer mplayer )
2013-04-17 10:22:51 +02:00
{
2014-09-17 13:29:58 +02:00
return this . isInvited ( mplayer . getId ( ) ) ;
2013-04-17 10:22:51 +02:00
}
2017-04-20 11:05:56 +02:00
public boolean uninvite ( String playerId )
2013-04-17 10:22:51 +02:00
{
2017-05-28 18:23:14 +02:00
System . out . println ( playerId ) ;
2017-05-28 18:17:08 +02:00
return this . getInvitations ( ) . detachId ( playerId ) ! = null ;
2013-04-17 10:22:51 +02:00
}
2017-04-20 11:05:56 +02:00
public boolean uninvite ( MPlayer mplayer )
2013-04-17 10:22:51 +02:00
{
2017-04-20 11:05:56 +02:00
return uninvite ( mplayer . getId ( ) ) ;
2013-04-17 10:22:51 +02:00
}
2017-04-20 11:05:56 +02:00
public void invite ( String playerId , Invitation invitation )
2015-01-13 13:50:38 +01:00
{
2017-04-20 11:05:56 +02:00
uninvite ( playerId ) ;
this . invitations . attach ( invitation , playerId ) ;
2015-01-13 13:50:38 +01:00
}
2013-04-17 11:47:48 +02:00
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
// FIELD: relationWish
2013-04-17 11:47:48 +02:00
// -------------------------------------------- //
2013-04-17 12:08:30 +02:00
// RAW
2013-04-17 11:47:48 +02:00
2013-04-17 12:08:30 +02:00
public Map < String , Rel > getRelationWishes ( )
2013-04-17 11:47:48 +02:00
{
2014-11-13 11:41:21 +01:00
return this . relationWishes ;
2013-04-17 11:47:48 +02:00
}
2013-04-17 12:08:30 +02:00
public void setRelationWishes ( Map < String , Rel > relationWishes )
2013-04-17 11:47:48 +02:00
{
2013-04-25 08:34:10 +02:00
// Clean input
2017-03-24 14:03:29 +01:00
MassiveMapDef < String , Rel > target = new MassiveMapDef < > ( relationWishes ) ;
2013-04-25 08:34:10 +02:00
// Detect Nochange
if ( MUtil . equals ( this . relationWishes , target ) ) return ;
// Apply
this . relationWishes = target ;
// Mark as changed
2013-04-17 12:08:30 +02:00
this . changed ( ) ;
2013-04-17 11:47:48 +02:00
}
2013-04-17 12:08:30 +02:00
// FINER
2013-04-17 11:47:48 +02:00
2013-04-17 12:08:30 +02:00
public Rel getRelationWish ( String factionId )
2013-04-17 11:47:48 +02:00
{
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 11:47:48 +02:00
}
2013-04-17 12:08:30 +02:00
public Rel getRelationWish ( Faction faction )
2013-04-17 11:47:48 +02:00
{
2013-04-17 12:08:30 +02:00
return this . getRelationWish ( faction . getId ( ) ) ;
2013-04-17 11:47:48 +02:00
}
2013-04-17 12:08:30 +02:00
public void setRelationWish ( String factionId , Rel rel )
2013-04-17 11:47:48 +02:00
{
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 11:47:48 +02:00
}
2013-04-17 12:08:30 +02:00
public void setRelationWish ( Faction faction , Rel rel )
2013-04-17 11:47:48 +02:00
{
2013-04-17 12:08:30 +02:00
this . setRelationWish ( faction . getId ( ) , rel ) ;
2013-04-17 11:47:48 +02:00
}
2013-04-17 10:22:51 +02:00
// -------------------------------------------- //
// FIELD: flagOverrides
// -------------------------------------------- //
// RAW
2014-10-02 11:45:06 +02:00
public Map < MFlag , Boolean > getFlags ( )
2013-04-17 10:22:51 +02:00
{
2014-10-02 11:45:06 +02:00
// We start with default values ...
2017-03-25 00:47:01 +01:00
Map < MFlag , Boolean > ret = new MassiveMap < > ( ) ;
2014-10-02 11:45:06 +02:00
for ( MFlag mflag : MFlag . getAll ( ) )
2013-04-17 10:22:51 +02:00
{
2014-10-02 11:45:06 +02:00
ret . put ( mflag , mflag . isStandard ( ) ) ;
2013-04-17 10:22:51 +02:00
}
2014-10-02 14:02:07 +02:00
// ... and if anything is explicitly set we use that info ...
2014-11-13 11:41:21 +01:00
Iterator < Entry < String , Boolean > > iter = this . flags . entrySet ( ) . iterator ( ) ;
while ( iter . hasNext ( ) )
2013-04-17 10:22:51 +02:00
{
2014-11-13 11:41:21 +01:00
// ... for each entry ...
Entry < String , Boolean > entry = iter . next ( ) ;
// ... extract id and remove null values ...
String id = entry . getKey ( ) ;
if ( id = = null )
2013-04-17 10:22:51 +02:00
{
2014-11-13 11:41:21 +01:00
iter . remove ( ) ;
this . changed ( ) ;
continue ;
2013-04-17 10:22:51 +02:00
}
2014-11-13 11:41:21 +01:00
// ... resolve object and skip unknowns ...
MFlag mflag = MFlag . get ( id ) ;
if ( mflag = = null ) continue ;
ret . put ( mflag , entry . getValue ( ) ) ;
2013-04-17 10:22:51 +02:00
}
return ret ;
}
2014-11-13 11:41:21 +01:00
public void setFlags ( Map < MFlag , Boolean > flags )
{
2017-03-25 00:47:01 +01:00
Map < String , Boolean > flagIds = new MassiveMap < > ( ) ;
2014-11-13 11:41:21 +01:00
for ( Entry < MFlag , Boolean > entry : flags . entrySet ( ) )
{
flagIds . put ( entry . getKey ( ) . getId ( ) , entry . getValue ( ) ) ;
}
setFlagIds ( flagIds ) ;
}
public void setFlagIds ( Map < String , Boolean > flagIds )
2013-04-17 10:22:51 +02:00
{
2013-04-25 08:34:10 +02:00
// Clean input
2017-03-24 14:03:29 +01:00
MassiveMapDef < String , Boolean > target = new MassiveMapDef < > ( ) ;
2014-11-13 11:41:21 +01:00
for ( Entry < String , Boolean > entry : flagIds . entrySet ( ) )
2013-04-17 10:22:51 +02:00
{
2014-11-13 11:41:21 +01:00
String key = entry . getKey ( ) ;
if ( key = = null ) continue ;
key = key . toLowerCase ( ) ; // Lowercased Keys Version 2.6.0 --> 2.7.0
2013-04-25 08:34:10 +02:00
2014-11-13 11:41:21 +01:00
Boolean value = entry . getValue ( ) ;
if ( value = = null ) continue ;
target . put ( key , value ) ;
2013-04-17 10:22:51 +02:00
}
2013-04-25 08:34:10 +02:00
// Detect Nochange
if ( MUtil . equals ( this . flags , target ) ) return ;
2013-04-17 10:22:51 +02:00
2013-04-25 08:34:10 +02:00
// Apply
2017-03-24 14:03:29 +01:00
this . flags = new MassiveMapDef < > ( target ) ;
2013-04-25 08:34:10 +02:00
// Mark as changed
2013-04-17 10:22:51 +02:00
this . changed ( ) ;
}
2014-11-13 11:41:21 +01:00
// FINER
public boolean getFlag ( String flagId )
2014-10-02 11:45:06 +02:00
{
2014-11-13 11:41:21 +01:00
if ( flagId = = null ) throw new NullPointerException ( " flagId " ) ;
Boolean ret = this . flags . get ( flagId ) ;
if ( ret ! = null ) return ret ;
MFlag flag = MFlag . get ( flagId ) ;
if ( flag = = null ) throw new NullPointerException ( " flag " ) ;
return flag . isStandard ( ) ;
2014-10-02 11:45:06 +02:00
}
public boolean getFlag ( MFlag flag )
2013-04-17 10:22:51 +02:00
{
2014-11-13 11:41:21 +01:00
if ( flag = = null ) throw new NullPointerException ( " flag " ) ;
String flagId = flag . getId ( ) ;
if ( flagId = = null ) throw new NullPointerException ( " flagId " ) ;
Boolean ret = this . flags . get ( flagId ) ;
if ( ret ! = null ) return ret ;
return flag . isStandard ( ) ;
2013-04-17 10:22:51 +02:00
}
2014-11-13 11:41:21 +01:00
public Boolean setFlag ( String flagId , boolean value )
2013-04-17 10:22:51 +02:00
{
2014-11-13 11:41:21 +01:00
if ( flagId = = null ) throw new NullPointerException ( " flagId " ) ;
Boolean ret = this . flags . put ( flagId , value ) ;
if ( ret = = null | | ret ! = value ) this . changed ( ) ;
return ret ;
}
public Boolean setFlag ( MFlag flag , boolean value )
{
if ( flag = = null ) throw new NullPointerException ( " flag " ) ;
String flagId = flag . getId ( ) ;
if ( flagId = = null ) throw new NullPointerException ( " flagId " ) ;
Boolean ret = this . flags . put ( flagId , value ) ;
if ( ret = = null | | ret ! = value ) this . changed ( ) ;
return ret ;
2013-04-17 10:22:51 +02:00
}
// -------------------------------------------- //
2017-04-06 22:32:52 +02:00
// FIELD: perms
2013-04-17 13:16:22 +02:00
// -------------------------------------------- //
// RAW
2017-04-06 22:32:52 +02:00
public MassiveMapDef < String , Set < String > > getPermIds ( )
{
return this . perms ;
}
2013-04-17 13:16:22 +02:00
2017-04-06 22:32:52 +02:00
public void setPermIds ( MassiveMapDef < String , Set < String > > perms )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
// Clean input
MassiveMapDef < String , Set < String > > target = new MassiveMapDef < String , Set < String > > ( ) ;
for ( Entry < String , Set < String > > entry : perms . entrySet ( ) )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
String key = entry . getKey ( ) ;
if ( key = = null ) continue ;
key = key . toLowerCase ( ) ; // Lowercased Keys Version 2.6.0 --> 2.7.0
Set < String > value = entry . getValue ( ) ;
if ( value = = null ) continue ;
target . put ( key , value ) ;
2013-04-17 13:16:22 +02:00
}
2017-04-06 22:32:52 +02:00
// Detect Nochange
if ( MUtil . equals ( this . perms , target ) ) return ;
// Apply
this . perms = target ;
// Mark as changed
this . changed ( ) ;
}
// Finer
public Map < MPerm , Set < String > > getPerms ( )
{
// We start with default values ...
Map < MPerm , Set < String > > ret = new MassiveMap < > ( ) ;
2014-10-02 14:02:07 +02:00
// ... and if anything is explicitly set we use that info ...
2017-04-06 22:32:52 +02:00
for ( Iterator < Entry < String , Set < String > > > it = this . getPermIds ( ) . entrySet ( ) . iterator ( ) ; it . hasNext ( ) ; )
2013-04-17 13:16:22 +02:00
{
2014-11-13 11:41:21 +01:00
// ... for each entry ...
2017-04-06 22:32:52 +02:00
Entry < String , Set < String > > entry = it . next ( ) ;
2014-11-13 11:41:21 +01:00
// ... extract id and remove null values ...
2017-04-06 22:32:52 +02:00
String id = entry . getKey ( ) ;
2014-11-13 11:41:21 +01:00
if ( id = = null )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
it . remove ( ) ;
2014-11-13 11:41:21 +01:00
continue ;
2013-04-17 13:16:22 +02:00
}
2014-11-13 11:41:21 +01:00
// ... resolve object and skip unknowns ...
MPerm mperm = MPerm . get ( id ) ;
if ( mperm = = null ) continue ;
2017-03-25 00:47:01 +01:00
ret . put ( mperm , new MassiveSet < > ( entry . getValue ( ) ) ) ;
2013-04-17 13:16:22 +02:00
}
2017-04-06 22:32:52 +02:00
for ( MPerm mperm : MPerm . getAll ( ) )
{
// Is already configured?
if ( ret . containsKey ( mperm ) ) continue ;
// Add
ret . put ( mperm , mperm . getStandardIds ( ) ) ;
}
2013-04-17 13:16:22 +02:00
return ret ;
}
2017-04-06 22:32:52 +02:00
public void setPerms ( Map < MPerm , Set < String > > perms )
2014-11-13 11:41:21 +01:00
{
2017-04-06 22:32:52 +02:00
// Create
MassiveMapDef < String , Set < String > > permIds = new MassiveMapDef < > ( ) ;
// Fill
for ( Entry < MPerm , Set < String > > entry : perms . entrySet ( ) )
2014-11-13 11:41:21 +01:00
{
permIds . put ( entry . getKey ( ) . getId ( ) , entry . getValue ( ) ) ;
}
2017-04-06 22:32:52 +02:00
// Set
this . setPermIds ( permIds ) ;
2014-11-13 11:41:21 +01:00
}
2017-04-06 22:32:52 +02:00
// -------------------------------------------- //
// PERMITTED
// -------------------------------------------- //
// Being permitted for a perm can have many reasons:
// For Players, either their Relation, Faction, Rank or themselves can have been permitted.
// For Factions, this can be their relation or themselves being permitted.
//
// For each selector we need to check if any of the sub-selectors are permitted.
private Set < String > getPermittedIds ( MPerm perm )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
String permId = perm . getId ( ) ;
Set < String > permitted = this . perms . get ( permId ) ;
return permitted ! = null ? permitted : perm . getStandardIds ( ) ;
}
public Set < MPerm > getPermittedFor ( Selector selector )
{
// Create
Set < MPerm > ret = new MassiveSet < > ( ) ;
// Fill
for ( MPerm perm : MPermColl . get ( ) . getAll ( ) )
2013-04-25 08:34:10 +02:00
{
2017-04-06 22:32:52 +02:00
if ( this . isPermitted ( perm , selector ) ) ret . add ( perm ) ;
2013-04-17 13:16:22 +02:00
}
2017-04-06 22:32:52 +02:00
// Return
return ret ;
}
public void setPermitted ( MPerm perm , Selector selector , boolean add )
{
if ( perm = = null ) throw new NullPointerException ( " perm " ) ;
if ( selector = = null ) throw new NullPointerException ( " selector " ) ;
2013-04-25 08:34:10 +02:00
2017-04-06 22:32:52 +02:00
// Get Ids
String idSelector = selector . getId ( ) ;
String idPerm = perm . getId ( ) ;
2013-04-25 08:34:10 +02:00
2017-04-06 22:32:52 +02:00
// Get perms
Map < String , Set < String > > perms = this . getPermIds ( ) ;
Set < String > selectors = perms . get ( idPerm ) ;
// If new, assign standard ids on first change.
if ( add & & selectors = = null ) selectors = new MassiveSetDef < > ( perm . getStandardIds ( ) ) ;
// Add || Remove
if ( add )
{
selectors . add ( idSelector ) ;
}
else if ( selectors ! = null )
{
selectors . remove ( idSelector ) ;
}
perms . put ( idPerm , selectors ) ;
// Changed
2013-04-17 13:16:22 +02:00
this . changed ( ) ;
}
2017-04-06 22:32:52 +02:00
public void setPermitted ( MPerm perm , Selector . . . selectors )
{
for ( Selector selector : selectors )
{
this . setPermitted ( perm , selector , true ) ;
}
}
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
public boolean isPermittedAny ( MPerm perm , Selector selector )
2014-10-02 14:02:07 +02:00
{
2017-04-06 22:32:52 +02:00
// Special
if ( selector instanceof MPlayer & & this . isPermittedPlayer ( perm , ( MPlayer ) selector ) ) return true ;
if ( selector instanceof Faction & & this . isPermittedFaction ( perm , ( Faction ) selector ) ) return true ;
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
// Default
return this . isPermitted ( perm , selector ) ;
2014-10-02 14:02:07 +02:00
}
2017-04-06 22:32:52 +02:00
private boolean isPermittedFaction ( MPerm perm , Faction faction )
2014-11-13 11:41:21 +01:00
{
2017-04-06 22:32:52 +02:00
return this . isPermittedAny ( perm , faction , faction . getRelationTo ( this ) ) ;
2014-11-13 11:41:21 +01:00
}
2013-04-17 13:16:22 +02:00
2017-04-06 22:32:52 +02:00
private boolean isPermittedPlayer ( MPerm perm , MPlayer mplayer )
{
// TODO: Add Rank in the future
return this . isPermittedAny ( perm , mplayer , mplayer . getFaction ( ) , mplayer . getRelationTo ( this ) ) ;
}
private boolean isPermittedAny ( MPerm perm , Selector . . . selectors )
{
for ( Selector selector : selectors )
{
if ( this . isPermitted ( perm , selector ) ) return true ;
}
return false ;
}
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
public boolean isPermitted ( MPerm perm , Selector selector )
2014-11-13 11:41:21 +01:00
{
if ( perm = = null ) throw new NullPointerException ( " perm " ) ;
2017-04-06 22:32:52 +02:00
if ( selector = = null ) throw new NullPointerException ( " selector " ) ;
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
// Is specifically granted?
Set < String > selectors = this . getPermIds ( ) . get ( perm . getId ( ) ) ;
if ( selectors ! = null ) return selectors . contains ( selector . getId ( ) ) ;
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
// Is standard?
return selector instanceof Rel & & perm . getStandard ( ) . contains ( selector ) ;
}
// -------------------------------------------- //
// PERMITTED > VISUAL
// -------------------------------------------- //
public List < Mson > getPermittedShow ( MPerm perm , RelationParticipator relationParticipator )
{
// Resolve Permitted
Map < SelectorType , List < Selector > > permitted = this . resolvePermitted ( perm ) ;
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
// Return show
return this . getPermittedShow ( perm , permitted , relationParticipator ) ;
2014-11-13 11:41:21 +01:00
}
2017-04-06 22:32:52 +02:00
public Mson getPermittedLine ( MPerm perm , RelationParticipator relationParticipator )
2014-11-13 11:41:21 +01:00
{
2017-04-06 22:32:52 +02:00
// Create
Mson ret = Mson . EMPTY ;
Map < SelectorType , List < Selector > > permitted = this . resolvePermitted ( perm ) ;
// Fill > Ranks
List < Selector > ranks = permitted . get ( SelectorType . RANK ) ;
if ( ranks ! = null )
{
Mson rankMson = Mson . EMPTY ;
for ( Selector selector : ranks )
{
Rel rank = ( Rel ) selector ;
// TODO: Change this to number after ranks are creatable
Mson mson = Mson . mson ( String . valueOf ( rank . getName ( ) . charAt ( 0 ) ) ) ;
rankMson = rankMson . add ( mson ) ;
}
ret = ret . add ( rankMson . color ( ChatColor . DARK_GREEN ) ) ;
}
// Fill > Relations
List < Selector > relations = permitted . get ( SelectorType . RELATION ) ;
if ( relations ! = null )
{
Mson relMson = Mson . EMPTY ;
for ( Selector selector : relations )
{
Rel rel = ( Rel ) selector ;
Mson mson = Mson . mson ( String . valueOf ( rel . getName ( ) . charAt ( 0 ) ) ) ;
relMson = relMson . add ( mson ) ;
}
ret = ret . add ( relMson . color ( ChatColor . LIGHT_PURPLE ) ) ;
}
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
// Fill > Factions
List < Selector > factions = permitted . get ( SelectorType . FACTION ) ;
if ( factions ! = null ) ret = ret . add ( Mson . mson ( " F " ) . color ( ChatColor . GREEN ) ) ;
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
// Fill > Factions
List < Selector > players = permitted . get ( SelectorType . PLAYER ) ;
if ( players ! = null ) ret = ret . add ( Mson . mson ( " P " ) . color ( ChatColor . WHITE ) ) ;
// Fill > Name
ret = ret . add ( Mson . SPACE ) . add ( Mson . mson ( perm . getName ( ) ) . uppercaseFirst ( ) . color ( ChatColor . YELLOW ) ) ;
// Fill > Show
ret = ret . command ( CmdFactions . get ( ) . cmdFactionsPerm . cmdFactionsPermShow , perm . getId ( ) ) ;
List < String > showLines = Mson . toPlain ( this . getPermittedShow ( perm , permitted , relationParticipator ) , true ) ;
showLines . add ( ret . getTooltip ( ) ) ;
ret = ret . tooltip ( showLines ) ;
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
// Return
return ret ;
2014-11-13 11:41:21 +01:00
}
2017-04-06 22:32:52 +02:00
private Map < SelectorType , List < Selector > > resolvePermitted ( MPerm perm )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
// Create
Map < SelectorType , List < Selector > > ret = new MassiveMap < > ( ) ;
// Fill
TypeSelector type = TypeSelector . get ( ) ;
for ( String id : this . getPermittedIds ( perm ) )
{
Selector selector = type . readSafe ( id , null ) ;
if ( selector = = null ) throw new IllegalStateException ( " Selector id " + id + " wasn't resolvable. " ) ;
SelectorType selectorType = selector . getType ( ) ;
List < Selector > selectors = ret . get ( selectorType ) ;
if ( selectors = = null )
{
selectors = new MassiveList < > ( selector ) ;
ret . put ( selectorType , selectors ) ;
}
else
{
selectors . add ( selector ) ;
}
}
// Return
return ret ;
2013-04-17 13:16:22 +02:00
}
2017-04-06 22:32:52 +02:00
private List < Mson > getPermittedShow ( MPerm perm , Map < SelectorType , List < Selector > > permitted , RelationParticipator relationParticipator )
{
String factionName = this . describeTo ( relationParticipator , true ) ;
Mson header = Txt . titleize ( factionName + " " + perm . getDesc ( true , true ) ) ;
Mson ranks = getResolveSection ( " Ranks: " , permitted . get ( SelectorType . RANK ) , TypeRel . get ( ) ) ;
Mson relations = getResolveSection ( " Relations: " , permitted . get ( SelectorType . RELATION ) , TypeRel . get ( ) ) ;
Mson factions = getResolveSection ( " Factions: " , permitted . get ( SelectorType . FACTION ) , TypeFaction . get ( ) ) ;
Mson players = getResolveSection ( " Players: " , permitted . get ( SelectorType . PLAYER ) , TypeMPlayer . get ( ) ) ;
return new MassiveList < > ( header , ranks , relations , factions , players ) ;
}
2014-11-13 11:41:21 +01:00
2017-04-06 22:32:52 +02:00
@SuppressWarnings ( " unchecked " )
private static < E > Mson getResolveSection ( String header , List < Selector > resolve , Type < E > type )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
Mson heading = Mson . mson ( header ) . color ( ChatColor . YELLOW ) ;
if ( resolve = = null ) return heading ;
List < Mson > ret = new MassiveList < > ( ) ;
for ( Selector selector : resolve )
{
E element = ( E ) selector ;
ret . add ( type . getVisualMson ( element ) ) ;
}
return heading . add ( Mson . implode ( ret , Mson . mson ( " , " ) ) ) ;
2013-04-17 13:16:22 +02:00
}
2017-04-06 22:32:52 +02:00
// -------------------------------------------- //
// FIELD: factionBans
// -------------------------------------------- //
// Raw
public EntityInternalMap < FactionBan > getFactionBans ( )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
return factionBans ;
2013-04-17 13:16:22 +02:00
}
2017-04-06 22:32:52 +02:00
// Finer
public boolean isFactionBannedInherited ( Selector selector )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
if ( selector instanceof Faction )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
if ( this . isFactionBanned ( ( ( Faction ) selector ) . getRelationTo ( this ) ) ) return true ;
2013-04-17 13:16:22 +02:00
}
2017-04-06 22:32:52 +02:00
else if ( selector instanceof MPlayer )
2013-04-17 13:16:22 +02:00
{
2017-04-06 22:32:52 +02:00
MPlayer mplayer = ( MPlayer ) selector ;
if ( this . isFactionBanned ( mplayer . getRelationTo ( this ) ) | | this . isFactionBanned ( mplayer . getFaction ( ) ) ) return true ;
2013-04-17 13:16:22 +02:00
}
2017-04-06 22:32:52 +02:00
return this . isFactionBanned ( selector ) ;
}
private boolean isFactionBanned ( Selector selector )
{
return this . factionBans . containsKey ( selector . getId ( ) ) ;
}
// -------------------------------------------- //
// OVERRIDE: Selector
// -------------------------------------------- //
@Override
public SelectorType getType ( )
{
return SelectorType . FACTION ;
2013-04-17 13:16:22 +02:00
}
// -------------------------------------------- //
// OVERRIDE: RelationParticipator
2013-04-17 10:22:51 +02:00
// -------------------------------------------- //
@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 ) ;
}
2013-04-10 09:40:39 +02:00
// -------------------------------------------- //
2013-04-17 08:49:43 +02:00
// POWER
2013-04-10 09:40:39 +02:00
// -------------------------------------------- //
2013-04-17 14:44:08 +02:00
// TODO: Implement a has enough feature.
2013-04-17 08:49:43 +02:00
2011-10-08 22:03:44 +02:00
public double getPower ( )
{
2014-10-07 12:30:44 +02:00
if ( this . getFlag ( MFlag . getFlagInfpower ( ) ) ) return 999999 ;
2011-10-22 18:12:15 +02:00
2011-02-07 21:42:14 +01:00
double ret = 0 ;
2014-09-17 13:29:58 +02:00
for ( MPlayer mplayer : this . getMPlayers ( ) )
2011-10-21 20:08:54 +02:00
{
2014-09-17 13:29:58 +02:00
ret + = mplayer . getPower ( ) ;
2011-02-06 13:36:11 +01:00
}
2013-04-22 17:20:34 +02:00
2017-03-15 18:22:17 +01:00
ret = this . limitWithPowerMax ( ret ) ;
2013-04-25 07:53:21 +02:00
ret + = this . getPowerBoost ( ) ;
2013-04-22 17:20:34 +02:00
2013-04-23 12:14:36 +02:00
return ret ;
2011-02-06 13:36:11 +01:00
}
2011-10-21 20:08:54 +02:00
public double getPowerMax ( )
{
2014-10-07 12:30:44 +02:00
if ( this . getFlag ( MFlag . getFlagInfpower ( ) ) ) return 999999 ;
2013-04-25 07:53:21 +02:00
double ret = 0 ;
2014-09-17 13:29:58 +02:00
for ( MPlayer mplayer : this . getMPlayers ( ) )
2013-04-25 07:53:21 +02:00
{
2014-09-17 13:29:58 +02:00
ret + = mplayer . getPowerMax ( ) ;
2013-04-25 07:53:21 +02:00
}
2017-03-15 18:22:17 +01:00
ret = this . limitWithPowerMax ( ret ) ;
2013-04-25 07:53:21 +02:00
ret + = this . getPowerBoost ( ) ;
return ret ;
2011-02-06 13:36:11 +01:00
}
2017-03-15 18:22:17 +01:00
private double limitWithPowerMax ( double power )
{
// NOTE: 0.0 powerMax means there is no max power
double powerMax = MConf . get ( ) . factionPowerMax ;
return powerMax < = 0 | | power < powerMax ? power : powerMax ;
}
2011-10-21 20:08:54 +02:00
public int getPowerRounded ( )
{
2011-02-06 13:36:11 +01:00
return ( int ) Math . round ( this . getPower ( ) ) ;
}
2011-10-21 20:08:54 +02:00
public int getPowerMaxRounded ( )
{
2011-02-06 13:36:11 +01:00
return ( int ) Math . round ( this . getPowerMax ( ) ) ;
}
2013-04-17 08:49:43 +02:00
public int getLandCount ( )
2013-04-11 11:11:31 +02:00
{
2014-09-17 13:17:33 +02:00
return BoardColl . get ( ) . getCount ( this ) ;
2011-02-06 13:36:11 +01:00
}
2013-04-17 08:49:43 +02:00
public int getLandCountInWorld ( String worldName )
2011-10-21 20:08:54 +02:00
{
2013-05-29 14:31:09 +02:00
return Board . get ( worldName ) . getCount ( this ) ;
2011-06-30 13:13:47 +02:00
}
2011-10-21 20:08:54 +02:00
public boolean hasLandInflation ( )
{
2013-04-17 08:49:43 +02:00
return this . getLandCount ( ) > this . getPowerRounded ( ) ;
2011-02-06 13:36:11 +01:00
}
2016-04-19 17:57:28 +02:00
// -------------------------------------------- //
// WORLDS
// -------------------------------------------- //
public Set < String > getClaimedWorlds ( )
{
return BoardColl . get ( ) . getClaimedWorlds ( this ) ;
}
2013-04-10 09:40:39 +02:00
// -------------------------------------------- //
2014-09-17 13:29:58 +02:00
// FOREIGN KEY: MPLAYER
2013-04-10 09:40:39 +02:00
// -------------------------------------------- //
2013-04-17 14:44:08 +02:00
2014-09-17 13:29:58 +02:00
public List < MPlayer > getMPlayers ( )
2013-04-17 14:44:08 +02:00
{
2017-03-24 22:59:44 +01:00
return new MassiveList < > ( FactionsIndex . get ( ) . getMPlayers ( this ) ) ;
2012-01-13 10:46:31 +01:00
}
2013-04-17 08:49:43 +02:00
2017-05-01 21:15:25 +02:00
public List < MPlayer > getMPlayers ( Predicate < ? super MPlayer > where , Comparator < ? super MPlayer > orderby , Integer limit , Integer offset )
{
return MUtil . transform ( this . getMPlayers ( ) , where , orderby , limit , offset ) ;
}
2016-01-25 09:49:43 +01:00
public List < MPlayer > getMPlayersWhere ( Predicate < ? super MPlayer > predicate )
2012-01-13 10:46:31 +01:00
{
2017-05-01 21:15:25 +02:00
return this . getMPlayers ( predicate , null , null , null ) ;
2016-01-25 09:49:43 +01:00
}
public List < MPlayer > getMPlayersWhereOnline ( boolean online )
{
return this . getMPlayersWhere ( online ? SenderColl . PREDICATE_ONLINE : SenderColl . PREDICATE_OFFLINE ) ;
2017-01-20 09:32:23 +01:00
}
public List < MPlayer > getMPlayersWhereOnlineTo ( Object senderObject )
{
return this . getMPlayersWhere ( PredicateAnd . get ( SenderColl . PREDICATE_ONLINE , PredicateVisibleTo . get ( senderObject ) ) ) ;
}
2011-02-06 13:36:11 +01:00
2014-09-17 13:29:58 +02:00
public List < MPlayer > getMPlayersWhereRole ( Rel role )
2011-10-08 22:03:44 +02:00
{
2017-03-24 14:25:29 +01:00
return this . getMPlayersWhere ( PredicateMPlayerRole . get ( role ) ) ;
2011-02-06 13:36:11 +01:00
}
2014-09-17 13:17:33 +02:00
public MPlayer getLeader ( )
2011-10-08 22:03:44 +02:00
{
2016-01-25 09:49:43 +01:00
List < MPlayer > ret = this . getMPlayersWhereRole ( Rel . LEADER ) ;
if ( ret . size ( ) = = 0 ) return null ;
return ret . get ( 0 ) ;
2011-08-02 00:54:05 +02:00
}
2013-04-17 08:49:43 +02:00
public List < CommandSender > getOnlineCommandSenders ( )
2011-10-22 17:42:13 +02:00
{
2015-05-16 14:30:49 +02:00
// Create Ret
2017-03-25 00:47:01 +01:00
List < CommandSender > ret = new MassiveList < > ( ) ;
2015-05-16 14:30:49 +02:00
// Fill Ret
2015-07-24 13:42:06 +02:00
for ( CommandSender sender : IdUtil . getLocalSenders ( ) )
2011-10-22 17:42:13 +02:00
{
2015-05-16 14:30:49 +02:00
if ( MUtil . isntSender ( sender ) ) continue ;
MPlayer mplayer = MPlayer . get ( sender ) ;
2014-09-17 13:29:58 +02:00
if ( mplayer . getFaction ( ) ! = this ) continue ;
2015-05-16 14:30:49 +02:00
ret . add ( sender ) ;
2011-02-06 13:36:11 +01:00
}
2015-05-16 14:30:49 +02:00
// Return Ret
2011-02-06 13:36:11 +01:00
return ret ;
}
2013-04-17 08:49:43 +02:00
public List < Player > getOnlinePlayers ( )
2011-10-08 22:03:44 +02:00
{
2015-05-16 14:30:49 +02:00
// Create Ret
2017-03-25 00:47:01 +01:00
List < Player > ret = new MassiveList < > ( ) ;
2015-05-16 14:30:49 +02:00
// Fill Ret
2014-12-03 02:13:39 +01:00
for ( Player player : MUtil . getOnlinePlayers ( ) )
2011-10-08 22:03:44 +02:00
{
2015-05-16 14:30:49 +02:00
if ( MUtil . isntPlayer ( player ) ) continue ;
2014-09-17 13:29:58 +02:00
MPlayer mplayer = MPlayer . get ( player ) ;
if ( mplayer . getFaction ( ) ! = this ) continue ;
2015-05-16 14:30:49 +02:00
2013-04-17 08:49:43 +02:00
ret . add ( player ) ;
2011-02-06 13:36:11 +01:00
}
2015-05-16 14:30:49 +02:00
// Return Ret
2011-02-06 13:36:11 +01:00
return ret ;
}
2011-12-18 14:50:41 +01:00
// 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 ( )
{
2013-04-17 08:49:43 +02:00
if ( ! this . isNormal ( ) ) return ;
2014-10-07 12:30:44 +02:00
if ( this . getFlag ( MFlag . getFlagPermanent ( ) ) & & MConf . get ( ) . permanentFactionsDisableLeaderPromotion ) return ;
2011-12-18 14:50:41 +01:00
2014-09-17 13:17:33 +02:00
MPlayer oldLeader = this . getLeader ( ) ;
2011-12-18 14:50:41 +01:00
// get list of officers, or list of normal members if there are no officers
2014-09-17 13:29:58 +02:00
List < MPlayer > replacements = this . getMPlayersWhereRole ( Rel . OFFICER ) ;
2011-12-18 14:50:41 +01:00
if ( replacements = = null | | replacements . isEmpty ( ) )
2013-04-17 08:49:43 +02:00
{
2014-09-17 13:29:58 +02:00
replacements = this . getMPlayersWhereRole ( Rel . MEMBER ) ;
2013-04-17 08:49:43 +02:00
}
2011-12-18 14:50:41 +01:00
if ( replacements = = null | | replacements . isEmpty ( ) )
2013-04-25 20:21:23 +02:00
{
// faction leader is the only member; one-man faction
2014-10-07 12:30:44 +02:00
if ( this . getFlag ( MFlag . getFlagPermanent ( ) ) )
2011-12-18 14:50:41 +01:00
{
2012-01-18 13:01:50 +01:00
if ( oldLeader ! = null )
2013-04-17 08:49:43 +02:00
{
2013-04-25 20:21:23 +02:00
// TODO: Where is the logic in this? Why MEMBER? Why not LEADER again? And why not OFFICER or RECRUIT?
2012-01-18 13:01:50 +01:00
oldLeader . setRole ( Rel . MEMBER ) ;
2013-04-17 08:49:43 +02:00
}
2011-12-18 14:50:41 +01:00
return ;
}
// no members left and faction isn't permanent, so disband it
2013-04-22 10:05:03 +02:00
if ( MConf . get ( ) . logFactionDisband )
2013-04-17 08:49:43 +02:00
{
2013-04-24 19:01:17 +02:00
Factions . get ( ) . log ( " The faction " + this . getName ( ) + " ( " + this . getId ( ) + " ) has been disbanded since it has no members left. " ) ;
2013-04-17 08:49:43 +02:00
}
2011-12-18 14:50:41 +01:00
2014-09-17 13:17:33 +02:00
for ( MPlayer mplayer : MPlayerColl . get ( ) . getAllOnline ( ) )
2011-12-18 14:50:41 +01:00
{
2014-09-17 13:17:33 +02:00
mplayer . msg ( " <i>The faction %s<i> was disbanded. " , this . getName ( mplayer ) ) ;
2011-12-18 14:50:41 +01:00
}
this . detach ( ) ;
}
else
2014-10-06 13:08:34 +02:00
{
// promote new faction leader
2012-01-18 13:01:50 +01:00
if ( oldLeader ! = null )
2013-04-17 08:49:43 +02:00
{
2012-01-18 13:01:50 +01:00
oldLeader . setRole ( Rel . MEMBER ) ;
2013-04-17 08:49:43 +02:00
}
2011-12-18 14:50:41 +01:00
replacements . get ( 0 ) . setRole ( Rel . LEADER ) ;
2012-01-18 13:01:50 +01:00
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 ( ) ) ;
2013-04-24 19:01:17 +02:00
Factions . get ( ) . log ( " Faction " + this . getName ( ) + " ( " + this . getId ( ) + " ) leader was removed. Replacement leader: " + replacements . get ( 0 ) . getName ( ) ) ;
2011-12-18 14:50:41 +01:00
}
}
2013-08-23 10:45:27 +02:00
// -------------------------------------------- //
// FACTION ONLINE STATE
// -------------------------------------------- //
2011-12-18 14:50:41 +01:00
2014-09-17 13:29:58 +02:00
public boolean isAllMPlayersOffline ( )
2013-08-23 10:45:27 +02:00
{
2014-09-17 13:29:58 +02:00
return this . getMPlayersWhereOnline ( true ) . size ( ) = = 0 ;
2013-08-23 10:45:27 +02:00
}
2014-09-17 13:29:58 +02:00
public boolean isAnyMPlayersOnline ( )
2013-08-23 10:45:27 +02:00
{
2014-09-17 13:29:58 +02:00
return ! this . isAllMPlayersOffline ( ) ;
2013-08-23 10:45:27 +02:00
}
public boolean isFactionConsideredOffline ( )
{
2014-09-17 13:29:58 +02:00
return this . isAllMPlayersOffline ( ) ;
2013-08-23 10:45:27 +02:00
}
public boolean isFactionConsideredOnline ( )
{
return ! this . isFactionConsideredOffline ( ) ;
}
public boolean isExplosionsAllowed ( )
{
2014-10-07 12:30:44 +02:00
boolean explosions = this . getFlag ( MFlag . getFlagExplosions ( ) ) ;
boolean offlineexplosions = this . getFlag ( MFlag . getFlagOfflineexplosions ( ) ) ;
2015-10-06 21:18:10 +02:00
if ( explosions & & offlineexplosions ) return true ;
if ( ! explosions & & ! offlineexplosions ) return false ;
2013-08-23 10:45:27 +02:00
boolean online = this . isFactionConsideredOnline ( ) ;
return ( online & & explosions ) | | ( ! online & & offlineexplosions ) ;
}
2013-04-10 09:40:39 +02:00
// -------------------------------------------- //
2013-04-17 08:49:43 +02:00
// MESSAGES
2013-04-10 09:40:39 +02:00
// -------------------------------------------- //
2013-04-17 13:16:22 +02:00
// These methods are simply proxied in from the Mixin.
2013-04-10 10:32:04 +02:00
2013-04-17 08:49:43 +02:00
// CONVENIENCE SEND MESSAGE
2015-09-08 19:18:45 +02:00
public boolean sendMessage ( Object message )
2011-10-09 14:53:38 +02:00
{
2017-03-24 14:25:29 +01:00
return MixinMessage . get ( ) . messagePredicate ( new PredicateCommandSenderFaction ( this ) , message ) ;
2011-10-09 14:53:38 +02:00
}
2015-09-08 19:18:45 +02:00
public boolean sendMessage ( Object . . . messages )
2011-10-08 22:03:44 +02:00
{
2017-03-24 14:25:29 +01:00
return MixinMessage . get ( ) . messagePredicate ( new PredicateCommandSenderFaction ( this ) , messages ) ;
2011-02-06 13:36:11 +01:00
}
2015-09-08 19:18:45 +02:00
public boolean sendMessage ( Collection < Object > messages )
2011-10-08 22:03:44 +02:00
{
2017-03-24 14:25:29 +01:00
return MixinMessage . get ( ) . messagePredicate ( new PredicateCommandSenderFaction ( this ) , messages ) ;
2013-04-17 08:49:43 +02:00
}
// CONVENIENCE MSG
public boolean msg ( String msg )
{
2017-03-24 14:25:29 +01:00
return MixinMessage . get ( ) . msgPredicate ( new PredicateCommandSenderFaction ( this ) , msg ) ;
2011-02-06 13:36:11 +01:00
}
2013-04-17 08:49:43 +02:00
public boolean msg ( String msg , Object . . . args )
{
2017-03-24 14:25:29 +01:00
return MixinMessage . get ( ) . msgPredicate ( new PredicateCommandSenderFaction ( this ) , msg , args ) ;
2013-04-17 08:49:43 +02:00
}
public boolean msg ( Collection < String > msgs )
{
2017-03-24 14:25:29 +01:00
return MixinMessage . get ( ) . msgPredicate ( new PredicateCommandSenderFaction ( this ) , msgs ) ;
2013-04-17 08:49:43 +02:00
}
2011-03-18 17:33:23 +01:00
2017-04-21 20:12:41 +02:00
// -------------------------------------------- //
// UTIL
// -------------------------------------------- //
// FIXME this probably needs to be moved elsewhere
public static String clean ( String message )
{
String target = message ;
if ( target = = null ) return null ;
target = target . trim ( ) ;
if ( target . isEmpty ( ) ) target = null ;
return target ;
}
2011-02-06 13:36:11 +01:00
}