538 lines
26 KiB
Java
538 lines
26 KiB
Java
package de.lunarakai.minecleaner;
|
|
|
|
import de.iani.cubesidestats.api.SettingKey;
|
|
import de.lunarakai.minecleaner.utils.ChatUtils;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map.Entry;
|
|
import java.util.Objects;
|
|
import java.util.UUID;
|
|
import java.util.function.Consumer;
|
|
import java.util.logging.Level;
|
|
import net.kyori.adventure.text.Component;
|
|
import net.kyori.adventure.text.format.NamedTextColor;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.OfflinePlayer;
|
|
import org.bukkit.Sound;
|
|
import org.bukkit.World;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.event.inventory.InventoryType;
|
|
import org.bukkit.inventory.Inventory;
|
|
import org.bukkit.inventory.ItemStack;
|
|
import org.bukkit.scheduler.BukkitTask;
|
|
import org.jetbrains.annotations.NotNull;
|
|
import com.google.common.base.Preconditions;
|
|
import de.iani.cubesidestats.api.PlayerStatistics;
|
|
import de.iani.cubesidestats.api.PlayerStatisticsQueryKey;
|
|
import de.iani.cubesidestats.api.PlayerStatisticsQueryKey.QueryType;
|
|
import de.iani.cubesidestats.api.StatisticKey;
|
|
import de.iani.cubesidestats.api.StatisticsQueryKey;
|
|
import de.iani.cubesidestats.api.TimeFrame;
|
|
import de.iani.cubesideutils.bukkit.items.ItemStacks;
|
|
import de.iani.playerUUIDCache.CachedPlayer;
|
|
import de.lunarakai.minecleaner.game.BoardSize;
|
|
import de.lunarakai.minecleaner.utils.MinecleanerStringUtil;
|
|
import net.md_5.bungee.api.ChatColor;
|
|
|
|
public class MinecleanerManager {
|
|
private final MinecleanerPlugin plugin;
|
|
private final Inventory confirmPlayingInventory;
|
|
private final HashMap<Integer, String> sizes;
|
|
public BukkitTask schedulerGameOver;
|
|
|
|
// Statistics
|
|
private final StatisticKey statisticsWonGamesTotal;
|
|
private final StatisticKey statisticsPointsAcquired;
|
|
private final HashMap<Integer, StatisticKey> statisticsGames;
|
|
private final HashMap<Integer, StatisticKey> statisticsTimeRecord;
|
|
private final HashMap<Integer, StatisticKey> statisticsTotalGamesPlayed;
|
|
|
|
// Settings
|
|
|
|
private Inventory settingsInventory;
|
|
private SettingKey minecleanerSettingTimerKey;
|
|
private SettingKey minecleanerAdditionalDisplaySettingKey;
|
|
private SettingKey minecleanerResetTimerSettingKey;
|
|
private SettingKey minecleanerAllowManualResetSettingKey;
|
|
|
|
public MinecleanerManager(MinecleanerPlugin plugin) {
|
|
this.plugin = plugin;
|
|
|
|
this.sizes = new HashMap<>();
|
|
this.sizes.put(0, "klein");
|
|
this.sizes.put(1, "mittel");
|
|
this.sizes.put(2, "groß");
|
|
this.sizes.put(3, "experte");
|
|
|
|
this.confirmPlayingInventory = plugin.getServer().createInventory(null, InventoryType.HOPPER, plugin.getDisplayedPluginName() + " starten?");
|
|
this.confirmPlayingInventory.setItem(1, ItemStacks.rename(new ItemStack(Material.GREEN_CONCRETE), Component.text("Bestätigen", NamedTextColor.GREEN)));
|
|
this.confirmPlayingInventory.setItem(3, ItemStacks.rename(new ItemStack(Material.RED_CONCRETE), Component.text("Abbrechen", NamedTextColor.RED)));
|
|
|
|
// Settings
|
|
|
|
if(plugin.isStatisticsEnabled()) {
|
|
minecleanerSettingTimerKey = plugin.getCubesideStatistics().getSettingKey("minecleaner.settings.timer");
|
|
minecleanerSettingTimerKey.setDefault(0);
|
|
minecleanerSettingTimerKey.setDisplayName("Timer");
|
|
|
|
minecleanerAdditionalDisplaySettingKey = plugin.getCubesideStatistics().getSettingKey("minecleaner.settings.additionaldisplay");
|
|
minecleanerAdditionalDisplaySettingKey.setDefault(0);
|
|
minecleanerAdditionalDisplaySettingKey.setDisplayName("Zusätzliche Anzeige in der Action Bar");
|
|
|
|
minecleanerResetTimerSettingKey = plugin.getCubesideStatistics().getSettingKey("minecleaner.settings.resettime");
|
|
minecleanerResetTimerSettingKey.setDefault(5);
|
|
minecleanerResetTimerSettingKey.setDisplayName("Dauer die das Spielfeld für das Zurücksetzen brauchen soll");
|
|
|
|
minecleanerAllowManualResetSettingKey = plugin.getCubesideStatistics().getSettingKey("minecleaner.settings.allowmanualreset");
|
|
minecleanerAllowManualResetSettingKey.setDefault(0);
|
|
minecleanerAllowManualResetSettingKey.setDisplayName("Erlaube das manuelle Zurücksetzen des Spielfeldes");
|
|
|
|
this.settingsInventory = plugin.getServer().createInventory(null, InventoryType.CHEST,
|
|
plugin.getDisplayedPluginName() + " Einstellungen");
|
|
|
|
|
|
// Statistics
|
|
|
|
statisticsWonGamesTotal = plugin.getCubesideStatistics().getStatisticKey("minecleaner.wonGamestotal");
|
|
statisticsWonGamesTotal.setIsMonthlyStats(true);
|
|
statisticsWonGamesTotal.setDisplayName("Runden gewonnen");
|
|
|
|
statisticsPointsAcquired = plugin.getCubesideStatistics().getStatisticKey("minecleaner.pointstotal");
|
|
statisticsPointsAcquired.setIsMonthlyStats(true);
|
|
statisticsPointsAcquired.setDisplayName("Punkte erspielt");
|
|
|
|
statisticsGames = new HashMap<>();
|
|
statisticsTimeRecord = new HashMap<>();
|
|
statisticsTotalGamesPlayed = new HashMap<>();
|
|
|
|
for(Entry<Integer, String> e : this.sizes.entrySet()) {
|
|
String sizeDisplay = e.getValue();
|
|
StatisticKey s = plugin.getCubesideStatistics().getStatisticKey("minecleaner.wongames.boardsize." + e.getKey());
|
|
s.setIsMonthlyStats(true);
|
|
s.setDisplayName("Runden gewonnen auf Spielfeldgröße " + sizeDisplay);
|
|
statisticsGames.put(e.getKey(), s);
|
|
|
|
s = plugin.getCubesideStatistics().getStatisticKey("minecleaner.gamestotal.boardsize." + e.getKey());
|
|
s.setIsMonthlyStats(true);
|
|
s.setDisplayName("Runden gespielt auf Spielfeldgröße " + sizeDisplay );
|
|
statisticsTotalGamesPlayed.put(e.getKey(), s);
|
|
|
|
s = plugin.getCubesideStatistics().getStatisticKey("minecleaner.timerecord." + e.getKey());
|
|
s.setIsMonthlyStats(true);
|
|
s.setDisplayName("Bestzeit bei Größe " + sizeDisplay);
|
|
statisticsTimeRecord.put(e.getKey(), s);
|
|
}
|
|
} else {
|
|
this.statisticsWonGamesTotal = null;
|
|
this.statisticsPointsAcquired = null;
|
|
this.statisticsGames = null;
|
|
this.statisticsTimeRecord = null;
|
|
this.statisticsTotalGamesPlayed = null;
|
|
}
|
|
}
|
|
|
|
|
|
public void joinArena(Player[] players, MinecleanerArena arena) {
|
|
if ((plugin.getGroupManager().getGroup(players[0]) == null && !players[0].hasPermission(MinecleanerPlugin.PERMISSION_PLAY)) || (plugin.getGroupManager().getGroup(players[0]) != null && !Bukkit.getPlayer(plugin.getGroupManager().getGroup(players[0]).getOwner()).hasPermission(MinecleanerPlugin.PERMISSION_PLAY))) {
|
|
return;
|
|
}
|
|
|
|
Preconditions.checkArgument(plugin.getArenaList().getPlayerArena(players) == null, "player is in an arena");
|
|
Preconditions.checkArgument(arena.getArenaStatus() == ArenaStatus.INACTIVE, "arena is in use");
|
|
|
|
arena.addJoiningPlayers(players);
|
|
plugin.getArenaList().setArenaForPlayers(players, arena);
|
|
for(int i = 0; i < players.length; i++) {
|
|
if(plugin.getGroupManager().getGroup(players[i]) == null) {
|
|
players[i].openInventory(confirmPlayingInventory);
|
|
break;
|
|
}
|
|
if(players[i] == Bukkit.getPlayer(plugin.getGroupManager().getGroup(players[i]).getOwner())) {
|
|
players[i].openInventory(confirmPlayingInventory);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void leaveArena(Player[] players, boolean message, boolean reset) {
|
|
MinecleanerGroupManager.MinecleanerGroup group = null;
|
|
MinecleanerArena arena;
|
|
if(plugin.getGroupManager().getGroup(players[0]) != null) {
|
|
group = plugin.getGroupManager().getGroup(players[0]);
|
|
arena = plugin.getArenaList().getPlayerArena(Objects.requireNonNull(Bukkit.getPlayer(group.getOwner())));
|
|
} else {
|
|
arena = plugin.getArenaList().getPlayerArena(players);
|
|
}
|
|
Player[] players1 = group != null ? new Player[group.getPlayers().size()] : new Player[1];
|
|
if(plugin.getGroupManager().getGroup(players[0]) != null) {
|
|
int i = 0;
|
|
for(Iterator<UUID> iterator = group.getPlayers().iterator(); iterator.hasNext();) {
|
|
Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
|
|
players1[i] = iteratorPlayer;
|
|
i++;
|
|
}
|
|
} else {
|
|
players1 = players;
|
|
}
|
|
|
|
Preconditions.checkArgument(arena != null, "player is in no arena");
|
|
|
|
if(reset) {
|
|
arena.setArenaStaus(ArenaStatus.INACTIVE);
|
|
for(int i = 0; i < players1.length; i++) {
|
|
players1[i].closeInventory();
|
|
}
|
|
arena.removePlayers();
|
|
if(message) {
|
|
for(int i = 0; i < players.length; i++) {
|
|
players1[i].sendMessage(ChatColor.YELLOW + "Das " + plugin.getDisplayedPluginName() + "spiel wurde abgebrochen.");
|
|
}
|
|
}
|
|
}
|
|
|
|
plugin.getArenaList().setArenaForPlayers(players1, null);
|
|
}
|
|
|
|
|
|
public void startGame(Player[] players) {
|
|
MinecleanerArena arena = plugin.getArenaList().getPlayerArena(players);
|
|
Preconditions.checkArgument(arena != null, "player is in no arena");
|
|
Preconditions.checkState(arena.getArenaStatus() == ArenaStatus.CONFIRM_PLAYING, "not confirming playing status");
|
|
arena.startNewGame();
|
|
|
|
|
|
if(plugin.getGroupManager().getGroup(players[0]) != null) {
|
|
for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(players[0]).getPlayers().iterator(); iterator.hasNext();) {
|
|
Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
|
|
assert iteratorPlayer != null;
|
|
ChatUtils.sendSimpleInfoMessage(iteratorPlayer, "Du hast eine neue Runde " + plugin.getDisplayedPluginName() + " gestartet.");
|
|
}
|
|
} else {
|
|
ChatUtils.sendSimpleInfoMessage(players[0], "Du hast eine neue Runde " + plugin.getDisplayedPluginName() + " gestartet.");
|
|
}
|
|
}
|
|
|
|
public void handleGameover(Player[] player, MinecleanerArena arena, boolean isSuccessfullyCleared) {
|
|
|
|
if(plugin.getGroupManager().getGroup(player[0]) != null) {
|
|
World world = player[0].getWorld();
|
|
MinecleanerGroupManager.MinecleanerGroup group = plugin.getGroupManager().getGroup(player[0]);
|
|
|
|
if(!isSuccessfullyCleared) {
|
|
world.playSound(Bukkit.getPlayer(group.getOwner()).getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 0.5f, 0.5f);
|
|
for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player[0]).getPlayers().iterator(); iterator.hasNext();) {
|
|
Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
|
|
assert iteratorPlayer != null;
|
|
ChatUtils.sendSimpleInfoMessage(iteratorPlayer, "Game Over! Ihr konntest das " + plugin.getDisplayedPluginName() + "-Feld nicht erfolgreich lösen!");
|
|
if(plugin.isStatisticsEnabled()) {
|
|
|
|
PlayerStatistics ps = plugin.getCubesideStatistics().getStatistics(iteratorPlayer.getUniqueId());
|
|
ps.increaseScore(statisticsTotalGamesPlayed.get(arena.getWidthIndex()), 1);
|
|
}
|
|
}
|
|
|
|
arena.showMines();
|
|
scheduleArenaReset(Bukkit.getPlayer(plugin.getGroupManager().getGroup(player[0]).getOwner()), arena);
|
|
return;
|
|
}
|
|
|
|
int millis = (int) (System.currentTimeMillis() - arena.getCurrentGameStartTime());
|
|
|
|
|
|
world.playSound(Bukkit.getPlayer(group.getOwner()).getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 0.5f, 0.5f);
|
|
for(UUID currentPlayer : group.getPlayers()) {
|
|
|
|
Player iteratorPlayer = Bukkit.getPlayer(currentPlayer);
|
|
if(iteratorPlayer != null) {
|
|
iteratorPlayer.sendMessage(Component.text(
|
|
"Glückwunsch, ihr konntet das " + plugin.getDisplayedPluginName() + "-Feld in ", NamedTextColor.YELLOW)
|
|
.append(Component.text(MinecleanerStringUtil.timeToString(millis, false), NamedTextColor.RED))
|
|
.append(Component.text(" erfolgreich lösen!", NamedTextColor.YELLOW)));
|
|
}
|
|
|
|
|
|
if(!plugin.isStatisticsEnabled())
|
|
continue;
|
|
|
|
PlayerStatistics ps = plugin.getCubesideStatistics().getStatistics(currentPlayer);
|
|
ps.increaseScore(statisticsTotalGamesPlayed.get(arena.getWidthIndex()), 1);
|
|
ps.increaseScore(statisticsWonGamesTotal, 1);
|
|
ps.increaseScore(statisticsGames.get(arena.getWidthIndex()), 1);
|
|
|
|
int wIndex = arena.getWidthIndex();
|
|
increaseScore(wIndex, ps, group.getPlayers().size());
|
|
}
|
|
scheduleArenaReset(Bukkit.getPlayer(group.getOwner()), arena);
|
|
return;
|
|
}
|
|
|
|
World world = player[0].getWorld();
|
|
PlayerStatistics ps = null;
|
|
StatisticKey sg = null;
|
|
if(plugin.isStatisticsEnabled()) {
|
|
ps = plugin.getCubesideStatistics().getStatistics(player[0].getUniqueId());
|
|
sg = statisticsTotalGamesPlayed.get(arena.getWidthIndex());
|
|
}
|
|
|
|
if(!isSuccessfullyCleared) {
|
|
world.playSound(player[0].getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 0.5f, 0.5f);
|
|
ChatUtils.sendSimpleInfoMessage(player[0], "Game Over! Du konntest das " + plugin.getDisplayedPluginName() + "-Feld nicht erfolgreich lösen!");
|
|
arena.showMines();
|
|
|
|
if(sg != null && plugin.isStatisticsEnabled()) {
|
|
ps.increaseScore(sg, 1);
|
|
}
|
|
|
|
scheduleArenaReset(player[0], arena);
|
|
return;
|
|
}
|
|
int millis = (int) (System.currentTimeMillis() - arena.getCurrentGameStartTime());
|
|
|
|
world.playSound(player[0].getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 0.5f, 0.5f);
|
|
|
|
if(sg != null && plugin.isStatisticsEnabled()) {
|
|
ps.increaseScore(sg, 1);
|
|
}
|
|
|
|
if(plugin.isStatisticsEnabled()) {
|
|
ps.increaseScore(statisticsWonGamesTotal, 1);
|
|
|
|
sg = statisticsGames.get(arena.getWidthIndex());
|
|
if(sg != null) {
|
|
ps.increaseScore(sg, 1);
|
|
}
|
|
sg = statisticsTimeRecord.get(arena.getWidthIndex());
|
|
if(sg != null) {
|
|
ps.minScore(sg, millis, isUpdated -> {
|
|
if(isUpdated != null && isUpdated) {
|
|
player[0].sendMessage(ChatColor.GOLD + "Herzlichen Glückwunsch! Du hast eine neue Bestzeit erreicht! " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) );
|
|
} else {
|
|
player[0].sendMessage(ChatColor.YELLOW + "Glückwunsch, du konntest das " + plugin.getDisplayedPluginName() + "-Feld in " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) + ChatColor.YELLOW + " erfolgreich lösen!");
|
|
}
|
|
});
|
|
}
|
|
|
|
int wIndex = arena.getWidthIndex();
|
|
increaseScore(wIndex, ps, 1);
|
|
} else {
|
|
player[0].sendMessage(ChatColor.YELLOW + "Glückwunsch, du konntest das " + plugin.getDisplayedPluginName() + "-Feld in " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) + ChatColor.YELLOW + " erfolgreich lösen!");
|
|
}
|
|
|
|
scheduleArenaReset(player[0], arena);
|
|
}
|
|
|
|
private void increaseScore(int wIndex, PlayerStatistics ps, int groupSize) {
|
|
switch (wIndex) {
|
|
case 0: {
|
|
ps.increaseScore(statisticsPointsAcquired, (int) Math.floor((double) plugin.getConfig().getInt("winpoints.size.small") /groupSize));
|
|
break;
|
|
}
|
|
case 1: {
|
|
ps.increaseScore(statisticsPointsAcquired, (int) Math.floor((double) plugin.getConfig().getInt("winpoints.size.medium") /groupSize));
|
|
break;
|
|
}
|
|
case 2: {
|
|
ps.increaseScore(statisticsPointsAcquired, (int) Math.floor((double) plugin.getConfig().getInt("winpoints.size.large") /groupSize));
|
|
break;
|
|
}
|
|
case 3: {
|
|
ps.increaseScore(statisticsPointsAcquired, (int) Math.floor((double) plugin.getConfig().getInt("winpoints.size.expert") /groupSize));
|
|
break;
|
|
}
|
|
default: {
|
|
ps.increaseScore(statisticsPointsAcquired, 0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void scheduleArenaReset(Player player, MinecleanerArena arena) {
|
|
plugin.getLogger().log(Level.INFO, "scheduled reset for arena '" + arena.getName() + "', loc: " + arena.getLocation() + " ArenaStatus: " + arena.getArenaStatus() + " in " + plugin.getManager().getSettingsValue("resettime", player) * 20 + " ticks. Current Players: " + Arrays.toString(arena.getCurrentPlayers()));
|
|
Bukkit.getScheduler().runTaskLater(plugin, () -> {
|
|
plugin.getLogger().log(Level.INFO, "ArenaStatus for arena '" + arena.getName() + "', loc: " + arena.getLocation() + " after 5 Ticks (should be completed): " + arena.getArenaStatus());
|
|
}, 5L);
|
|
schedulerGameOver = Bukkit.getScheduler().runTaskLater(plugin, () -> {
|
|
if(arena.getArenaStatus() == ArenaStatus.COMPLETED) {
|
|
if (arena.getCurrentPlayers() == null) {
|
|
arena.removePlayers();
|
|
} else {
|
|
int arraySize = plugin.getGroupManager().getGroup(player) != null ? plugin.getGroupManager().getGroup(player).getPlayers().size() : 1;
|
|
Player[] players = new Player[arraySize];
|
|
int i = 0;
|
|
if(plugin.getGroupManager().getGroup(player) != null) {
|
|
for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
|
|
Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
|
|
players[i] = iteratorPlayer;
|
|
i++;
|
|
}
|
|
} else {
|
|
Arrays.fill(players, player);
|
|
}
|
|
leaveArena(players, false, true);
|
|
}
|
|
}
|
|
}, plugin.getManager().getSettingsValue("resettime", player) * 20L);
|
|
}
|
|
|
|
public void clearAllArenas() {
|
|
for(MinecleanerArena arena : plugin.getArenaList().getArenas()) {
|
|
if(arena.hasPlayers()) {
|
|
leaveArena(arena.getCurrentPlayers(), true, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void handleFieldClick(@NotNull Player player, int x, int y, boolean hasRightClicked) {
|
|
MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
|
|
Preconditions.checkArgument(arena != null, "player is in no arena");
|
|
Preconditions.checkState(arena.getArenaStatus() == ArenaStatus.PLAYING, "not running");
|
|
|
|
if(hasRightClicked) {
|
|
arena.flagCell(x, y);
|
|
} else {
|
|
arena.revealCell(x, y);
|
|
}
|
|
}
|
|
|
|
public void getStatisticsForPlayer(OfflinePlayer player, Consumer<PlayerStatisticsData> callback) {
|
|
List<StatisticsQueryKey> keys = new ArrayList<>();
|
|
PlayerStatistics pStatistics = plugin.getCubesideStatistics().getStatistics(player.getUniqueId());
|
|
|
|
PlayerStatisticsQueryKey kMatchesPlayed;
|
|
keys.add(kMatchesPlayed = new PlayerStatisticsQueryKey(pStatistics, statisticsWonGamesTotal, QueryType.SCORE));
|
|
PlayerStatisticsQueryKey kMatchesPlayedMonth;
|
|
keys.add(kMatchesPlayedMonth = new PlayerStatisticsQueryKey(pStatistics, statisticsWonGamesTotal, QueryType.SCORE, TimeFrame.MONTH));
|
|
|
|
HashMap<Integer, PlayerStatisticsQueryKey> kWonGamesPlayedSize = new HashMap<>();
|
|
HashMap<Integer, PlayerStatisticsQueryKey> kWonGamesPlayedSizeMonth = new HashMap<>();
|
|
HashMap<Integer, PlayerStatisticsQueryKey> kSizeTimeRecord = new HashMap<>();
|
|
HashMap<Integer, PlayerStatisticsQueryKey> kSizeTimeRecordMonth = new HashMap<>();
|
|
HashMap<Integer, PlayerStatisticsQueryKey> kSizeTotalGamesPlayed = new HashMap<>();
|
|
HashMap<Integer, PlayerStatisticsQueryKey> kSizeTotalGamesPlayedMonth = new HashMap<>();
|
|
|
|
for (int i = 0; i < BoardSize.boardSizesWidth.length; i++) {
|
|
PlayerStatisticsQueryKey qk;
|
|
StatisticKey statisticKeyGames = statisticsGames.get(i);
|
|
keys.add(qk = new PlayerStatisticsQueryKey(pStatistics, statisticKeyGames, QueryType.SCORE));
|
|
kWonGamesPlayedSize.put(i, qk);
|
|
keys.add(qk = new PlayerStatisticsQueryKey(pStatistics, statisticKeyGames, QueryType.SCORE, TimeFrame.MONTH));
|
|
kWonGamesPlayedSizeMonth.put(i, qk);
|
|
|
|
StatisticKey statisticKeyTotalGames = statisticsTotalGamesPlayed.get(i);
|
|
keys.add(qk = new PlayerStatisticsQueryKey(pStatistics, statisticKeyTotalGames, QueryType.SCORE));
|
|
kSizeTotalGamesPlayed.put(i, qk);
|
|
keys.add(qk = new PlayerStatisticsQueryKey(pStatistics, statisticKeyTotalGames, QueryType.SCORE, TimeFrame.MONTH));
|
|
kSizeTotalGamesPlayedMonth.put(i, qk);
|
|
|
|
StatisticKey statisticKeyTime = statisticsTimeRecord.get(i);
|
|
keys.add(qk = new PlayerStatisticsQueryKey(pStatistics, statisticKeyTime, QueryType.SCORE));
|
|
kSizeTimeRecord.put(i, qk);
|
|
keys.add(qk = new PlayerStatisticsQueryKey(pStatistics, statisticKeyTime, QueryType.SCORE, TimeFrame.MONTH));
|
|
kSizeTimeRecordMonth.put(i, qk);
|
|
}
|
|
|
|
PlayerStatisticsQueryKey kPointsAcquired;
|
|
keys.add(kPointsAcquired = new PlayerStatisticsQueryKey(pStatistics, statisticsPointsAcquired, QueryType.SCORE));
|
|
PlayerStatisticsQueryKey kPointsAcquiredMonth;
|
|
keys.add(kPointsAcquiredMonth = new PlayerStatisticsQueryKey(pStatistics, statisticsPointsAcquired, QueryType.SCORE, TimeFrame.MONTH));
|
|
|
|
plugin.getCubesideStatistics().queryStats(keys, (c) -> {
|
|
int matchesPlayed = c.getOrDefault(kMatchesPlayed, 0);
|
|
int matchesPlayedMonth = c.getOrDefault(kMatchesPlayedMonth, 0);
|
|
int pointsAcquiredTotal = c.getOrDefault(kPointsAcquired, 0);
|
|
int pointsAcquiredMonth = c.getOrDefault(kPointsAcquiredMonth, 0);
|
|
|
|
HashMap<Integer, Integer> sizeWonGames = new HashMap<>();
|
|
HashMap<Integer, Integer> sizeWonGamesMonth = new HashMap<>();
|
|
HashMap<Integer, Integer> sizeTimeRecord = new HashMap<>();
|
|
HashMap<Integer, Integer> sizeTimeRecordMonth = new HashMap<>();
|
|
HashMap<Integer, Integer> sizeTotalGamesPlayed = new HashMap<>();
|
|
HashMap<Integer, Integer> sizeTotalGamesPlayedMonth = new HashMap<>();
|
|
|
|
for(int i = 0; i < BoardSize.boardSizesWidth.length; i++) {
|
|
sizeWonGames.put(i, c.getOrDefault(kWonGamesPlayedSize.get(i), 0));
|
|
sizeWonGamesMonth.put(i, c.getOrDefault(kWonGamesPlayedSizeMonth.get(i), 0));
|
|
sizeTimeRecord.put(i, c.getOrDefault(kSizeTimeRecord.get(i), null));
|
|
sizeTimeRecordMonth.put(i, c.getOrDefault(kSizeTimeRecordMonth.get(i), null));
|
|
sizeTotalGamesPlayed.put(i, c.getOrDefault(kSizeTotalGamesPlayed.get(i), 0));
|
|
sizeTotalGamesPlayedMonth.put(i, c.getOrDefault(kSizeTotalGamesPlayedMonth.get(i), 0));
|
|
}
|
|
|
|
callback.accept(new PlayerStatisticsData(player.getUniqueId(), player.getName(),
|
|
sizeTotalGamesPlayed,
|
|
sizeTotalGamesPlayedMonth,
|
|
matchesPlayed,
|
|
matchesPlayedMonth,
|
|
sizeWonGames,
|
|
sizeWonGamesMonth,
|
|
pointsAcquiredTotal,
|
|
pointsAcquiredMonth,
|
|
sizeTimeRecord,
|
|
sizeTimeRecordMonth));
|
|
});
|
|
}
|
|
|
|
public void getStatisticsForPlayerIfExists(String player, Consumer<PlayerStatisticsData> callback) {
|
|
CachedPlayer cPlayer = plugin.getPlayerUUIDCache().getPlayerFromNameOrUUID(player);
|
|
if(cPlayer == null) {
|
|
callback.accept(null);
|
|
} else {
|
|
getStatisticsForPlayer(cPlayer, callback);
|
|
}
|
|
}
|
|
|
|
public void deleteScores(UUID playerId) {
|
|
PlayerStatistics statsPlayer = plugin.getCubesideStatistics().getStatistics(playerId);
|
|
statsPlayer.deleteScore(statisticsWonGamesTotal);
|
|
statsPlayer.deleteScore(statisticsPointsAcquired);
|
|
for(StatisticKey statsKey : statisticsGames.values()) {
|
|
statsPlayer.deleteScore(statsKey);
|
|
}
|
|
for(StatisticKey statsKey : statisticsTimeRecord.values()) {
|
|
statsPlayer.deleteScore(statsKey);
|
|
}
|
|
for(StatisticKey statsKey : statisticsTotalGamesPlayed.values()) {
|
|
statsPlayer.deleteScore(statsKey);
|
|
}
|
|
}
|
|
|
|
public int getSettingsValue(String settingsKeyString, Player player) {
|
|
PlayerStatistics playerStatistics = plugin.getCubesideStatistics().getStatistics(player.getUniqueId());
|
|
SettingKey settingKey = plugin.getCubesideStatistics().getSettingKey("minecleaner.settings." + settingsKeyString);
|
|
|
|
return playerStatistics.getSettingValueOrDefault(settingKey);
|
|
}
|
|
|
|
public void updateSettingsValue(String settingsKeyString, int newValue, Player player) {
|
|
PlayerStatistics playerStatistics = plugin.getCubesideStatistics().getStatistics(player.getUniqueId());
|
|
SettingKey settingKey = plugin.getCubesideStatistics().getSettingKey("minecleaner.settings." + settingsKeyString);
|
|
playerStatistics.setSettingValue(settingKey, newValue);
|
|
}
|
|
|
|
public HashMap<Integer, String> getSizes() {
|
|
return sizes;
|
|
}
|
|
|
|
public Inventory getConfirmPlayingInventory() {
|
|
return confirmPlayingInventory;
|
|
}
|
|
|
|
public Inventory getSettingsInventory() {
|
|
return settingsInventory;
|
|
}
|
|
|
|
public SettingKey getMinecleanerSettingTimerKey() {
|
|
return minecleanerSettingTimerKey;
|
|
}
|
|
|
|
public SettingKey getMinecleanerAdditionalDisplaySettingKey() {
|
|
return minecleanerAdditionalDisplaySettingKey;
|
|
}
|
|
|
|
public SettingKey getMinecleanerResetTimeSettingKey() {return minecleanerResetTimerSettingKey; }
|
|
|
|
public BukkitTask getSchedulerGameOver() { return schedulerGameOver; }
|
|
}
|