Player player = ...;
KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(player);

Kingdom kingdom = Kingdom.getKingdom(name/id);
Nation nation = Nation.getNation(name/id);

KingdomPlayer kp = ...;
if (kp.hasKingdom()) { // A better way is to use kp.getKingdom() and check if it's null. Same for nations.
  Kingdom kingdom = kp.getKingdom();
  if (kingdom.hasNation()) {
     Nation nation = kingdom.getNation();
     // ...
  }
}

Player player = ...;
SimpleChunkLocation chunk = SimpleChunkLocation.of(player.getLocation());
Land land = chunk.getLand();
// or simply
Land land = Land.getLand(player.getLocation());
if (land == null) return;

Structure structure = land.getStructure();
SimpleLocation = simpLocation = SimpleLocation.of(player.getLocation());
Turret turret = land.getTurrets().get(simpLocation);
if (land.isClaimed()) {
  Kingdom kingdom = land.getKingdom();
  // ...
}

// Kingdoms
Collection<Kingdom> kingdoms = DataHandler.get().getKingdomManager().getKingdoms();

// Nations
Collection<Nation> nations = DataHandler.get().getNationManager().getNations();

// Lands
Collection<Land> lands = DataHandler.get().getLandManager().getLands();

// Kingdoms
List<Kingdom> kingdoms = DataHandler.get().getKingdomManager().getTopKingdoms(0, 10);

// Nations
List<Nation> kingdoms = DataHandler.get().getNationManager().getTopNations(0, 10);

Block block = ...;
Optional<ProtectionSign> protectionSign = ProtectionSign.getProtection(block);
if (!protectionSign.isPresent()) return;
ProtectionSign protection = protectionSign.get();
List<UUID> group = protection.getGroup();

public final class CustomClaimProcessor extends ClaimProcessor {
    public static void register() { // Call this on your onEnable()
        ClaimProcessor.setBuilder(CustomClaimProcessor::new);
    }

    protected CustomClaimProcessor(SimpleChunkLocation chunk, KingdomPlayer kp, Kingdom kingdom) {
        super(chunk, kp, kingdom);
    }

    @Override
    protected Messenger initialChecks() {
        if (kingdom.getMembers().size() > 100) {
            return new StaticMessenger("&cKingdoms with more than 100 members cannot claim lands.");
        }
        return null; // There are no issues.
    }
}

KingdomPlayer kp = ...;

// DONT
if (kp.hasKingdom()) {
    if (kp.getKingdom().hasAttribute(...) && kp.getKingdom().equals(...)) 
}

// DO
Kingdom kingdom = kp.getKingdom();
if (kingdom != null) {
    if (kingdom.hasAttribute(...) && kingdom.equals(...))
}

// Or convert it to SimpleChunkLocation of other types.
SimpleChunkLocation chunk = ...;
Kingdom kingdom = ...;

// DONT
Land land = chunk.getLand();
if (land != null && land.isClaimed && land.getKingdom().equals(kingdom))

// DO
if (kingdom.isClaimed(chunk))

Land land = ...;
UUID kingdomId = ...;

// DONT
Kingdom kingdom = Kingdom.getKingdom(kingdomId);
if (kingdom.isClaimed(land.getLocation()))
// OR
if (kingdom.getId().equals(land.getKingdomId()))

// DO
if (land.getKingdomId().equals(kingdomID))

Land one = ...;
Land two = ...;

// DONT
if (one.equals(two))

// DO
if (one.simpleEquals(two))

// DONT
Map<Land, ...> map = new HashMap<>();
Set<Land> set = new HashSet<>();

// DO
Map<SimpleChunkLocation, ...> map = new HashMap<>();
Set<SimpleChunkLocation> set = new HashSet<>();

// DONT
Map<Turret, ...> map = new HashMap<>();
Set<Turret> set = new HashSet<>();

// DO
Map<SimpleLocation, ...> map = new HashMap<>();
Set<SimpleLocation> set = new HashSet<>();

// This applies for structures which need to be saved with their SimpleLocation as well and
// Kingdom and KingdomPlayer which need to saved with their UUID.

