okx-code
139 lines
3.9 KiB
Java
139 lines
3.9 KiB
Java
package sh.okx.rankup.ranks;
|
|
|
|
import lombok.AccessLevel;
|
|
import lombok.Getter;
|
|
import lombok.RequiredArgsConstructor;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.configuration.ConfigurationSection;
|
|
import org.bukkit.entity.Player;
|
|
import sh.okx.rankup.Rankup;
|
|
import sh.okx.rankup.messages.MessageBuilder;
|
|
import sh.okx.rankup.messages.Variable;
|
|
import sh.okx.rankup.ranks.requirements.Requirement;
|
|
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.function.BinaryOperator;
|
|
|
|
@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
|
|
public class Rank {
|
|
private final Rankup plugin;
|
|
@Getter
|
|
private final String name;
|
|
@Getter
|
|
private final String next;
|
|
@Getter
|
|
private final String rank;
|
|
private final Set<Requirement> requirements;
|
|
private final BinaryOperator<Boolean> reducer;
|
|
private final List<String> commands;
|
|
|
|
public static Rank deserialize(Rankup plugin, ConfigurationSection section) {
|
|
String rank = section.getString("rank");
|
|
|
|
Set<Requirement> requirements = new HashSet<>();
|
|
BinaryOperator<Boolean> reducer = null;
|
|
ConfigurationSection requirementsSection = section.getConfigurationSection("requirements");
|
|
if(requirementsSection != null) {
|
|
for (Map.Entry<String, Object> entry : requirementsSection.getValues(false).entrySet()) {
|
|
String name = entry.getKey();
|
|
double amount = Double.parseDouble(String.valueOf(entry.getValue()));
|
|
|
|
Requirement requirement = plugin.getRequirementRegistry().newRequirement(name, amount);
|
|
if (requirement == null) {
|
|
plugin.getLogger().warning("Unknown requirement " + name);
|
|
} else {
|
|
requirements.add(requirement);
|
|
}
|
|
}
|
|
|
|
String operation = section.getString("operation");
|
|
if (operation == null) {
|
|
operation = "and";
|
|
}
|
|
switch (operation) {
|
|
case "and":
|
|
reducer = (a, b) -> a && b;
|
|
break;
|
|
case "or":
|
|
reducer = (a, b) -> a || b;
|
|
break;
|
|
case "xor":
|
|
reducer = (a, b) -> (a && !b) || (b && !a);
|
|
break;
|
|
case "none":
|
|
reducer = (a, b) -> !a && !b;
|
|
break;
|
|
default:
|
|
throw new IllegalArgumentException("Invalid operation type for rank " + rank);
|
|
}
|
|
}
|
|
|
|
return new Rank(plugin,
|
|
section.getName(),
|
|
section.getString("next"),
|
|
rank,
|
|
requirements,
|
|
reducer,
|
|
section.getStringList("commands"));
|
|
}
|
|
|
|
public boolean checkRequirements(Player player) {
|
|
return requirements.stream()
|
|
.map(requirement -> requirement.check(player))
|
|
.reduce(reducer)
|
|
.orElse(true);
|
|
}
|
|
|
|
public boolean isInRank(Player player) {
|
|
String[] groups = plugin.getPermissions().getPlayerGroups(player);
|
|
for (String group : groups) {
|
|
if(group.equalsIgnoreCase(rank)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isLastRank() {
|
|
return next == null;
|
|
}
|
|
|
|
public Requirement getRequirement(String name) {
|
|
for(Requirement requirement : requirements) {
|
|
if(requirement.getName().equalsIgnoreCase(name)) {
|
|
return requirement;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void applyRequirements(Player player) {
|
|
for(Requirement requirement : requirements) {
|
|
requirement.apply(player);
|
|
}
|
|
}
|
|
|
|
public void runCommands(Player player, Rank nextRank) {
|
|
for (String command : commands) {
|
|
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), new MessageBuilder(command)
|
|
.replace(Variable.PLAYER, player.getName())
|
|
.replace(Variable.OLD_RANK, rank)
|
|
.replace(Variable.OLD_RANK_NAME, name)
|
|
.replace(Variable.RANK, nextRank.rank)
|
|
.replace(Variable.RANK_NAME, nextRank.name)
|
|
.toString());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if(!(o instanceof Rank)) {
|
|
return false;
|
|
}
|
|
return ((Rank) o).name.equals(name);
|
|
}
|
|
}
|