548 lines
18 KiB
Java
548 lines
18 KiB
Java
///
|
|
// Created by BONNe
|
|
// Copyright - 2021
|
|
///
|
|
|
|
package world.bentobox.level.panels;
|
|
|
|
|
|
import java.io.File;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
import java.util.stream.Collectors;
|
|
|
|
import org.bukkit.Material;
|
|
import org.bukkit.World;
|
|
import org.bukkit.event.inventory.ClickType;
|
|
|
|
import world.bentobox.bentobox.api.addons.GameModeAddon;
|
|
import world.bentobox.bentobox.api.localization.TextVariables;
|
|
import world.bentobox.bentobox.api.panels.PanelItem;
|
|
import world.bentobox.bentobox.api.panels.TemplatedPanel;
|
|
import world.bentobox.bentobox.api.panels.builders.PanelItemBuilder;
|
|
import world.bentobox.bentobox.api.panels.builders.TemplatedPanelBuilder;
|
|
import world.bentobox.bentobox.api.panels.reader.ItemTemplateRecord;
|
|
import world.bentobox.bentobox.api.user.User;
|
|
import world.bentobox.bentobox.database.objects.Island;
|
|
import world.bentobox.bentobox.managers.RanksManager;
|
|
import world.bentobox.level.Level;
|
|
import world.bentobox.level.util.Utils;
|
|
|
|
|
|
/**
|
|
* This panel opens top likes panel
|
|
*/
|
|
public class TopLevelPanel
|
|
{
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Internal Constructor
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
/**
|
|
* This is internal constructor. It is used internally in current class to avoid creating objects everywhere.
|
|
*
|
|
* @param addon Level object.
|
|
* @param user User who opens Panel.
|
|
* @param world World where gui is opened
|
|
* @param permissionPrefix Permission Prefix
|
|
*/
|
|
private TopLevelPanel(Level addon, User user, World world, String permissionPrefix)
|
|
{
|
|
this.addon = addon;
|
|
this.user = user;
|
|
this.world = world;
|
|
|
|
this.iconPermission = permissionPrefix + "level.icon";
|
|
|
|
this.topIslands = this.addon.getManager().getTopTen(this.world, 10).entrySet().stream().
|
|
map(entry -> {
|
|
Island island = this.addon.getIslandsManager().getIsland(this.world, entry.getKey());
|
|
return new IslandTopRecord(island, entry.getValue());
|
|
}).
|
|
collect(Collectors.toList());
|
|
}
|
|
|
|
|
|
/**
|
|
* Build method manages current panel opening. It uses BentoBox PanelAPI that is easy to use and users can get nice
|
|
* panels.
|
|
*/
|
|
public void build()
|
|
{
|
|
TemplatedPanelBuilder panelBuilder = new TemplatedPanelBuilder();
|
|
|
|
panelBuilder.user(this.user);
|
|
panelBuilder.world(this.world);
|
|
|
|
panelBuilder.template("top_panel", new File(this.addon.getDataFolder(), "panels"));
|
|
|
|
panelBuilder.registerTypeBuilder("VIEW", this::createViewerButton);
|
|
panelBuilder.registerTypeBuilder("TOP", this::createPlayerButton);
|
|
|
|
// Register unknown type builder.
|
|
panelBuilder.build();
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Methods
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
/**
|
|
* Creates fallback based on template.
|
|
* @param template Template record for fallback button.
|
|
* @param index Place of the fallback.
|
|
* @return Fallback panel item.
|
|
*/
|
|
private PanelItem createFallback(ItemTemplateRecord template, long index)
|
|
{
|
|
if (template == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
PanelItemBuilder builder = new PanelItemBuilder();
|
|
|
|
if (template.icon() != null)
|
|
{
|
|
builder.icon(template.icon().clone());
|
|
}
|
|
|
|
if (template.title() != null)
|
|
{
|
|
builder.name(this.user.getTranslation(this.world, template.title(),
|
|
TextVariables.NAME, String.valueOf(index)));
|
|
}
|
|
else
|
|
{
|
|
builder.name(this.user.getTranslation(this.world, REFERENCE,
|
|
TextVariables.NAME, String.valueOf(index)));
|
|
}
|
|
|
|
if (template.description() != null)
|
|
{
|
|
builder.description(this.user.getTranslation(this.world, template.description(),
|
|
TextVariables.NUMBER, String.valueOf(index)));
|
|
}
|
|
|
|
builder.amount(index != 0 ? (int) index : 1);
|
|
|
|
return builder.build();
|
|
}
|
|
|
|
|
|
/**
|
|
* This method creates player icon with warp functionality.
|
|
*
|
|
* @return PanelItem for PanelBuilder.
|
|
*/
|
|
private PanelItem createPlayerButton(ItemTemplateRecord template, TemplatedPanel.ItemSlot itemSlot)
|
|
{
|
|
int index = (int) template.dataMap().getOrDefault("index", 0);
|
|
|
|
if (index < 1)
|
|
{
|
|
return this.createFallback(template.fallback(), index);
|
|
}
|
|
|
|
IslandTopRecord islandTopRecord = this.topIslands.size() < index ? null : this.topIslands.get(index - 1);
|
|
|
|
if (islandTopRecord == null)
|
|
{
|
|
return this.createFallback(template.fallback(), index);
|
|
}
|
|
|
|
return this.createIslandIcon(template, islandTopRecord, index);
|
|
}
|
|
|
|
|
|
/**
|
|
* This method creates button from template for given island top record.
|
|
* @param template Icon Template.
|
|
* @param islandTopRecord Island Top Record.
|
|
* @param index Place Index.
|
|
* @return PanelItem for PanelBuilder.
|
|
*/
|
|
private PanelItem createIslandIcon(ItemTemplateRecord template, IslandTopRecord islandTopRecord, int index)
|
|
{
|
|
// Get player island.
|
|
Island island = islandTopRecord.island();
|
|
|
|
if (island == null)
|
|
{
|
|
return this.createFallback(template.fallback(), index);
|
|
}
|
|
|
|
PanelItemBuilder builder = new PanelItemBuilder();
|
|
|
|
this.populateIslandIcon(builder, template, island);
|
|
this.populateIslandTitle(builder, template, island);
|
|
this.populateIslandDescription(builder, template, island, islandTopRecord, index);
|
|
|
|
builder.amount(index);
|
|
|
|
// Get only possible actions, by removing all inactive ones.
|
|
List<ItemTemplateRecord.ActionRecords> activeActions = new ArrayList<>(template.actions());
|
|
|
|
activeActions.removeIf(action ->
|
|
{
|
|
switch (action.actionType().toUpperCase())
|
|
{
|
|
case "WARP" -> {
|
|
return island.getOwner() == null ||
|
|
this.addon.getWarpHook() == null ||
|
|
!this.addon.getWarpHook().getWarpSignsManager().hasWarp(this.world, island.getOwner());
|
|
}
|
|
case "VISIT" -> {
|
|
return island.getOwner() == null ||
|
|
this.addon.getVisitHook() == null ||
|
|
!this.addon.getVisitHook().getAddonManager().preprocessTeleportation(this.user, island);
|
|
}
|
|
case "VIEW" -> {
|
|
return island.getOwner() == null ||
|
|
!island.getMemberSet(RanksManager.MEMBER_RANK).contains(this.user.getUniqueId());
|
|
}
|
|
default -> {
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
|
|
// Add Click handler
|
|
builder.clickHandler((panel, user, clickType, i) ->
|
|
{
|
|
for (ItemTemplateRecord.ActionRecords action : activeActions)
|
|
{
|
|
if (clickType == action.clickType() || action.clickType() == ClickType.UNKNOWN)
|
|
{
|
|
switch (action.actionType().toUpperCase())
|
|
{
|
|
case "WARP" -> {
|
|
this.user.closeInventory();
|
|
this.addon.getWarpHook().getWarpSignsManager().warpPlayer(this.world, this.user, island.getOwner());
|
|
}
|
|
case "VISIT" ->
|
|
// The command call implementation solves necessity to check for all visits options,
|
|
// like cool down, confirmation and preprocess in single go. Would it be better to write
|
|
// all logic here?
|
|
|
|
this.addon.getPlugin().getIWM().getAddon(this.world).
|
|
flatMap(GameModeAddon::getPlayerCommand).ifPresent(command ->
|
|
{
|
|
String mainCommand =
|
|
this.addon.getVisitHook().getSettings().getPlayerMainCommand();
|
|
|
|
if (!mainCommand.isBlank())
|
|
{
|
|
this.user.closeInventory();
|
|
this.user.performCommand(command.getTopLabel() + " " + mainCommand + " " + island.getOwner());
|
|
}
|
|
});
|
|
|
|
case "VIEW" -> {
|
|
this.user.closeInventory();
|
|
// Open Detailed GUI.
|
|
DetailsPanel.openPanel(this.addon, this.world, this.user);
|
|
}
|
|
// Catch default
|
|
default -> {
|
|
this.user.closeInventory();
|
|
addon.logError("Unknown action type " + action.actionType().toUpperCase());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
// Collect tooltips.
|
|
List<String> tooltips = activeActions.stream().
|
|
filter(action -> action.tooltip() != null).
|
|
map(action -> this.user.getTranslation(this.world, action.tooltip())).
|
|
filter(text -> !text.isBlank()).
|
|
collect(Collectors.toCollection(() -> new ArrayList<>(template.actions().size())));
|
|
|
|
// Add tooltips.
|
|
if (!tooltips.isEmpty())
|
|
{
|
|
// Empty line and tooltips.
|
|
builder.description("");
|
|
builder.description(tooltips);
|
|
}
|
|
|
|
return builder.build();
|
|
}
|
|
|
|
|
|
/**
|
|
* Populate given panel item builder name with values from template and island objects.
|
|
*
|
|
* @param builder the builder
|
|
* @param template the template
|
|
* @param island the island
|
|
*/
|
|
private void populateIslandTitle(PanelItemBuilder builder,
|
|
ItemTemplateRecord template,
|
|
Island island)
|
|
{
|
|
|
|
// Get Island Name
|
|
String nameText;
|
|
|
|
if (island.getName() == null || island.getName().isEmpty())
|
|
{
|
|
nameText = this.user.getTranslation(REFERENCE + "owners-island",
|
|
PLAYER,
|
|
island.getOwner() == null ?
|
|
this.user.getTranslation(REFERENCE + "unknown") :
|
|
this.addon.getPlayers().getName(island.getOwner()));
|
|
}
|
|
else
|
|
{
|
|
nameText = island.getName();
|
|
}
|
|
|
|
// Template specific title is always more important than custom one.
|
|
if (template.title() != null && !template.title().isBlank())
|
|
{
|
|
builder.name(this.user.getTranslation(this.world, template.title(),
|
|
TextVariables.NAME, nameText));
|
|
}
|
|
else
|
|
{
|
|
builder.name(this.user.getTranslation(REFERENCE + "name", TextVariables.NAME, nameText));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Populate given panel item builder icon with values from template and island objects.
|
|
*
|
|
* @param builder the builder
|
|
* @param template the template
|
|
* @param island the island
|
|
*/
|
|
private void populateIslandIcon(PanelItemBuilder builder,
|
|
ItemTemplateRecord template,
|
|
Island island)
|
|
{
|
|
User owner = island.getOwner() == null ? null : User.getInstance(island.getOwner());
|
|
|
|
// Get permission or island icon
|
|
String permissionIcon = owner == null ? null :
|
|
Utils.getPermissionValue(owner, this.iconPermission, null);
|
|
|
|
Material material;
|
|
|
|
if (permissionIcon != null && !permissionIcon.equals("*"))
|
|
{
|
|
material = Material.matchMaterial(permissionIcon);
|
|
}
|
|
else
|
|
{
|
|
material = null;
|
|
}
|
|
|
|
if (material != null)
|
|
{
|
|
if (!material.equals(Material.PLAYER_HEAD))
|
|
{
|
|
builder.icon(material);
|
|
}
|
|
else
|
|
{
|
|
builder.icon(owner.getName());
|
|
}
|
|
}
|
|
else if (template.icon() != null)
|
|
{
|
|
builder.icon(template.icon().clone());
|
|
}
|
|
else if (owner != null)
|
|
{
|
|
builder.icon(owner.getName());
|
|
}
|
|
else
|
|
{
|
|
builder.icon(Material.PLAYER_HEAD);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Populate given panel item builder description with values from template and island objects.
|
|
*
|
|
* @param builder the builder
|
|
* @param template the template
|
|
* @param island the island
|
|
* @param islandTopRecord the top record object
|
|
* @param index place index.
|
|
*/
|
|
private void populateIslandDescription(PanelItemBuilder builder,
|
|
ItemTemplateRecord template,
|
|
Island island,
|
|
IslandTopRecord islandTopRecord,
|
|
int index)
|
|
{
|
|
// Get Owner Name
|
|
String ownerText = this.user.getTranslation(REFERENCE + "owner",
|
|
PLAYER,
|
|
island.getOwner() == null ?
|
|
this.user.getTranslation(REFERENCE + "unknown") :
|
|
this.addon.getPlayers().getName(island.getOwner()));
|
|
|
|
// Get Members Text
|
|
String memberText;
|
|
|
|
if (island.getMemberSet().size() > 1)
|
|
{
|
|
StringBuilder memberBuilder = new StringBuilder(
|
|
this.user.getTranslationOrNothing(REFERENCE + "members-title"));
|
|
|
|
for (UUID uuid : island.getMemberSet())
|
|
{
|
|
User member = User.getInstance(uuid);
|
|
|
|
if (memberBuilder.length() > 0)
|
|
{
|
|
memberBuilder.append("\n");
|
|
}
|
|
|
|
memberBuilder.append(
|
|
this.user.getTranslationOrNothing(REFERENCE + "member",
|
|
PLAYER, member.getName()));
|
|
}
|
|
|
|
memberText = memberBuilder.toString();
|
|
}
|
|
else
|
|
{
|
|
memberText = "";
|
|
}
|
|
|
|
String placeText = this.user.getTranslation(REFERENCE + "place",
|
|
TextVariables.NUMBER, String.valueOf(index));
|
|
|
|
String levelText = this.user.getTranslation(REFERENCE + "level",
|
|
TextVariables.NUMBER, this.addon.getManager().formatLevel(islandTopRecord.level()));
|
|
|
|
// Template specific description is always more important than custom one.
|
|
if (template.description() != null && !template.description().isBlank())
|
|
{
|
|
builder.description(this.user.getTranslation(this.world, template.description(),
|
|
"[owner]", ownerText,
|
|
"[members]", memberText,
|
|
"[level]", levelText,
|
|
"[place]", placeText).
|
|
replaceAll("(?m)^[ \\t]*\\r?\\n", "").
|
|
replaceAll("(?<!\\\\)\\|", "\n").
|
|
replace("\\\\\\|", "|")); // Not a regex - replace is more efficient
|
|
}
|
|
else
|
|
{
|
|
// Now combine everything.
|
|
String descriptionText = this.user.getTranslation(REFERENCE + "description",
|
|
"[owner]", ownerText,
|
|
"[members]", memberText,
|
|
"[level]", levelText,
|
|
"[place]", placeText);
|
|
|
|
builder.description(descriptionText.
|
|
replaceAll("(?m)^[ \\t]*\\r?\\n", "").
|
|
replaceAll("(?<!\\\\)\\|", "\n").
|
|
replace("\\\\\\|", "|")); // Not a regex - replace is more efficient
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Create viewer button panel item.
|
|
*
|
|
* @return PanelItem for PanelBuilder.
|
|
*/
|
|
private PanelItem createViewerButton(ItemTemplateRecord template, TemplatedPanel.ItemSlot itemSlot)
|
|
{
|
|
Island island = this.addon.getIslands().getIsland(this.world, this.user);
|
|
|
|
if (island == null || island.getOwner() == null)
|
|
{
|
|
// Player do not have an island.
|
|
return null;
|
|
}
|
|
|
|
int place = this.addon.getManager().getRank(this.world, this.user.getUniqueId());
|
|
long level = this.addon.getIslandLevel(this.world, island.getOwner());
|
|
|
|
IslandTopRecord topRecord = new IslandTopRecord(island, level);
|
|
|
|
return this.createIslandIcon(template, topRecord, place);
|
|
}
|
|
|
|
|
|
/**
|
|
* This method is used to open UserPanel outside this class. It will be much easier to open panel with single method
|
|
* call then initializing new object.
|
|
*
|
|
* @param addon Level Addon object
|
|
* @param user User who opens panel
|
|
* @param world World where gui is opened
|
|
* @param permissionPrefix Permission Prefix
|
|
*/
|
|
public static void openPanel(Level addon, User user, World world, String permissionPrefix)
|
|
{
|
|
new TopLevelPanel(addon, user, world, permissionPrefix).build();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Constants
|
|
// ---------------------------------------------------------------------
|
|
|
|
private static final String REFERENCE = "level.gui.buttons.island.";
|
|
private static final String PLAYER = "[player]";
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Record
|
|
// ---------------------------------------------------------------------
|
|
|
|
/**
|
|
* This record is used internally. It converts user -> level to island -> level.
|
|
*/
|
|
private record IslandTopRecord(Island island, Long level) {}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Variables
|
|
// ---------------------------------------------------------------------
|
|
|
|
/**
|
|
* This variable allows to access addon object.
|
|
*/
|
|
private final Level addon;
|
|
|
|
/**
|
|
* This variable holds user who opens panel. Without it panel cannot be opened.
|
|
*/
|
|
private final User user;
|
|
|
|
/**
|
|
* This variable holds a world to which gui referee.
|
|
*/
|
|
private final World world;
|
|
|
|
/**
|
|
* Location to icon permission.
|
|
*/
|
|
private final String iconPermission;
|
|
|
|
/**
|
|
* List of top 10 island records.
|
|
*/
|
|
private final List<IslandTopRecord> topIslands;
|
|
}
|