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
• PlayerAutomineEvent
• PlayerAutoMinerTimeReceiveEvent
• PlayerGemsLostEvent
• PlayerGemsReceiveEvent
• PlayerTokensReceiveEvent
• PlayerTokensLostEvent
• PlayerRankUpEvent
• PlayerPrestigeEvent
• UltraPrisonBlockBreakEvent
• UltraPrisonAutoSellEvent
• UltraPrisonSellAllEvent
• GangCreateEvent
• GangDisbandEvent
• GangJoinEvent
• GangLeaveEvent
• MineCreateEvent
• MineDeleteEvent
• MinePreResetEvent
• MinePostResetEvent
• PlayerMultiplierReceiveEvent
• PlayerMultiplierExpireEvent
• LayerTriggerEvent
• NukeTriggerEvent
• ExplosionTriggerEvent

API

---

Auto-Sell

package dev.drawethree.ultraprisoncore.autosell.api;

import dev.drawethree.ultraprisoncore.autosell.model.SellRegion;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;

import java.util.Collection;

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 ItemStack in specified mine region
	 *
	 * @param regionName Name of region
	 * @param item       ItemStack
	 * @return Price for item
	 */
	double getPriceForItem(String regionName, ItemStack item);

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

	/**
	 * Method to get all sell regions
	 *
	 * @return Collection of all loaded and active Sell Regions
	 */
	Collection<SellRegion> getSellRegions();

	/**
	 * Method to get SellRegion at specified location
	 *
	 * @return Sell Region at given location or null if not present.
	 */
	SellRegion getSellRegionAtLocation(Location location);
}

---

AutoMiner

package dev.drawethree.ultraprisoncore.autominer.api;

import org.bukkit.entity.Player;

public interface UltraPrisonAutoMinerAPI {

	/**
	 * Returns true if player is in autominer region, otherwise return false
	 *
	 * @param player Player
	 * @return returns true if player is in autominer region, otherwise return false
	 */
	boolean isInAutoMinerRegion(Player player);

	/**
	 * Returns remaining autominer time in seconds for specific player
	 *
	 * @param player Player
	 * @return time in seconds left for specific player autominer
	 */
	int getAutoMinerTime(Player player);
}

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 set enchant with specific level to ItemStack
     * @param item ItemStack
     * @param id Enchant ID
     * @param level Enchant Level
     * @return modified ItemStack
     */
	ItemStack setEnchantLevel(ItemStack item, int id, int level);

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

    /**
     * Method to get Enchant by ID
     * @param id enchant id
     * @return UltraPrisonEnchantment
     */
    UltraPrisonEnchantment getById(int id);

    /**
     * Method to get Enchant by ID
     * @param rawName enchant rawname
     * @return UltraPrisonEnchantment
     */
    UltraPrisonEnchantment getByName(String rawName);

}

---

Gems

package me.drawethree.ultraprisoncore.gems.api;

import me.drawethree.ultraprisoncore.api.enums.ReceiveCause;
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 Player
	 * @param amount amount
	 * @param cause - Represents why player get these gemes
	 */
	void addGems(OfflinePlayer p, long amount, ReceiveCause cause);

}

---

Multipliers

package me.drawethree.ultraprisoncore.multipliers.api;

import me.drawethree.ultraprisoncore.multipliers.enums.MultiplierType;
import me.drawethree.ultraprisoncore.multipliers.multiplier.GlobalMultiplier;
import me.drawethree.ultraprisoncore.multipliers.multiplier.Multiplier;
import me.drawethree.ultraprisoncore.multipliers.multiplier.PlayerMultiplier;
import org.bukkit.entity.Player;

public interface UltraPrisonMultipliersAPI {


	/**
	 * Method to get current global sell multiplier
	 *
	 * @return global multiplier value
	 */
	GlobalMultiplier getGlobalSellMultiplier();

	/**
	 * Method to get current global token multiplier
	 *
	 * @return global multiplier value
	 */
	GlobalMultiplier getGlobalTokenMultiplier();

	/**
	 * Method to get player's sell multiplier
	 *
	 * @param p Player
	 * @return vote multiplier
	 */
	PlayerMultiplier getSellMultiplier(Player p);

	/**
	 * Method to get player's token multiplier
	 *
	 * @param p Player
	 * @return vote multiplier
	 */
	PlayerMultiplier getTokenMultiplier(Player p);

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

	/**
	 * Method to get overall player's multiplier based on multiplier type (SELL / TOKENS)
	 *
	 * @param p              Player
	 * @param multiplierType MultiplierType.SELL or MultiplierType.TOKENS
	 * @return overall player's multiplier
	 */
	double getPlayerMultiplier(Player p, MultiplierType multiplierType);

