Developer API

You can only use API and events of modules you have enabled in your config.yml!

If you would like to see how to create your own custom enchant head over here

Events

• UltraPrisonPlayerEnchantEvent
• UltraPrisonPlayerGemsReceiveEvent
• UltraPrisonPlayerTokensReceiveEvent
• UltraPrisonPlayerRankUpEvent
• UltraPrisonPlayerPrestigeEvent
• UltraPrisonBlockBreakEvent
• UltraPrisonAutoSellEvent
• GangCreateEvent
• GangDisbandEvent
• GangJoinEvent
• GangLeaveEvent

API

---

Auto-Sell

package me.drawethree.ultraprisoncore.autosell.api;

import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.codemc.worldguardwrapper.region.IWrappedRegion;

public interface UltraPrisonAutoSellAPI {

    /**
     * Method to get current earnings of player
     *
     * @param player Player
     * @return Current earnings
     */
    double getCurrentEarnings(Player player);

    /**
     * Method to get price for broken block in specified mine region
     * @param region IWrappedRegion
     * @param block Block
     * @return Price for broken block
     */
    double getPriceForBrokenBlock(IWrappedRegion region, Block block);

    /**
     * Method to get if player has autosell enabled
     * @param p Player
     * @return true if player has autosell enabled, otherwise false
     */
    boolean hasAutoSellEnabled(Player p);
}

---

Enchants

package me.drawethree.ultraprisoncore.enchants.api;

import me.drawethree.ultraprisoncore.enchants.enchants.UltraPrisonEnchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;

import java.util.HashMap;

public interface UltraPrisonEnchantsAPI {


    /**
     * Method to get all custom enchants applied on specific ItemStack
     *
     * @param itemStack ItemStack
     * @return
     */
    HashMap<UltraPrisonEnchantment, Integer> getPlayerEnchants(ItemStack itemStack);

    /**
     * Method to check if player has specific enchant on his current item in hand
     * @param p Player
     * @param id Enchant ID
     * @return true if player has specified enchant
     */
    boolean hasEnchant(Player p, int id);

    /**
     * Method to get enchant level of specific ItemStack
     * @param item ItemStack
     * @param id Enchant ID
     * @return 0 if enchant was not found, otherwise level of enchant
     */
    int getEnchantLevel(ItemStack item, int id);

    /**
     * Method to add custom enchant to ItemStack
     * @param item ItemStack
     * @param p Player
     * @param id Enchant ID
     * @param level Enchant Level
     * @return modified ItemStack
     */
    ItemStack addEnchant(ItemStack item, Player p, int id, int level);

    /**
     * Method to remove custom enchant from ItemStack
     * @param item ItemStack
     * @param p Player
     * @param id Enchant ID
     * @return modified ItemStack
     */
    ItemStack removeEnchant(ItemStack item, Player p, int id);

    /**
     * @deprecated NOT CURRENTLY WORKING!
     * Method to register new enchantment
     * @param enchantment Enchant
     * @return true if enchant was registered properly
     */
    boolean registerEnchant(UltraPrisonEnchantment enchantment);
}

---

Gems

package me.drawethree.ultraprisoncore.gems.api;

import org.bukkit.OfflinePlayer;

public interface UltraPrisonGemsAPI {

	/**
	 * Method to get player gems
	 *
	 * @param p Player
	 * @return Player gems amount
	 */
	long getPlayerGems(OfflinePlayer p);

	/**
	 * Method to check if player has more or equal gems than specified amount
	 * @param p Player
	 * @param amount amount
	 * @return true if player has more or equal gems
	 */
	boolean hasEnough(OfflinePlayer p, long amount);

	/**
	 * Method to remove gems from player
	 * @param p Player
	 * @param amount amount
	 */
	void removeGems(OfflinePlayer p, long amount);

	/**
	 * Method to add gems to player
	 * @param p
	 * @param amount
	 */
	void addGems(OfflinePlayer p, long amount);
}

---

Multipliers

package me.drawethree.ultraprisoncore.multipliers.api;

import org.bukkit.entity.Player;

public interface UltraPrisonMultipliersAPI {


    /**
     * Method to get current global multiplier
     *
     * @return global multiplier value
     */
    double getGlobalMultiplier();

    /**
     * Method to get player's vote multiplier
     * @param p Player
     * @return vote multiplier
     */
    double getVoteMultiplier(Player p);

    /**
     * Method to get player's rank multiplier
     * @param p Player
     * @return rank multiplier
     */
    double getRankMultiplier(Player p);

    /**
     * Method to get overall player's multiplier
     * @param p Player
     * @return overall player's multiplier
     */
    double getPlayerMultiplier(Player p);

    /**
     * Method to calculate total amount to deposit
     * @param p Player
     * @param deposit original amount to deposit
     * @return new amount to deposit
     */
    default double getTotalToDeposit(Player p, double deposit) {
        return deposit * (1 + getPlayerMultiplier(p));
    }

}

---

Ranks

package me.drawethree.ultraprisoncore.ranks.api;


import me.drawethree.ultraprisoncore.ranks.rank.Prestige;
import me.drawethree.ultraprisoncore.ranks.rank.Rank;
import org.bukkit.entity.Player;

public interface UltraPrisonRankupAPI {

	/**
	 * Method to get player Rank
	 *
	 * @param p Player
	 * @return Rank
	 */
	Rank getPlayerRank(Player p);

	/**
	 * Method to get player Prestige
	 * @param p Player
	 * @return Prestige
	 */
	Prestige getPlayerPrestige(Player p);

	/**
	 * Method to get next player rank
	 * @param player Player
	 * @return null if he has max rank, otherwise next Rank
	 */
	Rank getNextPlayerRank(Player player);

	/**
	 * Method to get player's rankup progress
	 * @param player Player
	 * @return int 0-100 percentage
	 */
	int getRankupProgress(Player player);
}

---

Tokens

package me.drawethree.ultraprisoncore.tokens.api;

import org.bukkit.OfflinePlayer;

public interface UltraPrisonTokensAPI {


    /**
     * Method to get player's tokens
     *
     * @param p Player
     * @return amount of player's tokens
     */
    long getPlayerTokens(OfflinePlayer p);

    /**
     * Method to check if player has more or equal tokens than specified amount
     * @param p Player
     * @param amount amount
     * @return true if player has more or equal tokens than amount
     */
    boolean hasEnough(OfflinePlayer p, long amount);

    /**
     * Method to remove tokens from player
     * @param p Player
     * @param amount amount
     */
    void removeTokens(OfflinePlayer p, long amount);

    /**
     * Method to add tokens to player
     * @param p Player
     * @param amount amount
     */
    void addTokens(OfflinePlayer p, long amount);
}

Gangs

import me.drawethree.ultraprisoncore.gangs.models.Gang;
import org.bukkit.OfflinePlayer;

import java.util.Optional;

public interface UltraPrisonGangsAPI {

    /**
     * Method to get Gang from player
     * @param player OfflinePlayer
     * @return Optional<Gang> gang
     */
    Optional<Gang> getPlayerGang(OfflinePlayer player);

    /**
     * Method to get Gang from name
     * @param name name of gang
     * @return Optional<Gang> gang
     */
    Optional<Gang> getByName(String name);
}