@Override
public int hashCode() {
    int prime = 31;
    int result = 15;

    result = prime * result + super.hashCode();
    result = prime * result + lastCollector.hashCode();
    result = prime * result + Long.hashCode(lastCollected);
    return result;
}

public class TurretGhasterBlaster extends RangedTurret { // RangedTurret extend Turret and Turret extends KingdomItem<Turret>
    private int blasts = 0;
    private int durability = 1000;
    public GhasterBlasterTurret(KingdomItemStyle type, SimpleLocation location) {
          super(type, location);
    }

    @Override
    public void activate(LivingEntity target, Kingdom kingdom) {
        super.activate(target, kingdom);
        target.setVelocity(new Vector(0, blasts, 0));
        blasts++;
        durability--;
        if (durability == 0) remove(getLand());
    }

    @Override
    public int hashCode() {
        int prime = 31;
        int result = 15;

        result = prime * result + super.hashCode();
        result = prime * result + blasts;
        result = prime * result + durability;
        return result;
    }

    public int getBlasts() { return blasts; }
    public void setBlasts(int blasts) { this.blasts = blasts; }
}

public class TurretGhasterBlaster extends TurretTypeRanged { // TurretTypeRanged extend TurretType and TurretType extends KingdomItemType<Turret>
    public TurretGhasterBlaster () {
        super("ghasterblaster", false, true);
    }

    @Override
    public boolean activate(TurretActivateEvent event) { ... }

    @Override
    public void serialize(JsonObject json, Turret turret, Type type, JsonSerializationContext context) {
        GhasterBlaster rangedTurret = (GhasterBlaster) turret;
        super.serialize(json, turret, type, context);
        json.addProperty("ammo", rangedTurret.getAmmo());
        json.addProperty("blasts", rangedTurret.getBlasts());        
    }

    @Override
    public Turret deserialize(KingdomItemStyle style, JsonObject json, Type type, JsonDeserializationContext context) throws JsonParseException {
        GhasterBlaster turret = new GhasterBlaster(style, null);
        turret.setLevel(json.get("level").getAsInt());
        turret.setAmmo(json.get("ammo").getAsInt());
        turret.setBlasts(json.get("blasts").getAsInt());
        turret.setHolograms(context.deserialize(json.get("holograms"), new TypeToken<List<UUID>>() {
        }.getType()));
        return turret;
    }