	/**
	 * Method to calculate total amount to deposit (tokens / money )
	 *
	 * @param p       Player
	 * @param deposit original amount to deposit
	 * @param type    MultiplierType.SELL or MultiplierType.TOKENS
	 * @return new amount to deposit
	 */
	default double getTotalToDeposit(Player p, double deposit, MultiplierType type) {
		return deposit * (1.0 + this.getPlayerMultiplier(p, type));
	}

}

---

Ranks

package me.drawethree.ultraprisoncore.ranks.api;


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

public interface UltraPrisonRanksAPI {

	/**
	 * Method to get player Rank
	 *
	 * @param p Player
	 * @return Rank
	 */
	Rank getPlayerRank(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);

	/**
	 * Sets a rank to online player
	 *
	 * @param player Player
	 * @param rank   Rank
	 */
	void setPlayerRank(Player player, Rank rank);

}

---

Prestiges

package me.drawethree.ultraprisoncore.prestiges.api;


import me.drawethree.ultraprisoncore.prestiges.model.Prestige;
import org.bukkit.entity.Player;

public interface UltraPrisonPrestigesAPI {

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

	/**
	 * Sets a prestige to online player
	 *
	 * @param player   Player
	 * @param prestige Prestige
	 */
	void setPlayerPrestige(Player player, Prestige prestige);

	/**
	 * Sets a prestige to online player
	 *
	 * @param player   Player
	 * @param prestige Prestige
	 */
	void setPlayerPrestige(Player player, long prestige);

}

---

Tokens

package me.drawethree.ultraprisoncore.tokens.api;

import me.drawethree.ultraprisoncore.api.enums.LostCause;
import me.drawethree.ultraprisoncore.api.enums.ReceiveCause;
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, LostCause cause);

    /**
     * Method to add tokens to player
     * @param p Player
     * @param amount amount
     * @param cause - Represents why player get these tokens
     */
    void addTokens(OfflinePlayer p, long amount, ReceiveCause cause);
}

Gangs

package dev.drawethree.ultraprisoncore.gangs.api;

import dev.drawethree.ultraprisoncore.gangs.model.Gang;
import org.bukkit.OfflinePlayer;

import java.util.Collection;
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);

	/**
	 * Method to get all gangs
	 *
	 * @return List of gangs
	 */
	Collection<Gang> getAllGangs();
}

---

PickaxeLevels

package dev.drawethree.ultraprisoncore.pickaxelevels.api;

import dev.drawethree.ultraprisoncore.pickaxelevels.model.PickaxeLevel;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;

public interface UltraPrisonPickaxeLevelsAPI {

	/**
	 * Method to get PickaxeLevel of itemstack
	 *
	 * @param item ItemStack
	 * @return instance of PickaxeLevel
	 */
	PickaxeLevel getPickaxeLevel(ItemStack item);

	/**
	 * Method to get PickaxeLevel of Player
	 *
	 * @param player Player
	 * @return instance of PickaxeLevel
	 */
	PickaxeLevel getPickaxeLevel(Player player);

	/**
	 * Method to get PickaxeLevel by specific level
	 *
	 * @param level level
	 * @return instance of PickaxeLevel
	 */
	PickaxeLevel getPickaxeLevel(int level);

	/**
	 * Method to set PickaxeLevel of itemstack
	 *
	 * @param player Player
	 * @param item   ItemStack to change
	 * @param level  PickaxeLevel to set
	 */
	void setPickaxeLevel(Player player, ItemStack item, PickaxeLevel level);

	/**
	 * Method to set PickaxeLevel of itemstack
	 *
	 * @param player Player
	 * @param item   ItemStack to change
	 * @param level  level to set
	 */
	void setPickaxeLevel(Player player, ItemStack item, int level);
}

---

Mines

package me.drawethree.ultraprisoncore.mines.api;

import me.drawethree.ultraprisoncore.mines.model.mine.Mine;
import org.bukkit.Location;

public interface UltraPrisonMinesAPI {

	/**
	 * Gets a mine by name
	 * @param name String
	 * @return Mine.class
	 */
	Mine getMineByName(String name);

	/**
	 * Gets a mine by location
	 * @param loc Location
	 * @return Mine.class
	 */
	Mine getMineAtLocation(Location loc);
}

---

History

package me.drawethree.ultraprisoncore.history.api;

import me.drawethree.ultraprisoncore.UltraPrisonModule;
import me.drawethree.ultraprisoncore.history.model.HistoryLine;
import org.bukkit.OfflinePlayer;

import java.util.List;

public interface UltraPrisonHistoryAPI {

	/**
	 * Gets players history
	 *
	 * @param player Player
	 * @return List containing all HistoryLine.class of Player
	 */
	List<HistoryLine> getPlayerHistory(OfflinePlayer player);

	/**
	 * Creates a new history line for player
	 *
	 * @param player  Player
	 * @param context Context of the history
	 * @param module  UltraPrisonModule associated with the history
	 */
	void createHistoryLine(OfflinePlayer player, UltraPrisonModule module, String context);
}