Fixes POM, and moves things around

src/main/java/com/massivecraft/factions/cmd/CmdFactions.java

@@ -0,0 +1,96 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.command.MassiveCommandDeprecated;
+import com.massivecraft.massivecore.command.MassiveCommandVersion;
+
+import java.util.List;
+
+public class CmdFactions extends FactionsCommand {
+    // -------------------------------------------- //
+    // INSTANCE
+    // -------------------------------------------- //
+
+    private static CmdFactions i = new CmdFactions();
+
+    public static CmdFactions get() {
+        return i;
+    }
+
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentation cmdFactionsDocumentation = new CmdFactionsDocumentation();
+    public CmdFactionsList cmdFactionsList = new CmdFactionsList();
+    public CmdFactionsFaction cmdFactionsFaction = new CmdFactionsFaction();
+    public CmdFactionsPlayer cmdFactionsPlayer = new CmdFactionsPlayer();
+    public CmdFactionsStatus cmdFactionsStatus = new CmdFactionsStatus();
+    public CmdFactionsJoin cmdFactionsJoin = new CmdFactionsJoin();
+    public CmdFactionsLeave cmdFactionsLeave = new CmdFactionsLeave();
+    public CmdFactionsWarp cmdFactionsWarp = new CmdFactionsWarp();
+    public CmdFactionsHome cmdFactionsHome = new CmdFactionsHome();
+    public CmdFactionsSethome cmdFactionsSethome = new CmdFactionsSethome();
+    public CmdFactionsUnsethome cmdFactionsUnsethome = new CmdFactionsUnsethome();
+    public CmdFactionsVote cmdFactionsVote = new CmdFactionsVote();
+    public CmdFactionsMap cmdFactionsMap = new CmdFactionsMap();
+    public CmdFactionsCreate cmdFactionsCreate = new CmdFactionsCreate();
+    public CmdFactionsName cmdFactionsName = new CmdFactionsName();
+    public CmdFactionsDescription cmdFactionsDescription = new CmdFactionsDescription();
+    public CmdFactionsMotd cmdFactionsMotd = new CmdFactionsMotd();
+    public CmdFactionsInvite cmdFactionsInvite = new CmdFactionsInvite();
+    public CmdFactionsKick cmdFactionsKick = new CmdFactionsKick();
+    public CmdFactionsTitle cmdFactionsTitle = new CmdFactionsTitle();
+    public CmdFactionsRank cmdFactionsRank = new CmdFactionsRank();
+    public CmdFactionsMoney cmdFactionsMoney = new CmdFactionsMoney();
+    public CmdFactionsTop cmdFactionsTop = new CmdFactionsTop();
+    public CmdFactionsSeeChunk cmdFactionsSeeChunk = new CmdFactionsSeeChunk();
+    public CmdFactionsSeeChunkOld cmdFactionsSeeChunkOld = new CmdFactionsSeeChunkOld();
+    public CmdFactionsTerritorytitles cmdFactionsTerritorytitles = new CmdFactionsTerritorytitles();
+    public CmdFactionsClaim cmdFactionsClaim = new CmdFactionsClaim();
+    public CmdFactionsUnclaim cmdFactionsUnclaim = new CmdFactionsUnclaim();
+    public CmdFactionsAccess cmdFactionsAccess = new CmdFactionsAccess();
+    public CmdFactionsChunkname cmdFactionsChunkname = new CmdFactionsChunkname();
+    public CmdFactionsRelation cmdFactionsRelation = new CmdFactionsRelation();
+    public CmdFactionsRelationOld cmdFactionsRelationOldAlly = new CmdFactionsRelationOld("ally");
+    public CmdFactionsRelationOld cmdFactionsRelationOldTruce = new CmdFactionsRelationOld("truce");
+    public CmdFactionsRelationOld cmdFactionsRelationOldNeutral = new CmdFactionsRelationOld("neutral");
+    public CmdFactionsRelationOld cmdFactionsRelationOldEnemy = new CmdFactionsRelationOld("enemy");
+    public CmdFactionsTax cmdFactionsTax = new CmdFactionsTax();
+    public CmdFactionsPerm cmdFactionsPerm = new CmdFactionsPerm();
+    public CmdFactionsFlag cmdFactionsFlag = new CmdFactionsFlag();
+    public CmdFactionsFly cmdFactionsFly = new CmdFactionsFly();
+    public CmdFactionsUnstuck cmdFactionsUnstuck = new CmdFactionsUnstuck();
+    public CmdFactionsOverride cmdFactionsOverride = new CmdFactionsOverride();
+    public CmdFactionsDisband cmdFactionsDisband = new CmdFactionsDisband();
+    public CmdFactionsPowerboost cmdFactionsPowerBoost = new CmdFactionsPowerboost();
+    public CmdFactionsSetpower cmdFactionsSetpower = new CmdFactionsSetpower();
+    public CmdFactionsMoneyconvert cmdFactionsMoneyconvert = new CmdFactionsMoneyconvert();
+    public CmdFactionsConfig cmdFactionsConfig = new CmdFactionsConfig();
+    public CmdFactionsClean cmdFactionsClean = new CmdFactionsClean();
+    public MassiveCommandVersion cmdFactionsVersion = new MassiveCommandVersion(Factions.get());
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactions() {
+        // Old rank stuff
+        this.addChild(new CmdFactionsRankOld("demote"));
+        this.addChild(new CmdFactionsRankOld("promote"));
+
+        // Deprecated Commands
+        this.addChild(new MassiveCommandDeprecated(this.cmdFactionsRank, "leader", "owner", "officer", "moderator", "coleader"));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public List<String> getAliases() {
+        return MConf.get().aliasesF;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccess.java

@@ -0,0 +1,24 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+
+public class CmdFactionsAccess extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessView cmdFactionsAccessView = new CmdFactionsAccessView();
+    public CmdFactionsAccessGrant cmdFactionsAccessGrant = new CmdFactionsAccessGrant();
+    public CmdFactionsAccessDeny cmdFactionsAccessDeny = new CmdFactionsAccessDeny();
+    public CmdFactionsAccessInspect cmdFactionsAccessInspect = new CmdFactionsAccessInspect();
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccess() {
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessAbstract.java

@@ -0,0 +1,93 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.TerritoryAccess;
+import com.massivecraft.factions.entity.BoardColl;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPerm.MPermable;
+import com.massivecraft.factions.util.AsciiMap;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.Collection;
+
+
+public abstract class CmdFactionsAccessAbstract extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public PS chunk;
+    public TerritoryAccess ta;
+    public Faction hostFaction;
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessAbstract() {
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void senderFields(boolean set) {
+        super.senderFields(set);
+
+        if (set) {
+            chunk = PS.valueOf(me.getLocation()).getChunk(true);
+            ta = BoardColl.get().getTerritoryAccessAt(chunk);
+            hostFaction = ta.getHostFaction();
+        } else {
+            chunk = null;
+            ta = null;
+            hostFaction = null;
+        }
+    }
+
+    public void sendAccessInfo() {
+        String chunkDesc = AsciiMap.getChunkDescWithName(chunk, ta);
+        Object title = "Access" + chunkDesc;
+        title = Txt.titleize(title);
+        message(title);
+
+        msg("<k>Host Faction: %s", hostFaction.describeTo(msender, true));
+        msg("<k>Host Faction Allowed: %s", ta.isHostFactionAllowed() ? Txt.parse("<lime>TRUE") : Txt.parse("<rose>FALSE"));
+        msg("<k>Granted to: %s", CmdFactionsPermShow.permablesToDisplayString(ta.getGranteds(), msender));
+    }
+
+    public void setAccess(Collection<PS> chunks, MPermable mpermable, boolean granted) {
+        chunks.forEach(chunk -> setAccess(chunk, mpermable, granted));
+    }
+
+    public void setAccess(PS chunk, MPermable mpermable, boolean granted) {
+        TerritoryAccess ta = BoardColl.get().getTerritoryAccessAt(chunk);
+        Faction faction = ta.getHostFaction();
+
+
+        String chunkDesc = AsciiMap.getChunkDescWithName(chunk, ta);
+        String grantedDenied = granted ? "granted" : "denied";
+        String mpermableDesc = mpermable.getDisplayName(msender);
+
+        if (!MPerm.getPermAccess().has(msender, faction, false)) {
+            msg("<b>You do not have permission to edit access%s<b>.", chunkDesc);
+            return;
+        }
+
+        if (ta.isGranted(mpermable) == granted) {
+            msg("<b>Access%s <b>is already %s to %s<b>.", chunkDesc, grantedDenied, mpermableDesc);
+            return;
+        }
+
+        ta = ta.withGranted(mpermable, granted);
+        BoardColl.get().setTerritoryAccessAt(chunk, ta);
+
+        msg("<i>Access%s<i> is now %s to %s<i>.", chunkDesc, grantedDenied, mpermableDesc);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessDeny.java

@@ -0,0 +1,24 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+
+public class CmdFactionsAccessDeny extends CmdFactionsAccessAbstract {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetOne cmdFactionsAccessDenyOne = new CmdFactionsAccessSetOne(false);
+    public CmdFactionsAccessSetSquare cmdFactionsAccessDenySquare = new CmdFactionsAccessSetSquare(false);
+    public CmdFactionsAccessSetCircle cmdFactionsAccessDenyCircle = new CmdFactionsAccessSetCircle(false);
+    public CmdFactionsAccessSetFill cmdFactionsAccessDenyFill = new CmdFactionsAccessSetFill(false);
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessDeny() {
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessGrant.java

@@ -0,0 +1,24 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+
+public class CmdFactionsAccessGrant extends CmdFactionsAccessAbstract {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetOne cmdFactionsAccessGrantOne = new CmdFactionsAccessSetOne(true);
+    public CmdFactionsAccessSetSquare cmdFactionsAccessGrantSquare = new CmdFactionsAccessSetSquare(true);
+    public CmdFactionsAccessSetCircle cmdFactionsAccessGrantCircle = new CmdFactionsAccessSetCircle(true);
+    public CmdFactionsAccessSetFill cmdFactionsAccessGrantFill = new CmdFactionsAccessSetFill(true);
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessGrant() {
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessInspect.java

@@ -0,0 +1,93 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPermable;
+import com.massivecraft.factions.entity.Board;
+import com.massivecraft.factions.entity.BoardColl;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPerm.MPermable;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveMap;
+import com.massivecraft.massivecore.mixin.MixinWorld;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.ps.PSFormatHumanSpace;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class CmdFactionsAccessInspect extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessInspect() {
+        // Parameters
+        this.addParameter(TypeMPermable.get(), "rank/rel/player/faction");
+        this.addParameter(TypeFaction.get(), "faction", "your");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Parameter
+        Faction faction = this.readArgAt(1, msenderFaction);
+        MPermable mpermable = TypeMPermable.get(faction).read(this.argAt(0), sender);
+
+        String factionId = faction.getId();
+
+        // Check if they have access perms, unless they are checking for their own access
+        if (mpermable != msender && mpermable != msenderFaction && mpermable != msender.getRank()) {
+			if (!MPerm.getPermAccess().has(msender, faction, true)) {
+				return;
+			}
+        }
+
+        // Turn into id->chunks
+        // And filter the ones that are empty
+        Map<String, Set<PS>> world2Chunks = new MassiveMap<>();
+        for (Board board : BoardColl.get().getAll()) {
+            String worldId = board.getId();
+            Set<PS> chunks = board.getMap().entrySet().stream()
+                    .filter(e -> e.getValue().getHostFactionId().equals(factionId))
+                    .filter(e -> e.getValue().isGranted(mpermable))
+                    .map(Entry::getKey)
+                    .collect(Collectors.toSet());
+			if (!chunks.isEmpty()) {
+				world2Chunks.put(worldId, chunks);
+			}
+        }
+
+        if (world2Chunks.isEmpty()) {
+            msg("%s <i>has no special access in <reset>%s<i>.", mpermable.getDisplayName(msender), faction.describeTo(msender));
+            return;
+        }
+
+        msg("%s <i>has special access in <reset>%s <i>in the following chunks:", mpermable.getDisplayName(msender), faction.describeTo(msender));
+
+        for (Entry<String, Set<PS>> entry : world2Chunks.entrySet()) {
+            String worldId = entry.getKey();
+            Set<PS> chunks = entry.getValue();
+
+            String worldName = MixinWorld.get().getWorldDisplayName(worldId);
+
+            // Remove world from chunks
+            List<String> chunkNames = chunks.stream()
+                    .map(PS::getChunkCoords)
+                    .map(PSFormatHumanSpace.get()::format)
+                    .collect(Collectors.toList());
+
+            String chunkDesc = Txt.implodeCommaAnd(chunkNames, Txt.parse("<i>"));
+
+            msg("%s<i> (%d): <reset>%s", worldName, chunks.size(), chunkDesc);
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessSetCircle.java

@@ -0,0 +1,42 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.ChunkUtil;
+
+import java.util.Set;
+
+
+public class CmdFactionsAccessSetCircle extends CmdFactionsAccessSetXRadius {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetCircle(boolean grant) {
+        // Super
+        super(grant);
+
+        // Aliases
+        this.addAliases("circle");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+        Perm perm = grant ? Perm.ACCESS_GRANT_CIRCLE : Perm.ACCESS_DENY_CIRCLE;
+        this.addRequirements(RequirementHasPerm.get(perm));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public Set<PS> getChunks() throws MassiveException {
+        // Common Startup
+        final PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+        return ChunkUtil.getChunksCircle(chunk, this.getRadius());
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessSetFill.java

@@ -0,0 +1,53 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.factions.entity.BoardColl;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.ChunkUtil;
+
+import java.util.Set;
+import java.util.function.Predicate;
+
+public class CmdFactionsAccessSetFill extends CmdFactionsAccessSetXSimple {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetFill(boolean claim) {
+        // Super
+        super(claim);
+
+        // Aliases
+        this.addAliases("fill");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+        Perm perm = claim ? Perm.ACCESS_GRANT_FILL : Perm.ACCESS_DENY_FILL;
+        this.addRequirements(RequirementHasPerm.get(perm));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public Set<PS> getChunks() throws MassiveException {
+        // Common Startup
+        final PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+
+        // What faction (aka color) resides there?
+        // NOTE: Wilderness/None is valid. 
+        final Faction color = BoardColl.get().getFactionAt(chunk);
+
+        // Calculate
+        int max = MConf.get().setFillMax;
+        Predicate<PS> matcher = ps -> BoardColl.get().getFactionAt(ps) == color;
+        return ChunkUtil.getChunkArea(chunk, matcher, max);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessSetOne.java

@@ -0,0 +1,40 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+
+import java.util.Collections;
+import java.util.Set;
+
+
+public class CmdFactionsAccessSetOne extends CmdFactionsAccessSetXSimple {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetOne(boolean claim) {
+        // Super
+        super(claim);
+
+        // Aliases
+        this.addAliases("one");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+        Perm perm = claim ? Perm.ACCESS_GRANT_ONE : Perm.ACCESS_DENY_ONE;
+        this.addRequirements(RequirementHasPerm.get(perm));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public Set<PS> getChunks() {
+        final PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+        return Collections.singleton(chunk);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessSetSquare.java

@@ -0,0 +1,42 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.ChunkUtil;
+
+import java.util.Set;
+
+
+public class CmdFactionsAccessSetSquare extends CmdFactionsAccessSetXRadius {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetSquare(boolean grant) {
+        // Super
+        super(grant);
+
+        // Aliases
+        this.addAliases("square");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+        Perm perm = grant ? Perm.ACCESS_GRANT_SQUARE : Perm.ACCESS_DENY_SQUARE;
+        this.addRequirements(RequirementHasPerm.get(perm));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public Set<PS> getChunks() throws MassiveException {
+        // Common Startup
+        final PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+        return ChunkUtil.getChunksSquare(chunk, this.getRadius());
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessSetX.java

@@ -0,0 +1,78 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPermable;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPerm.MPermable;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.ps.PS;
+
+import java.util.Set;
+
+public abstract class CmdFactionsAccessSetX extends CmdFactionsAccessAbstract {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    private boolean grant = true;
+
+    public boolean isGranting() {
+        return this.grant;
+    }
+
+    public void setGranting(boolean grant) {
+        this.grant = grant;
+    }
+
+    private int mpermableArgIndex = 0;
+
+    public int getMPermableArgIndex() {
+        return this.mpermableArgIndex;
+    }
+
+    public void setMPermableArgIndex(int mpermableArgIndex) {
+        this.mpermableArgIndex = mpermableArgIndex;
+    }
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetX(boolean grant) {
+        this.setGranting(grant);
+        this.setSetupEnabled(false);
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        final MPermable mpermable = this.getMPermable(hostFaction);
+
+        final Set<PS> chunks = this.getChunks();
+		if (chunks == null) {
+			throw new NullPointerException("chunks");
+		}
+
+        // Apply / Inform
+        setAccess(chunks, mpermable, this.isGranting());
+    }
+
+    // -------------------------------------------- //
+    // ABSTRACT
+    // -------------------------------------------- //
+
+    public abstract Set<PS> getChunks() throws MassiveException;
+
+    // -------------------------------------------- //
+    // EXTRAS
+    // -------------------------------------------- //
+
+    public MPermable getMPermable(Faction faction) throws MassiveException {
+        String arg = this.argAt(this.getMPermableArgIndex());
+        return TypeMPermable.get(faction).read(arg, sender);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessSetXRadius.java

@@ -0,0 +1,46 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPermable;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeInteger;
+
+
+public abstract class CmdFactionsAccessSetXRadius extends CmdFactionsAccessSetX {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetXRadius(boolean claim) {
+        // Super
+        super(claim);
+
+        // Parameters
+        this.addParameter(TypeInteger.get(), "radius");
+
+        this.addParameter(TypeMPermable.get(), "rank/rel/faction/player");
+        this.setMPermableArgIndex(1);
+
+    }
+
+    // -------------------------------------------- //
+    // EXTRAS
+    // -------------------------------------------- //
+
+    public Integer getRadius() throws MassiveException {
+        int radius = this.readArgAt(0);
+
+        // Radius Claim Min
+        if (radius < 1) {
+            throw new MassiveException().setMsg("<b>If you specify a radius, it must be at least 1.");
+        }
+
+        // Radius Claim Max
+        if (radius > MConf.get().setRadiusMax && !msender.isOverriding()) {
+            throw new MassiveException().setMsg("<b>The maximum radius allowed is <h>%s<b>.", MConf.get().setRadiusMax);
+        }
+
+        return radius;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessSetXSimple.java

@@ -0,0 +1,19 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPermable;
+
+public abstract class CmdFactionsAccessSetXSimple extends CmdFactionsAccessSetX {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsAccessSetXSimple(boolean claim) {
+        // Super
+        super(claim);
+
+        // Parameters
+        this.addParameter(TypeMPermable.get(), "rank/rel/player/faction");
+        this.setMPermableArgIndex(0);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsAccessView.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsAccessView extends CmdFactionsAccessAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() {
+        this.sendAccessInfo();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsChunkname.java

@@ -0,0 +1,75 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.TerritoryAccess;
+import com.massivecraft.factions.entity.BoardColl;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.util.AsciiMap;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.command.type.TypeNullable;
+import com.massivecraft.massivecore.command.type.primitive.TypeString;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.MUtil;
+import com.massivecraft.massivecore.util.Txt;
+
+public class CmdFactionsChunkname extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsChunkname() {
+        // Parameters
+        this.addParameter(TypeNullable.get(TypeString.get()), "name", "read");
+
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+        TerritoryAccess ta = BoardColl.get().getTerritoryAccessAt(chunk);
+
+        if (!this.argIsSet(0)) {
+            String name = ta.getChunkName();
+            if (name == null) {
+                msg("<i>This chunk has no name.");
+            } else {
+                msg("<i>This chunk is called <h>%s<i>.", name);
+            }
+            return;
+        }
+
+        // MPerm
+        if (!MPerm.getPermTerritory().has(msender, msenderFaction, true)) {
+            return;
+        }
+
+        // Args
+        String target = this.readArg();
+        if (target != null) {
+            target = target.trim();
+            target = Txt.parse(target);
+        }
+
+        String old = ta.getChunkName();
+
+        // NoChange
+        if (MUtil.equals(old, target)) {
+            if (old == null) {
+                throw new MassiveException().addMsg("<b>This chunk already has no name.");
+            }
+            throw new MassiveException().addMsg("<b>The name for this chunk is already <h>%s<b>.", old);
+        }
+
+        ta = ta.withChunkName(target);
+        BoardColl.get().setTerritoryAccessAt(chunk, ta);
+
+        String chunkDesc = AsciiMap.getChunkDesc(chunk);
+        msg("<i>The chunk name%s<i> is now %s.", chunkDesc, target);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsClaim.java

@@ -0,0 +1,15 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsClaim extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsSetOne cmdFactionsClaimOne = new CmdFactionsSetOne(true);
+    public CmdFactionsSetAuto cmdFactionsClaimAuto = new CmdFactionsSetAuto(true);
+    public CmdFactionsSetFill cmdFactionsClaimFill = new CmdFactionsSetFill(true);
+    public CmdFactionsSetSquare cmdFactionsClaimSquare = new CmdFactionsSetSquare(true);
+    public CmdFactionsSetCircle cmdFactionsClaimCircle = new CmdFactionsSetCircle(true);
+    public CmdFactionsSetAll cmdFactionsClaimAll = new CmdFactionsSetAll(true);
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsClean.java

@@ -0,0 +1,158 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Rel;
+import com.massivecraft.factions.TerritoryAccess;
+import com.massivecraft.factions.entity.Board;
+import com.massivecraft.factions.entity.BoardColl;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.factions.entity.Invitation;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.entity.MPlayerColl;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveSet;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.store.EntityInternalMap;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class CmdFactionsClean extends FactionsCommand {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        Object message;
+        int count;
+
+        // Title
+        message = Txt.titleize("Factions Cleaner Results");
+        message(message);
+
+        // Yada
+        cleanMessage(this.cleanPlayer(), "player");
+        cleanMessage(this.cleanFactionInvites(), "faction invites");
+        cleanMessage(this.cleanFactionRelationWhishes(), "faction relation whishes");
+        cleanMessage(this.cleanBoardHost(), "chunk whole");
+        cleanMessage(this.cleanBoardGrant(), "chunk access");
+    }
+
+    // -------------------------------------------- //
+    // CLEAN
+    // -------------------------------------------- //
+
+    private void cleanMessage(int count, String name) {
+        msg("<v>%d<k> %s", count, name);
+    }
+
+    private int cleanPlayer() {
+        int ret = 0;
+
+        for (MPlayer mplayer : MPlayerColl.get().getAll()) {
+			if (!mplayer.isFactionOrphan()) {
+				continue;
+			}
+
+            mplayer.resetFactionData();
+            ret += 1;
+        }
+
+        return ret;
+    }
+
+    private int cleanFactionInvites() {
+        int ret = 0;
+
+        for (Faction faction : FactionColl.get().getAll()) {
+            EntityInternalMap<Invitation> invitations = faction.getInvitations();
+			if (invitations.isEmpty()) {
+				continue;
+			}
+
+            ret += invitations.size();
+            Set<String> invitationIds = new MassiveSet<>(invitations.keySet());
+            for (String inviteId : invitationIds) {
+                invitations.detachIdFixed(inviteId);
+            }
+
+            faction.changed();
+        }
+
+        return ret;
+    }
+
+    private int cleanFactionRelationWhishes() {
+        int ret = 0;
+
+        for (Faction faction : FactionColl.get().getAll()) {
+            for (Iterator<Entry<String, Rel>> iterator = faction.getRelationWishes().entrySet().iterator(); iterator.hasNext(); ) {
+                Entry<String, Rel> entry = iterator.next();
+                String factionId = entry.getKey();
+				if (FactionColl.get().containsId(factionId)) {
+					continue;
+				}
+
+                iterator.remove();
+                ret += 1;
+                faction.changed();
+            }
+        }
+
+        return ret;
+    }
+
+    private int cleanBoardHost() {
+        int ret = 0;
+
+        for (Board board : BoardColl.get().getAll()) {
+            for (Entry<PS, TerritoryAccess> entry : board.getMap().entrySet()) {
+                PS ps = entry.getKey();
+                TerritoryAccess territoryAccess = entry.getValue();
+                String factionId = territoryAccess.getHostFactionId();
+
+				if (FactionColl.get().containsId(factionId)) {
+					continue;
+				}
+
+                board.removeAt(ps);
+                ret += 1;
+            }
+        }
+
+        return ret;
+    }
+
+    private int cleanBoardGrant() {
+        int ret = 0;
+
+        for (Board board : BoardColl.get().getAll()) {
+            for (Entry<PS, TerritoryAccess> entry : board.getMap().entrySet()) {
+                PS ps = entry.getKey();
+                TerritoryAccess territoryAccess = entry.getValue();
+                boolean changed = false;
+
+                for (String grantedIds : territoryAccess.getGrantedIds()) {
+					if (MPerm.idToMPermableOptional(grantedIds).isPresent()) {
+						continue;
+					}
+
+                    territoryAccess = territoryAccess.withGrantedId(grantedIds, false);
+                    ret += 1;
+                    changed = true;
+                }
+
+                if (changed) {
+                    board.setTerritoryAccessAt(ps, territoryAccess);
+                }
+            }
+        }
+
+        return ret;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsConfig.java

@@ -0,0 +1,20 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.command.editor.CommandEditSingleton;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+
+public class CmdFactionsConfig extends CommandEditSingleton<MConf> {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsConfig() {
+        super(MConf.get());
+
+        // Requirements
+        this.addRequirements(RequirementHasPerm.get(Perm.CONFIG));
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsCreate.java

@@ -0,0 +1,73 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.req.ReqHasntFaction;
+import com.massivecraft.factions.cmd.type.TypeFactionNameStrict;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.event.EventFactionsCreate;
+import com.massivecraft.factions.event.EventFactionsMembershipChange;
+import com.massivecraft.factions.event.EventFactionsMembershipChange.MembershipChangeReason;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.mson.Mson;
+import com.massivecraft.massivecore.store.MStore;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsCreate extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsCreate() {
+        // Aliases
+        this.addAliases("new");
+
+        // Parameters
+        this.addParameter(TypeFactionNameStrict.get(), "name").setDesc("the name of your new faction");
+
+        // Requirements
+        this.addRequirements(ReqHasntFaction.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        String newName = this.readArg();
+
+        // Pre-Generate Id
+        String factionId = MStore.createId();
+
+        // Event
+        EventFactionsCreate createEvent = new EventFactionsCreate(sender, factionId, newName);
+        createEvent.run();
+		if (createEvent.isCancelled()) {
+			return;
+		}
+
+        // Apply
+        Faction faction = FactionColl.get().create(factionId);
+        faction.setName(newName);
+
+        msender.setRank(faction.getLeaderRank());
+        msender.setFaction(faction);
+
+        EventFactionsMembershipChange joinEvent = new EventFactionsMembershipChange(sender, msender, faction, MembershipChangeReason.CREATE);
+        joinEvent.run();
+        // NOTE: join event cannot be cancelled or you'll have an empty faction
+
+        // Inform
+        msg("<i>You created the faction %s", faction.getName(msender));
+        message(Mson.mson(mson("You should now: ").color(ChatColor.YELLOW), CmdFactions.get().cmdFactionsDescription.getTemplate()));
+
+        // Log
+        if (MConf.get().logFactionCreate) {
+            Factions.get().log(msender.getName() + " created a new faction: " + newName);
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDescription.java

@@ -0,0 +1,55 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.req.ReqHasFaction;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.event.EventFactionsDescriptionChange;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeString;
+import com.massivecraft.massivecore.mixin.MixinDisplayName;
+
+public class CmdFactionsDescription extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDescription() {
+        // Parameters
+        this.addParameter(TypeString.get(), "desc", true).setDesc("the new faction desciption");
+
+        // Requirements
+        this.addRequirements(ReqHasFaction.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        String newDescription = this.readArg();
+
+        // MPerm
+        if (!MPerm.getPermDesc().has(msender, msenderFaction, true)) {
+            return;
+        }
+
+        // Event
+        EventFactionsDescriptionChange event = new EventFactionsDescriptionChange(sender, msenderFaction, newDescription);
+        event.run();
+        if (event.isCancelled()) {
+            return;
+        }
+        newDescription = event.getNewDescription();
+
+        // Apply
+        msenderFaction.setDescription(newDescription);
+
+        // Inform
+        for (MPlayer follower : msenderFaction.getMPlayers()) {
+            follower.msg("<i>%s <i>set your faction description to:\n%s", MixinDisplayName.get().getDisplayName(sender, follower), msenderFaction.getDescriptionDesc());
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDisband.java

@@ -0,0 +1,88 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MFlag;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.event.EventFactionsDisband;
+import com.massivecraft.factions.event.EventFactionsMembershipChange;
+import com.massivecraft.factions.event.EventFactionsMembershipChange.MembershipChangeReason;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeStringConfirmation;
+import com.massivecraft.massivecore.util.ConfirmationUtil;
+import com.massivecraft.massivecore.util.IdUtil;
+import com.massivecraft.massivecore.util.Txt;
+
+public class CmdFactionsDisband extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDisband() {
+        // Parameters
+        this.addParameter(TypeFaction.get(), "faction");
+        this.addParameter(TypeStringConfirmation.get(), "confirmation", "");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        Faction faction = this.readArg();
+        String confirmationString = this.readArg(null);
+
+		if (MConf.get().requireConfirmationForFactionDisbanding) {
+			ConfirmationUtil.tryConfirm(this);
+		}
+
+        // MPerm
+		if (!MPerm.getPermDisband().has(msender, faction, true)) {
+			return;
+		}
+
+        // Verify
+        if (faction.getFlag(MFlag.getFlagPermanent())) {
+            throw new MassiveException().addMsg("<i>This faction is designated as permanent, so you cannot disband it.");
+        }
+
+        // Event
+        EventFactionsDisband event = new EventFactionsDisband(me, faction);
+        event.run();
+		if (event.isCancelled()) {
+			return;
+		}
+
+        // Merged Apply and Inform
+
+        // Run event for each player in the faction
+        for (MPlayer mplayer : faction.getMPlayers()) {
+            EventFactionsMembershipChange membershipChangeEvent = new EventFactionsMembershipChange(sender, mplayer, FactionColl.get().getNone(), MembershipChangeReason.DISBAND);
+            membershipChangeEvent.run();
+        }
+
+        // Inform
+        for (MPlayer mplayer : faction.getMPlayersWhereOnline(true)) {
+            mplayer.msg("<h>%s<i> disbanded your faction.", msender.describeTo(mplayer));
+        }
+
+        if (msenderFaction != faction) {
+            msender.msg("<i>You disbanded <h>%s<i>.", faction.describeTo(msender));
+        }
+
+        // Log
+        if (MConf.get().logFactionDisband) {
+            Factions.get().log(Txt.parse("<i>The faction <h>%s <i>(<h>%s<i>) was disbanded by <h>%s<i>.", faction.getName(), faction.getId(), msender.getDisplayName(IdUtil.getConsole())));
+        }
+
+        // Apply
+        faction.detach();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDocumentation.java

@@ -0,0 +1,26 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsDocumentation extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentation() {
+        String web = Factions.get().getDescription().getWebsite();
+        this.setHelp(mson("More help can be found at ", mson(web).link(web).color(ChatColor.AQUA)));
+    }
+
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentationPower cmdFactionsDocumentationPower = new CmdFactionsDocumentationPower();
+    public CmdFactionsDocumentationRanks cmdFactionsDocumentationRanks = new CmdFactionsDocumentationRanks();
+    public CmdFactionsDocumentationWarps cmdFactionsDocumentationWarps = new CmdFactionsDocumentationWarps();
+    public CmdFactionsDocumentationFlags cmdFactionsDocumentationFlags = new CmdFactionsDocumentationFlags();
+    public CmdFactionsDocumentationPerms cmdFactionsDocumentationPerms = new CmdFactionsDocumentationPerms();
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDocumentationFlags.java

@@ -0,0 +1,36 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.entity.MFlag;
+import com.massivecraft.factions.entity.MFlagColl;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CmdFactionsDocumentationFlags extends FactionsCommandDocumentation {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentationFlags() {
+
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        msgDoc("Flags are a way to give certain factions certain attributes " +
+                " such as disabling pvp or enabling friendly fire.");
+        msgDoc("To see all the flags type:");
+        message(CmdFactions.get().cmdFactionsFlag.cmdFactionsFlagList.getTemplate(false, true, sender));
+
+        List<String> flags = MFlagColl.get().getAll(MFlag::isEditable).stream().map(flag -> Txt.parse("<h>%s", flag.getName())).collect(Collectors.toList());
+        String str = Txt.implodeCommaAndDot(flags, Txt.parse("<i>"));
+        msgDoc("The flags you can edit for your faction are: %s", str);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDocumentationPerms.java

@@ -0,0 +1,42 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.massivecore.MassiveException;
+
+public class CmdFactionsDocumentationPerms extends FactionsCommandDocumentation {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentationPerms() {
+
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        msgDoc("Permissions decide who can do what in your faction. " +
+                "Permissions can be given to a rank, a player, a relation, " +
+                "everyone in another faction or everyone with a specific rank in another faction.");
+        msgDoc("Because perms can be given to all of these groups individually, it allows for extreme degrees of fine tuning.");
+
+        msgDoc("To list all permissions type:");
+        message(CmdFactions.get().cmdFactionsPerm.cmdFactionsPermList.getTemplate(false, true, sender));
+
+        msgDoc("To see who has a specific perm type:");
+        message(CmdFactions.get().cmdFactionsPerm.cmdFactionsPermShow.getTemplate(false, true, sender));
+
+        msgDoc("Per default permissions are only granted to ranks within your faction " +
+                "and a few perms are given to allies, but if you have changed it that will be displayed by the command above.");
+        msgDoc("When you create a new rank, you will have to set up their perms from scratch.");
+
+        msgDoc("If you want to know what permissions are specifically given to someone do:");
+        message(CmdFactions.get().cmdFactionsPerm.cmdFactionsPermView.getTemplate(false, true, sender));
+
+        msgDoc("To set perms do: ");
+        message(CmdFactions.get().cmdFactionsPerm.cmdFactionsPermSet.getTemplate(false, true, sender));
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDocumentationPower.java

@@ -0,0 +1,34 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.MassiveException;
+
+public class CmdFactionsDocumentationPower extends FactionsCommandDocumentation {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentationPower() {
+
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        msgDoc("All players  have an amount of power ranging from <h>%.2f <i>to <h>%.2f<i>.", MConf.get().powerMin, MConf.get().powerMax);
+        msgDoc("The power of a faction is equal to the combined power of all it's members.");
+        msgDoc("Your power is <h>%.2f<i>", msender.getPower());
+        msgDoc("Your faction's power is <h>%.2f<i>", msenderFaction.getPower());
+        msgDoc("The amount of chunks a faction can claim is the amount power it has.");
+        msgDoc("For every hour you are online you gain <h>%.2f <i>power.", MConf.get().powerPerHour);
+        msgDoc("Every time you die you power is decreased by <h>%.2f <i>.", MConf.get().powerPerDeath * -1);
+        if (!MConf.get().canLeaveWithNegativePower && MConf.get().powerMin < 0) {
+            msgDoc("You can't leave a faction if your power is negative.");
+        }
+
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDocumentationRanks.java

@@ -0,0 +1,52 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.mson.Mson;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CmdFactionsDocumentationRanks extends FactionsCommandDocumentation {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentationRanks() {
+
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        msgDoc("Ranks divide the faction into groups.");
+
+        List<Rank> ranks = msenderFaction.getRanks().getAll(Comparator.comparingInt(Rank::getPriority).reversed());
+        List<String> rankDesc = ranks.stream().map(r -> r.getDisplayName(msender)).collect(Collectors.toList());
+        msgDoc("Your faction has: <reset>%s", Txt.implodeCommaAndDot(rankDesc, Txt.parse("<i>")));
+
+        msgDoc("Ranks can have a prefix that will be prepended before any player name. Prefixes can be coloured.");
+        msgDoc("All ranks have a priority showed in parentheses after the name.");
+
+        Mson msonLeader = mson("The rank with the highest priority is deemed the “leader rank”" +
+                "(can be renamed) and only one person can have that rank")
+                .tooltip("For yor faction the leader rank is" + rankDesc.get(0))
+                .color(ChatColor.YELLOW);
+        messageDoc(msonLeader);
+        msgDoc("Whenever a new person joins the faction they will be assigned the rank with the lowest priority.");
+        msgDoc("Priorities are important because they determine who can do what." +
+                "For example: you can’t kick someone with the same or higher rank than yourself." +
+                "So if you have both Officers, and Co-leaders, do not fear officers kicking co-leaders or the co-leaders kicking each other." +
+                "They can’t. The same goes for changing ranks, titles and other similar things.");
+
+        msgDoc("To show, set or edit ranks do:");
+        message(CmdFactions.get().cmdFactionsRank.getTemplate(false, true, sender));
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDocumentationTax.java

@@ -0,0 +1,51 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.req.ReqTaxEnabled;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.money.Money;
+import com.massivecraft.massivecore.util.TimeDiffUtil;
+import com.massivecraft.massivecore.util.TimeUnit;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.LinkedHashMap;
+
+public class CmdFactionsDocumentationTax extends FactionsCommandDocumentation {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentationTax() {
+        this.addRequirements(ReqTaxEnabled.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        LinkedHashMap<TimeUnit, Long> timeUnitcounts = TimeDiffUtil.limit(TimeDiffUtil.unitcounts(MConf.get().taxTaskPeriodMillis, TimeUnit.getAll()), 3);
+        String periodString = TimeDiffUtil.formatedVerboose(timeUnitcounts);
+
+        msgDoc("<key>Taxation Period: <i>every %s<i>.", periodString);
+
+        long nextTaxationTime = MConf.get().taxTaskPeriodMillis + MConf.get().taxTaskPeriodMillis;
+
+        msgDoc("<key>Next Taxation: %s", Txt.getTimeDeltaDescriptionRelNow(nextTaxationTime));
+
+        String minTax = Money.format(MConf.get().taxPlayerMinimum);
+        String maxTax = Money.format(MConf.get().taxPlayerMaximum);
+        msgDoc("<i>Taxes for players can be set between <reset>%s <i>and <reset>%s<i>.", minTax, maxTax);
+
+        double tax = msenderFaction.getTaxForPlayer(msender);
+        if (tax > 0) {
+            msgDoc("<i>You pay <reset>%s <i>in taxes.", Money.format(tax));
+        } else if (tax < 0) {
+            msgDoc("<i>Instead of taxes you faction pays you <reset>%s <i>.", Money.format(tax * -1));
+        } else {
+            msgDoc("<i>You don't pay taxes.");
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsDocumentationWarps.java

@@ -0,0 +1,67 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.req.ReqFactionWarpsEnabled;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPerm.MPermable;
+import com.massivecraft.massivecore.MassiveException;
+
+import java.util.Set;
+
+public class CmdFactionsDocumentationWarps extends FactionsCommandDocumentation {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsDocumentationWarps() {
+        this.addRequirements(ReqFactionWarpsEnabled.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        msgDoc("A faction can have warps which allows it's members to easily go to important places within the faction.");
+
+        if (MConf.get().warpsMax < 0) {
+            msgDoc("There is <h>no limit <i>to how many warps a faction can have.");
+        } else {
+            msgDoc("A faction can only have <h>%d <i>warps.", MConf.get().warpsMax);
+        }
+
+        if (MConf.get().warpsMustBeInClaimedTerritory) {
+            msgDoc("Warps must be within claimed territory.");
+        }
+
+        if (MConf.get().warpsTeleportToOnDeathActive) {
+            msgDoc("If your faction has a warp with the name <h>%s <i>you will teleport there after death.", MConf.get().warpsTeleportToOnDeathName);
+        }
+
+        if (!MConf.get().warpsTeleportAllowedFromEnemyTerritory) {
+            msgDoc("You can't use faction warps while in enemy territory.");
+        }
+
+        if (!MConf.get().warpsTeleportAllowedFromDifferentWorld) {
+            msgDoc("You can't teleporty to a warp from another world.");
+        }
+
+        if (MConf.get().warpsTeleportAllowedEnemyDistance > 0) {
+            String str = String.format("You can't teleport home if there is an enemy within <h>%.1f <i>blocks of you", MConf.get().warpsTeleportAllowedEnemyDistance);
+            if (MConf.get().warpsTeleportIgnoreEnemiesIfInOwnTerritory) {
+                str += " unless you are in your own territory.";
+            } else {
+                str += ".";
+            }
+            msgDoc(str);
+        }
+
+        if (msenderFaction.isNormal()) {
+            Set<MPermable> set = msenderFaction.getPermittedPermables(MPerm.getPermWarp());
+            String permables = CmdFactionsPermShow.permablesToDisplayString(set, msender);
+            msgDoc("In your faction warps can be used by: %s<i>.", permables);
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsFaction.java

@@ -0,0 +1,59 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.event.EventFactionsFactionShowAsync;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.PriorityLines;
+import com.massivecraft.massivecore.mixin.MixinMessage;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+
+import java.util.TreeSet;
+
+public class CmdFactionsFaction extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsFaction() {
+        // Aliases
+        this.addAliases("f", "show", "who").setDesc("the faction to show info about");
+
+        // Parameters
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        final Faction faction = this.readArg(msenderFaction);
+        final CommandSender sender = this.sender;
+
+        Bukkit.getScheduler().runTaskAsynchronously(Factions.get(), () -> {
+            // Event
+            EventFactionsFactionShowAsync event = new EventFactionsFactionShowAsync(sender, faction);
+            event.run();
+            if (event.isCancelled()) {
+                return;
+            }
+
+            // Title
+            MixinMessage.get().messageOne(sender, Txt.titleize("Faction " + faction.getName(msender)));
+
+            // Lines
+            TreeSet<PriorityLines> priorityLiness = new TreeSet<>(event.getIdPriorityLiness().values());
+            for (PriorityLines priorityLines : priorityLiness) {
+                MixinMessage.get().messageOne(sender, priorityLines.getLines());
+            }
+        });
+
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsFlag.java

@@ -0,0 +1,12 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsFlag extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsFlagList cmdFactionsFlagList = new CmdFactionsFlagList();
+    public CmdFactionsFlagShow cmdFactionsFlagShow = new CmdFactionsFlagShow();
+    public CmdFactionsFlagSet cmdFactionsFlagSet = new CmdFactionsFlagSet();
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsFlagList.java

@@ -0,0 +1,51 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.entity.MFlag;
+import com.massivecraft.factions.entity.MFlagColl;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.Parameter;
+import com.massivecraft.massivecore.pager.Pager;
+import com.massivecraft.massivecore.pager.Stringifier;
+import org.bukkit.Bukkit;
+
+import java.util.List;
+
+public class CmdFactionsFlagList extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsFlagList() {
+        // Parameters
+        this.addParameter(Parameter.getPage());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Parameter
+        final int page = this.readArg();
+        final MPlayer mplayer = msender;
+
+        // Pager create
+        String title = "Flag List for " + msenderFaction.describeTo(mplayer);
+        final Pager<MFlag> pager = new Pager<>(this, title, page, (Stringifier<MFlag>) (mflag, index) -> mflag.getStateDesc(false, false, true, true, true, false));
+
+        Bukkit.getScheduler().runTaskAsynchronously(Factions.get(), () -> {
+            // Get items
+            List<MFlag> items = MFlagColl.get().getAll(mplayer.isOverriding() ? null : MFlag::isVisible);
+
+            // Pager items
+            pager.setItems(items);
+
+            // Pager message
+            pager.message();
+        });
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsFlagSet.java

@@ -0,0 +1,72 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMFlag;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MFlag;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.event.EventFactionsFlagChange;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeBooleanYes;
+
+public class CmdFactionsFlagSet extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsFlagSet() {
+        // Parameters
+        this.addParameter(TypeMFlag.get(), "flag").setDesc("the faction flag to set a value for");
+        this.addParameter(TypeBooleanYes.get(), "yes/no").setDesc("should the flag be on or off?");
+        this.addParameter(TypeFaction.get(), "faction", "you").setDesc("the faction to set the flag for (per default your own)");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        MFlag flag = this.readArg();
+        boolean value = this.readArg();
+        Faction faction = this.readArg(msenderFaction);
+
+        // Do the sender have the right to change flags for this faction?
+        if (!MPerm.getPermFlags().has(msender, faction, true)) {
+            return;
+        }
+
+        // Is this flag editable?
+        if (!msender.isOverriding() && !flag.isEditable()) {
+            throw new MassiveException().addMsg("<b>The flag <h>%s <b>is not editable.", flag.getName());
+        }
+
+        // Event
+        EventFactionsFlagChange event = new EventFactionsFlagChange(sender, faction, flag, value);
+        event.run();
+        if (event.isCancelled()) {
+            return;
+        }
+        value = event.isNewValue();
+
+        // No change 
+        if (faction.getFlag(flag) == value) {
+            throw new MassiveException().addMsg("%s <i>already has %s <i>set to %s<i>.", faction.describeTo(msender), flag.getStateDesc(value, false, true, true, false, true), flag.getStateDesc(value, true, true, false, false, false));
+        }
+
+        // Apply
+        faction.setFlag(flag, value);
+
+        // Inform
+        String stateInfo = flag.getStateDesc(faction.getFlag(flag), true, false, true, true, true);
+        if (msender.getFaction() != faction) {
+            // Send message to sender
+            msg("<h>%s <i>set a flag for <h>%s<i>.", msender.describeTo(msender, true), faction.describeTo(msender, true));
+            message(stateInfo);
+        }
+        faction.msg("<h>%s <i>set a flag for <h>%s<i>.", msender.describeTo(faction, true), faction.describeTo(faction, true));
+        faction.sendMessage(stateInfo);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsFlagShow.java

@@ -0,0 +1,50 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MFlag;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveList;
+import com.massivecraft.massivecore.command.Parameter;
+import com.massivecraft.massivecore.pager.Pager;
+import com.massivecraft.massivecore.pager.Stringifier;
+
+import java.util.List;
+
+public class CmdFactionsFlagShow extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsFlagShow() {
+        // Parameters
+        this.addParameter(TypeFaction.get(), "faction", "you").setDesc("the faction to show flags for");
+        this.addParameter(Parameter.getPage());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Parameters
+        final Faction faction = this.readArg(msenderFaction);
+        int page = this.readArg();
+
+        // Pager create
+        String title = "Flags for " + faction.describeTo(msender);
+        Pager<MFlag> pager = new Pager<>(this, title, page, MFlag.getAll(), (Stringifier<MFlag>) (mflag, index) -> mflag.getStateDesc(faction.getFlag(mflag), true, true, true, true, true));
+
+        // Pager args
+        List<String> pagerArgs = new MassiveList<>(
+                faction.getId(),
+                String.valueOf(page)
+        );
+        pager.setArgs(pagerArgs);
+
+        // Pager message
+        pager.messageAsync();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsFly.java

@@ -0,0 +1,61 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.engine.EngineFly;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.MassiveCommandToggle;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.engine.EngineMassiveCorePlayerUpdate;
+import com.massivecraft.massivecore.ps.PS;
+import org.bukkit.entity.Player;
+
+public class CmdFactionsFly extends MassiveCommandToggle {
+    // -------------------------------------------- //
+    // INSTANCE
+    // -------------------------------------------- //
+
+    private static CmdFactionsFly i = new CmdFactionsFly();
+
+    public static CmdFactionsFly get() {
+        return i;
+    }
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsFly() {
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public String getName() {
+        return "faction flying";
+    }
+
+    @Override
+    public boolean getValue() throws MassiveException {
+        return MPlayer.get(sender).isFlying();
+    }
+
+    public void setValue(boolean value) throws MassiveException {
+        MPlayer mplayer = MPlayer.get(sender);
+        Player player = me;
+		if (player == null) {
+			throw new MassiveException().addMsg("<b>Could not find player.");
+		}
+
+        PS ps = PS.valueOf(player);
+		if (value) {
+			EngineFly.canFlyInTerritoryOrThrow(mplayer, ps);
+		}
+
+        mplayer.setFlying(value);
+        EngineMassiveCorePlayerUpdate.update(player, false);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsHome.java

@@ -0,0 +1,39 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.Visibility;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.util.MUtil;
+
+import java.util.List;
+
+public class CmdFactionsHome extends FactionsCommandWarp {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsHome() {
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+
+        // Parameters
+        this.addParameter(TypeFaction.get(), "faction", "you");
+
+
+        // Visibility
+        this.setVisibility(Visibility.INVISIBLE);
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        List<String> args = MUtil.list(MConf.get().warpsHomeName, this.argAt(0));
+        CmdFactions.get().cmdFactionsWarp.cmdFactionsWarpGo.execute(me, args);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsInvite.java

@@ -0,0 +1,12 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsInvite extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsInviteList cmdFactionsInviteList = new CmdFactionsInviteList();
+    public CmdFactionsInviteAdd cmdFactionsInviteAdd = new CmdFactionsInviteAdd();
+    public CmdFactionsInviteRemove cmdFactionsInviteRemove = new CmdFactionsInviteRemove();
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsInviteAdd.java

@@ -0,0 +1,88 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.entity.Invitation;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.event.EventFactionsInvitedChange;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.container.TypeSet;
+import com.massivecraft.massivecore.mson.Mson;
+import com.massivecraft.massivecore.util.IdUtil;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+import java.util.Collection;
+
+public class CmdFactionsInviteAdd extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsInviteAdd() {
+        // Parameters
+        this.addParameter(TypeSet.get(TypeMPlayer.get()), "players", true).setDesc("the player to invite");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //	
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        Collection<MPlayer> mplayers = this.readArg();
+
+        String senderId = IdUtil.getId(sender);
+        long creationMillis = System.currentTimeMillis();
+
+        // MPerm
+		if (!MPerm.getPermInvite().has(msender, msenderFaction, true)) {
+			return;
+		}
+
+        for (MPlayer mplayer : mplayers) {
+            // Already member?
+            if (mplayer.getFaction() == msenderFaction) {
+                msg("%s<i> is already a member of %s<i>.", mplayer.getName(), msenderFaction.getName(msender));
+                continue;
+            }
+
+            // Already invited?
+            boolean isInvited = msenderFaction.isInvited(mplayer);
+
+            if (!isInvited) {
+                // Event
+                EventFactionsInvitedChange event = new EventFactionsInvitedChange(sender, mplayer, msenderFaction, isInvited);
+                event.run();
+				if (event.isCancelled()) {
+					continue;
+				}
+                isInvited = event.isNewInvited();
+
+                // Inform
+                mplayer.msg("%s<i> invited you to %s<i>.", msender.describeTo(mplayer, true), msenderFaction.describeTo(mplayer));
+                msenderFaction.msg("%s<i> invited %s<i> to your faction.", msender.describeTo(msenderFaction, true), mplayer.describeTo(msenderFaction));
+
+                // Apply
+                Invitation invitation = new Invitation(senderId, creationMillis);
+                msenderFaction.invite(mplayer.getId(), invitation);
+                msenderFaction.changed();
+            } else {
+                // Mson
+                String command = CmdFactions.get().cmdFactionsInvite.cmdFactionsInviteRemove.getCommandLine(mplayer.getName());
+                String tooltip = Txt.parse("<i>Click to <c>%s<i>.", command);
+
+                Mson remove = Mson.mson(
+                        mson("You might want to remove him. ").color(ChatColor.YELLOW),
+                        mson("Click to " + command).color(ChatColor.RED).tooltip(tooltip).suggest(command)
+                );
+
+                // Inform
+                msg("%s <i>is already invited to %s<i>.", mplayer.getName(), msenderFaction.getName(msender));
+                message(remove);
+            }
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsInviteList.java

@@ -0,0 +1,83 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.Invitation;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveList;
+import com.massivecraft.massivecore.command.Parameter;
+import com.massivecraft.massivecore.comparator.ComparatorSmart;
+import com.massivecraft.massivecore.mixin.MixinDisplayName;
+import com.massivecraft.massivecore.pager.Pager;
+import com.massivecraft.massivecore.pager.Stringifier;
+import com.massivecraft.massivecore.util.TimeDiffUtil;
+import com.massivecraft.massivecore.util.TimeUnit;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map.Entry;
+
+public class CmdFactionsInviteList extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsInviteList() {
+        // Parameters
+        this.addParameter(Parameter.getPage());
+        this.addParameter(TypeFaction.get(), "faction", "you").setDesc("the faction to list invites for");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //	
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args	
+        int page = this.readArg();
+
+        Faction faction = this.readArg(msenderFaction);
+
+		if (faction != msenderFaction && !Perm.INVITE_LIST_OTHER.has(sender, true)) {
+			return;
+		}
+
+        // MPerm
+		if (!MPerm.getPermInvite().has(msender, msenderFaction, true)) {
+			return;
+		}
+
+        // Pager Create
+        final List<Entry<String, Invitation>> invitations = new MassiveList<>(faction.getInvitations().entrySet());
+
+        invitations.sort((i1, i2) -> ComparatorSmart.get().compare(i2.getValue().getCreationMillis(), i1.getValue().getCreationMillis()));
+
+        final long now = System.currentTimeMillis();
+
+        final Pager<Entry<String, Invitation>> pager = new Pager<>(this, "Invited Players List", page, invitations, (Stringifier<Entry<String, Invitation>>) (entry, index) -> {
+            String inviteeId = entry.getKey();
+            String inviterId = entry.getValue().getInviterId();
+
+            String inviteeDisplayName = MixinDisplayName.get().getDisplayName(inviteeId, sender);
+            String inviterDisplayName = inviterId != null ? MixinDisplayName.get().getDisplayName(inviterId, sender) : Txt.parse("<silver>unknown");
+
+            String ageDesc = "";
+            if (entry.getValue().getCreationMillis() != null) {
+                long millis = now - entry.getValue().getCreationMillis();
+                LinkedHashMap<TimeUnit, Long> ageUnitcounts = TimeDiffUtil.limit(TimeDiffUtil.unitcounts(millis, TimeUnit.getAllButMillis()), 2);
+                ageDesc = TimeDiffUtil.formatedMinimal(ageUnitcounts, "<i>");
+                ageDesc = " " + ageDesc + Txt.parse(" ago");
+            }
+
+            return Txt.parse("%s<i> was invited by %s<reset>%s<i>.", inviteeDisplayName, inviterDisplayName, ageDesc);
+        });
+
+        // Pager Message
+        pager.message();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsInviteRemove.java

@@ -0,0 +1,136 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.event.EventFactionsInvitedChange;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.container.TypeSet;
+import com.massivecraft.massivecore.mson.Mson;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class CmdFactionsInviteRemove extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+    public CmdFactionsInviteRemove() {
+        // Parameters
+        this.addParameter(TypeSet.get(TypeMPlayer.get()), "players/all", true).setDesc("the player to deinvite");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //	
+
+    @Override
+    public void perform() throws MassiveException {
+        Set<MPlayer> mplayers = new HashSet<>();
+        boolean all = false;
+
+        // Args
+        if ("all".equalsIgnoreCase(this.argAt(0))) {
+            Set<String> ids = msenderFaction.getInvitations().keySet();
+            // Doesn't show up if list is empty. Test at home if it worked.
+            if (ids == null || ids.isEmpty()) {
+                throw new MassiveException().addMsg("<b>No one is invited to your faction.");
+            }
+            all = true;
+
+            for (String id : ids) {
+                mplayers.add(MPlayer.get(id));
+            }
+        } else {
+            mplayers = this.readArgAt(0);
+        }
+
+        // MPerm
+		if (!MPerm.getPermInvite().has(msender, msenderFaction, true)) {
+			return;
+		}
+
+        for (MPlayer mplayer : mplayers) {
+            // Already member?
+            if (mplayer.getFaction() == msenderFaction) {
+                // Mson
+                String command = CmdFactions.get().cmdFactionsKick.getCommandLine(mplayer.getName());
+                String tooltip = Txt.parse("Click to <c>%s<i>.", command);
+
+                Mson kick = Mson.mson(
+                        mson("You might want to kick him. ").color(ChatColor.YELLOW),
+                        mson(ChatColor.RED.toString() + tooltip).tooltip(ChatColor.YELLOW.toString() + tooltip).suggest(command)
+                );
+
+                // Inform
+                msg("%s<i> is already a member of %s<i>.", mplayer.getName(), msenderFaction.getName(msender));
+                message(kick);
+                continue;
+            }
+
+            // Already invited?
+            boolean isInvited = msenderFaction.isInvited(mplayer);
+
+            if (isInvited) {
+                // Event
+                EventFactionsInvitedChange event = new EventFactionsInvitedChange(sender, mplayer, msenderFaction, isInvited);
+                event.run();
+				if (event.isCancelled()) {
+					continue;
+				}
+                isInvited = event.isNewInvited();
+
+                // Inform Player
+                mplayer.msg("%s<i> revoked your invitation to <h>%s<i>.", msender.describeTo(mplayer, true), msenderFaction.describeTo(mplayer));
+
+                // Inform Faction
+                if (!all) {
+                    msenderFaction.msg("%s<i> revoked %s's<i> invitation.", msender.describeTo(msenderFaction), mplayer.describeTo(msenderFaction));
+                }
+
+                // Apply
+                msenderFaction.uninvite(mplayer);
+
+                // If all, we do this at last. So we only do it once.
+				if (!all) {
+					msenderFaction.changed();
+				}
+            } else {
+                // Mson
+                String command = CmdFactions.get().cmdFactionsInvite.cmdFactionsInviteAdd.getCommandLine(mplayer.getName());
+                String tooltip = Txt.parse("Click to <c>%s<i>.", command);
+
+                Mson invite = Mson.mson(
+                        mson("You might want to invite him. ").color(ChatColor.YELLOW),
+                        mson(ChatColor.GREEN.toString() + tooltip).tooltip(ChatColor.YELLOW.toString() + tooltip).suggest(command)
+                );
+
+                // Inform
+                msg("%s <i>is not invited to %s<i>.", mplayer.describeTo(msender, true), msenderFaction.describeTo(mplayer));
+                message(invite);
+            }
+        }
+
+        // Inform Faction if all
+        if (all) {
+            List<String> names = new ArrayList<>();
+            for (MPlayer mplayer : mplayers) {
+                names.add(mplayer.describeTo(msender, true));
+            }
+
+            Mson factionsRevokeAll = mson(
+                    Mson.parse("%s<i> revoked ", msender.describeTo(msenderFaction)),
+                    Mson.parse("<i>all <h>%s <i>pending invitations", mplayers.size()).tooltip(names),
+                    mson(" from your faction.").color(ChatColor.YELLOW)
+            );
+
+            msenderFaction.sendMessage(factionsRevokeAll);
+            msenderFaction.changed();
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsJoin.java

@@ -0,0 +1,124 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.Perm;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MFlag;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.event.EventFactionsMembershipChange;
+import com.massivecraft.factions.event.EventFactionsMembershipChange.MembershipChangeReason;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.mson.Mson;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsJoin extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsJoin() {
+        // Parameters
+        this.addParameter(TypeFaction.get(), "faction").setDesc("the faction to join");
+        this.addParameter(TypeMPlayer.get(), "player", "you").setDesc("the player that should join tje faction (for admins only)");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        Faction faction = this.readArg();
+
+        MPlayer mplayer = this.readArg(msender);
+        Faction mplayerFaction = mplayer.getFaction();
+
+        boolean samePlayer = mplayer == msender;
+
+        // Validate
+        if (!samePlayer && !Perm.JOIN_OTHERS.has(sender, false)) {
+            msg("<b>You do not have permission to move other players into a faction.");
+            return;
+        }
+
+        if (faction == mplayerFaction) {
+            String command = CmdFactions.get().cmdFactionsKick.getCommandLine(mplayer.getName());
+
+            // Mson creation
+            Mson alreadyMember = Mson.mson(
+                    Mson.parse(mplayer.describeTo(msender, true)),
+                    mson((samePlayer ? " are" : " is") + " already a member of " + faction.getName(msender) + ".").color(ChatColor.YELLOW)
+            );
+
+            message(alreadyMember.suggest(command).tooltip(Txt.parse("<i>Click to <c>%s<i>.", command)));
+            return;
+        }
+
+        if (MConf.get().factionMemberLimit > 0 && faction.getMPlayers().size() >= MConf.get().factionMemberLimit) {
+            msg(" <b>!<white> The faction %s is at the limit of %d members, so %s cannot currently join.", faction.getName(msender), MConf.get().factionMemberLimit, mplayer.describeTo(msender, false));
+            return;
+        }
+
+        if (mplayerFaction.isNormal()) {
+            String command = CmdFactions.get().cmdFactionsLeave.getCommandLine(mplayer.getName());
+
+            // Mson creation
+            Mson leaveFirst = Mson.mson(
+                    Mson.parse(mplayer.describeTo(msender, true)),
+                    mson(" must leave " + (samePlayer ? "your" : "their") + " current faction first.").color(ChatColor.RED)
+            );
+
+            message(leaveFirst.suggest(command).tooltip(Txt.parse("<i>Click to <c>%s<i>.", command)));
+            return;
+        }
+
+        if (!MConf.get().canLeaveWithNegativePower && mplayer.getPower() < 0) {
+            msg("<b>%s cannot join a faction with a negative power level.", mplayer.describeTo(msender, true));
+            return;
+        }
+
+        if (!(faction.getFlag(MFlag.getFlagOpen()) || faction.isInvited(mplayer) || msender.isOverriding())) {
+            msg("<i>This faction requires invitation.");
+            if (samePlayer) {
+                faction.msg("%s<i> tried to join your faction.", mplayer.describeTo(faction, true));
+            }
+            return;
+        }
+
+        // Event
+        EventFactionsMembershipChange membershipChangeEvent = new EventFactionsMembershipChange(sender, msender, faction, MembershipChangeReason.JOIN);
+        membershipChangeEvent.run();
+        if (membershipChangeEvent.isCancelled()) {
+            return;
+        }
+
+        // Inform
+        if (!samePlayer) {
+            mplayer.msg("<i>%s <i>moved you into the faction %s<i>.", msender.describeTo(mplayer, true), faction.getName(mplayer));
+        }
+        faction.msg("<i>%s <i>joined <lime>your faction<i>.", mplayer.describeTo(faction, true));
+        msender.msg("<i>%s <i>successfully joined %s<i>.", mplayer.describeTo(msender, true), faction.getName(msender));
+
+        // Apply
+        mplayer.resetFactionData();
+        mplayer.setFaction(faction);
+        mplayer.setRank(faction.getLowestRank());
+
+        faction.uninvite(mplayer);
+
+        // Derplog
+        if (MConf.get().logFactionJoin) {
+            if (samePlayer) {
+                Factions.get().log(Txt.parse("%s joined the faction %s.", mplayer.getName(), faction.getName()));
+            } else {
+                Factions.get().log(Txt.parse("%s moved the player %s into the faction %s.", msender.getName(), mplayer.getName(), faction.getName()));
+            }
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsKick.java

@@ -0,0 +1,91 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.event.EventFactionsMembershipChange;
+import com.massivecraft.factions.event.EventFactionsMembershipChange.MembershipChangeReason;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.util.IdUtil;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsKick extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsKick() {
+        // Parameters
+        this.addParameter(TypeMPlayer.get(), "player").setDesc("the player to kick");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Arg
+        MPlayer mplayer = this.readArg();
+
+        // Validate
+        if (msender == mplayer) {
+            msg("<b>You can't kick yourself.");
+            message(mson(mson("You might want to: ").color(ChatColor.YELLOW), CmdFactions.get().cmdFactionsLeave.getTemplate(false)));
+            return;
+        }
+
+        if (!msender.isOverriding() && mplayer.getRank().isLeader()) {
+            throw new MassiveException().addMsg("<b>The leader cannot be kicked.");
+        }
+
+        if (!msender.isOverriding() && mplayer.getFaction() == msenderFaction && mplayer.getRank().isMoreThan(msender.getRank())) {
+            throw new MassiveException().addMsg("<b>You can't kick people of higher rank than yourself.");
+        }
+
+        if (!msender.isOverriding() && mplayer.getRank() == msender.getRank()) {
+            throw new MassiveException().addMsg("<b>You can't kick people of the same rank as yourself.");
+        }
+
+        if (!msender.isOverriding() && !MConf.get().canLeaveWithNegativePower && mplayer.getPower() < 0) {
+            msg("<b>You can't kick that person until their power is positive.");
+            return;
+        }
+
+        // MPerm
+        Faction mplayerFaction = mplayer.getFaction();
+        if (!MPerm.getPermKick().has(msender, mplayerFaction, true)) {
+            return;
+        }
+
+        // Event
+        EventFactionsMembershipChange event = new EventFactionsMembershipChange(sender, mplayer, FactionColl.get().getNone(), MembershipChangeReason.KICK);
+        event.run();
+        if (event.isCancelled()) {
+            return;
+        }
+
+        // Inform
+        mplayerFaction.msg("%s<i> kicked %s<i> from the faction! :O", msender.describeTo(mplayerFaction, true), mplayer.describeTo(mplayerFaction, true));
+        mplayer.msg("%s<i> kicked you from %s<i>! :O", msender.describeTo(mplayer, true), mplayerFaction.describeTo(mplayer));
+        if (mplayerFaction != msenderFaction) {
+            msender.msg("<i>You kicked %s<i> from the faction %s<i>!", mplayer.describeTo(msender), mplayerFaction.describeTo(msender));
+        }
+
+        if (MConf.get().logFactionKick) {
+            Factions.get().log(msender.getDisplayName(IdUtil.getConsole()) + " kicked " + mplayer.getName() + " from the faction " + mplayerFaction.getName());
+        }
+
+        // Apply
+        if (mplayer.getRank().isLeader()) {
+            mplayerFaction.promoteNewLeader();
+        }
+        mplayerFaction.uninvite(mplayer);
+        mplayer.resetFactionData();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsLeave.java

@@ -0,0 +1,24 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.req.ReqHasFaction;
+
+public class CmdFactionsLeave extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsLeave() {
+        // Requirements
+        this.addRequirements(ReqHasFaction.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() {
+        msender.leave();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsList.java

@@ -0,0 +1,68 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.comparator.ComparatorFactionList;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.Parameter;
+import com.massivecraft.massivecore.pager.Pager;
+import com.massivecraft.massivecore.pager.Stringifier;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+
+import java.util.List;
+
+public class CmdFactionsList extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsList() {
+        // Parameters
+        this.addParameter(Parameter.getPage());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        int page = this.readArg();
+        final CommandSender sender = this.sender;
+        final MPlayer msender = this.msender;
+
+        // NOTE: The faction list is quite slow and mostly thread safe.
+        // We run it asynchronously to spare the primary server thread.
+
+        // Pager Create
+        final Pager<Faction> pager = new Pager<>(this, "Faction List", page, (Stringifier<Faction>) (faction, index) -> {
+            if (faction.isNone()) {
+                return Txt.parse("<i>Factionless<i> %d online", FactionColl.get().getNone().getMPlayersWhereOnlineTo(sender).size());
+            } else {
+                return Txt.parse("%s<i> %d/%d online, %d/%d/%d",
+                        faction.getName(msender),
+                        faction.getMPlayersWhereOnlineTo(sender).size(),
+                        faction.getMPlayers().size(),
+                        faction.getLandCount(),
+                        faction.getPowerRounded(),
+                        faction.getPowerMaxRounded()
+                );
+            }
+        });
+
+        Bukkit.getScheduler().runTaskAsynchronously(Factions.get(), () -> {
+            // Pager Items
+            final List<Faction> factions = FactionColl.get().getAll(ComparatorFactionList.get(sender));
+            pager.setItems(factions);
+
+            // Pager Message
+            pager.message();
+        });
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMap.java

@@ -0,0 +1,58 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.util.AsciiMap;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.command.type.primitive.TypeBooleanYes;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.Txt;
+
+public class CmdFactionsMap extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMap() {
+        // Parameters
+        this.addParameter(TypeBooleanYes.get(), "on/off", "once").setDesc("set to yes to get an auto updating map\nset to no to disable");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // NOTE: Map show is performed when auto == true || once
+        boolean argSet = this.argIsSet();
+        boolean showMap = true;
+
+        // Auto update
+        if (argSet) {
+            showMap = this.adjustAutoUpdating();
+        }
+        if (!showMap) {
+            return;
+        }
+
+        // Show Map
+        AsciiMap map = new AsciiMap(msender, PS.valueOf(me), !argSet);
+        message(map.render());
+    }
+
+    private boolean adjustAutoUpdating() throws MassiveException {
+        // Get
+        boolean autoUpdating = this.readArg(!msender.isMapAutoUpdating());
+
+        // Set
+        msender.setMapAutoUpdating(autoUpdating);
+
+        // Inform
+        msg("<i>Map auto update %s<i>.", Txt.parse(autoUpdating ? "<green>ENABLED" : "<red>DISABLED"));
+        return autoUpdating;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMoney.java

@@ -0,0 +1,26 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.req.ReqBankCommandsEnabled;
+
+public class CmdFactionsMoney extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsMoneyBalance cmdMoneyBalance = new CmdFactionsMoneyBalance();
+    public CmdFactionsMoneyDeposit cmdMoneyDeposit = new CmdFactionsMoneyDeposit();
+    public CmdFactionsMoneyWithdraw cmdMoneyWithdraw = new CmdFactionsMoneyWithdraw();
+    public CmdFactionsMoneyTransferF2f cmdMoneyTransferFf = new CmdFactionsMoneyTransferF2f();
+    public CmdFactionsMoneyTransferF2p cmdMoneyTransferFp = new CmdFactionsMoneyTransferF2p();
+    public CmdFactionsMoneyTransferP2f cmdMoneyTransferPf = new CmdFactionsMoneyTransferP2f();
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMoney() {
+        // Requirements
+        this.addRequirements(ReqBankCommandsEnabled.get());
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMoneyBalance.java

@@ -0,0 +1,38 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.factions.cmd.req.ReqBankCommandsEnabled;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.integration.Econ;
+import com.massivecraft.massivecore.MassiveException;
+
+public class CmdFactionsMoneyBalance extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMoneyBalance() {
+        // Parameters
+        this.addParameter(TypeFaction.get(), "faction", "you").setDesc("the faction whose balance to check");
+
+        // Requirements
+        this.addRequirements(ReqBankCommandsEnabled.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        Faction faction = this.readArg(msenderFaction);
+
+		if (faction != msenderFaction && !Perm.MONEY_BALANCE_ANY.has(sender, true)) {
+			return;
+		}
+
+        Econ.sendBalanceInfo(msender, faction);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMoneyDeposit.java

@@ -0,0 +1,46 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.req.ReqBankCommandsEnabled;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.integration.Econ;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeDouble;
+import com.massivecraft.massivecore.money.Money;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsMoneyDeposit extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMoneyDeposit() {
+        // Parameters
+        this.addParameter(TypeDouble.get(), "amount").setDesc("the amount of money to deposit");
+        this.addParameter(TypeFaction.get(), "faction", "you").setDesc("the faction to deposit money to");
+
+        // Requirements
+        this.addRequirements(ReqBankCommandsEnabled.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        double amount = this.readArg();
+
+        Faction faction = this.readArg(msenderFaction);
+
+        boolean success = Econ.transferMoney(msender, msender, faction, amount);
+
+        if (success && MConf.get().logMoneyTransactions) {
+            Factions.get().log(ChatColor.stripColor(Txt.parse("%s deposited %s in the faction bank: %s", msender.getName(), Money.format(amount), faction.describeTo(null))));
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMoneyTransferF2f.java

@@ -0,0 +1,53 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.req.ReqBankCommandsEnabled;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.integration.Econ;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeDouble;
+import com.massivecraft.massivecore.money.Money;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsMoneyTransferF2f extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMoneyTransferF2f() {
+        // Fields
+        this.setSetupEnabled(false);
+
+        // Aliases
+        this.addAliases("ff");
+
+        // Parameters
+        this.addParameter(TypeDouble.get(), "amount").setDesc("the amount of money to transfer");
+        this.addParameter(TypeFaction.get(), "faction").setDesc("the faction to transfer money from");
+        this.addParameter(TypeFaction.get(), "faction").setDesc("the faction to transfer money to");
+
+        // Requirements
+        this.addRequirements(ReqBankCommandsEnabled.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        double amount = this.readArg();
+        Faction from = this.readArg();
+        Faction to = this.readArg();
+
+        boolean success = Econ.transferMoney(msender, from, to, amount);
+
+        if (success && MConf.get().logMoneyTransactions) {
+            Factions.get().log(ChatColor.stripColor(Txt.parse("%s transferred %s from the faction \"%s\" to the faction \"%s\"", msender.getName(), Money.format(amount), from.describeTo(null), to.describeTo(null))));
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMoneyTransferF2p.java

@@ -0,0 +1,55 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.req.ReqBankCommandsEnabled;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.integration.Econ;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeDouble;
+import com.massivecraft.massivecore.money.Money;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsMoneyTransferF2p extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMoneyTransferF2p() {
+        // Fields
+        this.setSetupEnabled(false);
+
+        // Aliases
+        this.addAliases("fp");
+
+        // Parameters
+        this.addParameter(TypeDouble.get(), "amount").setDesc("the amount of money to transfer");
+        this.addParameter(TypeFaction.get(), "faction").setDesc("the faction to transfer money from");
+        this.addParameter(TypeMPlayer.get(), "player").setDesc("the player to transfer money to");
+
+        // Requirements
+        this.addRequirements(ReqBankCommandsEnabled.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        double amount = this.readArg();
+        Faction from = this.readArg();
+        MPlayer to = this.readArg();
+
+        boolean success = Econ.transferMoney(msender, from, to, amount);
+
+        if (success && MConf.get().logMoneyTransactions) {
+            Factions.get().log(ChatColor.stripColor(Txt.parse("%s transferred %s from the faction \"%s\" to the player \"%s\"", msender.getName(), Money.format(amount), from.describeTo(null), to.describeTo(null))));
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMoneyTransferP2f.java

@@ -0,0 +1,55 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.req.ReqBankCommandsEnabled;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.integration.Econ;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeDouble;
+import com.massivecraft.massivecore.money.Money;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsMoneyTransferP2f extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMoneyTransferP2f() {
+        // Fields
+        this.setSetupEnabled(false);
+
+        // Aliases
+        this.addAliases("pf");
+
+        // Parameters
+        this.addParameter(TypeDouble.get(), "amount").setDesc("the amount of money to transfer");
+        this.addParameter(TypeMPlayer.get(), "player").setDesc("the player to transfer money from");
+        this.addParameter(TypeFaction.get(), "faction").setDesc("the faction to transfer money to");
+
+        // Requirements
+        this.addRequirements(ReqBankCommandsEnabled.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        double amount = this.readArg();
+        MPlayer from = this.readArg();
+        Faction to = this.readArg();
+
+        boolean success = Econ.transferMoney(msender, from, to, amount);
+
+        if (success && MConf.get().logMoneyTransactions) {
+            Factions.get().log(ChatColor.stripColor(Txt.parse("%s transferred %s from the player \"%s\" to the faction \"%s\"", msender.getName(), Money.format(amount), from.describeTo(null), to.describeTo(null))));
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMoneyWithdraw.java

@@ -0,0 +1,48 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.req.ReqBankCommandsEnabled;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.integration.Econ;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeDouble;
+import com.massivecraft.massivecore.money.Money;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsMoneyWithdraw extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMoneyWithdraw() {
+        // Parameters
+        this.addParameter(TypeDouble.get(), "amount").setDesc("the amount of money to withdraw");
+        this.addParameter(TypeFaction.get(), "faction", "you").setDesc("the faction to transfer money to");
+
+        // Requirements
+        this.addRequirements(ReqBankCommandsEnabled.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        Double amount = this.readArg();
+        Faction from = this.readArg(msenderFaction);
+
+        MPlayer to = msender;
+
+        boolean success = Econ.transferMoney(msender, from, to, amount);
+
+        if (success && MConf.get().logMoneyTransactions) {
+            Factions.get().log(ChatColor.stripColor(Txt.parse("%s withdrew %s from the faction bank: %s", msender.getName(), Money.format(amount), from.describeTo(null))));
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMoneyconvert.java

@@ -0,0 +1,69 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.Visibility;
+import com.massivecraft.massivecore.command.type.primitive.TypeStringConfirmation;
+import com.massivecraft.massivecore.money.Money;
+import com.massivecraft.massivecore.util.ConfirmationUtil;
+
+public class CmdFactionsMoneyconvert extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMoneyconvert() {
+        // Parameters
+        this.addParameter(TypeStringConfirmation.get(), "confirmation", "");
+
+        // Low priority
+        this.setPriority(-100);
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public Visibility getVisibility() {
+        //return Visibility.INVISIBLE;
+        return MConf.get().useNewMoneySystem ? Visibility.INVISIBLE : Visibility.SECRET;
+    }
+
+    @Override
+    public void perform() throws MassiveException {
+        if (MConf.get().useNewMoneySystem) {
+            throw new MassiveException().addMsg("<b>The economy system is already converted.");
+        }
+
+        // Args
+        if (!this.argIsSet(0)) {
+            msg("<i>Money in Factions used to be stored within the applicable economy plugin." +
+                    " This is problematic because not all economy plugins support that." +
+                    " This command allows to convert to the new system where the money of a Faction" +
+                    " is stored within the Factions plugin. Then all economy plugins can be used with Factions.");
+        }
+
+        ConfirmationUtil.tryConfirm(this);
+
+        MConf.get().useNewMoneySystem = true;
+
+        for (Faction f : FactionColl.get().getAll()) {
+            if (!Money.exists(f)) {
+                msg("<h>%s <i>does not have any money.", f.getName());
+                continue;
+            }
+
+            double money = Money.get(f);
+            f.setMoney(money);
+
+            Money.set(f, null, 0);
+
+            msg("<h>%s <i>has <h>%s <i> and has been converted.", f.getName(), Money.format(money));
+        }
+        msg("<i>Converted all factions. Hooray!");
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsMotd.java

@@ -0,0 +1,75 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.event.EventFactionsMotdChange;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.TypeNullable;
+import com.massivecraft.massivecore.command.type.primitive.TypeString;
+import com.massivecraft.massivecore.mixin.MixinDisplayName;
+import com.massivecraft.massivecore.util.MUtil;
+import com.massivecraft.massivecore.util.Txt;
+
+public class CmdFactionsMotd extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsMotd() {
+        // Parameters
+        this.addParameter(TypeNullable.get(TypeString.get()), "new", "read", true).setDesc("the new motd\nif not specified you will just see the current one");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Read
+        if (!this.argIsSet(0)) {
+            message(msenderFaction.getMotdMessages());
+            return;
+        }
+
+        // MPerm
+        if (!MPerm.getPermMotd().has(msender, msenderFaction, true)) {
+            return;
+        }
+
+        // Args
+        String target = this.readArg();
+
+        if (target != null) {
+            target = target.trim();
+            target = Txt.parse(target);
+        }
+
+        // Get Old
+        String old = msenderFaction.getMotd();
+
+        // NoChange
+        if (MUtil.equals(old, target)) {
+            msg("<i>The motd for %s <i>is already: <h>%s", msenderFaction.describeTo(msender, true), msenderFaction.getMotdDesc());
+            return;
+        }
+
+        // Event
+        EventFactionsMotdChange event = new EventFactionsMotdChange(sender, msenderFaction, target);
+        event.run();
+        if (event.isCancelled()) {
+            return;
+        }
+        target = event.getNewMotd();
+
+        // Apply
+        msenderFaction.setMotd(target);
+
+        // Inform
+        for (MPlayer follower : msenderFaction.getMPlayers()) {
+            follower.msg("<i>%s <i>changed your faction motd.", MixinDisplayName.get().getDisplayName(sender, follower));
+            follower.message(msenderFaction.getMotdMessages());
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsName.java

@@ -0,0 +1,54 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeFactionNameLenient;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.event.EventFactionsNameChange;
+import com.massivecraft.massivecore.MassiveException;
+
+public class CmdFactionsName extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsName() {
+        // Parameters
+        this.addParameter(TypeFactionNameLenient.get(), "new name").setDesc("the new name of the faction");
+        this.addParameter(TypeFaction.get(), "faction", "you").setDesc("the faction whose name to change");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        String newName = this.readArg();
+        Faction faction = this.readArg(msenderFaction);
+
+        // MPerm
+		if (!MPerm.getPermName().has(msender, faction, true)) {
+			return;
+		}
+
+        // Event
+        EventFactionsNameChange event = new EventFactionsNameChange(sender, faction, newName);
+        event.run();
+		if (event.isCancelled()) {
+			return;
+		}
+        newName = event.getNewName();
+
+        // Apply
+        faction.setName(newName);
+
+        // Inform
+        faction.msg("%s<i> changed your faction name to %s", msender.describeTo(faction, true), faction.getName(faction));
+        if (msenderFaction != faction) {
+            msg("<i>You changed the faction name to %s", faction.getName(msender));
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsOverride.java

@@ -0,0 +1,44 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeBooleanYes;
+import com.massivecraft.massivecore.util.IdUtil;
+import com.massivecraft.massivecore.util.Txt;
+
+public class CmdFactionsOverride extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsOverride() {
+        // Aliases
+        this.addAliases("admin");
+
+        // Parameters
+        this.addParameter(TypeBooleanYes.get(), "on/off", "flip");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        boolean target = this.readArg(!msender.isOverriding());
+
+        // Apply
+        msender.setOverriding(target);
+
+        // Inform
+        String desc = Txt.parse(msender.isOverriding() ? "<g>ENABLED" : "<b>DISABLED");
+
+        String messageYou = Txt.parse("<i>%s %s <i>override mode.", msender.getDisplayName(msender), desc);
+        String messageLog = Txt.parse("<i>%s %s <i>override mode.", msender.getDisplayName(IdUtil.getConsole()), desc);
+
+        msender.message(messageYou);
+        Factions.get().log(messageLog);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPerm.java

@@ -0,0 +1,14 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPerm extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    CmdFactionsPermList cmdFactionsPermList = new CmdFactionsPermList();
+    CmdFactionsPermShow cmdFactionsPermShow = new CmdFactionsPermShow();
+    CmdFactionsPermView cmdFactionsPermView = new CmdFactionsPermView();
+    CmdFactionsPermViewall cmdFactionsPermViewall = new CmdFactionsPermViewall();
+    CmdFactionsPermSet cmdFactionsPermSet = new CmdFactionsPermSet();
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPermList.java

@@ -0,0 +1,51 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPermColl;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.Parameter;
+import com.massivecraft.massivecore.pager.Pager;
+import com.massivecraft.massivecore.pager.Stringifier;
+import org.bukkit.Bukkit;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+public class CmdFactionsPermList extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPermList() {
+        // Parameters
+        this.addParameter(Parameter.getPage());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Parameter
+        int page = this.readArg();
+
+        // Pager create
+        String title = String.format("Perms for %s", msenderFaction.describeTo(msender));
+        final Pager<MPerm> pager = new Pager<>(this, title, page, (Stringifier<MPerm>) (mp, i) -> mp.getDesc(true, true));
+        final Predicate<MPerm> predicate = msender.isOverriding() ? null : MPerm::isVisible;
+
+        Bukkit.getScheduler().runTaskAsynchronously(Factions.get(), () -> {
+            // Get items
+            List<MPerm> items = MPermColl.get().getAll(predicate);
+
+            // Pager items
+            pager.setItems(items);
+
+            // Pager message
+            pager.message();
+        });
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPermSet.java

@@ -0,0 +1,80 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPerm;
+import com.massivecraft.factions.cmd.type.TypeMPermable;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.event.EventFactionsPermChange;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeBooleanYes;
+import com.massivecraft.massivecore.util.Txt;
+
+public class CmdFactionsPermSet extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPermSet() {
+        // Parameters
+        this.addParameter(TypeMPerm.get(), "perm");
+        this.addParameter(TypeMPermable.get(), "rank/rel/player/faction");
+        this.addParameter(TypeBooleanYes.get(), "yes/no");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        MPerm perm = this.readArgAt(0);
+        Boolean value = this.readArgAt(2);
+        Faction faction = this.readArgAt(3, msenderFaction);
+
+        MPerm.MPermable permable = TypeMPermable.get(faction).read(this.argAt(1), sender);
+
+        // Do the sender have the right to change perms for this faction?
+		if (!MPerm.getPermPerms().has(msender, faction, true)) {
+			return;
+		}
+
+        // Is this perm editable?
+        if (!msender.isOverriding() && !perm.isEditable()) {
+            throw new MassiveException().addMsg("<b>The perm <h>%s <b>is not editable.", perm.getName());
+        }
+
+        if (permable == faction) {
+            throw new MassiveException().addMsg("<b>A faction can't have perms for itself. Perhaps try ranks.");
+        }
+
+        // Event
+        EventFactionsPermChange event = new EventFactionsPermChange(sender, faction, perm, permable, value);
+        event.run();
+		if (event.isCancelled()) {
+			return;
+		}
+        value = event.getNewValue();
+
+        // Apply
+        boolean change = faction.setPermitted(permable, perm, value);
+
+        // No change
+        if (!change) {
+            throw new MassiveException().addMsg("%s <i>already has %s <i>set to %s <i>for %s<i>.", faction.describeTo(msender), perm.getDesc(true, false), Txt.parse(value ? "<g>YES" : "<b>NOO"), permable.getDisplayName(msender));
+        }
+
+        // The following is to make sure the leader always has the right to change perms if that is our goal.
+        if (perm == MPerm.getPermPerms() && MConf.get().perm2default.get(MPerm.ID_PERMS).contains("LEADER")) {
+            faction.setPermitted(faction.getLeaderRank(), MPerm.getPermPerms(), true);
+        }
+
+        // Inform sender
+        String yesNo = Txt.parse(value ? "<g>YES" : "<b>NOO");
+        msg("<i>Set perm <h>%s <i>to <h>%s <i>for <reset>%s<i> in <reset>%s<i>.", perm.getName(), yesNo, permable.getDisplayName(msender), faction.describeTo(msender));
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPermShow.java

@@ -0,0 +1,81 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPerm;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPerm.MPermable;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveList;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class CmdFactionsPermShow extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPermShow() {
+        // Parameters
+        this.addParameter(TypeMPerm.get(), "perm");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Arg: Faction
+        MPerm mperm = this.readArg();
+        Faction faction = this.readArg(msenderFaction);
+
+        Set<String> permittedIds = faction.getPerms().get(mperm.getId());
+        List<MPermable> permables = new MassiveList<>();
+
+        for (String permitted : permittedIds) {
+            permables.add(MPerm.idToMPermable(permitted));
+        }
+
+        String removeString = Txt.parse(" of ") + faction.getDisplayName(msender);
+        List<String> permableList = permables.stream()
+                .map(permable -> permable.getDisplayName(msender))
+                .map(s -> s.replace(removeString, ""))
+                .collect(Collectors.toList());
+        String permableNames = Txt.implodeCommaAnd(permableList, Txt.parse("<i>"));
+
+        // Create messages
+        msg("<i>In <reset>%s <i>permission <reset>%s <i>is granted to <reset>%s<i>.", faction.describeTo(msender), mperm.getDesc(true, false), permableNames);
+    }
+
+    @Deprecated
+    public static MPerm.MPermable idToMPermable(String id) {
+        return MPerm.idToMPermable(id);
+    }
+
+    public static String permablesToDisplayString(Collection<MPermable> permables, Object watcherObject) {
+        MPlayer mplayer = MPlayer.get(watcherObject);
+        Faction faction = mplayer.getFaction();
+
+        String removeString;
+        if (faction.isNone()) {
+            removeString = "";
+        } else {
+            removeString = Txt.parse(" of ") + faction.getDisplayName(mplayer);
+        }
+
+        List<String> permableList = permables.stream()
+                .map(permable -> permable.getDisplayName(mplayer))
+                .map(s -> s.replace(removeString, ""))
+                .collect(Collectors.toList());
+
+        return Txt.implodeCommaAnd(permableList, Txt.parse("<i>"));
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPermView.java

@@ -0,0 +1,98 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPermable;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveList;
+import com.massivecraft.massivecore.mson.Mson;
+import com.massivecraft.massivecore.util.MUtil;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.ChatColor;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CmdFactionsPermView extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPermView() {
+        // Parameters
+        this.addParameter(TypeMPermable.get(), "rank/rel/player/faction");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Arg: Faction
+        Faction faction = this.readArgAt(1, msenderFaction);
+        TypeMPermable permableType = TypeMPermable.get(faction);
+        MPerm.MPermable permable = permableType.read(this.argAt(0), sender);
+
+        if (permable == faction) {
+            throw new MassiveException().addMsg("<b>A faction can't have perms for itself.");
+        }
+
+        List<MPerm> perms = new MassiveList<>();
+
+        for (MPerm mperm : MPerm.getAll()) {
+			if (faction.isPermitted(permable.getId(), mperm.getId())) {
+				perms.add(mperm);
+			}
+        }
+
+        if (perms.isEmpty()) {
+            msg("<i>In <reset>%s <reset>%s <i>specifically has <b>no permissions<i>.", faction.describeTo(msender), permable.getDisplayName(sender));
+        } else {
+            List<String> permNames = perms.stream().map(perm -> Txt.parse("<h>") + perm.getName()).collect(Collectors.toList());
+            String names = Txt.implodeCommaAnd(permNames, Txt.parse("<i>"));
+
+            // Create messages
+            String permissionSingularPlural = permNames.size() == 1 ? "permission" : "permissions";
+            msg("<i>In <reset>%s <reset>%s <i>specifically has the %s: <reset>%s<i>.", faction.describeTo(msender), permable.getDisplayName(sender), permissionSingularPlural, names);
+        }
+        if (permable instanceof MPlayer) {
+            MPlayer mplayer = (MPlayer) permable;
+            msg("<i>They may have other permissions through their faction membership, rank or relation to <reset>%s<i>.", faction.describeTo(msender));
+
+            List<Mson> msons = new MassiveList<>();
+
+			if (mplayer.getFaction() != faction) {
+				msons.add(Mson.parse("<command>[faction]").command(this, mplayer.getFaction().getName(), faction.getName()));
+			}
+            msons.add(Mson.parse("<command>[rank]").command(this, mplayer.getFaction().getName() + "-" + mplayer.getRank().getName(), faction.getName()));
+			if (mplayer.getFaction() != faction) {
+				msons.add(Mson.parse("<command>[relation]").command(this, faction.getRelationTo(mplayer).toString(), faction.getName()));
+			}
+            Mson msons2 = Mson.implode(msons, Mson.SPACE);
+            message(mson(mson("Commands: ").color(ChatColor.YELLOW), msons2));
+        }
+        if (permable instanceof Faction) {
+            Faction faction1 = (Faction) permable;
+            msg("<i>They may have other permissions through their relation to <reset>%s<i>.", faction.describeTo(msender));
+            Mson msonRelation = Mson.parse("<command>[relation]").command(this, faction.getRelationTo(faction1).toString(), faction.getName());
+            Mson msons = Mson.implode(MUtil.list(msonRelation), Mson.SPACE);
+            message(mson(mson("Commands: ").color(ChatColor.YELLOW), msons));
+        }
+        if (permable instanceof Rank && !faction.hasRank((Rank) permable)) {
+            Rank rank = (Rank) permable;
+            msg("<i>They may have other permissions thorugh their faction membership or relation to <reset>%s<i>.", faction.describeTo(msender));
+            Mson msonFaction = Mson.parse("<command>[faction]").command(this, rank.getFaction().getName(), faction.getName());
+            Mson msonRelation = Mson.parse("<command>[relation]").command(this, faction.getRelationTo(rank.getFaction()).toString(), faction.getName());
+            Mson msons = Mson.implode(MUtil.list(msonFaction, msonRelation), Mson.SPACE);
+            message(mson(mson("Commands: ").color(ChatColor.YELLOW), msons));
+        }
+        msg("<i>To view all perms held by %s <i>type:", permable.getDisplayName(sender));
+        message(CmdFactions.get().cmdFactionsPerm.cmdFactionsPermViewall.getTemplateWithArgs(sender, MUtil.list(permable.getName(), faction.getName())));
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPermViewall.java

@@ -0,0 +1,94 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPermable;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPerm.MPermable;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveList;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CmdFactionsPermViewall extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPermViewall() {
+        // Parameters
+        this.addParameter(TypeMPermable.get(), "rank/rel/player/faction");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Arg: Faction
+        Faction faction = this.readArgAt(1, msenderFaction);
+        TypeMPermable permableType = TypeMPermable.get(faction);
+        MPerm.MPermable permable = permableType.read(this.argAt(0), sender);
+
+        // Self check
+        if (permable == faction) {
+            throw new MassiveException().addMsg("<b>A faction can't have perms for itself.");
+        }
+
+        // Create list of all applicable permables
+        List<MPermable> permables = new MassiveList<>();
+        permables.add(permable);
+
+        if (permable instanceof MPlayer) {
+            MPlayer mplayer = (MPlayer) permable;
+            permables.add(mplayer.getFaction());
+            permables.add(mplayer.getRank());
+            permables.add(faction.getRelationTo(mplayer));
+        }
+        if (permable instanceof Faction) {
+            Faction faction1 = (Faction) permable;
+            permables.add(faction.getRelationTo(faction1));
+        }
+        if (permable instanceof Rank && !faction.hasRank((Rank) permable)) {
+            Rank rank = (Rank) permable;
+            Faction faction1 = rank.getFaction();
+            permables.add(faction1);
+            permables.add(faction.getRelationTo(faction1));
+        }
+
+        // Find the perms they have
+        List<MPerm> perms = new MassiveList<>();
+
+        perm:
+        for (MPerm mperm : MPerm.getAll()) {
+            String mpermId = mperm.getId();
+            permable:
+            for (MPermable mpa : permables) {
+                if (!faction.isPermitted(mpa.getId(), mperm.getId())) {
+                    continue permable;
+                }
+                perms.add(mperm);
+                continue perm;
+            }
+
+        }
+
+        if (perms.isEmpty()) {
+            msg("<i>In <reset>%s <reset>%s <i>has <b>no permissions<i>.", faction.describeTo(msender), permable.getDisplayName(sender));
+        } else {
+            List<String> permNames = perms.stream().map(perm -> Txt.parse("<h>") + perm.getName()).collect(Collectors.toList());
+            String names = Txt.implodeCommaAnd(permNames, Txt.parse("<i>"));
+
+            // Create messages
+            String permissionSingularPlural = permNames.size() == 1 ? "permission" : "permissions";
+            msg("<i>In <reset>%s <reset>%s <i>has the %s: <reset>%s<i> either specifically granted to them or through rank, relation or faction membership.", faction.describeTo(msender), permable.getDisplayName(sender), permissionSingularPlural, names);
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPlayer.java

@@ -0,0 +1,103 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.Progressbar;
+import com.massivecraft.massivecore.event.EventMassiveCorePlayerCleanInactivityToleranceMillis;
+import com.massivecraft.massivecore.util.TimeDiffUtil;
+import com.massivecraft.massivecore.util.TimeUnit;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.LinkedHashMap;
+import java.util.Map.Entry;
+
+public class CmdFactionsPlayer extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPlayer() {
+        // Parameters
+        this.addParameter(TypeMPlayer.get(), "player", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        MPlayer mplayer = this.readArg(msender);
+
+        // INFO: Title
+        message(Txt.titleize("Player " + mplayer.describeTo(msender)));
+
+        // INFO: Rank
+        msg("<a>Rank: <v>%s", mplayer.getRank().getDisplayName(sender));
+
+        // INFO: Power (as progress bar)
+        double progressbarQuota = 0;
+        double playerPowerMax = mplayer.getPowerMax();
+        if (playerPowerMax != 0) {
+            progressbarQuota = mplayer.getPower() / playerPowerMax;
+        }
+
+        int progressbarWidth = (int) Math.round(mplayer.getPowerMax() / mplayer.getPowerMaxUniversal() * 100);
+        msg("<a>Power: <v>%s", Progressbar.HEALTHBAR_CLASSIC.withQuota(progressbarQuota).withWidth(progressbarWidth).render());
+
+        // INFO: Power (as digits)
+        msg("<a>Power: <v>%.2f / %.2f", mplayer.getPower(), mplayer.getPowerMax());
+
+        // INFO: Power Boost
+        if (mplayer.hasPowerBoost()) {
+            double powerBoost = mplayer.getPowerBoost();
+            String powerBoostType = (powerBoost > 0 ? "bonus" : "penalty");
+            msg("<a>Power Boost: <v>%f <i>(a manually granted %s)", powerBoost, powerBoostType);
+        }
+
+        // INFO: Power per Hour
+        // If the player is not at maximum we wan't to display how much time left.
+
+        String stringTillMax = "";
+        double powerTillMax = mplayer.getPowerMax() - mplayer.getPower();
+        if (powerTillMax > 0) {
+            long millisTillMax = (long) (powerTillMax * TimeUnit.MILLIS_PER_HOUR / mplayer.getPowerPerHour());
+            LinkedHashMap<TimeUnit, Long> unitcountsTillMax = TimeDiffUtil.unitcounts(millisTillMax, TimeUnit.getAllButMillis());
+            unitcountsTillMax = TimeDiffUtil.limit(unitcountsTillMax, 2);
+            String unitcountsTillMaxFormated = TimeDiffUtil.formatedVerboose(unitcountsTillMax, "<i>");
+            stringTillMax = Txt.parse(" <i>(%s <i>left till max)", unitcountsTillMaxFormated);
+        }
+
+        msg("<a>Power per Hour: <v>%.2f%s", mplayer.getPowerPerHour(), stringTillMax);
+
+        // INFO: Power per Death
+        msg("<a>Power per Death: <v>%.2f", mplayer.getPowerPerDeath());
+
+        // Display automatic kick / remove info if the system is in use
+        if (MConf.get().cleanInactivityToleranceMillis <= 0) {
+            return;
+        }
+
+        EventMassiveCorePlayerCleanInactivityToleranceMillis event = new EventMassiveCorePlayerCleanInactivityToleranceMillis(mplayer.getLastActivityMillis(), mplayer);
+        event.run();
+        msg("<i>Automatic removal after %s <i>of inactivity:", format(event.getToleranceMillis()));
+        for (Entry<String, Long> causeMillis : event.getToleranceCauseMillis().entrySet()) {
+            String cause = causeMillis.getKey();
+            long millis = causeMillis.getValue();
+            msg("<a>%s<a>: <v>%s", cause, format(millis));
+        }
+    }
+
+    // -------------------------------------------- //
+    // TIME FORMAT
+    // -------------------------------------------- //
+
+    public static String format(long millis) {
+        LinkedHashMap<TimeUnit, Long> unitcounts = TimeDiffUtil.unitcounts(millis, TimeUnit.getAllBut(TimeUnit.MILLISECOND, TimeUnit.WEEK, TimeUnit.MONTH));
+        return TimeDiffUtil.formatedVerboose(unitcounts);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboost.java

@@ -0,0 +1,21 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboost extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsPowerboostPlayer cmdFactionsPowerBoostPlayer = new CmdFactionsPowerboostPlayer();
+    public CmdFactionsPowerboostFaction cmdFactionsPowerBoostFaction = new CmdFactionsPowerboostFaction();
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPowerboost() {
+        // Child
+        this.addChild(this.cmdFactionsPowerBoostPlayer);
+        this.addChild(this.cmdFactionsPowerBoostFaction);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostAbstract.java

@@ -0,0 +1,76 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.FactionsParticipator;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.Type;
+import com.massivecraft.massivecore.command.type.primitive.TypeDouble;
+import com.massivecraft.massivecore.util.Txt;
+
+public abstract class CmdFactionsPowerboostAbstract extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    protected CmdFactionsPowerboostAbstract(Type<? extends FactionsParticipator> parameterType, String parameterName) {
+        // Parameters
+        this.addParameter(parameterType, parameterName);
+        if (!this.getClass().getSimpleName().contains("Show")) {
+            this.addParameter(TypeDouble.get(), "amount");
+        }
+    }
+
+    // -------------------------------------------- //
+    // ABSTRACT
+    // -------------------------------------------- //
+
+    public abstract double calcNewPowerboost(double current, double d);
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Parameters
+        FactionsParticipator factionsParticipator = this.readArg();
+
+        boolean updated = false;
+        // Try set the powerBoost
+        if (this.argIsSet(1)) {
+            // Yes updated
+            updated = true;
+
+            // Calc powerboost
+            double current = factionsParticipator.getPowerBoost();
+            double number = this.readArg();
+            double powerBoost = this.calcNewPowerboost(current, number);
+
+            // Set
+            factionsParticipator.setPowerBoost(powerBoost);
+        }
+
+        // Inform
+        this.informPowerBoost(factionsParticipator, updated);
+    }
+
+    private void informPowerBoost(FactionsParticipator factionsParticipator, boolean updated) {
+        // Prepare
+        Double powerBoost = factionsParticipator.getPowerBoost();
+        String participatorDescribe = factionsParticipator.describeTo(msender, true);
+        String powerDescription = Txt.parse(Double.compare(powerBoost, 0D) >= 0 ? "<g>bonus" : "<b>penalty");
+        String when = updated ? "now " : "";
+        String verb = factionsParticipator.equals(msender) ? "have" : "has";
+
+        // Create message
+        String messagePlayer = Txt.parse("<i>%s<i> %s%s a power %s<i> of <h>%.2f<i> to min and max power levels.", participatorDescribe, when, verb, powerDescription, powerBoost);
+        String messageLog = Txt.parse("%s %s set the power %s<i> for %s<i> to <h>%.2f<i>.", msender.getName(), verb, powerDescription, factionsParticipator.getName(), powerBoost);
+
+        // Inform
+        msender.message(messagePlayer);
+        if (updated) {
+            Factions.get().log(messageLog);
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostFaction.java

@@ -0,0 +1,14 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostFaction extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsPowerboostFactionShow cmdFactionsPowerBoostFactionShow = new CmdFactionsPowerboostFactionShow();
+    public CmdFactionsPowerboostFactionSet cmdFactionsPowerBoostFactionSet = new CmdFactionsPowerboostFactionSet();
+    public CmdFactionsPowerboostFactionAdd cmdFactionsPowerBoostFactionAdd = new CmdFactionsPowerboostFactionAdd();
+    public CmdFactionsPowerboostFactionTake cmdFactionsPowerBoostFactionTake = new CmdFactionsPowerboostFactionTake();
+    public CmdFactionsPowerboostFactionMultiply cmdFactionsPowerBoostFactionMultiply = new CmdFactionsPowerboostFactionMultiply();
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostFactionAbstract.java

@@ -0,0 +1,14 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+
+public abstract class CmdFactionsPowerboostFactionAbstract extends CmdFactionsPowerboostAbstract {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPowerboostFactionAbstract() {
+        super(TypeFaction.get(), "faction");
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostFactionAdd.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostFactionAdd extends CmdFactionsPowerboostFactionAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        return current + d;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostFactionMultiply.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostFactionMultiply extends CmdFactionsPowerboostFactionAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        return current * d;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostFactionSet.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostFactionSet extends CmdFactionsPowerboostFactionAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        return d;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostFactionShow.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostFactionShow extends CmdFactionsPowerboostFactionAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        throw new UnsupportedOperationException();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostFactionTake.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostFactionTake extends CmdFactionsPowerboostFactionAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        return current - d;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostPlayer.java

@@ -0,0 +1,14 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostPlayer extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsPowerboostPlayerShow cmdFactionsPowerBoostPlayerShow = new CmdFactionsPowerboostPlayerShow();
+    public CmdFactionsPowerboostPlayerSet cmdFactionsPowerBoostPlayerSet = new CmdFactionsPowerboostPlayerSet();
+    public CmdFactionsPowerboostPlayerAdd cmdFactionsPowerBoostPlayerAdd = new CmdFactionsPowerboostPlayerAdd();
+    public CmdFactionsPowerboostPlayerTake cmdFactionsPowerBoostPlayerTake = new CmdFactionsPowerboostPlayerTake();
+    public CmdFactionsPowerboostPlayerMultiply cmdFactionsPowerBoostPlayerMultiply = new CmdFactionsPowerboostPlayerMultiply();
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostPlayerAbstract.java

@@ -0,0 +1,14 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+
+public abstract class CmdFactionsPowerboostPlayerAbstract extends CmdFactionsPowerboostAbstract {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsPowerboostPlayerAbstract() {
+        super(TypeMPlayer.get(), "player");
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostPlayerAdd.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostPlayerAdd extends CmdFactionsPowerboostPlayerAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        return current + d;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostPlayerMultiply.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostPlayerMultiply extends CmdFactionsPowerboostPlayerAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        return current * d;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostPlayerSet.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostPlayerSet extends CmdFactionsPowerboostPlayerAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        return d;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostPlayerShow.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostPlayerShow extends CmdFactionsPowerboostPlayerAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        throw new UnsupportedOperationException();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsPowerboostPlayerTake.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsPowerboostPlayerTake extends CmdFactionsPowerboostPlayerAbstract {
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public double calcNewPowerboost(double current, double d) {
+        return current - d;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRank.java

@@ -0,0 +1,13 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsRank extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsRankSet cmdFactionsRankSet = new CmdFactionsRankSet();
+    public CmdFactionsRankShow cmdFactionsRankShow = new CmdFactionsRankShow();
+    public CmdFactionsRankList cmdFactionsRankList = new CmdFactionsRankList();
+    public CmdFactionsRankEdit cmdFactionsRankEdit = new CmdFactionsRankEdit();
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankEdit.java

@@ -0,0 +1,32 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.massivecore.MassiveException;
+
+public class CmdFactionsRankEdit extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsRankEditCreate cmdFactionsRankEditCreate = new CmdFactionsRankEditCreate();
+    public CmdFactionsRankEditDelete cmdFactionsRankEditDelete = new CmdFactionsRankEditDelete();
+    public CmdFactionsRankEditName cmdFactionsRankEditName = new CmdFactionsRankEditName();
+    public CmdFactionsRankEditPrefix cmdFactionsRankEditPrefix = new CmdFactionsRankEditPrefix();
+    public CmdFactionsRankEditPriority cmdFactionsRankEditPriority = new CmdFactionsRankEditPriority();
+
+    static void ensureAllowed(MPlayer msender, Faction faction, String action) throws MassiveException {
+        if (msender.isOverriding()) {
+            return;
+        }
+
+        if (faction != msender.getFaction()) {
+            throw new MassiveException().addMsg("<b>You can't manage ranks outside your own faction.");
+        }
+
+        if (!msender.getRank().isLeader()) {
+            throw new MassiveException().addMsg("<b>Only the leader can %s ranks.", action);
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankEditCreate.java

@@ -0,0 +1,62 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeInteger;
+import com.massivecraft.massivecore.command.type.primitive.TypeString;
+import com.massivecraft.massivecore.command.type.primitive.TypeStringParsed;
+
+import java.util.Collection;
+
+public class CmdFactionsRankEditCreate extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankEditCreate() {
+        // Parameters
+        this.addParameter(TypeString.get(), "name");
+        this.addParameter(TypeInteger.get(), "priority");
+        this.addParameter("", TypeStringParsed.get(), "prefix", "none");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        String name = this.readArg();
+        Integer priority = this.readArg();
+        String prefix = this.readArg();
+        Faction faction = this.readArg(msenderFaction);
+
+        CmdFactionsRankEdit.ensureAllowed(msender, faction, "create");
+
+        Collection<Rank> ranks = faction.getRanks().getAll();
+
+        if (ranks.stream().map(Rank::getName).anyMatch(s -> s.equalsIgnoreCase(name))) {
+            throw new MassiveException().addMsg("<b>There is already a rank called <h>%s<b>.", name);
+        }
+        if (ranks.stream().map(Rank::getPriority).anyMatch(i -> i.equals(priority))) {
+            throw new MassiveException().addMsg("<b>There is already a rank with priority <h>%s<b>.", priority);
+        }
+        if (priority > faction.getLeaderRank().getPriority()) {
+            throw new MassiveException().addMsg("<b>You can't create a rank of higher priority than the leader rank.");
+        }
+
+        Rank rank = new Rank(name, priority, prefix);
+
+        faction.getRanks().attach(rank);
+
+        // Inform
+        msg("<i>You created the rank <reset>%s<i>.", rank.getVisual());
+        msg("<i>You might want to change its permissions:");
+        CmdFactions.get().cmdFactionsPerm.getTemplate(false, true, sender).messageOne(msender);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankEditDelete.java

@@ -0,0 +1,63 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeRank;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeString;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CmdFactionsRankEditDelete extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankEditDelete() {
+        // Parameters
+        this.addParameter(TypeString.get(), "rank");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        Faction faction = this.readArgAt(1, msenderFaction);
+
+        // Rank if any passed.
+        TypeRank typeRank = new TypeRank(faction);
+        Rank rank = typeRank.read(this.argAt(0), sender);
+
+        CmdFactionsRankEdit.ensureAllowed(msender, faction, "delete");
+
+        Collection<Rank> ranks = faction.getRanks().getAll();
+        if (ranks.size() <= 2) {
+            throw new MassiveException().addMsg("<b>A faction must have at least two ranks.");
+        }
+
+        List<MPlayer> mplayers = faction.getMPlayersWhereRank(rank);
+        if (!mplayers.isEmpty()) {
+            int count = mplayers.size();
+            List<String> names = mplayers.stream().map(m -> m.getDisplayName(sender)).collect(Collectors.toList());
+            String namesDesc = Txt.implodeCommaAnd(names, Txt.parse("<i>"));
+            String rankRanks = count == 1 ? "rank" : "ranks";
+            throw new MassiveException().addMsg("<b>This rank is held by <h>%s <b>change their %s first.", namesDesc, rankRanks);
+        }
+
+        String visual = rank.getVisual();
+        faction.getRanks().detachEntity(rank);
+
+        // Inform
+        msg("<i>You deleted the rank <reset>%s<i>.", visual);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankEditName.java

@@ -0,0 +1,55 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeRank;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeString;
+
+import java.util.Collection;
+
+public class CmdFactionsRankEditName extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankEditName() {
+        // Parameters
+        this.addParameter(TypeRank.get(), "rank");
+        this.addParameter(TypeString.get(), "new name");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        String name = this.readArgAt(1);
+        Faction faction = this.readArgAt(2, msenderFaction);
+
+        // Rank if any passed.
+        TypeRank typeRank = new TypeRank(faction);
+        Rank rank = typeRank.read(this.argAt(0), sender);
+
+        // Args
+
+        CmdFactionsRankEdit.ensureAllowed(msender, faction, "rename");
+
+        Collection<Rank> ranks = faction.getRanks().getAll();
+
+        if (ranks.stream().map(Rank::getName).anyMatch(s -> s.equalsIgnoreCase(name))) {
+            throw new MassiveException().addMsg("<b>There is already a rank called <h>%s<b>.", name);
+        }
+
+        String priorVisual = rank.getVisual();
+        rank.setName(name);
+
+        // Visual
+        msg("<i>You renamed the rank from <reset>%s <i>to <reset>%s<i>.", priorVisual, rank.getVisual());
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankEditPrefix.java

@@ -0,0 +1,47 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeRank;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeString;
+
+public class CmdFactionsRankEditPrefix extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankEditPrefix() {
+        // Parameters
+        this.addParameter(TypeRank.get(), "rank");
+        this.addParameter(TypeString.get(), "new prefix");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        String prefix = this.readArgAt(1);
+        Faction faction = this.readArgAt(2, msenderFaction);
+
+        // Rank if any passed.
+        TypeRank typeRank = new TypeRank(faction);
+        Rank rank = typeRank.read(this.argAt(0), sender);
+
+        // Args
+
+        CmdFactionsRankEdit.ensureAllowed(msender, faction, "edit");
+
+        String priorPrefix = rank.getPrefix();
+        rank.setPrefix(prefix);
+
+        // Visual
+        msg("<i>You changed the prefix of <reset>%s <i>from <h>%s <i>to <h>%s<i>.", rank.getVisual(), priorPrefix, prefix);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankEditPriority.java

@@ -0,0 +1,64 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeRank;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.type.primitive.TypeInteger;
+
+import java.util.Collection;
+
+public class CmdFactionsRankEditPriority extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankEditPriority() {
+        // Parameters
+        this.addParameter(TypeRank.get(), "rank");
+        this.addParameter(TypeInteger.get(), "new priority");
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        Integer priority = this.readArgAt(1);
+        Faction faction = this.readArgAt(2, msenderFaction);
+
+        // Rank if any passed.
+        TypeRank typeRank = new TypeRank(faction);
+        Rank rank = typeRank.read(this.argAt(0), sender);
+
+        CmdFactionsRankEdit.ensureAllowed(msender, faction, "edit");
+
+        Collection<Rank> ranks = faction.getRanks().getAll();
+
+        if (ranks.stream().map(Rank::getPriority).anyMatch(s -> s.equals(priority))) {
+            throw new MassiveException().addMsg("<b>There is already a rank with the priority <h>%s<b>.", priority);
+        }
+
+        if (rank.isLeader()) {
+            Rank below = rank.getRankBelow();
+            if (below.getPriority() > priority) {
+                throw new MassiveException().addMsg("<b>The leader rank must have the highest priority.");
+            }
+        } else {
+            if (priority >= faction.getLeaderRank().getPriority()) {
+                throw new MassiveException().addMsg("<b>No rank can have higher priority than the leader rank.");
+            }
+        }
+
+        int priorPriority = rank.getPriority();
+        rank.setPriority(priority);
+
+        // Visual
+        msg("<i>You changed the priority of <reset>%s <i>from <h>%s <i>to <h>%s<i>.", rank.getVisual(), priorPriority, priority);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankList.java

@@ -0,0 +1,41 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.Parameter;
+import com.massivecraft.massivecore.pager.Pager;
+import com.massivecraft.massivecore.pager.Stringifier;
+
+import java.util.Comparator;
+import java.util.List;
+
+public class CmdFactionsRankList extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankList() {
+        // Parameters
+        this.addParameter(Parameter.getPage());
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        final int page = this.readArg();
+        Faction faction = this.readArg(msenderFaction);
+
+        List<Rank> ranks = faction.getRanks().getAll(Comparator.comparingInt(Rank::getPriority).reversed());
+
+        String title = "Rank list for " + faction.describeTo(msender);
+        Pager<Rank> pager = new Pager<>(this, title, page, ranks, (Stringifier<Rank>) (r, i) -> r.getVisual());
+        pager.message();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankOld.java

@@ -0,0 +1,45 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.massivecore.command.Visibility;
+import com.massivecraft.massivecore.util.MUtil;
+
+public class CmdFactionsRankOld extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public final String rankName;
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankOld(String rank) {
+        // Fields
+        this.rankName = rank.toLowerCase();
+        this.setSetupEnabled(false);
+
+        // Aliases
+        this.addAliases(rankName);
+
+        // Parameters
+        this.addParameter(TypeMPlayer.get(), "player");
+
+        // Visibility
+        this.setVisibility(Visibility.INVISIBLE);
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() {
+        CmdFactions.get().cmdFactionsRank.cmdFactionsRankSet.execute(sender, MUtil.list(
+                this.argAt(0),
+                this.rankName
+        ));
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankSet.java

@@ -0,0 +1,313 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.cmd.type.TypeRank;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.factions.entity.MFlag;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.entity.MPlayerColl;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.factions.event.EventFactionsMembershipChange;
+import com.massivecraft.factions.event.EventFactionsMembershipChange.MembershipChangeReason;
+import com.massivecraft.factions.event.EventFactionsRankChange;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveSet;
+import com.massivecraft.massivecore.util.Txt;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class CmdFactionsRankSet extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+    // These fields are set upon perform() and unset afterwards.
+
+    // Target
+    private Faction targetFaction = null;
+    private MPlayer target = null;
+
+    // End faction (the faction they are changed to)
+    private Faction endFaction = null;
+    private boolean factionChange = false;
+
+    // Ranks
+    private Rank senderRank = null;
+    private Rank targetRank = null;
+    private Rank rank = null;
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankSet() {
+        // Parameters
+        this.addParameter(TypeMPlayer.get(), "player");
+        this.addParameter(TypeRank.get(), "rank");
+        this.addParameter(TypeFaction.get(), "faction", "their");
+
+        // Too complicated for that
+        this.setSwapping(false);
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // This sets target and much other.
+        this.registerFields();
+
+        // Is the player allowed or not. Method can be found later down.
+        this.ensureAllowed();
+
+        if (factionChange) {
+            this.changeFaction();
+        }
+
+        // Does the change make sense.
+        this.ensureMakesSense();
+
+        // Event
+        EventFactionsRankChange event = new EventFactionsRankChange(sender, target, rank);
+        event.run();
+		if (event.isCancelled()) {
+			return;
+		}
+        rank = event.getNewRank();
+
+        // Change the rank.
+        this.changeRank();
+    }
+
+    // This is always run after performing a MassiveCommand.
+    @Override
+    public void senderFields(boolean set) {
+        super.senderFields(set);
+
+        if (!set) {
+            this.unregisterFields();
+        }
+    }
+
+    // -------------------------------------------- //
+    // PRIVATE: REGISTER & UNREGISTER
+    // -------------------------------------------- //
+
+    private void registerFields() throws MassiveException {
+        // Getting the target and faction.
+        target = this.readArg();
+        targetFaction = target.getFaction();
+
+
+        // Ranks
+        senderRank = msender.getRank();
+        targetRank = target.getRank();
+
+        endFaction = this.readArgAt(2, targetFaction);
+        factionChange = (endFaction != targetFaction);
+
+        // Rank if any passed.
+        TypeRank typeRank = new TypeRank(endFaction, target.getRank());
+        rank = typeRank.read(this.argAt(1), sender);
+
+    }
+
+    private void unregisterFields() {
+        targetFaction = null;
+        target = null;
+
+        endFaction = null;
+        factionChange = false;
+
+        senderRank = null;
+        targetRank = null;
+        rank = null;
+    }
+
+    // -------------------------------------------- //
+    // PRIVATE: ENSURE
+    // -------------------------------------------- //
+
+    private void ensureAllowed() throws MassiveException {
+        // People with permission don't follow the normal rules.
+		if (msender.isOverriding()) {
+			return;
+		}
+
+        // If somone gets the leadership of wilderness (Which has happened before).
+        // We can at least try to limit their powers.
+        if (endFaction.isNone()) {
+            throw new MassiveException().addMsg("%s <b>doesn't use ranks sorry :(", endFaction.getName());
+        }
+
+        if (target == msender) {
+            // Don't change your own rank.
+            throw new MassiveException().addMsg("<b>The target player mustn't be yourself.");
+        }
+
+        if (factionChange) {
+            // Don't change peoples faction
+            throw new MassiveException().addMsg("<b>You can't change %s's <b>faction.", target.describeTo(msender));
+        }
+
+        if (!MPerm.getPermRank().has(msender, targetFaction, false)) {
+            throw new MassiveException().addMessage(MPerm.getPermRank().createDeniedMessage(msender, targetFaction));
+        }
+
+        // The following two if statements could be merged. 
+        // But isn't for the sake of nicer error messages.
+        if (senderRank == targetRank) {
+            // You can't change someones rank if it is equal to yours.
+            throw new MassiveException().addMsg("<h>%s <b>can't manage eachother.", senderRank.getName() + "s");
+        }
+
+        if (senderRank.isLessThan(targetRank)) {
+            // You can't change someones rank if it is higher than yours.
+            throw new MassiveException().addMsg("<b>You can't manage people of higher rank.");
+        }
+
+        // The following two if statements could be merged. 
+        // But isn't for the sake of nicer error messages.
+        if (senderRank == rank && !senderRank.isLeader()) {
+            // You can't set ranks equal to your own. Unless you are the leader.
+            throw new MassiveException().addMsg("<b>You can't set ranks equal to your own.");
+        }
+
+        if (senderRank.isLessThan(rank)) {
+            // You can't set ranks higher than your own.
+            throw new MassiveException().addMsg("<b>You can't set ranks higher than your own.");
+        }
+    }
+
+    private void ensureMakesSense() throws MassiveException {
+        // Don't change their rank to something they already are.
+        if (target.getRank() == rank) {
+            throw new MassiveException().addMsg("%s <b>is already %s %s.", target.describeTo(msender), Txt.aan(rank.getName()), rank.getName());
+        }
+    }
+
+    // -------------------------------------------- //
+    // PRIVATE: CHANGE FACTION
+    // -------------------------------------------- //
+
+    private void changeFaction() throws MassiveException {
+        // Don't change a leader to a new faction.
+        if (targetRank.isLeader()) {
+            throw new MassiveException().addMsg("<b>You cannot remove the present leader. Demote them first.");
+        }
+
+        // Event
+        EventFactionsMembershipChange membershipChangeEvent = new EventFactionsMembershipChange(sender, msender, endFaction, MembershipChangeReason.RANK);
+        membershipChangeEvent.run();
+		if (membershipChangeEvent.isCancelled()) {
+			throw new MassiveException();
+		}
+
+        // Apply
+        target.resetFactionData();
+        target.setFaction(endFaction);
+
+        // No longer invited.
+        endFaction.uninvite(target);
+
+        // Create recipients
+        Set<MPlayer> recipients = new HashSet<>();
+        recipients.addAll(targetFaction.getMPlayersWhereOnline(true));
+        recipients.addAll(endFaction.getMPlayersWhereOnline(true));
+        recipients.add(msender);
+
+        // Send message
+        for (MPlayer recipient : recipients) {
+            recipient.msg("%s <i>was moved from <i>%s to <i>%s<i>.", target.describeTo(recipient), targetFaction.describeTo(recipient), endFaction.describeTo(recipient));
+        }
+
+        // Derplog
+        if (MConf.get().logFactionJoin) {
+            Factions.get().log(Txt.parse("%s moved %s from %s to %s.", msender.getName(), target.getName(), targetFaction.getName(), endFaction.getName()));
+        }
+
+        // Now we don't need the old values.
+        targetFaction = target.getFaction();
+        targetRank = target.getRank();
+        senderRank = msender.getRank(); // In case they changed their own rank
+
+    }
+
+    // -------------------------------------------- //
+    // PRIVATE: CHANGE RANK
+    // -------------------------------------------- //
+
+    private void changeRank() throws MassiveException {
+        // In case of leadership change, we do special things not done in other rank changes.
+        if (rank.isLeader()) {
+            this.changeRankLeader();
+        } else {
+            this.changeRankOther();
+        }
+    }
+
+    private void changeRankLeader() {
+        // If there is a current leader. Demote & inform them.
+        MPlayer targetFactionCurrentLeader = targetFaction.getLeader();
+        if (targetFactionCurrentLeader != null) {
+            // Inform & demote the old leader.
+            targetFactionCurrentLeader.setRank(rank.getRankBelow());
+            if (targetFactionCurrentLeader != msender) {
+                // They kinda know if they fired the command themself.
+                targetFactionCurrentLeader.msg("<i>You have been demoted from the position of faction leader by %s<i>.", msender.describeTo(targetFactionCurrentLeader, true));
+            }
+        }
+
+        // Promote the new leader.
+        target.setRank(rank);
+
+        // Inform everyone, this includes sender and target.
+        for (MPlayer recipient : MPlayerColl.get().getAllOnline()) {
+            String changerName = senderIsConsole ? "A server admin" : msender.describeTo(recipient);
+            recipient.msg("%s<i> gave %s<i> the leadership of %s<i>.", changerName, target.describeTo(recipient), targetFaction.describeTo(recipient));
+        }
+    }
+
+    private void changeRankOther() throws MassiveException {
+        // If the target is currently the leader and faction isn't permanent a new leader should be promoted.
+        // Sometimes a bug occurs and multiple leaders exist. Then we should be able to demote without promoting new leader
+        if (targetRank.isLeader() && (!MConf.get().permanentFactionsDisableLeaderPromotion || !targetFaction.getFlag(MFlag.ID_PERMANENT)) && targetFaction.getMPlayersWhereRank(targetFaction.getLeaderRank()).size() == 1)
+        // This if statement is very long. Should I nest it for readability?
+        {
+            targetFaction.promoteNewLeader(); // This might disband the faction.
+
+            // So if the faction disbanded...
+            if (targetFaction.detached()) {
+                // ... we inform the sender.
+                target.resetFactionData();
+                throw new MassiveException().addMsg("<i>The target was a leader and got demoted. The faction disbanded and no rank was set.");
+            }
+        }
+
+        // Create recipients
+        Set<MPlayer> recipients = new MassiveSet<>(targetFaction.getMPlayers());
+        recipients.add(msender);
+
+        // Were they demoted or promoted?
+        String change = (rank.isLessThan(targetRank) ? "demoted" : "promoted");
+
+        // The rank will be set before the msg, so they have the appropriate prefix.
+        target.setRank(rank);
+        String oldRankName = targetRank.getName().toLowerCase();
+        String rankName = rank.getName().toLowerCase();
+
+        // Send message
+        for (MPlayer recipient : recipients) {
+            String targetName = target.describeTo(recipient, true);
+            String wasWere = (recipient == target) ? "were" : "was";
+            recipient.msg("%s<i> %s %s from %s to <h>%s <i>in %s<i>.", targetName, wasWere, change, oldRankName, rankName, targetFaction.describeTo(msender));
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRankShow.java

@@ -0,0 +1,49 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeMPlayer;
+import com.massivecraft.factions.entity.MPlayer;
+import com.massivecraft.factions.entity.Rank;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.util.Txt;
+
+public class CmdFactionsRankShow extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRankShow() {
+        // Parameters
+        this.addParameter(TypeMPlayer.get(), "player");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        MPlayer target = this.readArg();
+        Rank rank = target.getRank();
+
+        // Damn you grammar, causing all these checks.
+        String targetName = target.describeTo(msender, true);
+        String isAre = (target == msender) ? "are" : "is"; // "you are" or "he is"
+
+        String theAan = (rank.isLeader()) ? "the" : Txt.aan(rank.getName()); // "a member", "an officer" or "the leader"
+        String rankName = rank.getName().toLowerCase();
+        String ofIn = (rank.isLeader()) ? "of" : "in"; // "member in" or "leader of"
+        String factionName = target.getFaction().describeTo(msender, true);
+        if (target.getFaction() == msenderFaction) {
+            // Having the "Y" in "Your faction" being uppercase in the middle of a sentence makes no sense.
+            factionName = factionName.toLowerCase();
+        }
+        if (target.getFaction().isNone()) {
+            // Wilderness aka none doesn't use ranks
+            msg("%s <i>%s factionless", targetName, isAre);
+        } else {
+            // Derp	is a member in Faction
+            msg("%s <i>%s %s <h>%s <i>%s %s<i>.", targetName, isAre, theAan, rankName, ofIn, factionName);
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRelation.java

@@ -0,0 +1,12 @@
+package com.massivecraft.factions.cmd;
+
+public class CmdFactionsRelation extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public CmdFactionsRelationSet cmdFactionsRelationSet = new CmdFactionsRelationSet();
+    public CmdFactionsRelationList cmdFactionsRelationList = new CmdFactionsRelationList();
+    public CmdFactionsRelationWishes cmdFactionsRelationWishes = new CmdFactionsRelationWishes();
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRelationList.java

@@ -0,0 +1,79 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.Rel;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeRelation;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveList;
+import com.massivecraft.massivecore.collections.MassiveSet;
+import com.massivecraft.massivecore.command.Parameter;
+import com.massivecraft.massivecore.command.type.container.TypeSet;
+import com.massivecraft.massivecore.pager.Pager;
+import com.massivecraft.massivecore.pager.Stringifier;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.Bukkit;
+
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class CmdFactionsRelationList extends FactionsCommand {
+    // -------------------------------------------- //
+    // COSTANTS
+    // -------------------------------------------- //
+
+    public static final Set<Rel> RELEVANT_RELATIONS = new MassiveSet<>(Rel.ENEMY, Rel.TRUCE, Rel.ALLY);
+    public static final String SEPERATOR = Txt.parse("<silver>: ");
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRelationList() {
+        // Parameter
+        this.addParameter(Parameter.getPage());
+        this.addParameter(TypeFaction.get(), "faction", "you");
+        this.addParameter(TypeSet.get(TypeRelation.get()), "relations", "all");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        int page = this.readArg();
+        final Faction faction = this.readArg(msenderFaction);
+        final Set<Rel> relations = this.readArg(RELEVANT_RELATIONS);
+
+        // Pager Create
+        final Pager<String> pager = new Pager<>(this, "", page, (Stringifier<String>) (item, index) -> item);
+
+        Bukkit.getScheduler().runTaskAsynchronously(Factions.get(), () -> {
+            // Prepare Items
+            List<String> relNames = new MassiveList<>();
+            for (Entry<Rel, List<String>> entry : FactionColl.get().getRelationNames(faction, relations).entrySet()) {
+                Rel relation = entry.getKey();
+                String coloredName = relation.getColor().toString() + relation.getName();
+
+                for (String name : entry.getValue()) {
+                    relNames.add(coloredName + SEPERATOR + name);
+                }
+            }
+
+            // Pager Title
+            pager.setTitle(Txt.parse("<white>%s's <green>Relations <a>(%d)", faction.getName(), relNames.size()));
+
+            // Pager Items
+            pager.setItems(relNames);
+
+            // Pager Message
+            pager.message();
+        });
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRelationOld.java

@@ -0,0 +1,51 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.Visibility;
+import com.massivecraft.massivecore.util.MUtil;
+
+public class CmdFactionsRelationOld extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    public final String relName;
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRelationOld(String rel) {
+        // Fields
+        this.relName = rel.toLowerCase();
+        this.setSetupEnabled(false);
+
+        // Aliases
+        this.addAliases(relName);
+
+        // Parameters
+        this.addParameter(TypeFaction.get(), "faction", true);
+
+        // Visibility
+        this.setVisibility(Visibility.INVISIBLE);
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Arguments
+        Faction faction = this.readArg();
+
+        // Apply
+        CmdFactions.get().cmdFactionsRelation.cmdFactionsRelationSet.execute(sender, MUtil.list(
+                faction.getId(),
+                this.relName
+        ));
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRelationSet.java

@@ -0,0 +1,98 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Rel;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.cmd.type.TypeRelation;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MFlag;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.factions.event.EventFactionsRelationChange;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.MassiveCommand;
+import com.massivecraft.massivecore.mson.Mson;
+import org.bukkit.ChatColor;
+
+public class CmdFactionsRelationSet extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRelationSet() {
+        // Parameter
+        this.addParameter(TypeFaction.get(), "faction");
+        this.addParameter(TypeRelation.get(), "relation");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        Faction otherFaction = this.readArg();
+        Rel newRelation = this.readArg();
+
+        // MPerm
+		if (!MPerm.getPermRel().has(msender, msenderFaction, true)) {
+			return;
+		}
+
+        // Verify
+        if (otherFaction == msenderFaction) {
+            throw new MassiveException().setMsg("<b>Nope! You can't declare a relation to yourself :)");
+        }
+        if (msenderFaction.getRelationWish(otherFaction) == newRelation) {
+            throw new MassiveException().setMsg("<b>You already have that relation wish set with %s.", otherFaction.getName());
+        }
+
+        // Event
+        EventFactionsRelationChange event = new EventFactionsRelationChange(sender, msenderFaction, otherFaction, newRelation);
+        event.run();
+		if (event.isCancelled()) {
+			return;
+		}
+        newRelation = event.getNewRelation();
+
+        // try to set the new relation
+        msenderFaction.setRelationWish(otherFaction, newRelation);
+        Rel currentRelation = msenderFaction.getRelationTo(otherFaction, true);
+
+        // if the relation change was successful
+        if (newRelation == currentRelation) {
+            otherFaction.msg("%s<i> is now %s.", msenderFaction.describeTo(otherFaction, true), newRelation.getDescFactionOne());
+            msenderFaction.msg("%s<i> is now %s.", otherFaction.describeTo(msenderFaction, true), newRelation.getDescFactionOne());
+        }
+        // inform the other faction of your request
+        else {
+            MassiveCommand command = CmdFactions.get().cmdFactionsRelation.cmdFactionsRelationSet;
+            String colorOne = newRelation.getColor() + newRelation.getDescFactionOne();
+
+            // Mson creation
+            Mson factionsRelationshipChange = mson(
+                    Mson.parse("%s<i> wishes to be %s.", msenderFaction.describeTo(otherFaction, true), colorOne),
+                    Mson.SPACE,
+                    mson("[Accept]").color(ChatColor.AQUA).command(command, msenderFaction.getName(), newRelation.name())
+            );
+
+            otherFaction.sendMessage(factionsRelationshipChange);
+            msenderFaction.msg("%s<i> were informed that you wish to be %s<i>.", otherFaction.describeTo(msenderFaction, true), colorOne);
+        }
+
+        // TODO: The ally case should work!!
+        // this might have to be bumped up to make that happen, & allow ALLY,NEUTRAL only
+        if (newRelation != Rel.TRUCE && otherFaction.getFlag(MFlag.getFlagPeaceful())) {
+            otherFaction.msg("<i>This will have no effect while your faction is peaceful.");
+            msenderFaction.msg("<i>This will have no effect while their faction is peaceful.");
+        }
+
+        if (newRelation != Rel.TRUCE && msenderFaction.getFlag(MFlag.getFlagPeaceful())) {
+            otherFaction.msg("<i>This will have no effect while their faction is peaceful.");
+            msenderFaction.msg("<i>This will have no effect while your faction is peaceful.");
+        }
+
+        // Mark as changed
+        msenderFaction.changed();
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsRelationWishes.java

@@ -0,0 +1,75 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Factions;
+import com.massivecraft.factions.Rel;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.collections.MassiveMap;
+import com.massivecraft.massivecore.command.Parameter;
+import com.massivecraft.massivecore.pager.Pager;
+import com.massivecraft.massivecore.pager.Stringifier;
+import com.massivecraft.massivecore.util.MUtil;
+import com.massivecraft.massivecore.util.Txt;
+import org.bukkit.Bukkit;
+
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class CmdFactionsRelationWishes extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsRelationWishes() {
+        // Parameter
+        this.addParameter(Parameter.getPage());
+        this.addParameter(TypeFaction.get(), "faction", "you");
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        int page = this.readArg();
+        final Faction faction = this.readArg(msenderFaction);
+
+        // Pager Create
+        final Pager<Entry<Faction, Rel>> pager = new Pager<>(this, "", page, (Stringifier<Entry<Faction, Rel>>) (item, index) -> {
+            Rel rel = item.getValue();
+            Faction fac = item.getKey();
+            return rel.getColor().toString() + rel.getName() + CmdFactionsRelationList.SEPERATOR + fac.describeTo(faction, true);
+        });
+
+        Bukkit.getScheduler().runTaskAsynchronously(Factions.get(), () -> {
+            Map<Faction, Rel> realWishes = new MassiveMap<>();
+
+            for (Entry<String, Rel> entry : faction.getRelationWishes().entrySet()) {
+                Rel rel = entry.getValue();
+                Faction fac = FactionColl.get().getFixed(entry.getKey());
+                if (fac == null) {
+                    continue;
+                }
+
+                // A wish is not a wish anymore if both factions have atleast equal "wishes"
+                if (fac.getRelationTo(faction).isAtLeast(rel)) {
+                    continue;
+                }
+                realWishes.put(fac, rel);
+            }
+
+            // Pager Title
+            pager.setTitle(Txt.parse("<white>%s's <green>Relation wishes <a>(%d)", faction.getName(), realWishes.size()));
+
+            // Pager Items
+            pager.setItems(MUtil.entriesSortedByValues(realWishes));
+
+            // Pager Message
+            pager.message();
+        });
+    }
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsSeeChunk.java

@@ -0,0 +1,49 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.command.type.primitive.TypeBooleanOn;
+import com.massivecraft.massivecore.util.Txt;
+
+public class CmdFactionsSeeChunk extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsSeeChunk() {
+        // Aliases
+        this.addAliases("sc");
+
+        // Parameters
+        this.addParameter(TypeBooleanOn.get(), "active", "toggle");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        boolean old = msender.isSeeingChunk();
+        boolean targetDefault = !old;
+        boolean target = this.readArg(targetDefault);
+        String targetDesc = Txt.parse(target ? "<g>ON" : "<b>OFF");
+
+        // NoChange
+        if (target == old) {
+            msg("<i>See Chunk is already %s<i>.", targetDesc);
+            return;
+        }
+
+        // Apply
+        msender.setSeeingChunk(target);
+
+        // Inform
+        msg("<i>See Chunk is now %s<i>.", targetDesc);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsSeeChunkOld.java

@@ -0,0 +1,75 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.util.AsciiMap;
+import com.massivecraft.factions.util.VisualizeUtil;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.ps.PSFormatHumanSpace;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+public class CmdFactionsSeeChunkOld extends FactionsCommand {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsSeeChunkOld() {
+        // Aliases
+        this.addAliases("sco");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() {
+        // Args
+        World world = me.getWorld();
+        PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+        int chunkX = chunk.getChunkX();
+        int chunkZ = chunk.getChunkZ();
+
+        // Apply
+        int blockX;
+        int blockZ;
+
+        blockX = chunkX * 16;
+        blockZ = chunkZ * 16;
+        showPillar(me, world, blockX, blockZ);
+
+        blockX = chunkX * 16 + 15;
+        blockZ = chunkZ * 16;
+        showPillar(me, world, blockX, blockZ);
+
+        blockX = chunkX * 16;
+        blockZ = chunkZ * 16 + 15;
+        showPillar(me, world, blockX, blockZ);
+
+        blockX = chunkX * 16 + 15;
+        blockZ = chunkZ * 16 + 15;
+        showPillar(me, world, blockX, blockZ);
+
+        // Inform
+        boolean showCoords = AsciiMap.showChunkCoords(chunk);
+        String chunkDesc = showCoords ? chunk.toString(PSFormatHumanSpace.get()) : "chunk";
+        msg("<i>Visualized %s", chunkDesc);
+    }
+
+    public static void showPillar(Player player, World world, int blockX, int blockZ) {
+        for (int blockY = 0; blockY < world.getMaxHeight(); blockY++) {
+            Location loc = new Location(world, blockX, blockY, blockZ);
+            if (loc.getBlock().getType() != Material.AIR) {
+                continue;
+            }
+            Material type = blockY % 5 == 0 ? Material.GLOWSTONE : Material.GLASS;
+            VisualizeUtil.addLocation(player, loc, type);
+        }
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsSetAll.java

@@ -0,0 +1,86 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.factions.entity.Board;
+import com.massivecraft.factions.entity.BoardColl;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+import com.massivecraft.massivecore.mixin.MixinWorld;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.MUtil;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+
+public class CmdFactionsSetAll extends CmdFactionsSetXAll {
+    // -------------------------------------------- //
+    // CONSTANTS
+    // -------------------------------------------- //
+
+    public static final List<String> LIST_ALL = Collections.unmodifiableList(MUtil.list("a", "al", "all"));
+    public static final List<String> LIST_MAP = Collections.singletonList("map");
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsSetAll(boolean claim) {
+        // Super
+        super(claim);
+
+        // Aliases
+        this.addAliases("all");
+
+        // Requirements
+        Perm perm = claim ? Perm.CLAIM_ALL : Perm.UNCLAIM_ALL;
+        this.addRequirements(RequirementHasPerm.get(perm));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public Set<PS> getChunks() throws MassiveException {
+        // World
+        String word = (this.isClaim() ? "claim" : "unclaim");
+
+        // Create Ret
+        Set<PS> chunks = null;
+
+        // Args
+        Faction oldFaction = this.getOldFaction();
+
+        if (LIST_ALL.contains(this.argAt(0).toLowerCase())) {
+            chunks = BoardColl.get().getChunks(oldFaction);
+            this.setFormatOne("<h>%s<i> %s <h>%d <i>chunk using " + word + " all.");
+            this.setFormatMany("<h>%s<i> %s <h>%d <i>chunks using " + word + " all.");
+        } else {
+            String worldId = null;
+            if (LIST_MAP.contains(this.argAt(0).toLowerCase())) {
+                if (me != null) {
+                    worldId = me.getWorld().getName();
+                } else {
+                    throw new MassiveException().addMsg("<b>You must specify which map from console.");
+                }
+            } else {
+                worldId = this.argAt(0);
+                if (worldId == null) {
+                    return null;
+                }
+            }
+            Board board = BoardColl.get().get(worldId);
+            chunks = board.getChunks(oldFaction);
+            String worldDisplayName = MixinWorld.get().getWorldDisplayName(worldId);
+            this.setFormatOne("<h>%s<i> %s <h>%d <i>chunk using " + word + " <h>" + worldDisplayName + "<i>.");
+            this.setFormatMany("<h>%s<i> %s <h>%d <i>chunks using " + word + " <h>" + worldDisplayName + "<i>.");
+        }
+
+        // Return Ret
+        return chunks;
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsSetAuto.java

@@ -0,0 +1,92 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.factions.cmd.type.TypeFaction;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.FactionColl;
+import com.massivecraft.factions.entity.MPerm;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+
+import java.util.Collections;
+import java.util.Set;
+
+
+public class CmdFactionsSetAuto extends FactionsCommand {
+    // -------------------------------------------- //
+    // FIELDS
+    // -------------------------------------------- //
+
+    private boolean claim = true;
+
+    public boolean isClaim() {
+        return this.claim;
+    }
+
+    public void setClaim(boolean claim) {
+        this.claim = claim;
+    }
+
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsSetAuto(boolean claim) {
+        // Fields
+        this.setClaim(claim);
+        this.setSetupEnabled(false);
+
+        // Aliases
+        this.addAliases("auto");
+
+        // Parameters
+        if (claim) {
+            this.addParameter(TypeFaction.get(), "faction", "you");
+        }
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+        Perm perm = claim ? Perm.CLAIM_AUTO : Perm.UNCLAIM_AUTO;
+        this.addRequirements(RequirementHasPerm.get(perm));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public void perform() throws MassiveException {
+        // Args
+        final Faction newFaction;
+        if (claim) {
+            newFaction = this.readArg(msenderFaction);
+        } else {
+            newFaction = FactionColl.get().getNone();
+        }
+
+        // Disable?
+        if (newFaction == null || newFaction == msender.getAutoClaimFaction()) {
+            msender.setAutoClaimFaction(null);
+            throw new MassiveException().addMsg("<i>Disabled auto-setting as you walk around.");
+        }
+
+        // MPerm Preemptive Check
+        if (newFaction.isNormal() && !MPerm.getPermTerritory().has(msender, newFaction, true)) {
+            return;
+        }
+
+        // Apply / Inform
+        msender.setAutoClaimFaction(newFaction);
+        msg("<i>Now auto-setting <h>%s<i> land.", newFaction.describeTo(msender));
+
+        // Chunks
+        final PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+        Set<PS> chunks = Collections.singleton(chunk);
+
+        // Apply / Inform
+        msender.tryClaim(newFaction, chunks);
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsSetCircle.java

@@ -0,0 +1,46 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.ChunkUtil;
+
+import java.util.Set;
+
+
+public class CmdFactionsSetCircle extends CmdFactionsSetXRadius {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsSetCircle(boolean claim) {
+        // Super
+        super(claim);
+
+        // Aliases
+        this.addAliases("circle");
+
+        // Format
+        this.setFormatOne("<h>%s<i> %s <h>%d <i>chunk %s<i> using circle.");
+        this.setFormatMany("<h>%s<i> %s <h>%d <i>chunks near %s<i> using circle.");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+        Perm perm = claim ? Perm.CLAIM_CIRCLE : Perm.UNCLAIM_CIRCLE;
+        this.addRequirements(RequirementHasPerm.get(perm));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public Set<PS> getChunks() throws MassiveException {
+        // Common Startup
+        final PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+        return ChunkUtil.getChunksCircle(chunk, this.getRadius());
+    }
+
+}

src/main/java/com/massivecraft/factions/cmd/CmdFactionsSetFill.java

@@ -0,0 +1,58 @@
+package com.massivecraft.factions.cmd;
+
+import com.massivecraft.factions.Perm;
+import com.massivecraft.factions.entity.BoardColl;
+import com.massivecraft.factions.entity.Faction;
+import com.massivecraft.factions.entity.MConf;
+import com.massivecraft.massivecore.MassiveException;
+import com.massivecraft.massivecore.command.requirement.RequirementHasPerm;
+import com.massivecraft.massivecore.command.requirement.RequirementIsPlayer;
+import com.massivecraft.massivecore.ps.PS;
+import com.massivecraft.massivecore.util.ChunkUtil;
+
+import java.util.Set;
+import java.util.function.Predicate;
+
+
+public class CmdFactionsSetFill extends CmdFactionsSetXSimple {
+    // -------------------------------------------- //
+    // CONSTRUCT
+    // -------------------------------------------- //
+
+    public CmdFactionsSetFill(boolean claim) {
+        // Super
+        super(claim);
+
+        // Aliases
+        this.addAliases("fill");
+
+        // Format
+        this.setFormatOne("<h>%s<i> %s <h>%d <i>chunk %s<i> using fill.");
+        this.setFormatMany("<h>%s<i> %s <h>%d <i>chunks near %s<i> using fill.");
+
+        // Requirements
+        this.addRequirements(RequirementIsPlayer.get());
+        Perm perm = claim ? Perm.CLAIM_FILL : Perm.UNCLAIM_FILL;
+        this.addRequirements(RequirementHasPerm.get(perm));
+    }
+
+    // -------------------------------------------- //
+    // OVERRIDE
+    // -------------------------------------------- //
+
+    @Override
+    public Set<PS> getChunks() throws MassiveException {
+        // Common Startup
+        final PS chunk = PS.valueOf(me.getLocation()).getChunk(true);
+
+        // What faction (aka color) resides there?
+        // NOTE: Wilderness/None is valid. 
+        final Faction color = BoardColl.get().getFactionAt(chunk);
+
+        // Calculate
+        int max = MConf.get().setFillMax;
+        Predicate<PS> matcher = ps -> BoardColl.get().getFactionAt(ps) == color;
+        return ChunkUtil.getChunkArea(chunk, matcher, max);
+    }
+
+}