    @Override
    public Turret build(KingdomItemStyle style, SimpleLocation location, KingdomPlayer kp, NBTWrappers.NBTTagCompound tag) {
        Turret turret = new GhasterBlaster(style, location);
        if (tag != null) turret.setData(tag);
        return turret;
    }

register(new TurretGhasterBlaster());

// You should preferably only use a single namespace for all your data.
private static final META_NS = new Namespace("MyPlugin", "LEVEL");

Kingdom kingdom = ...;
KingdomMetadataHandler metaInt = new StandardKingdomMetadataHandler(META_NS);
kingdom.getMetadata().put(metaInt, new StandardKingdomMetadata(10));

// Retrieve the value:
StandardKingdomMetadata data = (StandardKingdomMetadata) kingdom.getMetadata().get(META_NS);
int lvl = data.asInt(); // If the data types don't match, an error will be thrown.

Namespace ns = new Namespace("PluginName", "TEST");

public static final KingdomPermission PERMISSION_INV_TAKE = new KingdomPermission(new Namespace("PluginName", "INV_TAKE"));

@Override
public void onLoad() {
  Kingdoms.get().getPermissionRegistery().register(PERMISSION_INV_TAKE);
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onInventoryTake(InventoryClickEvent event) {
  Player player = (Player) event.getWhoClicked();
  KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(player);
  SimpleChunkLocation chunk = SimpleChunkLocation.of(player.getLocation);
  Kingdom kingdom = kp.getKingdom();
  
  if (kingdom == null || land == null || !kingdom.isClaimed(chunk)) return;
  if (!kp.hasPermission(PERMISSION_INV_TAKE)) event.setCancelled(true);
}

public static final RelationAttribute ATTR_SHOOT_IN_LAND = new RelationAttribute(new Namespace("PluginName", "SHOOT"));

@Override
public void onLoad() {
  Kingdoms.get().getRelationAttributeRegistry().register(ATTR_SHOOT_IN_LAND);
}

@EventHandler(ignoreCancelled = true)
public void onPlayerShoot(ProjectileLaunchEvent event) {
    Projectile projectile = event.getEntity();
    if (!(projectile.getShooter() instanceof Player)) return;
    
    Player shooter = (Player) projectile.getShooter();
    KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(shooter);
    Kingdom kpKingdom = kp.getKingdom();
    Land land = Land.getLand(shooter.getLocation());
    Kingdom landKingdom = land == null || !land.isClaimed() ? null : land.getKingdom();
    
    if (!ATTR_SHOOT_IN_LAND.hasAttribute(kpKingdom, landKingdom)) event.setCancelled(true);
}

public final class LogLandChange extends AuditLog {
    private SimpleChunkLocation from, to;
    
    protected LogLandChange() {}
    
    public LogLandChange(SimpleChunkLocation from, SimpleChunkLocation to) {
        this.from = from;
        this.to = to;
    }
    
    private static final Namespace NS = new Namespace("PluginName", "LAND_CHANGE");
    public static final AuditLogProvider PROVIDER = new AuditLogProvider() {
        @Override
        public AuditLog construct() {
            return new LogLandChange();
        }
        @Override
        public Namespace getNamespace() {
            return NS;
        }
    };
    @Override
    public AuditLogProvider getProvider() {
        return PROVIDER;
    }

    @Override
    public void deserialize(DeserializationContext context) {
        super.deserialize(context);
        JsonObject json = context.getJson();
        this.from = SimpleChunkLocation.fromString(json.get("from").getAsString());
        this.to = SimpleChunkLocation.fromString(json.get("to").getAsString());
    }

    @Override
    public void serialize(SerializationContext context) {
        super.serialize(context);
        JsonObject json = context.getJson();
        json.addProperty("from", from.toString());
        json.addProperty("to", to.toString());
    }

    @Override
    protected void addEdits(MessageBuilder builder) {
        super.addEdits(builder);
        builder.parse("from", "&2" + + from.getWorld() + ", " + from.getX() + ", " + from.getZ());
        
        // Or using kingdoms built-in language entries:
        builder.parse("to", KingdomsLang.LOCATIONS_CHUNK.parse(LocationUtils.getChunkEdits(to)));
    }
}

@Override
public void onLoad() {
  Kingdoms.get().getAuditLogRegistry().register(LogLandChange.PROVIDER);
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onLandChange(LandChangeEvent event) {
    KingdomPlayer kp = event.getKingdomPlayer();
    Kingdom kingdom = kp.getKingdom();
    if (kingdom == null) return;
    if (kingdom.isClaimed(event.getFromChunk()) || kingdom.isClaimed(event.getToChunk())) {
        kingdom.log(new LogLandChange(event.getFromChunk(), event.getToChunk()));
    }
}

List<Kingdom> allies = damagerKingdom.getKingdomsWithRelation(KingdomRelation.ALLY);

Player player = ...;
KingdomPlayer kp = new KingdomPlayer(player);
if (kp.hasKingdom()) {
    kp.hasPermission(DefaultKingdomPermission.HOME);
    if (kp.getKingdom().hasNation()) kp.hasNationPermission(DefaultKingdomPermission.HOME); // Spawn
}

Player player = ...;
KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(player);
Kingdom kingdom = Kingdom.getKingdom(...);
kp.joinKingdom(kingdom);

Player player = ...;
KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(player);
kp.buildMap().display(); // This considers the custom map size set by the player.

// or
new KingdomsMap().forPlayer(player).display();

Player damager = ...;
Player victim = ...;
boolean canFight = PvPManager.canFight(damager, victim);

Player damager = ...;
Player victim = ...;

KingdomPlayer damagerKp = KingdomPlayer.getKingdomPlayer(damager);
if (damagerKp.isAdmin() || !damagerKp.hasKingdom()) return true;
KingdomPlayer victimKp = KingdomPlayer.getKingdomPlayer(victim);
if (!victimKp.hasKingdom()) return true;

if (damagerKp.isPvp() && victimKp.isPvp()) return true;
Kingdom damagerKingdom = damagerKp.getKingdom();
Kingdom victimKingdom = victimKp.getKingdom();

return !victimKingdom.hasAttribute(damagerKingdom, KingdomRelation.Attribute.CEASEFIRE);

LivingEntity entity = ...;
boolean isKingdomMob = KingdomEntityRegistry.isKingdomEntity(entity);

Player player = ...;
Location location = player.getLocation();
KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(player);
if (!kp.hasKingdom()) return;

// WorldGuard Support
if (ServiceHandler.isLocationInRegion(loc)) return;
SimpleChunkLocation simpLocation = new SimpleChunkLocation(loc);
Land land = Land.getLand(location);
if (land != null && !land.isClaimed()) kp.getKingdom().claim(kp, simpLocation);

Collection<ItemStack> items = ...;
List<ItemStack> stacked = XItemStack.stack(items);
Player player = ...;
KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(player);

// You can leave the second argument as null if you don't want to modify anything.
Pair<Long, List<ItemStack>> result = ResourcePointManager.convertToResourcePoints(stacked, (item, leftOvers) -> {
    // Return null if you want the item to be handled normally according to the config.
    // You can also add a part of the item to the leftOvers list. You don't need to clone the item.
    // If you return a nonnull value, the item will not be added to the leftOvers list and the amount will be added to the result.
});
long added = result.getKey();
List<ItemStack> leftOvers = result.getValue();
KingdomResourcePointDonateEvent event = kp.donate(added, stacked, leftOvers);

if (!event.isCancelled()) {
    added = event.getAmount();
    leftOvers = event.getLeftOvers();

    kingdom.addResourcePoints(added);
    if (leftOvers != null) XItemStack.giveOrDrop(player, true, leftOvers.toArray(new ItemStack[0]));
}

OfflinePlayer player = ...;
KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(player);
Kingdom kingdom = kp.getKingdom();

Pair<Boolean, Double> result = kingdom.payTaxes(player);
result.getKey(); // Could pay?
result.getValue(); // Tax amount the player paid.

if (!kingdom.hasNation()) return;
Nation nation = kingdom.getNation();
nation.payTaxes(kingdom);

Block block = ...;
SimpleLocation location = new SimpleLocation(block);

TurretStyle turretStyle = TurretRegistry.getStyle("arrow");
StructureStyle structureStyle = StructureRegistry.getStyle("powercell");

// You can leave the kp and nbt data as null if you don't have it.
Land land = location.toSimpleChunkLocation().getLand();
Turret turret = turretStyle.getType().build(type, location, kp, nbt);
Structure structure = structureStyle.getType().build(type, location, kp, nbt);

land.getTurrets().put(location, turret);
land.getStructures().put(location, structure);

turret.spawnHolograms(land.getKingdom());
structure.spawnHolograms(land.getKingdom());

# This can be aquired using Land#getStructures() or Land#getTurrets()
KingdomItem<?> kingdomItem = ...;

KingdomItemRemoveContext context = new KingdomItemRemoveContext(); # All the properties are optional.
context.setCause(event); # If this was caused by another event
context.setPlayer(kp); # If a player caused this item to be removed.
context.dropsItem(false); # If the item should be dropped after being removed.
context.modifier(Consumer<KingdomItemBreakEvent<?>>) # Usually used for modifying the metadata of the event being firing it.
kingdomItem.remove(context);

ItemStack item = ...;
NBTWrappers.NBTTagCompound nbt = ItemNBT.getTag(item);
nbt = nbt.getCompound(Kingdoms.NBT);

// It's not a kingdom item!
if (nbt == null) return;
String tag = nbt.get(StructureType.METADATA, NBTType.STRING);
// It's a structure.
if (tag != null) return;

tag = nbt.get(TurretType.METADATA, NBTType.STRING);
if (tag != null) return;// It's a turret.
// If it ever passed the above check then I don't know what the hell you did to the item.

Entity entity;
if (entity.hasMetadata(Invasion.METADATA)) {
   if (entity instanceof Player) // invader
   else // champion
}

// Or more easily for players
KingdomPlayer kp;
kp.isInvading()

// From players:
Player player = ...;
KingdomPlayer kp = KingdomPlayer.getKingdomPlayer(player);
Invasion invasion = kp.getInvasion();

// From entity (champions):
Entity entity = ...;
Invasion invasion = Invasion.getInvasion(entity);

Land mainLand = invasion.getOriginLand();

Land land = ...;
Invasion invasion = land.getInvasions().get(invaderKingdomId);
if (invasion.getChampion().isValid()) invasion.end(KingdomInvadeEndEvent.InvasionResult.TIMES_UP);

KingdomPreInvadeEvent event = InvasionFactory.standardInvasion(land, acceptedLands, player, ransackMode);
if (event.isCancelled()) return;
Invasion invasion = event.getInvasion();

// The KingdomInvadeEvent gets called when the cooldown of standardInvasion is ended.

public class ChampionAbilityBoom extends ChampionAbility implements Listener {
    public ChampionAbilityResistance() {
        super(ChampionUpgrade.THOR);
    }

    @EventHandler
    public void onDamage(KingdomInvadeAttackEvent event) {
        if (cantUse(event.getInvasion().getDefender().getKingdom())) return;
        if (event.isAttackerChampion()) return;
        if (!MathUtils.hasChance(10) return;
        if (callEvent(event.getInvasion())) return;

        Entity champion = event.getEntity();
        Player player = event.getInvasion().getInvader().getPlayer();
        // A much better way of getting the player is:
        player = (Player) event.getDamager();
        player.getWorld().createExplosion(player.getLocation(), 3f);
    }
}
new ChampionAbilityBoom();

Kingdom defender = ...;
Kingdom attacker = ...;
boolean hasAttribute = defender.hasAttribute(attacker, ...);

boolean hasAttribute = attacker.hasAttribute(defender, ...);

KingdomRelation.Attribute attribute = ...;
boolean hasAttribute = attribute.hasAttribute(kingdom, otherKingdom);

// If you want to listen to either structures or turrets.
@EventHandler
public void onPlace(KingdomItemPlaceEvent<?> event) {
    if (event.getKingdomItem() instanceof Structure) {
        Structure structure = (Structure) event.getKingdomItem(); 
    }
    if (event.getKingdomItem() instanceof Turret) {
        Turret structure = (Turret) event.getKingdomItem();
    }
}

// Listening to only one type of kingdom item. In this example, structures.
@EventHandler
public void onPlace(KingdomItemPlaceEvent<Structure> event) {
    if (!(event.getKingdomItem() instanceof Structure)) return; // Yes, this line is still necessary.
    Structure structure = event.getKingdomItem();
}

@EventHandler(ignoreCancelled = true)
public void onNexusOpen(KingdomGUIOpenEvent event) {
    InteractiveGUI gui = event.getGUI();

    // Make sure this is the turret's GUI that's being opened.
    if (!gui.is(KingdomsGUI.STRUCTURES_NEXUS_TURRETS)) return;

    // getOption() returns an option that has been already pushed to the GUI.
    Optional<GUIOption> optionOpt = gui.getOption("arrow");
    if (!optionOpt.isPresent()) return;

    GUIOption option = optionOpt.get();
    Runnable fn = option.getRunnables().values().iterator().next();

    Runnable newFn = () -> {
        if (!event.getPlayer().isOp()) {
            event.getPlayer().sendMessage("You need to be op to buy this turret.");
            return;
        }

        // This preserves the original functionality of the option so you won't need to copy the entire functionality yourself.
        fn.run();
    };

    // toArray() is necessary to prevent concurrent modification.
    for (ClickType clickType : option.getRunnables().keySet().toArray(new ClickType[0])) {
        // The plugin usually has a single functionality for all clicking types.
        option.getRunnables().put(clickType, newFn);
    }
}