file_name stringlengths 6 86 | file_path stringlengths 45 249 | content stringlengths 47 6.26M | file_size int64 47 6.26M | language stringclasses 1 value | extension stringclasses 1 value | repo_name stringclasses 767 values | repo_stars int64 8 14.4k | repo_forks int64 0 1.17k | repo_open_issues int64 0 788 | repo_created_at stringclasses 767 values | repo_pushed_at stringclasses 767 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
SpectatorFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/spectator/SpectatorFeature.java | package me.patothebest.gamecore.feature.features.spectator;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.command.ChatColor;
import me.patothebest.gamecore.event.player.SpectateEvent;
import me.patothebest.gamecore.guis.user.SpectatorUI;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.title.Title;
import me.patothebest.gamecore.title.TitleManager;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerInteractEvent;
public class SpectatorFeature extends AbstractFeature {
private final CorePlugin plugin;
private final PlayerManager playerManager;
private final PluginScheduler pluginScheduler;
@Inject private SpectatorFeature(CorePlugin plugin, PlayerManager playerManager, PluginScheduler pluginScheduler) {
this.plugin = plugin;
this.playerManager = playerManager;
this.pluginScheduler = pluginScheduler;
}
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event) {
if (!isSpectating(event.getPlayer())) {
return;
}
if (event.getItem() == null) {
return;
}
if (event.getItem().getType() == null) {
return;
}
switch (event.getItem().getType()) {
case COMPASS:
new SpectatorUI(plugin, event.getPlayer(), arena);
break;
case MAGMA_CREAM:
arena.removePlayer(event.getPlayer());
break;
default:
event.setCancelled(true);
break;
}
}
@EventHandler
public void onPlayerStateChange(SpectateEvent event) {
Player player = event.getPlayer();
player.getInventory().setItem(0, new ItemStackBuilder().material(Material.COMPASS).name(ChatColor.GREEN + "Spectate"));
player.getInventory().setItem(8, new ItemStackBuilder().material(Material.MAGMA_CREAM).name(ChatColor.RED + "Leave"));
pluginScheduler.runTaskLater(() -> {
if(!player.isOnline()) {
return;
}
Title title = TitleManager.newInstance(CoreLang.DEATH_TITLE.getMessage(player));
title.setSubtitle(CoreLang.DEATH_SUBTITLE.getMessage(player));
title.setFadeInTime(0);
title.setFadeOutTime(1);
title.setStayTime(2);
title.send(player);
}, 1L);
}
private boolean isSpectating(Player player) {
return playerManager.getPlayer(player).getCurrentArena() != null && playerManager.getPlayer(player).getCurrentArena() == arena && playerManager.getPlayer(player).getCurrentArena().getSpectators().contains(player);
}
} | 3,071 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DeathSpectatorFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/spectator/DeathSpectatorFeature.java | package me.patothebest.gamecore.feature.features.spectator;
import com.google.inject.Inject;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.util.Vector;
public class DeathSpectatorFeature extends AbstractFeature {
private final PluginScheduler pluginScheduler;
@Inject private DeathSpectatorFeature(PluginScheduler pluginScheduler) {
this.pluginScheduler = pluginScheduler;
}
@EventHandler
public void onDeath(CombatDeathEvent event) {
if (!isPlayingInArena(event)) {
return;
}
Player player = event.getPlayer();
player.setHealth(20);
player.setFallDistance(0);
player.setVelocity(new Vector(0, 0, 0));
boolean shouldTeleport = false;
if(event.getPlayer().getLocation().getY() < 1 || !arena.getArea().contains(event.getPlayer().getLocation())) {
shouldTeleport = true;
event.getDrops().clear();
} else {
switch (event.getDeathCause()) {
case BORDER:
case OUT_OF_WORLD:
event.getDrops().clear();
case FALLING_BLOCK:
case IN_WALL:
shouldTeleport = true;
break;
}
}
arena.changeToSpectator(event.getPlayer(), shouldTeleport);
arena.checkWin();
event.setCancelled(true);
}
} | 1,611 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameOptionsGUIFactory.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/GameOptionsGUIFactory.java | package me.patothebest.gamecore.feature.features.gameoptions;
import me.patothebest.gamecore.feature.features.gameoptions.time.TimeSelectorGameOption;
import me.patothebest.gamecore.feature.features.gameoptions.time.TimeVoteUI;
import me.patothebest.gamecore.feature.features.gameoptions.weather.WeatherSelectorGameOption;
import me.patothebest.gamecore.feature.features.gameoptions.weather.WeatherVoteUI;
import org.bukkit.entity.Player;
public interface GameOptionsGUIFactory {
WeatherVoteUI openWeatherUI(Player player, WeatherSelectorGameOption weatherSelectorGameOption);
TimeVoteUI openTimeUI(Player player, TimeSelectorGameOption timeSelectorGameOption);
}
| 677 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameOption.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/GameOption.java | package me.patothebest.gamecore.feature.features.gameoptions;
import me.patothebest.gamecore.feature.Feature;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import org.bukkit.entity.Player;
public interface GameOption extends Feature {
SimpleButton getButton(Player player);
}
| 304 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameOptionsFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/GameOptionsFeature.java | package me.patothebest.gamecore.feature.features.gameoptions;
import com.google.inject.Inject;
import me.patothebest.gamecore.guis.UserGUIFactory;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.event.player.LobbyJoinEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.phase.Phase;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import java.util.HashMap;
import java.util.Map;
public class GameOptionsFeature extends AbstractFeature {
private final Map<Integer, GameOption> buttonsInMenu = new HashMap<>();
private final UserGUIFactory userGUIFactory;
private int slot = 4;
@Inject private GameOptionsFeature(UserGUIFactory userGUIFactory) {
this.userGUIFactory = userGUIFactory;
}
public <T extends GameOption> void registerGameOption(Phase<?> phase, Class<T> gameOptionClass, int slot) {
T gameOption = arena.createFeature(gameOptionClass);
phase.getFeatures().put(gameOptionClass, gameOption);
buttonsInMenu.put(slot, gameOption);
}
@EventHandler
public void onArenaJoin(LobbyJoinEvent event) {
if(!isPlayingInArena(event.getPlayer())) {
return;
}
event.getPlayer().getInventory().setItem(slot, new ItemStackBuilder().material(Material.CHEST).name(event.getPlayer(), CoreLang.LOBBY_GAME_OPTIONS));
}
@SuppressWarnings("deprecation")
@EventHandler
public void onInteract(PlayerInteractEvent event) {
if(!isPlayingInArena(event)) {
return;
}
if(event.getPlayer().getItemInHand() == null) {
return;
}
switch (event.getPlayer().getItemInHand().getType()) {
case CHEST:
userGUIFactory.openGameOptions(event.getPlayer(), this);
break;
default:
}
}
@EventHandler
public void onInventoryClick(InventoryClickEvent event) {
if(!isPlayingInArena(event)) {
return;
}
if(event.getCurrentItem() == null) {
return;
}
switch (event.getCurrentItem().getType()) {
case CHEST:
userGUIFactory.openGameOptions((Player) event.getWhoClicked(), this);
break;
default:
}
event.setCancelled(true);
}
public Map<Integer, GameOption> getButtonsInMenu() {
return buttonsInMenu;
}
/**
* Sets the slot
*/
public void setSlot(int slot) {
this.slot = slot;
}
}
| 2,806 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WalkTrailSelectorGameOption.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/individual/WalkTrailSelectorGameOption.java | package me.patothebest.gamecore.feature.features.gameoptions.individual;
import com.google.inject.Inject;
import me.patothebest.gamecore.cosmetics.shop.ShopFactory;
import me.patothebest.gamecore.cosmetics.walkparticles.WalkTrailsManager;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.feature.features.gameoptions.GameOption;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import org.bukkit.entity.Player;
public class WalkTrailSelectorGameOption extends AbstractFeature implements GameOption {
private final ShopFactory shopFactory;
private final WalkTrailsManager walkTrailsManager;
@Inject private WalkTrailSelectorGameOption(ShopFactory shopFactory, WalkTrailsManager walkTrailsManager) {
this.shopFactory = shopFactory;
this.walkTrailsManager = walkTrailsManager;
}
@Override
public SimpleButton getButton(Player player) {
return new SimpleButton(new ItemStackBuilder().material(Material.REDSTONE).name(CoreLang.LOBBY_WALK_TRAIL_MENU.getMessage(player))).action(() -> {
shopFactory.createShopMenu(player, walkTrailsManager);
});
}
}
| 1,331 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CageSelectorGameOption.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/individual/CageSelectorGameOption.java | package me.patothebest.gamecore.feature.features.gameoptions.individual;
import com.google.inject.Inject;
import me.patothebest.gamecore.cosmetics.cage.CageManager;
import me.patothebest.gamecore.cosmetics.shop.ShopFactory;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.feature.features.gameoptions.GameOption;
import org.bukkit.entity.Player;
public class CageSelectorGameOption extends AbstractFeature implements GameOption {
private final ShopFactory shopFactory;
private final CageManager cageManager;
@Inject private CageSelectorGameOption(ShopFactory shopFactory, CageManager cageManager) {
this.shopFactory = shopFactory;
this.cageManager = cageManager;
}
@Override
public SimpleButton getButton(Player player) {
return new SimpleButton(new ItemStackBuilder().material(Material.GLASS).name(CoreLang.LOBBY_CAGE_MENU.getMessage(player))).action(() -> {
shopFactory.createShopMenu(player, cageManager);
});
}
}
| 1,255 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ProjectileTrailSelectorGameOption.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/individual/ProjectileTrailSelectorGameOption.java | package me.patothebest.gamecore.feature.features.gameoptions.individual;
import com.google.inject.Inject;
import me.patothebest.gamecore.cosmetics.projectiletrails.ProjectileManager;
import me.patothebest.gamecore.cosmetics.shop.ShopFactory;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.feature.features.gameoptions.GameOption;
import org.bukkit.entity.Player;
public class ProjectileTrailSelectorGameOption extends AbstractFeature implements GameOption {
private final ShopFactory shopFactory;
private final ProjectileManager arrowManager;
@Inject private ProjectileTrailSelectorGameOption(ShopFactory shopFactory, ProjectileManager arrowManager) {
this.shopFactory = shopFactory;
this.arrowManager = arrowManager;
}
@Override
public SimpleButton getButton(Player player) {
return new SimpleButton(new ItemStackBuilder().material(Material.BLAZE_POWDER).name(CoreLang.LOBBY_PROJECTILE_TRAIL_MENU.getMessage(player))).action(() -> {
shopFactory.createShopMenu(player, arrowManager);
});
}
}
| 1,331 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WeatherSelectorGameOption.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/weather/WeatherSelectorGameOption.java | package me.patothebest.gamecore.feature.features.gameoptions.weather;
import com.google.inject.Inject;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.event.arena.ArenaPrePhaseChangeEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.feature.features.gameoptions.GameOption;
import me.patothebest.gamecore.feature.features.gameoptions.GameOptionsGUIFactory;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import java.util.HashMap;
import java.util.Map;
public class WeatherSelectorGameOption extends AbstractFeature implements GameOption {
private final Map<Player, WeatherType> weatherVoting = new HashMap<>();
private final GameOptionsGUIFactory gameOptionsGUIFactory;
@Inject private WeatherSelectorGameOption(GameOptionsGUIFactory gameOptionsGUIFactory) {
this.gameOptionsGUIFactory = gameOptionsGUIFactory;
}
@Override
public void initializeFeature() {
super.initializeFeature();
weatherVoting.clear();
}
@EventHandler
public void onArenaLeave(ArenaLeaveEvent event) {
weatherVoting.remove(event.getPlayer());
}
@EventHandler
public void onArenaPhasePreChangeEvent(ArenaPrePhaseChangeEvent event) {
if(event.getNewPhase() != arena.getNextPhase()) {
return;
}
if(event.getArena() != arena) {
return;
}
Map.Entry<WeatherType, Integer> maxEntry = null;
if(!weatherVoting.isEmpty()) {
Map<WeatherType, Integer> voteMapResults = new HashMap<>();
for (Map.Entry<Player, WeatherType> playerWeatherTypeEntry : weatherVoting.entrySet()) {
voteMapResults.putIfAbsent(playerWeatherTypeEntry.getValue(), 0);
Integer vote = voteMapResults.remove(playerWeatherTypeEntry.getValue());
vote++;
voteMapResults.put(playerWeatherTypeEntry.getValue(), vote);
}
for (Map.Entry<WeatherType, Integer> entry : voteMapResults.entrySet()) {
if(maxEntry == null || entry.getValue().compareTo(maxEntry.getValue()) > 0) {
maxEntry = entry;
}
}
}
arena.getWorld().setStorm(maxEntry != null && maxEntry.getKey().isStorm());
arena.getWorld().setWeatherDuration(Integer.MAX_VALUE);
}
@Override
public SimpleButton getButton(Player player) {
return new SimpleButton(new ItemStackBuilder().material(Material.LILY_PAD).name(player, CoreLang.GUI_WEATHER_ITEM)).action(() -> {
if(!player.hasPermission(Permission.CHOOSE_WEATHER.getBukkitPermission())) {
CoreLang.GUI_WEATHER_NO_PERMISSION.sendMessage(player);
return;
}
gameOptionsGUIFactory.openWeatherUI(player, this);
});
}
public Map<Player, WeatherType> getWeatherVoting() {
return weatherVoting;
}
}
| 3,293 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WeatherType.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/weather/WeatherType.java | package me.patothebest.gamecore.feature.features.gameoptions.weather;
import me.patothebest.gamecore.itemstack.StainedClay;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.lang.interfaces.ILang;
import org.bukkit.inventory.ItemStack;
public enum WeatherType {
SUN(CoreLang.GUI_WEATHER_VOTE_SUN, StainedClay.YELLOW, false, 2),
RAIN(CoreLang.GUI_WEATHER_VOTE_RAIN, StainedClay.LIGHT_BLUE, true, 6);
private final ILang langMessage;
private final ItemStack stainedClay;
private final boolean storm;
private final int slot;
WeatherType(ILang langMessage, ItemStack stainedClay, boolean storm, int slot) {
this.langMessage = langMessage;
this.stainedClay = stainedClay;
this.storm = storm;
this.slot = slot;
}
public ILang getLangMessage() {
return langMessage;
}
public ItemStack getItem() {
return stainedClay;
}
public boolean isStorm() {
return storm;
}
public int getSlot() {
return slot;
}
}
| 1,059 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WeatherVoteUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/weather/WeatherVoteUI.java | package me.patothebest.gamecore.feature.features.gameoptions.weather;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import org.bukkit.entity.Player;
public class WeatherVoteUI extends GUIPage {
private final WeatherSelectorGameOption weatherSelectorGameOption;
@Inject private WeatherVoteUI(CorePlugin plugin, @Assisted Player player, @Assisted WeatherSelectorGameOption weatherSelectorGameOption) {
super(plugin, player, CoreLang.GUI_WEATHER_VOTE_TITLE.getMessage(player), 9);
this.weatherSelectorGameOption = weatherSelectorGameOption;
build();
}
@Override
protected void buildPage() {
WeatherType selectedWeather = weatherSelectorGameOption.getWeatherVoting().get(getPlayer());
for (WeatherType weatherType : WeatherType.values()) {
addButton(new SimpleButton(new ItemStackBuilder(weatherType.getItem())
.name(weatherType.getLangMessage().getMessage(getPlayer()))
.lore(selectedWeather == weatherType ? CoreLang.GUI_SHOP_SELECTED.getMessage(getPlayer()) : CoreLang.GUI_SHOP_CLICK_TO_SELECT.getMessage(getPlayer()))
.glowing(selectedWeather == weatherType))
.action(() -> {
weatherSelectorGameOption.getWeatherVoting().remove(player);
CoreLang.GUI_WEATHER_VOTE_VOTED.replaceAndSend(player, weatherType.getLangMessage());
weatherSelectorGameOption.getWeatherVoting().put(player, weatherType);
refresh();
}), weatherType.getSlot());
}
}
}
| 1,931 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TimeSelectorGameOption.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/time/TimeSelectorGameOption.java | package me.patothebest.gamecore.feature.features.gameoptions.time;
import com.google.inject.Inject;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.event.arena.ArenaPrePhaseChangeEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.feature.features.gameoptions.GameOption;
import me.patothebest.gamecore.feature.features.gameoptions.GameOptionsGUIFactory;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import java.util.HashMap;
import java.util.Map;
public class TimeSelectorGameOption extends AbstractFeature implements GameOption {
private final Map<Player, TimeOfTheDay> weatherVoting = new HashMap<>();
private final GameOptionsGUIFactory gameOptionsGUIFactory;
@Inject private TimeSelectorGameOption(GameOptionsGUIFactory gameOptionsGUIFactory) {
this.gameOptionsGUIFactory = gameOptionsGUIFactory;
}
@Override
public void initializeFeature() {
super.initializeFeature();
weatherVoting.clear();
}
@EventHandler
public void onArenaLeave(ArenaLeaveEvent event) {
weatherVoting.remove(event.getPlayer());
}
@EventHandler
public void onArenaPhasePreChangeEvent(ArenaPrePhaseChangeEvent event) {
if(event.getNewPhase() != arena.getNextPhase()) {
return;
}
if(event.getArena() != arena) {
return;
}
Map.Entry<TimeOfTheDay, Integer> maxEntry = null;
if(!weatherVoting.isEmpty()) {
Map<TimeOfTheDay, Integer> voteMapResults = new HashMap<>();
for (Map.Entry<Player, TimeOfTheDay> playerWeatherTypeEntry : weatherVoting.entrySet()) {
voteMapResults.putIfAbsent(playerWeatherTypeEntry.getValue(), 0);
Integer vote = voteMapResults.remove(playerWeatherTypeEntry.getValue());
vote++;
voteMapResults.put(playerWeatherTypeEntry.getValue(), vote);
}
for (Map.Entry<TimeOfTheDay, Integer> entry : voteMapResults.entrySet()) {
if(maxEntry == null || entry.getValue().compareTo(maxEntry.getValue()) > 0) {
maxEntry = entry;
}
}
}
arena.getWorld().setTime(maxEntry != null ? maxEntry.getKey().getTime() : 6000);
arena.getWorld().setGameRuleValue("doDaylightCycle", "false");
}
@Override
public SimpleButton getButton(Player player) {
return new SimpleButton(new ItemStackBuilder().material(Material.CLOCK).name(player, CoreLang.GUI_TIME_ITEM)).action(() -> {
if(!player.hasPermission(Permission.CHOOSE_TIME.getBukkitPermission())) {
CoreLang.GUI_TIME_NO_PERMISSION.sendMessage(player);
return;
}
gameOptionsGUIFactory.openTimeUI(player, this);
});
}
public Map<Player, TimeOfTheDay> getTimeVoting() {
return weatherVoting;
}
}
| 3,284 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TimeOfTheDay.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/time/TimeOfTheDay.java | package me.patothebest.gamecore.feature.features.gameoptions.time;
import me.patothebest.gamecore.itemstack.StainedClay;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.lang.interfaces.ILang;
import org.bukkit.inventory.ItemStack;
public enum TimeOfTheDay {
MORNING(CoreLang.GUI_TIME_VOTE_MORNING, StainedClay.YELLOW, 0, 1),
NOON(CoreLang.GUI_TIME_VOTE_NOON, StainedClay.ORANGE, 6000, 3),
SUNSET(CoreLang.GUI_TIME_VOTE_SUNSET, StainedClay.LIGHT_GRAY, 12000, 5),
MIDNIGHT(CoreLang.GUI_TIME_VOTE_MIDNIGHT, StainedClay.GRAY, 18000, 7);
private final ILang langMessage;
private final ItemStack stainedClay;
private final int time;
private final int slot;
TimeOfTheDay(ILang langMessage, ItemStack stainedClay, int time, int slot) {
this.langMessage = langMessage;
this.stainedClay = stainedClay;
this.time = time;
this.slot = slot;
}
public ILang getLangMessage() {
return langMessage;
}
public ItemStack getItem() {
return stainedClay;
}
public int getTime() {
return time;
}
public int getSlot() {
return slot;
}
}
| 1,187 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TimeVoteUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/gameoptions/time/TimeVoteUI.java | package me.patothebest.gamecore.feature.features.gameoptions.time;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import org.bukkit.entity.Player;
public class TimeVoteUI extends GUIPage {
private final TimeSelectorGameOption timeSelectorGameOption;
@Inject private TimeVoteUI(CorePlugin plugin, @Assisted Player player, @Assisted TimeSelectorGameOption timeSelectorGameOption) {
super(plugin, player, CoreLang.GUI_TIME_VOTE_TITLE.getMessage(player), 9);
this.timeSelectorGameOption = timeSelectorGameOption;
build();
}
@Override
protected void buildPage() {
TimeOfTheDay selectedTimeOfTheDay = timeSelectorGameOption.getTimeVoting().get(getPlayer());
for (TimeOfTheDay timeOfTheDay : TimeOfTheDay.values()) {
addButton(new SimpleButton(new ItemStackBuilder(timeOfTheDay.getItem())
.name(timeOfTheDay.getLangMessage().getMessage(getPlayer()))
.lore(selectedTimeOfTheDay == timeOfTheDay ? CoreLang.GUI_SHOP_SELECTED.getMessage(getPlayer()) : CoreLang.GUI_SHOP_CLICK_TO_SELECT.getMessage(getPlayer()))
.glowing(selectedTimeOfTheDay == timeOfTheDay))
.action(() -> {
timeSelectorGameOption.getTimeVoting().remove(player);
CoreLang.GUI_TIME_VOTE_VOTED.replaceAndSend(player, timeOfTheDay.getLangMessage());
timeSelectorGameOption.getTimeVoting().put(player, timeOfTheDay);
refresh();
}), timeOfTheDay.getSlot());
}
}
}
| 1,906 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AntiShareKitFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/kits/AntiShareKitFeature.java | package me.patothebest.gamecore.feature.features.kits;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import org.bukkit.ChatColor;
import org.bukkit.event.EventHandler;
import org.bukkit.event.inventory.InventoryAction;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
public class AntiShareKitFeature extends AbstractFeature {
@EventHandler
public void onDeath(CombatDeathEvent event) {
if(!isPlayingInArena(event)) {
return;
}
event.getDrops().removeIf(itemStack -> {
if(!itemStack.hasItemMeta()) {
return false;
}
ItemMeta itemMeta = itemStack.getItemMeta();
if(itemMeta.getLore() == null || itemMeta.getLore().isEmpty()) {
return false;
}
for (String s : itemMeta.getLore()) {
if(s.contains(ChatColor.YELLOW + "Kit ")) {
return true;
}
}
return false;
});
}
@EventHandler
public void onDrop(PlayerDropItemEvent event) {
if(!isPlayingInArena(event)) {
return;
}
if(!event.getItemDrop().getItemStack().hasItemMeta()) {
return;
}
ItemMeta itemMeta = event.getItemDrop().getItemStack().getItemMeta();
if(itemMeta.getLore() == null || itemMeta.getLore().isEmpty()) {
return;
}
for (String s : itemMeta.getLore()) {
if(s.contains(ChatColor.YELLOW + "Kit ")) {
event.setCancelled(true);
}
}
}
@EventHandler
public void onMoveItem(InventoryClickEvent event) {
if(!isPlayingInArena(event)) {
return;
}
if (event.getInventory().getType() == InventoryType.PLAYER || event.getInventory().getType() == InventoryType.CRAFTING) {
return;
}
if(!event.getAction().name().contains("HOTBAR") && !event.getAction().name().contains("PLACE") && !event.getAction().name().contains("SWAP") && event.getAction() != InventoryAction.MOVE_TO_OTHER_INVENTORY) {
return;
}
ItemStack item = event.getCurrentItem();
if (event.getAction().name().contains("HOTBAR")) {
item = event.getView().getBottomInventory().getItem(event.getHotbarButton());
} else if(event.getAction().name().contains("PLACE") || event.getAction().name().contains("SWAP")) {
item = event.getCursor();
}
if(event.getRawSlot() > event.getView().getTopInventory().getSize()-1 && event.getAction() != InventoryAction.MOVE_TO_OTHER_INVENTORY) {
return;
}
if(item == null) {
return;
}
if(!item.hasItemMeta()) {
return;
}
ItemMeta itemMeta = item.getItemMeta();
if(itemMeta.getLore() == null || itemMeta.getLore().isEmpty()) {
return;
}
for (String s : itemMeta.getLore()) {
if(s.contains(ChatColor.YELLOW + "Kit ")) {
event.setCancelled(true);
}
}
}
@EventHandler
public void onDragItem(InventoryDragEvent event) {
if(!isPlayingInArena(event)) {
return;
}
if (event.getInventory().getType() == InventoryType.PLAYER || event.getInventory().getType() == InventoryType.CRAFTING) {
return;
}
ItemStack item = event.getOldCursor();
if(event.getRawSlots().stream().filter(integer -> integer < event.getView().getTopInventory().getSize()-1).findFirst().orElse(null) == null) {
return;
}
if(item == null) {
return;
}
if(!item.hasItemMeta()) {
return;
}
ItemMeta itemMeta = item.getItemMeta();
if(itemMeta.getLore() == null || itemMeta.getLore().isEmpty()) {
return;
}
for (String s : itemMeta.getLore()) {
if(s.contains(ChatColor.YELLOW + "Kit ")) {
event.setCancelled(true);
}
}
}
} | 4,424 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
RespawnWithKitFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/kits/RespawnWithKitFeature.java | package me.patothebest.gamecore.feature.features.kits;
import com.google.inject.Inject;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.kit.KitManager;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.PlayerRespawnEvent;
public class RespawnWithKitFeature extends AbstractFeature {
private final KitManager kitManager;
private final PluginScheduler pluginScheduler;
@Inject private RespawnWithKitFeature(KitManager kitManager, PluginScheduler pluginScheduler) {
this.kitManager = kitManager;
this.pluginScheduler = pluginScheduler;
}
@EventHandler(priority = EventPriority.HIGHEST)
public void onRespawn(PlayerRespawnEvent event) {
if(!isPlayingInArena(event)) {
return;
}
kitManager.applyKit(event.getPlayer(), arena.getTeam(event.getPlayer()));
pluginScheduler.runTaskLater(() -> {
kitManager.applyPotionEffects(event.getPlayer());
}, 1L);
}
} | 1,116 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DragonFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/dragons/DragonFeature.java | package me.patothebest.gamecore.feature.features.dragons;
import com.google.inject.Inject;
import com.google.inject.Provider;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.nms.NMS;
import me.patothebest.gamecore.arena.types.CentrableArena;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import org.bukkit.Location;
import org.bukkit.entity.EnderDragon;
import org.bukkit.entity.Entity;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class DragonFeature extends AbstractRunnableFeature {
private final List<EnderDragon> dragons = new CopyOnWriteArrayList<>();
private final CorePlugin plugin;
private final Provider<NMS> nmsProvider;
private final int spawnDelay = 25; // 25 seconds between each dragon spawn
@Inject private DragonFeature(CorePlugin plugin, Provider<NMS> nmsProvider) {
this.plugin = plugin;
this.nmsProvider = nmsProvider;
}
@Override
public void run() {
Location centerLocation = ((CentrableArena) arena).getCenterLocation();
EnderDragon dragon = nmsProvider.get().spawnEnderdragon(centerLocation);
dragons.add(dragon);
}
@Override
public void initializeFeature() {
runTaskTimer(plugin, 0L, spawnDelay*20L);
}
@Override
public void stopFeature() {
cancel();
dragons.forEach(Entity::remove);
dragons.clear();
}
}
| 1,448 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CelebrationTitleFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/celebration/CelebrationTitleFeature.java | package me.patothebest.gamecore.feature.features.celebration;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.title.Title;
import me.patothebest.gamecore.title.TitleManager;
import org.bukkit.entity.Player;
public class CelebrationTitleFeature extends AbstractFeature {
@Override
public void initializeFeature() {
super.initializeFeature();
for (Player player : arena.getPlayers()) {
Title title = TitleManager.newInstance(CoreLang.WINNER_TITLE.getMessage(player));
title.setSubtitle(CoreLang.WINNER_SUBTITLE.getMessage(player));
title.setFadeInTime(0);
title.setFadeOutTime(1);
title.setStayTime(3);
title.send(player);
}
for (Player player : arena.getSpectators()) {
Title title = TitleManager.newInstance(CoreLang.LOSER_TITLE.getMessage(player));
title.setSubtitle(CoreLang.LOSER_SUBTITLE.getMessage(player));
title.setFadeInTime(0);
title.setFadeOutTime(1);
title.setStayTime(3);
title.send(player);
}
}
}
| 1,196 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CelebrationFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/celebration/CelebrationFeature.java | package me.patothebest.gamecore.feature.features.celebration;
import com.google.inject.Inject;
import me.patothebest.gamecore.cosmetics.victoryeffects.VictoryEffectItem;
import me.patothebest.gamecore.cosmetics.victoryeffects.VictoryManager;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class CelebrationFeature extends AbstractFeature {
private final PlayerManager playerManager;
private final VictoryManager victoryManager;
@Inject private CelebrationFeature(PlayerManager playerManager, VictoryManager victoryManager) {
this.playerManager = playerManager;
this.victoryManager = victoryManager;
}
@Override
public void initializeFeature() {
for (Player player : arena.getPlayers()) {
player.setAllowFlight(true);
player.setFlying(true);
IPlayer player1 = playerManager.getPlayer(player);
VictoryEffectItem victoryEffect = player1.getSelectedItemOrDefault(VictoryEffectItem.class, victoryManager.getDefaultItem());
if (victoryEffect != null) {
victoryEffect.display(player1);
}
}
}
}
| 1,290 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CelebrationMessagesFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/celebration/CelebrationMessagesFeature.java | package me.patothebest.gamecore.feature.features.celebration;
import com.google.inject.Inject;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.player.PlayerManager;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class CelebrationMessagesFeature extends AbstractFeature {
private final PlayerManager playerManager;
@Inject private CelebrationMessagesFeature(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public void initializeFeature() {
super.initializeFeature();
String winners = StringUtils.join(arena.getPlayers().stream().map(Player::getName).collect(Collectors.toList()), ", ");
for (Player player : arena.getPlayers()) {
arena.getTopKillers().put(player.getName(), playerManager.getPlayer(player).getGameKills());
}
List<Map.Entry<String, Integer>> entries = Utils.sortMap(arena.getTopKillers());
String[] killer1 = entries.size() > 0 ? new String[] {entries.get(0).getKey(), entries.get(0).getValue().toString()} : null;
String[] killer2 = entries.size() > 1 ? new String[] {entries.get(1).getKey(), entries.get(1).getValue().toString()} : null;
String[] killer3 = entries.size() > 2 ? new String[] {entries.get(2).getKey(), entries.get(2).getValue().toString()} : null;
for (Player player : arena.getPlayers()) {
sendMessage(player, killer1, killer2, killer3, winners);
}
for (Player player : arena.getSpectators()) {
sendMessage(player, killer1, killer2, killer3, winners);
}
}
private void sendMessage(Player player, String[] killer1, String[] killer2, String[] killer3, String winners) {
Utils.sendCenteredMessage(player, CoreLang.LINE_SEPARATOR.getMessage(player));
player.sendMessage("");
Utils.sendCenteredMessage(player, ChatColor.WHITE.toString() + ChatColor.BOLD + PluginConfig.GAME_TITLE);
player.sendMessage("");
Utils.sendCenteredMessage(player, CoreLang.WINNERS.replace(player, winners));
player.sendMessage("");
if(killer1 != null) {
Utils.sendCenteredMessage(player, CoreLang.FIRST_KILLER.replace(player, killer1[0], killer1[1]));
}
if(killer2 != null) {
Utils.sendCenteredMessage(player, CoreLang.SECOND_KILLER.replace(player, killer2[0], killer2[1]));
}
if(killer3 != null) {
Utils.sendCenteredMessage(player, CoreLang.THIRD_KILLER.replace(player, killer3[0], killer3[1]));
}
player.sendMessage("");
Utils.sendCenteredMessage(player, CoreLang.LINE_SEPARATOR.getMessage(player));
}
}
| 2,996 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LobbyFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/LobbyFeature.java | package me.patothebest.gamecore.feature.features.other;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.guis.UserGUIFactory;
import me.patothebest.gamecore.guis.admin.AdminUI;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.privatearenas.PrivateArena;
import me.patothebest.gamecore.privatearenas.PrivateArenasManager;
import me.patothebest.gamecore.privatearenas.ui.PrivateArenaUIFactory;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import javax.inject.Inject;
import java.util.concurrent.TimeUnit;
public class LobbyFeature extends AbstractFeature {
private final Cache<String, Long> cooldown = CacheBuilder.newBuilder().expireAfterWrite(2, TimeUnit.SECONDS).build();
private final CorePlugin plugin;
private final UserGUIFactory userGUIFactory;
private final PrivateArenaUIFactory privateArenaUIFactory;
private final PrivateArenasManager privateArenasManager;
@Inject private LobbyFeature(CorePlugin plugin, UserGUIFactory userGUIFactory, PrivateArenaUIFactory privateArenaUIFactory, PrivateArenasManager privateArenasManager) {
this.plugin = plugin;
this.userGUIFactory = userGUIFactory;
this.privateArenaUIFactory = privateArenaUIFactory;
this.privateArenasManager = privateArenasManager;
}
@SuppressWarnings("deprecation")
@EventHandler
public void onInteract(PlayerInteractEvent event) {
if(!isPlayingInArena(event)) {
return;
}
if(cooldown.getIfPresent(event.getPlayer().getName()) != null) {
return;
}
if(event.getPlayer().getItemInHand() == null) {
return;
}
switch (Material.matchMaterial(event.getPlayer().getItemInHand())) {
case NETHER_STAR:
userGUIFactory.openKitShop(event.getPlayer());
break;
case LIGHT_BLUE_WOOL:
if (!arena.isTeamSelector()) {
CoreLang.GUI_PRIVATE_ARENA_TEAM_SELECTION_DISABLED.sendMessage(event.getPlayer());
return;
}
if(!event.getPlayer().hasPermission(Permission.CHOOSE_TEAM.getBukkitPermission())) {
event.getPlayer().sendMessage(CoreLang.GUI_USER_CHOOSE_TEAM_NO_PERMISSION.getMessage(event.getPlayer()));
break;
}
userGUIFactory.createTeamUI(event.getPlayer(), arena, null);
break;
case MAGMA_CREAM:
arena.removePlayer(event.getPlayer());
break;
case COMPARATOR:
handleAdminClick(event.getPlayer(), arena);
break;
default:
}
}
@EventHandler
public void onInventoryClick(InventoryClickEvent event) {
if(!isPlayingInArena(event)) {
return;
}
if(event.getCurrentItem() == null) {
return;
}
if(event.getClickedInventory().getType() != InventoryType.PLAYER) {
return;
}
switch (Material.matchMaterial(event.getCurrentItem().getType())) {
case NETHER_STAR:
userGUIFactory.openKitShop((Player) event.getWhoClicked());
break;
case LIGHT_BLUE_WOOL:
if (!arena.isTeamSelector()) {
CoreLang.GUI_PRIVATE_ARENA_TEAM_SELECTION_DISABLED.sendMessage(event.getWhoClicked());
return;
}
if(!event.getWhoClicked().hasPermission(Permission.CHOOSE_TEAM.getBukkitPermission())) {
event.getWhoClicked().sendMessage(CoreLang.GUI_USER_CHOOSE_TEAM_NO_PERMISSION.getMessage(event.getWhoClicked()));
break;
}
userGUIFactory.createTeamUI((Player) event.getWhoClicked(), arena, null);
break;
case MAGMA_CREAM:
arena.removePlayer((Player) event.getWhoClicked());
break;
case COMPARATOR:
handleAdminClick((Player) event.getWhoClicked(), arena);
break;
default:
}
event.setCancelled(true);
}
private void handleAdminClick(Player player, AbstractArena arena) {
if (!arena.isPrivateArena()) {
new AdminUI(plugin, player, arena);
} else {
for (PrivateArena value : privateArenasManager.getPrivateArenaMap().values()) {
if (value.getArena() == arena) {
privateArenaUIFactory.createPrivateArenaMenu(player, value);
return;
}
}
}
}
@EventHandler
public void onPlayerQuit(PlayerQuitEvent event) {
arena.getTeamPreferences().forEach((team, players) -> players.remove(event.getPlayer()));
}
public void playerJoin(Player player) {
cooldown.put(player.getName(), System.currentTimeMillis());
}
}
| 5,534 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CompassRadarFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/CompassRadarFeature.java | package me.patothebest.gamecore.feature.features.other;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.actionbar.ActionBar;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import org.bukkit.entity.Player;
public class CompassRadarFeature extends AbstractRunnableFeature {
private final CorePlugin plugin;
@Inject private CompassRadarFeature(CorePlugin plugin) {
this.plugin = plugin;
}
@Override
public void run() {
for (Player player : arena.getPlayers()) {
if(player.getInventory().contains(Material.COMPASS.parseMaterial())) {
Player closest = null;
AbstractGameTeam gameTeam = arena.getTeam(player);
double closestDistance = 0;
// only track players
for (Player other : arena.getPlayers()) {
if(other == player) {
continue;
}
// don't track teammates
if(arena.getTeams().size() > 1) {
if(arena.getTeam(other) == gameTeam) {
continue;
}
}
double otherDistance = player.getLocation().distance(other.getLocation());
if(closest == null || otherDistance < closestDistance) {
closest = other;
closestDistance = otherDistance;
}
}
if(closest != null) {
player.setCompassTarget(closest.getLocation());
if (player.getItemInHand().getType() == Material.COMPASS.parseMaterial()) {
ActionBar.sendActionBar(player, CoreLang.COMPASS_TRACKER.replace(player, closest.getName(), Utils.roundToTwoDecimals(closestDistance)));
}
}
}
}
}
@Override
public void initializeFeature() {
runTaskTimer(plugin, 0L, 10L);
}
}
| 2,294 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WaitingPhaseFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/WaitingPhaseFeature.java | package me.patothebest.gamecore.feature.features.other;
import com.google.inject.Inject;
import me.patothebest.gamecore.cosmetics.cage.Cage;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.event.player.LobbyJoinEvent;
import me.patothebest.gamecore.event.player.PlayerSelectItemEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.phase.phases.CagePhase;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerMoveEvent;
import java.util.HashMap;
import java.util.Map;
public class WaitingPhaseFeature extends AbstractFeature {
private final Map<Player, Location> playerLocationMap = new HashMap<>();
private final PluginScheduler pluginScheduler;
@Inject private WaitingPhaseFeature(PluginScheduler pluginScheduler) {
this.pluginScheduler = pluginScheduler;
}
@EventHandler
public void onItemUpdate(PlayerSelectItemEvent event) {
if(!isPlayingInArena(event.getPlayer().getPlayer())) {
return;
}
if (!(arena.getPhase() instanceof CagePhase)) {
return;
}
if(!(event.getShopItem() instanceof Cage)) {
return;
}
((CagePhase) arena.getPhase()).updateCage(event.getPlayer().getPlayer());
}
@EventHandler
public void onPlayerLeave(ArenaLeaveEvent event) {
playerLocationMap.remove(event.getPlayer().getPlayer());
}
@EventHandler
public void onPlayerJoin(LobbyJoinEvent event) {
if(!isPlayingInArena(event.getPlayer())) {
return;
}
playerLocationMap.put(event.getPlayer(), event.getPlayer().getLocation());
}
@Override
public void initializeFeature() {
super.initializeFeature();
pluginScheduler.scheduleSyncDelayedTask(() -> {
for (Player player : arena.getPlayers()) {
playerLocationMap.put(player, player.getLocation());
}
}, 1L);
}
@Override
public void stopFeature() {
super.stopFeature();
playerLocationMap.clear();
}
@EventHandler
public void onMove(PlayerMoveEvent event) {
if (arena.getPhase() instanceof CagePhase) {
if (event.getFrom().getBlockX() == event.getTo().getBlockX() && event.getFrom().getBlockY() <= event.getTo().getBlockY() && event.getFrom().getBlockZ() == event.getTo().getBlockZ()) {
return;
}
if (!isPlayingInArena(event.getPlayer())) {
return;
}
Location location = playerLocationMap.get(event.getPlayer());
if (location == null) {
return;
}
if (event.getTo().getBlockY() == location.getBlockY()) {
return;
}
event.setTo(location);
} else {
if (event.getFrom().getX() == event.getTo().getX() && event.getFrom().getZ() == event.getTo().getZ()) {
return;
}
if (!isPlayingInArena(event.getPlayer())) {
return;
}
event.setTo(event.getFrom());
}
}
}
| 3,326 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CountdownFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/CountdownFeature.java | package me.patothebest.gamecore.feature.features.other;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.command.ChatColor;
import me.patothebest.gamecore.event.arena.CountdownStartEvent;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.event.EventRegistry;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import me.patothebest.gamecore.phase.phases.CagePhase;
import me.patothebest.gamecore.title.Title;
import me.patothebest.gamecore.title.TitleManager;
import javax.inject.Inject;
public class CountdownFeature extends AbstractRunnableFeature {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private final CorePlugin plugin;
private final CoreConfig coreConfig;
private final EventRegistry eventRegistry;
private int time;
private boolean running = false;
private boolean overrideRunning = false;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
@Inject
public CountdownFeature(CorePlugin plugin, CoreConfig coreConfig, EventRegistry eventRegistry) {
this.plugin = plugin;
this.coreConfig = coreConfig;
this.eventRegistry = eventRegistry;
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
@Override
public void run() {
if (!coreConfig.isSet("min-players") || coreConfig.getString("min-players").contains("-1")) {
// If a player has left the arena and the player count is lower
// then the required amount to start...
if (arena.getPlayers().size() < arena.getMinPlayers() && !overrideRunning) {
// ...return
running = false;
return;
}
} else {
int minSize;
int percentage = Integer.parseInt(coreConfig.getString("min-players").replace("%", ""));
minSize = (int) Math.ceil(percentage * arena.getMaxPlayers() / 100.0);
// If a player has left the arena and the player count is lower
// then the required amount to start...
if (arena.getPlayers().size() < minSize && !overrideRunning) {
// ...return
running = false;
return;
}
}
if (!running && overrideRunning) {
return;
}
if (!running) {
startCountdown();
}
// decrement the time by one
time--;
if (arena.getPlayers().size() == arena.getMaxPlayers() && time > 10) {
time = 10;
}
// If the time has hit 0...
if (time <= 0) {
// ...start the game and cancel the task
arena.startGame();
cancel();
return;
}
// iterate over each player
arena.getPlayers().forEach(player -> {
// set their xp level
player.setLevel(time);
if (time <= 10 || time % 10 == 0) {
// create and send the countdown message
CoreLang titleLang = CoreLang.GAME_STARTING_TITLE;
CoreLang subtitleLang = CoreLang.GAME_STARTING_SUBTITLE;
CoreLang chatMessage = CoreLang.GAME_STARTING_CHAT;
if (arena.getPhase() instanceof CagePhase) {
if (arena.getTeams().size() > 1) {
titleLang = CoreLang.TEAM_CAGE_RELEASING_TITLE;
subtitleLang = CoreLang.TEAM_CAGE_RELEASING_SUBTITLE;
chatMessage = CoreLang.TEAM_CAGE_RELEASING_CHAT;
} else {
titleLang = CoreLang.SOLO_CAGE_RELEASING_TITLE;
subtitleLang = CoreLang.SOLO_CAGE_RELEASING_SUBTITLE;
chatMessage = CoreLang.SOLO_CAGE_RELEASING_CHAT;
}
}
String secondLang = (time == 1 ? CoreLang.SECOND.getMessage(player) : CoreLang.SECONDS.getMessage(player));
String seconds = String.valueOf(time);
if (time == 3) {
seconds = ChatColor.RED + seconds;
} else if (time == 2) {
seconds = ChatColor.YELLOW + seconds;
} else if (time == 1) {
seconds = ChatColor.GREEN + seconds;
} else {
seconds = ChatColor.WHITE + seconds;
}
Title title = TitleManager.newInstance(titleLang.replace(player, seconds, secondLang));
title.setSubtitle(subtitleLang.replace(player, seconds, secondLang));
title.setFadeInTime(0);
title.setFadeOutTime(1);
title.setStayTime(2);
title.send(player);
// send the players the countdown message
player.sendMessage(chatMessage.replace(player, seconds, secondLang));
}
});
}
public void startCountdown(int time) {
// If is already running...
if (running) {
// ...return
return;
}
// set the time to the config seconds + 1 initial second since
// we decrement a second from the time at the beginning of the
// task, so we don't have any inconsistencies with the scoreboard
//time = plugin.getConfig().getCountdownTime()+1;
this.time = time + 1;
// run the task
running = true;
}
public void startCountdown() {
if (running) {
time--;
return;
}
// set the time to the config seconds + 1 initial second since
// we decrement a second from the time at the beginning of the
// task, so we don't have any inconsistencies with the scoreboard
//time = plugin.getConfig().getCountdownTime()+1;
time = coreConfig.getCountdownTime() + 1;
// run the task
running = true;
eventRegistry.callEvent(new CountdownStartEvent(arena));
}
@Override
public synchronized void cancel() throws IllegalStateException {
// If the task has not been scheduled yet...
if (!hasBeenScheduled()) {
// ...return
return;
}
// set running to false
running = false;
overrideRunning = false;
// cancel the actual task
super.cancel();
}
// -------------------------------------------- //
// GETTERS AND SETTERS
// -------------------------------------------- //
public boolean isOverrideRunning() {
return overrideRunning;
}
public void setOverrideRunning(boolean overrideRunning) {
this.overrideRunning = overrideRunning;
}
public boolean isRunning() {
return running;
}
public int getTime() {
return time;
}
public void setRunning(boolean running) {
this.running = running;
}
@Override
public String toString() {
return "Countdown{" +
"arena=" + arena.getName() +
", time=" + time +
", running=" + running +
'}';
}
@Override
public void initializeFeature() {
runTaskTimer(plugin, 0L, 20L);
}
}
| 7,522 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ThrowTNTFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/ThrowTNTFeature.java | package me.patothebest.gamecore.feature.features.other;
import com.google.inject.Inject;
import me.patothebest.gamecore.event.EventRegistry;
import me.patothebest.gamecore.event.player.PlayerThrowTNTEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.entity.TNTPrimed;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
public class ThrowTNTFeature extends AbstractFeature {
private final EventRegistry eventRegistry;
@Inject private ThrowTNTFeature(EventRegistry eventRegistry) {
this.eventRegistry = eventRegistry;
}
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event){
if (!isPlayingInArena(event)) {
return;
}
Player player = event.getPlayer();
if(event.getPlayer().getItemInHand().getType() != Material.TNT) {
return;
}
PlayerThrowTNTEvent throwTNTEvent = eventRegistry.callEvent(new PlayerThrowTNTEvent(player, arena));
if (throwTNTEvent.isCancelled()) {
return;
}
player.getInventory().removeItem(new ItemStack(Material.TNT, 1));
TNTPrimed tnt = player.getWorld().spawn(player.getLocation(), TNTPrimed.class);
tnt.setFuseTicks(40);
tnt.setVelocity(player.getLocation().getDirection().normalize().multiply(0.5));
event.setCancelled(true);
}
}
| 1,514 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
InformationalFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/InformationalFeature.java | package me.patothebest.gamecore.feature.features.other;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.actionbar.ActionBar;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.util.Sounds;
import org.bukkit.event.EventHandler;
public class InformationalFeature extends AbstractFeature {
@EventHandler
public void onKill(CombatDeathEvent event) {
if (event.getKillerPlayer() == null) {
return;
}
Sounds.ENTITY_EXPERIENCE_ORB_PICKUP.play(event.getKillerPlayer(), 10f, 1f);
ActionBar.sendActionBar(event.getKillerPlayer(), CoreLang.YOU_KILLED_ACTION_BAR.replace(event.getKillerPlayer(), event.getPlayer().getName()));
}
}
| 801 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LimitedTimePhaseFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/LimitedTimePhaseFeature.java | package me.patothebest.gamecore.feature.features.other;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import javax.inject.Inject;
public class LimitedTimePhaseFeature extends AbstractRunnableFeature {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private final CorePlugin plugin;
private final CoreConfig coreConfig;
private int timeUntilNextStage = 120;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
@Inject public LimitedTimePhaseFeature(CorePlugin plugin, CoreConfig coreConfig) {
this.plugin = plugin;
this.coreConfig = coreConfig;
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
@Override
public void run() {
cancel();
arena.nextPhase();
}
// -------------------------------------------- //
// GETTERS AND SETTERS
// -------------------------------------------- //
public int getTimeUntilNextStage() {
return timeUntilNextStage;
}
/**
* Set the time to the next stage
*
* @param timeUntilNextStage time in seconds
*/
public void setTimeUntilNextStage(int timeUntilNextStage) {
this.timeUntilNextStage = timeUntilNextStage;
}
@Override
public String toString() {
return "Countdown{" +
"arena=" + arena.getName() +
", timeUntilNextStage=" + timeUntilNextStage +
'}';
}
@Override
public void initializeFeature() {
runTaskLater(plugin, timeUntilNextStage*20L);
}
public int getRemainingTime() {
return (int) (timeUntilNextStage - (System.currentTimeMillis()/1000L - arena.getPhaseTime()/1000L));
}
}
| 2,003 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PetsFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/PetsFeature.java | package me.patothebest.gamecore.feature.features.other;
import com.google.inject.Inject;
import com.google.inject.Provider;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.feature.features.protection.NoTeamDamageFeature;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.nms.NMS;
import me.patothebest.gamecore.permission.PermissionGroup;
import me.patothebest.gamecore.permission.PermissionGroupManager;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.GameMode;
import org.bukkit.entity.Creature;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.entity.Slime;
import org.bukkit.entity.ThrownPotion;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.Action;
import org.bukkit.event.entity.EntityCombustEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityTargetEvent;
import org.bukkit.event.entity.EntityTeleportEvent;
import org.bukkit.event.entity.PotionSplashEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.metadata.FixedMetadataValue;
import org.bukkit.projectiles.ProjectileSource;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
public class PetsFeature extends AbstractFeature {
private final WeakHashMap<Player, List<WeakReference<Entity>>> pets = new WeakHashMap<>();
private final Map<PermissionGroup, Integer> petLimits = new HashMap<>();
private final CorePlugin plugin;
private final Provider<NMS> nms;
private final PermissionGroupManager permissionGroupManager;
private final PlayerManager playerManager;
private final CoreConfig coreConfig;
private boolean limitEnabled;
private int defaultLimit = 5;
@Inject private PetsFeature(CorePlugin plugin, Provider<NMS> nms, PermissionGroupManager permissionGroupManager, PlayerManager playerManager, CoreConfig coreConfig) {
this.plugin = plugin;
this.nms = nms;
this.permissionGroupManager = permissionGroupManager;
this.playerManager = playerManager;
this.coreConfig = coreConfig;
}
@Override
public void initializeFeature() {
super.initializeFeature();
petLimits.clear();
limitEnabled = coreConfig.getBoolean("pets.limit.enabled");
if(limitEnabled) {
Map<String, Object> limits = coreConfig.getConfigurationSection("pets.limit.groups").getValues(true);
limits.forEach((string, limit) -> {
if(string.equalsIgnoreCase("default")) {
defaultLimit = (Integer) limit;
}
if(!(limit instanceof Integer)) {
return;
}
PermissionGroup permissionGroup = permissionGroupManager.getOrCreatePermissionGroup(string);
petLimits.put(permissionGroup, (Integer) limit);
});
}
}
@SuppressWarnings("deprecation")
@EventHandler
public void onSpawnPet(PlayerInteractEvent event) {
if(!isPlayingInArena(event)) {
return;
}
if(event.getAction() != Action.RIGHT_CLICK_BLOCK) {
return;
}
if(event.getItem() == null) {
return;
}
Player player = event.getPlayer();
AbstractGameTeam gameTeam = playerManager.getPlayer(player).getGameTeam();
EntityType entityFromEgg = nms.get().getEntityFromEgg(event.getItem());
if(entityFromEgg == null) {
return;
}
if(entityFromEgg == EntityType.HORSE) {
return;
}
if(limitEnabled) {
int totalAlivePets = getTotalAlivePets(player);
if(totalAlivePets >= defaultLimit) {
final boolean[] canHaveMore = {false};
petLimits.forEach((permissionGroup, limit) -> {
if(limit > totalAlivePets) {
if(permissionGroup.hasPermission(player)) {
canHaveMore[0] = true;
}
}
});
if(!canHaveMore[0]) {
player.sendMessage(CoreLang.YOU_HAVE_REACHED_PET_LIMIT.getMessage(player));
event.setCancelled(true);
return;
}
}
}
Entity entity = player.getWorld().spawnEntity(event.getClickedBlock().getLocation().add(0.5, 1, 0.5), entityFromEgg);
nms.get().makePet((LivingEntity) entity, player.getUniqueId(), Utils.getColorFromDye(gameTeam.getColor()) + "Mascota de " + player.getName());
entity.setMetadata("PetOwner", new FixedMetadataValue(plugin, player));
getPets(player).add(new WeakReference<>(entity));
if(player.getGameMode() != GameMode.CREATIVE) {
if (player.getItemInHand().getAmount() > 1) {
player.getItemInHand().setAmount(player.getItemInHand().getAmount() - 1);
} else {
player.setItemInHand(new ItemStackBuilder(Material.AIR));
}
}
if (entity instanceof Slime) {
((Slime) entity).setSize(1);
}
event.setCancelled(true);
}
@EventHandler
public void onDamagePet(EntityDamageByEntityEvent event) {
if(!(event.getDamager() instanceof Player)) {
return;
}
if(!isEventInArena(event)) {
return;
}
Player player = (Player) event.getDamager();
if(!canAttack(player, event.getEntity())) {
event.setCancelled(true);
}
}
@EventHandler
public void onDamagePet2(EntityDamageByEntityEvent event) {
if(!(event.getEntity() instanceof Player)) {
return;
}
if(!isEventInArena(event)) {
return;
}
Player player = (Player) event.getEntity();
if(!canAttack(player, event.getDamager())) {
event.setCancelled(true);
}
}
@EventHandler
public void onAttackProjectile(EntityDamageByEntityEvent event) {
if(!(event.getDamager() instanceof Projectile)) {
return;
}
Projectile projectile = (Projectile) event.getDamager();
if(!(projectile.getShooter() instanceof Player)) {
return;
}
Player player = (Player) projectile.getShooter();
if(!canAttack(player, event.getEntity())) {
event.setCancelled(true);
}
}
@EventHandler
public void onAttackProjectilePet(EntityDamageByEntityEvent event) {
if(!(event.getDamager() instanceof Projectile)) {
return;
}
Projectile projectile = (Projectile) event.getDamager();
ProjectileSource projectileShooter = projectile.getShooter();
if(!(projectileShooter instanceof LivingEntity)) {
return;
}
LivingEntity shooter = (LivingEntity) projectileShooter;
if(event.getEntity() instanceof Player) {
if(!canAttack((Player) event.getEntity(), shooter)) {
event.setCancelled(true);
}
return;
}
if(hasPlayerOwner(shooter) && hasPlayerOwner(event.getEntity())) {
Player damagerOwner = getPlayerOwner(shooter);
Player damagedOwner = getPlayerOwner(event.getEntity());
if(damagedOwner == damagerOwner) {
event.setCancelled(true);
return;
}
AbstractArena arena = playerManager.getPlayer(damagedOwner).getCurrentArena();
AbstractGameTeam damagerTeam = arena.getTeam(damagerOwner);
AbstractGameTeam damagedTeam = arena.getTeam(damagedOwner);
if(damagedTeam.equals(damagerTeam)) {
event.setCancelled(true);
}
}
}
@EventHandler
public void onPotionSplash(PotionSplashEvent event) {
ThrownPotion projectile = event.getPotion();
ProjectileSource projectileShooter = projectile.getShooter();
if(!(projectileShooter instanceof LivingEntity)) {
return;
}
LivingEntity shooter = (LivingEntity) projectileShooter;
event.getAffectedEntities().forEach(affectedEntity -> {
if(affectedEntity instanceof Player) {
if(!canAttack((Player) affectedEntity, shooter)) {
event.setIntensity(affectedEntity, 0);
}
return;
}
if(hasPlayerOwner(shooter) && hasPlayerOwner(affectedEntity)) {
Player damagerOwner = getPlayerOwner(shooter);
Player damagedOwner = getPlayerOwner(affectedEntity);
if(damagedOwner == damagerOwner) {
event.setIntensity(affectedEntity, 0);
return;
}
AbstractArena arena = playerManager.getPlayer(damagedOwner).getCurrentArena();
AbstractGameTeam damagerTeam = arena.getTeam(damagerOwner);
AbstractGameTeam damagedTeam = arena.getTeam(damagedOwner);
if(damagedTeam.equals(damagerTeam)) {
event.setIntensity(affectedEntity, 0);
}
}
});
}
@EventHandler
public void killPets(CombatDeathEvent event) {
killPets(event.getPlayer());
for (List<WeakReference<Entity>> weakReferences : pets.values()) {
for (WeakReference<Entity> weakReference : weakReferences) {
Entity entity = weakReference.get();
if(entity == null) {
continue;
}
if(entity instanceof Creature) {
if(((Creature) entity).getTarget() == event.getPlayer()) {
((Creature) entity).setTarget(null);
}
}
}
}
}
@EventHandler
public void killPets(ArenaLeaveEvent event) {
killPets(event.getPlayer());
pets.remove(event.getPlayer());
}
private void killPets(Player player) {
if(!isPlayingInArena(player.getName())) {
return;
}
List<WeakReference<Entity>> pets = getPets(player);
for (WeakReference<Entity> pet : pets) {
if(pet.get() == null) {
pets.remove(pet);
continue;
}
if(pet.get().isDead()) {
pets.remove(pet);
continue;
}
pet.get().remove();
pets.remove(pet);
}
pets.clear();
}
@EventHandler
public void onTarget(EntityTargetEvent event) {
if(!(event.getTarget() instanceof Player)) {
return;
}
if(!isEventInArena(event)) {
return;
}
Player player = (Player) event.getTarget();
if(!canAttack(player, event.getEntity())) {
event.setCancelled(true);
}
}
@EventHandler
public void onCombust(EntityCombustEvent event) {
pets.values().forEach(entities -> entities.forEach(entity -> {
if(event.getEntity() == entity.get()) {
event.setCancelled(true);
}
}));
}
@EventHandler
public void onTeleport(EntityTeleportEvent event) {
if (!event.getEntity().hasMetadata("PetOwner")) {
return;
}
event.getEntity().setFallDistance(0);
}
private boolean canAttack(Player player, Entity entity) {
final boolean[] can = {true};
pets.forEach((playerIterated, entities) -> {
for (WeakReference<Entity> entityWeakReference : entities) {
if(entityWeakReference.get() == entity) {
IPlayer corePlayer = playerManager.getPlayer(player);
if(corePlayer == null) {
can[0] = false;
return;
}
if(corePlayer.getGameTeam() == null) {
can[0] = false;
return;
}
if(playerManager.getPlayer(playerIterated).getGameTeam() == null) {
can[0] = false;
return;
}
if(arena.getFeature(NoTeamDamageFeature.class) != null) {
if(corePlayer.getGameTeam() == playerManager.getPlayer(playerIterated).getGameTeam()) {
can[0] = false;
return;
}
}
}
}
});
return can[0];
}
private int getTotalAlivePets(Player player) {
int pets = 0;
List<WeakReference<Entity>> pets1 = getPets(player);
for (WeakReference<Entity> entityWeakReference : pets1) {
if(entityWeakReference.get() == null) {
pets1.remove(entityWeakReference);
continue;
}
if(entityWeakReference.get().isDead()) {
pets1.remove(entityWeakReference);
continue;
}
pets++;
}
return pets;
}
private List<WeakReference<Entity>> getPets(Player player) {
if(pets.containsKey(player)) {
return pets.get(player);
}
List<WeakReference<Entity>> petList = new CopyOnWriteArrayList<>();
pets.put(player, petList);
return petList;
}
private boolean hasPlayerOwner(Entity entity) {
return getPlayerOwner(entity) != null;
}
private Player getPlayerOwner(Entity entity) {
final Player[] player = {null};
pets.forEach((player1, weakReferences) -> {
for (WeakReference<Entity> weakReference : weakReferences) {
if(weakReference.get() == entity) {
player[0] = player1;
return;
}
}
});
return player[0];
}
public boolean isPlayingInArena(String playerName) {
return playerManager.getPlayer(playerName).isInArena() && playerManager.getPlayer(playerName).getCurrentArena().isInGame();
}
} | 15,155 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WorldBorderFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/WorldBorderFeature.java | package me.patothebest.gamecore.feature.features.other;
import me.patothebest.gamecore.feature.AbstractFeature;
import org.bukkit.WorldBorder;
public class WorldBorderFeature extends AbstractFeature {
/** Percentage indicating the starting area of
* the border in regards with the arena area */
private int startSize = 100;
/** Percentage indicating the ending area of
* the border in regards with the arena area */
private int endSize = 100;
private boolean shrink = false;
private int timeToShrink = 10;
@Override
public void initializeFeature() {
WorldBorder worldBorder = arena.getWorld().getWorldBorder();
double size = Math.max(arena.getArea().getSizeX(), arena.getArea().getSizeZ());
int startSize = (int) (this.startSize * size / 100.0);
worldBorder.setCenter(arena.getArea().getCenter());
worldBorder.setSize(startSize);
worldBorder.setWarningDistance(10);
worldBorder.setWarningTime(15);
worldBorder.setDamageAmount(2);
if (shrink) {
int endSize = Math.max((int) (this.endSize * size / 100.0), 2);
worldBorder.setSize(endSize, timeToShrink);
}
}
public int getStartSize() {
return startSize;
}
public void setStartSize(int startSize) {
this.startSize = startSize;
}
public int getEndSize() {
return endSize;
}
public void setEndSize(int endSize) {
this.endSize = endSize;
}
public boolean isShrink() {
return shrink;
}
public void setShrink(boolean shrink) {
this.shrink = shrink;
}
public int getTimeToShrink() {
return timeToShrink;
}
public void setTimeToShrink(int timeToShrink) {
this.timeToShrink = timeToShrink;
}
}
| 1,826 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DeathMessageFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/feature/features/other/DeathMessageFeature.java | package me.patothebest.gamecore.feature.features.other;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.feature.AbstractFeature;
import org.bukkit.event.EventHandler;
public class DeathMessageFeature extends AbstractFeature {
@EventHandler
public void onDeath(CombatDeathEvent event) {
if(!isPlayingInArena(event.getPlayer()) && !isSpectatingInArena(event.getPlayer())) {
return;
}
arena.sendMessageToArena(locale -> event.getDeathMessage());
event.setDeathMessage(null);
}
}
| 575 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AbstractPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/AbstractPhase.java | package me.patothebest.gamecore.phase;
import me.patothebest.gamecore.feature.Feature;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import org.apache.commons.lang.Validate;
import org.bukkit.event.HandlerList;
import java.util.HashMap;
import java.util.Map;
public abstract class AbstractPhase<PluginType extends CorePlugin, Arena extends AbstractArena> implements Phase<Arena> {
private final Map<Class<? extends Feature>, Feature> features = new HashMap<>();
protected final PluginType plugin;
protected Arena arena;
private boolean canJoin;
private Phase previousPhase;
private Phase nextPhase;
private boolean previousPhaseFeatures = false;
public AbstractPhase(PluginType plugin) {
this.plugin = plugin;
}
@Override
public void start() {
Validate.notNull(arena, "Arena is null! Please set it first using setArena(Arena)");
for (Feature feature : features.values()) {
if(!feature.hasBeenRegistered()) {
feature.initializeFeature();
plugin.registerListener(feature);
}
}
}
@Override
public void stop() {
for (Feature feature : features.values()) {
HandlerList.unregisterAll(feature);
feature.stopFeature();
}
}
@Override
public <T extends Feature> T registerFeature(Class<T> featureClass) {
T feature = arena.createFeature(featureClass);
features.put(featureClass, feature);
return feature;
}
@Override
public void destroy() {
for (Feature feature : features.values()) {
HandlerList.unregisterAll(feature);
feature.destroy();
}
features.clear();
setArena(null);
}
public void registerFeature(Feature feature) {
features.put(feature.getClass(), feature);
}
@Override
public boolean canJoin() {
return canJoin;
}
@Override
public void setCanJoin(boolean canJoin) {
this.canJoin = canJoin;
}
@Override
public boolean isPreviousPhaseFeatures() {
return previousPhaseFeatures;
}
@Override
public void setPreviousPhaseFeatures(boolean previousPhaseFeatures) {
this.previousPhaseFeatures = previousPhaseFeatures;
}
@Override
public void removeFeature(Feature feature) {
features.remove(feature.getClass());
}
@Override
public Phase getNextPhase() {
return nextPhase;
}
@Override
public Phase getPreviousPhase() {
return previousPhase;
}
@Override
public void setPreviousPhase(Phase previousPhase) {
this.previousPhase = previousPhase;
}
@Override
public Map<Class<? extends Feature>, Feature> getFeatures() {
return features;
}
@Override
public void setNextPhase(Phase nextPhase) {
this.nextPhase = nextPhase;
}
@Override
public void setArena(Arena arena) {
this.arena = arena;
}
}
| 3,081 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Phase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/Phase.java | package me.patothebest.gamecore.phase;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.feature.Feature;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import java.util.Map;
/**
* The Interface Phase.
*
* @param <Arena> the arena
*/
public interface Phase<Arena extends AbstractArena> extends Listener {
/**
* Configure the phase.
*/
default void configure() {}
/**
* Start the phase.
*/
void start();
/**
* Stop the phase.
*/
void stop();
/**
* Register a feature.
*
* @param <T> the feature
* @param featureClass the feature class
* @return the instantiated feature
*/
<T extends Feature> T registerFeature(Class<T> featureClass);
/**
* Can players join.
*
* @return true, if players can join
*/
boolean canJoin();
/**
* Sets if players can join.
*
* @param canJoin if players can join
*/
void setCanJoin(boolean canJoin);
/**
* Checks if it inherits the features from last phase.
*
* @return true, if it inherits the features from last phase
*/
boolean isPreviousPhaseFeatures();
/**
* Sets if the phase should inherit the features from last phase
*
* @param previousPhaseFeatures if it should inherit
*/
void setPreviousPhaseFeatures(boolean previousPhaseFeatures);
/**
* Removes a feature.
*
* @param feature the feature
*/
void removeFeature(Feature feature);
/**
* Gets the next phase.
*
* @return the next phase
*/
Phase getNextPhase();
/**
* Gets the previous phase.
*
* @return the previous phase
*/
Phase getPreviousPhase();
/**
* Gets the features.
*
* @return the features
*/
Map<Class<? extends Feature>, Feature> getFeatures();
/**
* Sets the next phase.
*
* @param nextPhase the new next phase
*/
void setNextPhase(Phase nextPhase);
/**
* Sets the previous phase.
*
* @param previousPhase the new next phase
*/
void setPreviousPhase(Phase previousPhase);
/**
* On player join method.
*
* @param player the player
*/
default void playerJoin(Player player) {}
/**
* On player leave method.
*
* @param player the player
*/
default void playerLeave(Player player) {}
/**
* Sets the arena.
*
* @param arena the new arena
*/
void setArena(Arena arena);
/**
* This method will return the arena state the phase is in
* <p>
* This state will automatically be set on the arena
*
* @return the arenaState
*/
ArenaState getArenaState();
/**
* Destroys the feature
*/
void destroy();
}
| 2,931 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeamAssignPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/phases/TeamAssignPhase.java | package me.patothebest.gamecore.phase.phases;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import org.bukkit.entity.Player;
public class TeamAssignPhase extends AbstractPhase<CorePlugin, AbstractArena> {
@Inject protected TeamAssignPhase(CorePlugin plugin) {
super(plugin);
}
@Override
public void start() {
arena.getTeamPreferences().forEach((key, value) -> {
for (Player player : value) {
key.addPlayer(player);
}
});
// iterate over each player
arena.getPlayers().forEach(player -> {
if(arena.getTeam(player) != null) {
return;
}
// get a team for the player and add him to it
AbstractGameTeam gameTeam = arena.getNewTeamForPlayer(player);
gameTeam.addPlayer(player);
});
// clear the team preferences
arena.getTeamPreferences().clear();
arena.nextPhase();
}
@Override
public void stop() {
}
@Override
public ArenaState getArenaState() {
return ArenaState.STARTING;
}
}
| 1,363 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CelebrationPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/phases/CelebrationPhase.java | package me.patothebest.gamecore.phase.phases;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.feature.features.celebration.CelebrationFeature;
import me.patothebest.gamecore.feature.features.celebration.CelebrationMessagesFeature;
import me.patothebest.gamecore.feature.features.celebration.CelebrationTitleFeature;
import me.patothebest.gamecore.feature.features.other.LimitedTimePhaseFeature;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.phase.AbstractPhase;
public class CelebrationPhase extends AbstractPhase<CorePlugin, AbstractArena> {
@Inject private CelebrationPhase(CorePlugin plugin) {
super(plugin);
}
@Override
public void configure() {
registerFeature(CelebrationFeature.class);
registerFeature(CelebrationTitleFeature.class);
registerFeature(CelebrationMessagesFeature.class);
registerFeature(SpectatorProtectionFeature.class);
registerFeature(LimitedTimePhaseFeature.class);
registerFeature(PlayerProtectionFeature.class);
}
@Override
public void start() {
((LimitedTimePhaseFeature)getFeatures().get(LimitedTimePhaseFeature.class)).setTimeUntilNextStage(10);
super.start();
}
@Override
public ArenaState getArenaState() {
return ArenaState.ENDING;
}
}
| 1,615 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
NullPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/phases/NullPhase.java | package me.patothebest.gamecore.phase.phases;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.phase.Phase;
public class NullPhase extends AbstractPhase<CorePlugin, AbstractArena> {
@Inject private NullPhase(CorePlugin plugin) {
super(plugin);
}
@Override
public Phase getNextPhase() {
return this;
}
@Override
public ArenaState getArenaState() {
return ArenaState.OTHER;
}
}
| 648 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CagePhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/phases/CagePhase.java | package me.patothebest.gamecore.phase.phases;
import com.google.inject.Inject;
import com.google.inject.Provider;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.types.SpawneableArena;
import me.patothebest.gamecore.cosmetics.cage.Cage;
import me.patothebest.gamecore.cosmetics.cage.CageManager;
import me.patothebest.gamecore.cosmetics.cage.CageStructure;
import me.patothebest.gamecore.nms.NMS;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.sign.SignManager;
import org.bukkit.Location;
import org.bukkit.entity.Player;
public class CagePhase<Arena extends AbstractArena & SpawneableArena> extends WaitingPhase<Arena> {
private final CageManager cageManager;
private CageStructure cage = CageStructure.INDIVIDUAL;
@Inject private CagePhase(CorePlugin plugin, Provider<NMS> nms, PlayerManager playerManager, SignManager signManager, CageManager cageManager) {
super(plugin, nms, playerManager, signManager);
this.cageManager = cageManager;
}
@Override
public void stop() {
usedLocations.values().forEach(location -> cage.createCage(nms, CageManager.NULL_CAGE, location.clone().subtract(cage.getOffset(), -1, cage.getOffset())));
super.stop();
}
@Override
protected void preTeleport(IPlayer iPlayer, Location location) {
cage.createCage(nms, iPlayer.getSelectedItemOrDefault(Cage.class, cageManager.getDefaultItem()), location.clone().subtract(cage.getOffset(), -1, cage.getOffset()));
}
public void updateCage(Player player) {
if(!usedLocations.containsKey(player)) {
throw new IllegalArgumentException(player.getName() + " is not in arena " + arena.getName() + "!");
}
IPlayer iPlayer = playerManager.getPlayer(player);
Location clone = usedLocations.get(player).clone();
clone.setX(usedLocations.get(player).getBlockX() + 0.5);
clone.setZ(usedLocations.get(player).getBlockZ() + 0.5);
clone.setY(usedLocations.get(player).getBlockY() + 2);
player.teleport(clone);
cage.createCage(nms, iPlayer.getSelectedItemOrDefault(Cage.class, cageManager.getDefaultItem()), usedLocations.get(player).clone().subtract(cage.getOffset(), -1, cage.getOffset()));
}
@Override
public void playerLeave(Player player) {
// spectator leave check
if (!usedLocations.containsKey(player)) {
return;
}
cage.createCage(nms, CageManager.NULL_CAGE, usedLocations.remove(player).clone().subtract(cage.getOffset(), -1, cage.getOffset()));
}
public void setCageType(CageStructure cage) {
this.cage = cage;
}
}
| 2,805 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EndPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/phases/EndPhase.java | package me.patothebest.gamecore.phase.phases;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.phase.AbstractPhase;
import javax.inject.Inject;
public class EndPhase extends AbstractPhase<CorePlugin, AbstractArena> {
@Inject public EndPhase(CorePlugin plugin) {
super(plugin);
}
@Override
public void start() {
arena.endArena(true);
}
@Override
public ArenaState getArenaState() {
return ArenaState.RESTARTING;
}
}
| 603 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LobbyPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/phases/LobbyPhase.java | package me.patothebest.gamecore.phase.phases;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.feature.features.other.CountdownFeature;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.privatearenas.PrivateArena;
import me.patothebest.gamecore.privatearenas.PrivateArenasManager;
import me.patothebest.gamecore.event.player.LobbyJoinEvent;
import me.patothebest.gamecore.feature.features.other.LobbyFeature;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.sign.SignManager;
import org.bukkit.entity.Player;
import javax.inject.Inject;
public class LobbyPhase extends AbstractPhase<CorePlugin, AbstractArena> {
private final PrivateArenasManager privateArenasManager;
private final PlayerManager playerManager;
private final SignManager signManager;
private int teamItemSlot = 4;
@Inject public LobbyPhase(CorePlugin plugin, PrivateArenasManager privateArenasManager, PlayerManager playerManager, SignManager signManager) {
super(plugin);
this.privateArenasManager = privateArenasManager;
this.playerManager = playerManager;
this.signManager = signManager;
}
@Override
public void configure() {
registerFeature(CountdownFeature.class);
registerFeature(LobbyFeature.class);
registerFeature(PlayerProtectionFeature.class);
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
setCanJoin(true);
}
@Override
public void playerJoin(Player player) {
// checks if the player has the arena permission
if(!arena.getPermissionGroup().hasPermission(player)) {
// sends the no permission message to the player
player.sendMessage(CoreLang.NO_PERMISSION_ARENA.getMessage(player));
return;
}
IPlayer iPlayer = playerManager.getPlayer(player);
// add the player to the arena
arena.getPlayers().add(player);
// sets the arena of the player and saves the player state
playerManager.getPlayer(player).setCurrentArena(arena);
iPlayer.executeWhenFullyLoaded(player1 -> {
player1.getPlayerInventory().savePlayer();
player.getInventory().setItem(0, new ItemStackBuilder().material(Material.NETHER_STAR).name(player, CoreLang.LOBBY_CHOOSE_KIT));
player.getInventory().setItem(teamItemSlot, new ItemStackBuilder().material(Material.LIGHT_BLUE_WOOL).name(player, CoreLang.LOBBY_CHOOSE_TEAM));
player.getInventory().setItem(8, new ItemStackBuilder().material(Material.MAGMA_CREAM).name(player, CoreLang.LOBBY_LEAVE));
if (!arena.isPrivateArena()) {
if(player.hasPermission(Permission.ADMIN.getBukkitPermission())) {
player.getInventory().setItem(7, new ItemStackBuilder().material(Material.COMPARATOR).name(player, CoreLang.LOBBY_ADMIN_MENU));
}
} else {
for (PrivateArena value : privateArenasManager.getPrivateArenaMap().values()) {
if (value.getArena() == arena) {
if (value.getCoHosts().contains(player.getName()) || player.hasPermission(Permission.ADMIN.getBukkitPermission())) {
player.getInventory().setItem(7, new ItemStackBuilder().material(Material.COMPARATOR).name(player, CoreLang.GUI_PRIVATE_ARENA_LOBBY_MENU));
}
break;
}
}
}
});
if(iPlayer.isFullyJoined()) {
// teleport the player and give items
player.teleport(arena.getLobbyLocation());
} else {
iPlayer.setJoinLocation(arena.getLobbyLocation());
}
// send the player joined message to the arena
arena.sendMessageToArena(locale -> CoreLang.PLAYER_JOINED.getMessage(locale).replace("%player%", player.getName()).replace("%players%", arena.getPlayers().size() + "").replace("%max_players%", arena.getMaxPlayers() + ""));
// add the player to the cooldown list
// this prevents instantly leaving the arena if the slot selected
// was the one with the leave item and the join method was by right
// clicking a sign to join
arena.getFeature(LobbyFeature.class).playerJoin(player);
// call event
iPlayer.executeWhenFullyLoaded(player1 -> {
plugin.getServer().getPluginManager().callEvent(new LobbyJoinEvent(player, arena));
});
// update signs
signManager.updateSigns();
}
/**
* Sets the slot where the team item will be given to the player
*/
public void setTeamItemSlot(int teamItemSlot) {
this.teamItemSlot = teamItemSlot;
}
@Override
public ArenaState getArenaState() {
return ArenaState.WAITING;
}
}
| 5,567 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GamePhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/phases/GamePhase.java | package me.patothebest.gamecore.phase.phases;
import com.google.inject.Provider;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.event.player.GameJoinEvent;
import me.patothebest.gamecore.event.player.PlayerStateChangeEvent;
import me.patothebest.gamecore.guis.UserGUIFactory;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.nms.NMS;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.sign.SignManager;
import me.patothebest.gamecore.util.Callback;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
public abstract class GamePhase<PluginType extends CorePlugin, Arena extends AbstractArena> extends AbstractPhase<PluginType, Arena> {
private final Provider<NMS> nmsProvider;
private final PlayerManager playerManager;
private final SignManager signManager;
private final UserGUIFactory userGUIFactory;
public GamePhase(PluginType plugin, Provider<NMS> nmsProvider, SignManager signManager, PlayerManager playerManager, UserGUIFactory userGUIFactory) {
super(plugin);
this.nmsProvider = nmsProvider;
this.signManager = signManager;
this.playerManager = playerManager;
this.userGUIFactory = userGUIFactory;
}
@Override
public void playerJoin(Player player) {
// checks if the player has the arena permission
if (!arena.getPermissionGroup().hasPermission(player)) {
// sends the no permission message to the player
player.sendMessage(CoreLang.NO_PERMISSION_ARENA.getMessage(player));
return;
}
Callback<Player> callback = (player2) -> {
// add the player to the arena
arena.getPlayers().add(player);
// sets the arena of the player and saves the player state
playerManager.getPlayer(player).setCurrentArena(arena);
playerManager.getPlayer(player).getPlayerInventory().savePlayer();
// gets a team for the player and add the player to the team
AbstractGameTeam gameTeam = arena.getNewTeamForPlayer(player);
gameTeam.addPlayer(player);
gameTeam.giveStuff(player);
// update the signs to display the new amount of players
signManager.updateSigns();
// call the PlayerJoinArenaEvent event
callJoinEvent(player);
};
if (arena.getTeams().size() != 1 && player.hasPermission(Permission.CHOOSE_TEAM.getBukkitPermission())) {
if (arena.hasLastTeam(player) && !player.hasPermission(Permission.CHOOSE_TEAM_OVERRIDE.getBukkitPermission())) {
callback.call(player);
} else {
userGUIFactory.createTeamUI(player, arena, callback);
}
} else {
callback.call(player);
}
}
@Override
public void start() {
super.start();
// iterate over each player
// call the PlayerJoinArenaEvent event
arena.getPlayers().forEach(player -> {
callJoinEvent(player);
playerManager.getPlayer(player).getGameTeam().giveStuff(player);
});
// update the signs to display the new arena state
signManager.updateSigns();
if (arena.getLobbyArea() != null) {
ItemStackBuilder AIR = new ItemStackBuilder(Material.AIR);
for (Block block : arena.getLobbyArea().getBlocks()) {
if (block.getType() != Material.AIR) {
nmsProvider.get().setBlock(block, AIR);
}
}
}
}
protected void callJoinEvent(Player player) {
plugin.getServer().getPluginManager().callEvent(new GameJoinEvent(player, arena));
plugin.getServer().getPluginManager().callEvent(new PlayerStateChangeEvent(player, arena, PlayerStateChangeEvent.PlayerState.PLAYER));
}
@Override
public ArenaState getArenaState() {
return ArenaState.IN_GAME;
}
}
| 4,374 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WaitingPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/phase/phases/WaitingPhase.java | package me.patothebest.gamecore.phase.phases;
import com.google.inject.Inject;
import com.google.inject.Provider;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.arena.types.SpawneableArena;
import me.patothebest.gamecore.event.player.LobbyJoinEvent;
import me.patothebest.gamecore.feature.features.other.CountdownFeature;
import me.patothebest.gamecore.feature.features.other.LobbyFeature;
import me.patothebest.gamecore.feature.features.other.WaitingPhaseFeature;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.nms.NMS;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.sign.SignManager;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.util.Vector;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class WaitingPhase<Arena extends AbstractArena & SpawneableArena> extends AbstractPhase<CorePlugin, Arena> {
protected final List<Location> spawnLocations = new ArrayList<>();
protected final Map<Player, Location> usedLocations = new HashMap<>();
protected final Provider<NMS> nms;
protected final PlayerManager playerManager;
protected final SignManager signManager;
protected boolean autoStart;
@Inject WaitingPhase(CorePlugin plugin, Provider<NMS> nms, PlayerManager playerManager, SignManager signManager) {
super(plugin);
this.nms = nms;
this.playerManager = playerManager;
this.signManager = signManager;
}
@Override
public void configure() {
registerFeature(CountdownFeature.class);
registerFeature(LobbyFeature.class);
registerFeature(PlayerProtectionFeature.class);
registerFeature(WaitingPhaseFeature.class);
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
}
@Override
public void start() {
super.start();
if(autoStart) {
CountdownFeature countdownFeature = arena.getFeature(CountdownFeature.class);
countdownFeature.setOverrideRunning(true);
countdownFeature.startCountdown(10);
}
this.spawnLocations.addAll(arena.getSpawns().stream().map(arenaLocation -> arenaLocation.clone().add(0, arena.getSpawnHeight(), 0)).collect(Collectors.toList()));
// iterate over each player
arena.getPlayers().forEach(player -> playerJoin(player, false));
}
@Override
public void stop() {
super.stop();
this.spawnLocations.clear();
this.usedLocations.clear();
}
@Override
public void playerJoin(Player player) {
playerJoin(player, true);
}
private void playerJoin(Player player, boolean newPlayer) {
// checks if the player has the arena permission
if(!arena.getPermissionGroup().hasPermission(player)) {
// sends the no permission message to the player
player.sendMessage(CoreLang.NO_PERMISSION_ARENA.getMessage(player));
return;
}
IPlayer iPlayer = playerManager.getPlayer(player);
Location spawnLocation;
if(spawnLocations.isEmpty()) {
spawnLocation = iPlayer.getGameTeam().getSpawn();
} else {
spawnLocation = Utils.getFromCollection(spawnLocations, t -> !usedLocations.containsValue(t));
}
preTeleport(iPlayer, spawnLocation);
Location clone = spawnLocation.clone();
clone.setX(spawnLocation.getBlockX() + 0.5);
clone.setZ(spawnLocation.getBlockZ() + 0.5);
clone.setY(spawnLocation.getBlockY() + 2);
if(iPlayer.isFullyJoined()) {
player.teleport(clone);
player.setVelocity(new Vector(0, 0, 0));
} else {
iPlayer.setJoinLocation(clone);
}
usedLocations.put(player, spawnLocation);
if(newPlayer) {
// sets the arena of the player and saves the player state
playerManager.getPlayer(player).setCurrentArena(arena);
iPlayer.executeWhenFullyLoaded(player1 -> {
player1.getPlayerInventory().savePlayer();
});
} else {
player.getInventory().clear();
}
// give items
iPlayer.executeWhenFullyLoaded(player1 -> {
player.getInventory().setItem(0, new ItemStackBuilder().material(Material.NETHER_STAR).name(player, CoreLang.LOBBY_CHOOSE_KIT));
player.getInventory().setItem(8, new ItemStackBuilder().material(Material.MAGMA_CREAM).name(player, CoreLang.LOBBY_LEAVE));
// if the player has the admin permission
if(player.hasPermission(Permission.ADMIN.getBukkitPermission())) {
// give the admin the admin item
player.getInventory().setItem(7, new ItemStackBuilder().material(Material.COMPARATOR).name(player, CoreLang.LOBBY_ADMIN_MENU));
}
});
// add the player to the cooldown list
// this prevents instantly leaving the arena if the slot selected
// was the one with the leave item and the join method was by right
// clicking a sign to join
arena.getFeature(LobbyFeature.class).playerJoin(player);
if(newPlayer) {
// add the player to the arena
arena.getPlayers().add(player);
// send the player joined message to the arena
arena.sendMessageToArena(locale -> CoreLang.PLAYER_JOINED.getMessage(locale).replace("%player%", player.getName()).replace("%players%", arena.getPlayers().size() + "").replace("%max_players%", arena.getMaxPlayers() + ""));
iPlayer.executeWhenFullyLoaded(player1 -> {
// call event
plugin.getServer().getPluginManager().callEvent(new LobbyJoinEvent(player, arena));
});
}
signManager.updateSigns();
}
protected void preTeleport(IPlayer player, Location location) { }
@Override
public ArenaState getArenaState() {
return getPreviousPhase() == null ? ArenaState.WAITING : getPreviousPhase().getArenaState();
}
public void setAutoStart(boolean autoStart) {
this.autoStart = autoStart;
}
}
| 6,976 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CombatTracker.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/CombatTracker.java | package me.patothebest.gamecore.combat;
import me.patothebest.gamecore.util.Tickable;
import org.bukkit.Material;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.inventory.ItemStack;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class CombatTracker implements Tickable {
private final LinkedList<CombatEntry> entries = new LinkedList<>();
private int aliveTicks = 0;
private boolean noTrack = false;
@Override
public void tick() {
if (!entries.isEmpty()) {
if (aliveTicks - entries.getLast().getTick() > 300) {
entries.clear();
}
}
aliveTicks++;
}
public void trackDamage(EntityDamageEvent entityDamageEvent, boolean noTrack) {
if (this.noTrack) {
this.noTrack = false;
return;
}
this.noTrack = noTrack;
entries.add(new CombatEntry(aliveTicks, entityDamageEvent));
}
public CombatDeathEvent onDeath(Player player) {
List<ItemStack> drops = new ArrayList<>();
for (ItemStack itemStack : player.getInventory().getContents()) {
if(itemStack != null && itemStack.getType() != Material.AIR) {
drops.add(itemStack);
}
}
for (ItemStack itemStack : player.getInventory().getArmorContents()) {
if(itemStack != null && itemStack.getType() != Material.AIR) {
drops.add(itemStack);
}
}
if (entries.isEmpty()) {
return new CombatDeathEvent(player, drops, null, entries, null, null, null, "");
}
CombatEntry reason = entries.getLast();
WeakReference<Entity> killer = reason.getKiller();
WeakReference<Player> playerKiller = reason.getPlayerKiller();
ItemStack killedWith = reason.getItemKilledWith();
int prevId = entries.size() - 1;
CombatEntry prev = reason;
while (killer == null && prevId > 0 && prev.hasOption(DamageOption.WHILE_ESCAPING_OPTIONAL)) {
prev = entries.get(--prevId);
killer = prev.getKiller();
playerKiller = prev.getPlayerKiller();
killedWith = prev.getItemKilledWith();
}
Entity killerEntity = killer == null ? null : killer.get();
if (killerEntity != null && killerEntity.isDead()) {
killerEntity = null;
}
Player killerPlayer = playerKiller == null ? null : playerKiller.get();
if (killerPlayer != null && (killerPlayer.isDead() || !killerPlayer.isOnline())) {
killerPlayer = null;
}
return new CombatDeathEvent(player, drops, reason, entries, killedWith, killerEntity, killerPlayer, "");
}
public void reset() {
this.entries.clear();
this.aliveTicks = 0;
this.noTrack = false;
}
}
| 3,001 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DamageOption.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/DamageOption.java | package me.patothebest.gamecore.combat;
public enum DamageOption {
WHILE_ESCAPING_OPTIONAL,
ENTITY_NAME_OPTIONAL,
ENTITY_NAME_REQUIRED,
ITEM_OPTIONAL
}
| 171 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DeathCause.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/DeathCause.java | package me.patothebest.gamecore.combat;
public enum DeathCause {
ANVIL,
ARROW,
BORDER,
CACTUS,
CRAMMING,
DRAGON_BREATH,
DROWN,
EXPLOSION,
FALL,
FALLING_BLOCK,
FIREBALL,
FIREWORKS,
FLY_INTO_WALL,
GENERIC,
HOT_FLOOR,
INDIRECT_MAGIC,
IN_FIRE,
IN_WALL,
LAVA,
LIGHTNING_BOLT,
MAGIC,
MOB,
NETHER_BED,
ON_FIRE,
OUT_OF_WORLD,
PLAYER,
STARVE,
STING,
SWEET_BERRY_BUSH,
THORNS,
THROWN,
TRIDENT,
WITHER,
}
| 530 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DeathCauseTranslator.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/DeathCauseTranslator.java | package me.patothebest.gamecore.combat;
import org.bukkit.event.entity.EntityDamageEvent;
public abstract class DeathCauseTranslator<T extends EntityDamageEvent> {
private final Class<T> eventClass;
public DeathCauseTranslator(Class<T> eventClass) {
this.eventClass = eventClass;
}
public abstract DeathCause getDeathCause(T event);
public abstract DamageOption[] getDamageOptions(DeathCause deathCause);
public Class<T> getEventClass() {
return eventClass;
}
}
| 513 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DamageCause.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/DamageCause.java | package me.patothebest.gamecore.combat;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.block.Block;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.FallingBlock;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.event.entity.EntityDamageByBlockEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
/**
* An enum to specify the cause of the damage
*/
public enum DamageCause {
/**
* Damage caused by being in the area when a block explodes.
* <p>
* Damage: variable
*/
BLOCK_EXPLOSION(DeathCause.EXPLOSION, DamageOption.ENTITY_NAME_OPTIONAL, DamageOption.ITEM_OPTIONAL),
/**
* Damage caused when an entity contacts a block such as a Cactus.
* <p>
* Damage: 1 (Cactus)
*/
CONTACT(new DeathCauseTranslator<EntityDamageByBlockEvent>(EntityDamageByBlockEvent.class) {
@Override
public DeathCause getDeathCause(EntityDamageByBlockEvent event) {
Player player = (Player) event.getEntity();
Block block = event.getDamager();
if (block == null) {
Utils.printError("Could not find block the player had contact with!", "Player: " + player.getName(), "Damage Cause: Contact");
return DeathCause.GENERIC;
}
if (block.getType() == Material.CACTUS.parseMaterial()) {
return DeathCause.CACTUS;
} else if (block.getType() == Material.SWEET_BERRY_BUSH.parseMaterial()) {
return DeathCause.SWEET_BERRY_BUSH;
}else if (block.getType() == Material.BARRIER.parseMaterial()) {
return DeathCause.BORDER;
}
Utils.printError("Could not find block the player had contact with!", "Player: " + player.getName(), "Damage Cause: Contact");
return DeathCause.GENERIC;
}
@Override
public DamageOption[] getDamageOptions(DeathCause deathCause) {
return new DamageOption[] { DamageOption.WHILE_ESCAPING_OPTIONAL};
}
}),
/**
* Damage caused when an entity is colliding with too many entities due
* to the maxEntityCramming game rule.
* <p>
* Damage: 6
*/
CRAMMING(DeathCause.CRAMMING, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Custom damage.
* <p>
* Damage: variable
*/
CUSTOM(DeathCause.GENERIC),
/**
* Damage caused by a dragon breathing fire.
* <p>
* Damage: variable
*/
DRAGON_BREATH(DeathCause.DRAGON_BREATH, DamageOption.ENTITY_NAME_OPTIONAL),
/**
* Damage caused by running out of air while in water
* <p>
* Damage: 2
*/
DROWNING(DeathCause.DROWN, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused when an entity that should be in water is not.
* <p>
* Damage: 1
*/
// Not supposed to be called for players
@Deprecated
DRYOUT(DeathCause.GENERIC),
/**
* Damage caused when an entity attacks another entity.
* <p>
* Damage: variable
*/
ENTITY_ATTACK(new DeathCauseTranslator<EntityDamageByEntityEvent>(EntityDamageByEntityEvent.class) {
@Override
public DeathCause getDeathCause(EntityDamageByEntityEvent event) {
EntityType type = event.getDamager().getType();
if (type == EntityType.PLAYER) {
return DeathCause.PLAYER;
} else if (type == EntityType.FIREWORK) {
return DeathCause.FIREWORKS;
} else if (type.name().equals("BEE")) {
return DeathCause.STING;
} else {
return DeathCause.MOB;
}
}
@Override
public DamageOption[] getDamageOptions(DeathCause deathCause) {
if (deathCause == DeathCause.FIREWORKS || deathCause == DeathCause.STING) {
return new DamageOption[] { DamageOption.ENTITY_NAME_OPTIONAL};
}
return new DamageOption[] { DamageOption.ENTITY_NAME_REQUIRED, DamageOption.ITEM_OPTIONAL };
}
}),
/**
* Damage caused by being in the area when an entity, such as a
* Creeper, explodes.
* <p>
* Damage: variable
*/
ENTITY_EXPLOSION(DeathCause.EXPLOSION, DamageOption.ENTITY_NAME_OPTIONAL, DamageOption.ITEM_OPTIONAL),
/**
* Damage caused when an entity attacks another entity in a sweep attack.
* <p>
* Damage: variable
*/
ENTITY_SWEEP_ATTACK(new DeathCauseTranslator<EntityDamageByEntityEvent>(EntityDamageByEntityEvent.class) {
@Override
public DeathCause getDeathCause(EntityDamageByEntityEvent event) {
EntityType type = event.getDamager().getType();
if (type == EntityType.PLAYER) {
return DeathCause.PLAYER;
} else {
return DeathCause.MOB;
}
}
@Override
public DamageOption[] getDamageOptions(DeathCause deathCause) {
return new DamageOption[] { DamageOption.ENTITY_NAME_REQUIRED, DamageOption.ITEM_OPTIONAL };
}
}),
/**
* Damage caused when an entity falls a distance greater than 3 blocks
* <p>
* Damage: fall height - 3.0
*/
FALL(DeathCause.FALL, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused by being hit by a falling block which deals damage
* <p>
* <b>Note:</b> Not every block deals damage
* <p>
* Damage: variable
*/
FALLING_BLOCK(new DeathCauseTranslator<EntityDamageByEntityEvent>(EntityDamageByEntityEvent.class) {
@Override
public DeathCause getDeathCause(EntityDamageByEntityEvent event) {
Entity damager = event.getDamager();
if (damager instanceof FallingBlock) {
// TODO: Fix pre 1.13 (FallingBlock.getMaterial is now FallingBlock.getBlockData().getMaterial())
Material material = Material.matchMaterial(((FallingBlock) damager).getBlockData().getMaterial());
if (material == Material.ANVIL) {
return DeathCause.ANVIL;
}
}
return DeathCause.FALLING_BLOCK;
}
@Override
public DamageOption[] getDamageOptions(DeathCause deathCause) {
return new DamageOption[] { DamageOption.WHILE_ESCAPING_OPTIONAL};
}
}),
/**
* Damage caused by direct exposure to fire
* <p>
* Damage: 1
*/
FIRE(DeathCause.IN_FIRE, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused due to burns caused by fire
* <p>
* Damage: 1
*/
FIRE_TICK(DeathCause.ON_FIRE, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused when an entity runs into a wall.
* <p>
* Damage: variable
*/
FLY_INTO_WALL(DeathCause.FLY_INTO_WALL, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused when an entity steps on {@link Material#MAGMA_BLOCK}.
* <p>
* Damage: 1
*/
HOT_FLOOR(DeathCause.HOT_FLOOR, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused by direct exposure to lava
* <p>
* Damage: 4
*/
LAVA(DeathCause.LAVA, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused by being struck by lightning
* <p>
* Damage: 5
*/
LIGHTNING(DeathCause.LIGHTNING_BOLT, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused by being hit by a damage potion or spell
* <p>
* Damage: variable
*/
MAGIC(DeathCause.MAGIC, DamageOption.ENTITY_NAME_OPTIONAL, DamageOption.ITEM_OPTIONAL),
/**
* Damage caused due to a snowman melting
* <p>
* Damage: 1
*/
// This is not a cause for players, so we use it for the border
MELTING(DeathCause.BORDER, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused due to an ongoing poison effect
* <p>
* Damage: 1
*/
// Shouldn't be a death cause
@Deprecated
POISON(DeathCause.MAGIC),
/**
* Damage caused when attacked by a projectile.
* <p>
* Damage: variable
*/
PROJECTILE(new DeathCauseTranslator<EntityDamageByEntityEvent>(EntityDamageByEntityEvent.class) {
@Override
public DeathCause getDeathCause(EntityDamageByEntityEvent event) {
// - fix for fishing rods -
// apparently fishing rod damage is caused by a projectile
// but the projectile is a player cause the fishing bob isn't
// a projectile
if (event.getDamager() instanceof Player) {
return DeathCause.THROWN;
}
Projectile projectile = (Projectile) event.getDamager();
String name = projectile.getType().name();
switch (name) {
case "ARROW":
case "SPECTRAL_ARROW": {
return DeathCause.ARROW;
}
case "TRIDENT": {
return DeathCause.TRIDENT;
}
case "FIREBALL":
case "SMALL_FIREBALL": {
return DeathCause.FIREBALL;
}
case "SHULKER_BULLET":
case "EGG":
case "SNOWBALL":
case "FISHING_HOOK":
case "ENDER_PEARL": {
return DeathCause.THROWN;
}
}
Utils.printError("Unknown projectile damage source: "+ name);
return DeathCause.THROWN;
}
@Override
public DamageOption[] getDamageOptions(DeathCause deathCause) {
return new DamageOption[] { DamageOption.ENTITY_NAME_REQUIRED, DamageOption.ITEM_OPTIONAL };
}
}),
/**
* Damage caused by starving due to having an empty hunger bar
* <p>
* Damage: 1
*/
STARVATION(DeathCause.STARVE, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused by being put in a block
* <p>
* Damage: 1
*/
SUFFOCATION(DeathCause.IN_WALL, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused by committing suicide using the command "/kill"
* <p>
* Damage: 1000
*/
SUICIDE(DeathCause.GENERIC),
/**
* Damage caused in retaliation to another attack by the Thorns
* enchantment.
* <p>
* Damage: 1-4 (Thorns)
*/
THORNS(DeathCause.THORNS, DamageOption.ENTITY_NAME_REQUIRED, DamageOption.ITEM_OPTIONAL),
/**
* Damage caused by falling into the void
* <p>
* Damage: 4 for players
*/
VOID(DeathCause.OUT_OF_WORLD, DamageOption.WHILE_ESCAPING_OPTIONAL),
/**
* Damage caused by Wither potion effect
*/
WITHER(DeathCause.WITHER, DamageOption.WHILE_ESCAPING_OPTIONAL);
private static final BiMap<EntityDamageEvent.DamageCause, DamageCause> DAMAGE_CAUSE_MAP = HashBiMap.create();
private final DeathCauseTranslator deathCauseTranslator;
DamageCause(DeathCause deathCause, DamageOption... damageOptions) {
this.deathCauseTranslator = new DeathCauseTranslator<EntityDamageEvent>(EntityDamageEvent.class) {
@Override
public DeathCause getDeathCause(EntityDamageEvent event) {
return deathCause;
}
@Override
public DamageOption[] getDamageOptions(DeathCause deathCause) {
return damageOptions;
}
};
}
DamageCause(DeathCauseTranslator deathCauseTranslator) {
this.deathCauseTranslator = deathCauseTranslator;
}
public DeathCauseTranslator getDeathCauseTranslator() {
return deathCauseTranslator;
}
public static DamageCause getCause(EntityDamageEvent.DamageCause damageCause) {
return DAMAGE_CAUSE_MAP.get(damageCause);
}
public static EntityDamageEvent.DamageCause getCause(DamageCause damageCause) {
return DAMAGE_CAUSE_MAP.inverse().get(damageCause);
}
static {
for (EntityDamageEvent.DamageCause value : EntityDamageEvent.DamageCause.values()) {
DamageCause damageCause = DamageCause.valueOf(value.name());
//noinspection ConstantConditions
if (damageCause == null) {
Utils.printError("Unknown damage cause " + value.name());
damageCause = DamageCause.CUSTOM;
}
DAMAGE_CAUSE_MAP.put(value, damageCause);
}
}
} | 12,736 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CombatManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/CombatManager.java | package me.patothebest.gamecore.combat;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.event.EventRegistry;
import me.patothebest.gamecore.util.WrappedBukkitRunnable;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.ItemStack;
import javax.inject.Inject;
import java.util.HashMap;
import java.util.Map;
public class CombatManager extends WrappedBukkitRunnable implements ActivableModule, ListenerModule {
private final Map<Player, CombatTracker> combatTrackers = new HashMap<>();
private final CorePlugin plugin;
private final EventRegistry eventRegistry;
private final Map<Player, CombatDeathEvent> deathEvents = new HashMap<>();
@Inject
private CombatManager(CorePlugin plugin, EventRegistry eventRegistry) {
this.plugin = plugin;
this.eventRegistry = eventRegistry;
}
@Override
public void onEnable() {
runTaskTimer(plugin, 1L, 1L);
}
@Override
public void onDisable() {
cancel();
}
@Override
public void run() {
combatTrackers.values().forEach(CombatTracker::tick);
}
@EventHandler
public void onPlayerJoin(PlayerJoinEvent event) {
combatTrackers.put(event.getPlayer(), new CombatTracker());
}
@EventHandler(priority = EventPriority.MONITOR)
public void onLeave(PlayerQuitEvent event) {
combatTrackers.remove(event.getPlayer());
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onDamage(EntityDamageEvent event) {
if (!(event.getEntity() instanceof Player)) {
return;
}
Player player = (Player) event.getEntity();
combatTrackers.get(player).trackDamage(event, false);
if (event.getFinalDamage() >= (player).getHealth()) {
Location playerLocation = player.getLocation();
CombatDeathEvent combatDeathEvent = callDeathEvent(player);
if (!combatDeathEvent.isCancelled()) {
deathEvents.put(player, combatDeathEvent);
} else {
event.setDamage(0);
for (ItemStack drop : combatDeathEvent.getDrops()) {
if(drop != null) {
player.getWorld().dropItemNaturally(playerLocation, drop);
}
}
}
}
}
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerDeath(PlayerDeathEvent event) {
CombatDeathEvent combatDeathEvent = deathEvents.remove(event.getEntity());
if (combatDeathEvent == null) {
Utils.printError("Unhandled death event!", event.getEntity().getName(), event.getDeathMessage());
return;
}
event.setDeathMessage(combatDeathEvent.getDeathMessage());
event.getDrops().removeIf(itemStack -> !combatDeathEvent.getDrops().contains(itemStack));
}
public void damagePlayer(Player player, DamageCause damageCause, double damage) {
combatTrackers.get(player).trackDamage(new EntityDamageEvent(player, DamageCause.getCause(damageCause), damage), true);
if (player.getHealth() <= damage) {
killPlayer(player, true);
} else {
player.damage(damage);
}
}
/**
* Kills a player
* <p>
* This will call {@link CombatDeathEvent}.
* If the event is cancelled, the items will drop (if any) on the player's
* death location.
* If the event is not cancelled, the player's health will be set to 0,
* triggering spigot's {@link PlayerDeathEvent} and shows the death screen.
* <p>
* The delegateEvent boolean is to override the isCancelled and never call
* spigot's death event, regardless of the event state.
*
* @param player the player
* @param delegateEvent whether to delegate the event to spigot
*/
public void killPlayer(Player player, boolean delegateEvent) {
Location playerLocation = player.getLocation();
CombatDeathEvent combatDeathEvent = callDeathEvent(player);
if (!combatDeathEvent.isCancelled() && delegateEvent) {
deathEvents.put(player, combatDeathEvent);
player.setHealth(0);
} else {
for (ItemStack drop : combatDeathEvent.getDrops()) {
if(drop != null) {
player.getWorld().dropItemNaturally(playerLocation, drop);
}
}
}
}
private CombatDeathEvent callDeathEvent(Player player) {
CombatTracker combatTracker = combatTrackers.get(player);
CombatDeathEvent combatDeathEvent = combatTracker.onDeath(player);
eventRegistry.callEvent(combatDeathEvent);
combatTracker.reset();
return combatDeathEvent;
}
}
| 5,269 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CombatDeathEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/CombatDeathEvent.java | package me.patothebest.gamecore.combat;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
import org.bukkit.inventory.ItemStack;
import javax.annotation.Nullable;
import java.util.LinkedList;
import java.util.List;
public class CombatDeathEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final List<ItemStack> drops;
private final CombatEntry lastDamage;
private final LinkedList<CombatEntry> combatEntries;
private final ItemStack itemKilledWith;
private final Entity killer;
private final Player killerPlayer;
private String deathMessage = "";
private boolean cancelled = false;
public CombatDeathEvent(Player player, List<ItemStack> drops, CombatEntry lastDamage, LinkedList<CombatEntry> combatEntries, ItemStack itemKilledWith, Entity killer, Player killerPlayer, String deathMessage) {
super(player);
this.drops = drops;
this.lastDamage = lastDamage;
this.combatEntries = combatEntries;
this.itemKilledWith = itemKilledWith;
this.killer = killer;
this.killerPlayer = killerPlayer;
this.deathMessage = deathMessage;
}
public DeathCause getDeathCause() {
if (lastDamage == null) {
return DeathCause.GENERIC;
}
return lastDamage.getDeathCause();
}
@Nullable
public ItemStack getItemKilledWith() {
return itemKilledWith;
}
@Nullable
public Entity getKiller() {
return killer;
}
/**
* This will return the player if the killer is a player, or
* will return the entity owner (pet owner)
* @return the player killer
*/
@Nullable
public Player getKillerPlayer() {
return killerPlayer;
}
public String getDeathMessage() {
return deathMessage;
}
public void setDeathMessage(String deathMessage) {
this.deathMessage = deathMessage;
}
public List<ItemStack> getDrops() {
return drops;
}
public CombatEntry getLastDamage() {
return lastDamage;
}
public LinkedList<CombatEntry> getCombatEvents() {
return combatEntries;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancel) {
this.cancelled = cancel;
}
}
| 2,688 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CombatModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/CombatModule.java | package me.patothebest.gamecore.combat;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
public class CombatModule extends AbstractBukkitModule<CorePlugin> {
public CombatModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
registerModule(CombatManager.class);
}
}
| 392 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CombatEntry.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/combat/CombatEntry.java | package me.patothebest.gamecore.combat;
import org.bukkit.Material;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.inventory.ItemStack;
import java.lang.ref.WeakReference;
public class CombatEntry {
private final int tick;
private final DamageCause damageCause;
private final DeathCause deathCause;
private final DamageOption[] damageOptions;
private final double damage;
private WeakReference<Player> playerKiller = null;
private WeakReference<Entity> killer = null;
private ItemStack itemKilledWith = null;
@SuppressWarnings("unchecked")
CombatEntry(int tick, EntityDamageEvent event) {
this.tick = tick;
this.damageCause = DamageCause.getCause(event.getCause());
if (!damageCause.getDeathCauseTranslator().getEventClass().isAssignableFrom(event.getClass())) {
throw new IllegalArgumentException(damageCause.getDeathCauseTranslator().getEventClass() + " is not assignable from " + event.getClass() + "! DamageCause: " + damageCause);
}
this.deathCause = damageCause.getDeathCauseTranslator().getDeathCause(event);
this.damage = event.getFinalDamage();
this.damageOptions = damageCause.getDeathCauseTranslator().getDamageOptions(deathCause);
Entity tempKiller = null;
if (event instanceof EntityDamageByEntityEvent) {
EntityDamageByEntityEvent entityDamageByEntityEvent = (EntityDamageByEntityEvent) event;
for (DamageOption damageOption : damageOptions) {
if (damageOption == DamageOption.ITEM_OPTIONAL) {
if (entityDamageByEntityEvent.getDamager() instanceof Player) {
itemKilledWith = ((Player) entityDamageByEntityEvent.getDamager()).getItemInHand();
if (itemKilledWith == null || itemKilledWith.getType() == Material.AIR) {
itemKilledWith = null;
}
}
} else if(damageOption == DamageOption.ENTITY_NAME_OPTIONAL || damageOption == DamageOption.ENTITY_NAME_REQUIRED) {
if (entityDamageByEntityEvent.getCause() == EntityDamageEvent.DamageCause.PROJECTILE) {
if (entityDamageByEntityEvent.getDamager() instanceof Player) {
tempKiller = entityDamageByEntityEvent.getDamager();
} else {
Projectile projectile = (Projectile) entityDamageByEntityEvent.getDamager();
Entity shooter = (projectile.getShooter() instanceof LivingEntity) ? (Entity) projectile.getShooter() : null;
if (shooter != null) {
tempKiller = shooter;
}
}
} else {
tempKiller = entityDamageByEntityEvent.getDamager();
}
}
}
}
if (tempKiller != null) {
if (tempKiller instanceof Player) {
playerKiller = new WeakReference<>((Player) tempKiller);
} else if (tempKiller.hasMetadata("PetOwner") && !tempKiller.getMetadata("PetOwner").isEmpty()) {
Player petOwner = (Player) tempKiller.getMetadata("PetOwner").get(0).value();
if (petOwner != null) {
playerKiller = new WeakReference<>(petOwner);
}
}
killer = new WeakReference<>(tempKiller);
}
}
public int getTick() {
return tick;
}
public DamageCause getDamageCause() {
return damageCause;
}
public DeathCause getDeathCause() {
return deathCause;
}
public DamageOption[] getDamageOptions() {
return damageOptions;
}
public boolean hasOption(DamageOption damageOption) {
for (DamageOption option : damageOptions) {
if (damageOption == option) {
return true;
}
}
return false;
}
public double getDamage() {
return damage;
}
public WeakReference<Entity> getKiller() {
return killer;
}
public WeakReference<Player> getPlayerKiller() {
return playerKiller;
}
public ItemStack getItemKilledWith() {
return itemKilledWith;
}
}
| 4,613 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Hologram.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/hologram/Hologram.java | package me.patothebest.gamecore.hologram;
import org.apache.commons.lang.Validate;
import org.bukkit.entity.ArmorStand;
import java.lang.ref.WeakReference;
public class Hologram {
private final WeakReference<ArmorStand> armorStand;
public Hologram(ArmorStand armorStandParam) {
armorStand = new WeakReference<>(armorStandParam);
armorStand.get().setVisible(false);
armorStand.get().setGravity(false);
armorStand.get().setMarker(true);
armorStand.get().setCustomNameVisible(true);
armorStand.get().setRemoveWhenFarAway(false);
}
public void setName(String name) {
validate();
armorStand.get().setCustomName(name);
}
public void hide() {
validate();
armorStand.get().setCustomNameVisible(false);
}
public void show() {
validate();
armorStand.get().setCustomNameVisible(true);
}
public void delete() {
validate();
armorStand.get().remove();
}
public boolean isAlive() {
return armorStand.get() != null && !armorStand.get().isDead();
}
private void validate() {
Validate.notNull(armorStand.get(), "Armor stand is null");
Validate.isTrue(!armorStand.get().isDead(), "Armor stand is dead");
}
public WeakReference<ArmorStand> getArmorStand() {
return armorStand;
}
}
| 1,385 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Title1_8_1_10.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/title/Title1_8_1_10.java | package me.patothebest.gamecore.title;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
/**
* Minecraft 1.8 (1.9 and 1.10) Title
*
* @version 1.0.4
* @author Maxim Van de Wynckel modified by PatoTheBest for GameCore
*/
class Title1_8_1_10 extends AbstractTitle {
Title1_8_1_10(String title) {
super(title);
}
@Override
protected void loadClasses() {
if (packetTitle == null) {
packetTitle = getNMSClass("PacketPlayOutTitle");
packetActions = getNMSClass("PacketPlayOutTitle$EnumTitleAction");
chatBaseComponent = getNMSClass("IChatBaseComponent");
nmsChatSerializer = getNMSClass("ChatComponentText");
}
}
@Override
public void send(Player player) {
if (packetTitle != null) {
// First reset previous settings
resetTitle(player);
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent, Integer.TYPE, Integer.TYPE, Integer.TYPE).newInstance(actions[2], null, fadeInTime * (ticks ? 1 : 20), stayTime * (ticks ? 1 : 20), fadeOutTime * (ticks ? 1 : 20));
// Send if set
if (fadeInTime != -1 && fadeOutTime != -1 && stayTime != -1) {
Utils.sendPacket(player, packet);
}
// Send title
Object serialized = nmsChatSerializer.getConstructor(String.class).newInstance(ChatColor.translateAlternateColorCodes('&', title));
packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[0], serialized);
Utils.sendPacket(player, packet);
if (subtitle != null && !subtitle.isEmpty()) {
// Send subtitle if present
serialized = nmsChatSerializer.getConstructor(String.class).newInstance(ChatColor.translateAlternateColorCodes('&', subtitle));
packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[1], serialized);
Utils.sendPacket(player, packet);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public void clearTitle(Player player) {
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[3], null);
Utils.sendPacket(player, packet);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void resetTitle(Player player) {
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[4], null);
Utils.sendPacket(player, packet);
} catch (Exception e) {
e.printStackTrace();
}
}
}
| 3,247 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Title1_11_1_16.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/title/Title1_11_1_16.java | package me.patothebest.gamecore.title;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
/**
* Minecraft 1.11 and 1.16
*
* @author Maxim Van de Wynckel modified by PatoTheBest for GameCore
* @version 1.0.4
*/
class Title1_11_1_16 extends AbstractTitle {
Title1_11_1_16(String title) {
super(title);
}
@Override
protected void loadClasses() {
if (packetTitle == null) {
packetTitle = getNMSClass("PacketPlayOutTitle");
packetActions = getNMSClass("PacketPlayOutTitle$EnumTitleAction");
chatBaseComponent = getNMSClass("IChatBaseComponent");
nmsChatSerializer = getNMSClass("ChatComponentText");
}
}
@Override
public void send(Player player) {
if (packetTitle != null) {
// First reset previous settings
resetTitle(player);
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent, Integer.TYPE, Integer.TYPE, Integer.TYPE).newInstance(actions[3], null, fadeInTime * (ticks ? 1 : 20), stayTime * (ticks ? 1 : 20), fadeOutTime * (ticks ? 1 : 20));
// Send if set
if (fadeInTime != -1 && fadeOutTime != -1 && stayTime != -1) {
Utils.sendPacket(player, packet);
}
Object serialized;
if (!subtitle.equals("")) {
// Send subtitle if present
serialized = nmsChatSerializer.getConstructor(String.class).newInstance(subtitleColor + ChatColor.translateAlternateColorCodes('&', subtitle));
packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[1], serialized);
Utils.sendPacket(player, packet);
}
// Send title
serialized = nmsChatSerializer.getConstructor(String.class).newInstance(titleColor + ChatColor.translateAlternateColorCodes('&', title));
packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[0], serialized);
Utils.sendPacket(player, packet);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public void clearTitle(Player player) {
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[4], null);
Utils.sendPacket(player, packet);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void resetTitle(Player player) {
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[5], null);
Utils.sendPacket(player, packet);
} catch (Exception e) {
e.printStackTrace();
}
}
}
| 3,277 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AbstractTitle.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/title/AbstractTitle.java | package me.patothebest.gamecore.title;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
abstract class AbstractTitle implements Title {
/* Title packet */ Class<?> packetTitle;
/* Title packet actions ENUM */ Class<?> packetActions;
/* Chat serializer */ Class<?> nmsChatSerializer;
Class<?> chatBaseComponent;
/* Title text and color */ String title = "";
ChatColor titleColor = ChatColor.WHITE;
/* Subtitle text and color */ String subtitle = "";
ChatColor subtitleColor = ChatColor.WHITE;
/* Title timings */ int fadeInTime = -1;
int stayTime = -1;
int fadeOutTime = -1;
boolean ticks = false;
private static final Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<>();
/**
* Create a new 1.8 title
*
* @param title Title
*/
AbstractTitle(String title) {
this.title = title;
loadClasses();
}
/**
* Create a new 1.8 title
*
* @param title Title text
* @param subtitle Subtitle text
*/
public AbstractTitle(String title, String subtitle) {
this.title = title;
this.subtitle = subtitle;
loadClasses();
}
/**
* Copy 1.8 title
*
* @param title Title
*/
public AbstractTitle(AbstractTitle title) {
// Copy title
this.title = title.title;
this.subtitle = title.subtitle;
this.titleColor = title.titleColor;
this.subtitleColor = title.subtitleColor;
this.fadeInTime = title.fadeInTime;
this.fadeOutTime = title.fadeOutTime;
this.stayTime = title.stayTime;
this.ticks = title.ticks;
loadClasses();
}
/**
* Create a new 1.8 title
*
* @param title Title text
* @param subtitle Subtitle text
* @param fadeInTime Fade in time
* @param stayTime Stay on screen time
* @param fadeOutTime Fade out time
*/
public AbstractTitle(String title, String subtitle, int fadeInTime, int stayTime, int fadeOutTime) {
this.title = title;
this.subtitle = subtitle;
this.fadeInTime = fadeInTime;
this.stayTime = stayTime;
this.fadeOutTime = fadeOutTime;
loadClasses();
}
/**
* Load spigot and NMS classes
*/
protected abstract void loadClasses();
/**
* Set title text
*
* @param title Title
*/
@Override
public void setTitle(String title) {
this.title = title;
}
/**
* Get title text
*
* @return Title text
*/
@Override
public String getTitle() {
return this.title;
}
/**
* Set subtitle text
*
* @param subtitle Subtitle text
*/
@Override
public void setSubtitle(String subtitle) {
this.subtitle = subtitle;
}
/**
* Get subtitle text
*
* @return Subtitle text
*/
@Override
public String getSubtitle() {
return this.subtitle;
}
/**
* Set the title color
*
* @param color Chat color
*/
@Override
public void setTitleColor(ChatColor color) {
this.titleColor = color;
}
/**
* Set the subtitle color
*
* @param color Chat color
*/
@Override
public void setSubtitleColor(ChatColor color) {
this.subtitleColor = color;
}
/**
* Set title fade in time
*
* @param time Time
*/
@Override
public void setFadeInTime(int time) {
this.fadeInTime = time;
}
/**
* Set title fade out time
*
* @param time Time
*/
@Override
public void setFadeOutTime(int time) {
this.fadeOutTime = time;
}
/**
* Set title stay time
*
* @param time Time
*/
@Override
public void setStayTime(int time) {
this.stayTime = time;
}
/**
* Set timings to ticks
*/
@Override
public void setTimingsToTicks() {
ticks = true;
}
/**
* Set timings to seconds
*/
@Override
public void setTimingsToSeconds() {
ticks = false;
}
/**
* Broadcast the title to all players
*/
@Override
public void broadcast() {
Bukkit.getOnlinePlayers().forEach(this::send);
}
/**
* Check if running spigot
*
* @return Spigot
*/
boolean isSpigot() {
return Bukkit.getVersion().contains("Spigot");
}
/**
* Get class by url
*
* @param namespace Namespace url
* @return Class
*/
Class<?> getClass(String namespace) {
try {
return Class.forName(namespace);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private Field getField(String name, Class<?> clazz) throws Exception {
return clazz.getDeclaredField(name);
}
Object getValue(String name, Object obj) throws Exception {
Field f = getField(name, obj.getClass());
f.setAccessible(true);
return f.get(obj);
}
private Class<?> getPrimitiveType(Class<?> clazz) {
return CORRESPONDING_TYPES
.getOrDefault(clazz, clazz);
}
private Class<?>[] toPrimitiveTypeArray(Class<?>[] classes) {
int a = classes != null ? classes.length : 0;
Class<?>[] types = new Class<?>[a];
for (int i = 0; i < a; i++)
types[i] = getPrimitiveType(classes[i]);
return types;
}
private static boolean equalsTypeArray(Class<?>[] a, Class<?>[] o) {
if (a.length != o.length)
return false;
for (int i = 0; i < a.length; i++)
if (!a[i].equals(o[i]) && !a[i].isAssignableFrom(o[i]))
return false;
return true;
}
Object getHandle(Object obj) {
try {
return getMethod("getHandle", obj.getClass()).invoke(obj);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
Method getMethod(String name, Class<?> clazz, Class<?>... paramTypes) {
Class<?>[] t = toPrimitiveTypeArray(paramTypes);
for (Method m : clazz.getMethods()) {
Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
if (m.getName().equals(name) && equalsTypeArray(types, t))
return m;
}
return null;
}
private String getVersion() {
String name = Bukkit.getServer().getClass().getPackage().getName();
return name.substring(name.lastIndexOf('.') + 1) + ".";
}
Class<?> getNMSClass(String className) {
String fullName = "net.minecraft.server." + getVersion() + className;
Class<?> clazz = null;
try {
clazz = Class.forName(fullName);
} catch (Exception e) {
e.printStackTrace();
}
return clazz;
}
Field getField(Class<?> clazz, String name) {
try {
Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
return field;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
Method getMethod(Class<?> clazz, String name, Class<?>... args) {
for (Method m : clazz.getMethods())
if (m.getName().equals(name) && (args.length == 0 || ClassListEqual(args, m.getParameterTypes()))) {
m.setAccessible(true);
return m;
}
return null;
}
private boolean ClassListEqual(Class<?>[] l1, Class<?>[] l2) {
boolean equal = true;
if (l1.length != l2.length)
return false;
for (int i = 0; i < l1.length; i++)
if (l1[i] != l2[i]) {
equal = false;
break;
}
return equal;
}
}
| 8,000 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Title.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/title/Title.java | package me.patothebest.gamecore.title;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
public interface Title {
void setTitle(String title);
String getTitle();
void setSubtitle(String subtitle);
String getSubtitle();
void setTitleColor(ChatColor color);
void setSubtitleColor(ChatColor color);
void setFadeInTime(int time);
void setFadeOutTime(int time);
void setStayTime(int time);
void setTimingsToTicks();
void setTimingsToSeconds();
/**
* Send the title to a player
*
* @param player Player
*/
void send(Player player);
void broadcast();
/**
* Clear the title
*
* @param player Player
*/
void clearTitle(Player player);
/**
* Reset the title settings
*
* @param player Player
*/
void resetTitle(Player player);
}
| 884 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TitleProtocol1_7.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/title/TitleProtocol1_7.java | package me.patothebest.gamecore.title;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
/**
* Minecraft 1.7 Protocol Title
*
* @version 1.0.4
* @author Maxim Van de Wynckel modified by PatoTheBest for GameCore
*/
class TitleProtocol1_7 extends AbstractTitle {
TitleProtocol1_7(String title) {
super(title);
}
@Override
protected void loadClasses() {
packetTitle = getClass("org.spigotmc.ProtocolInjector$PacketTitle");
packetActions = getClass("org.spigotmc.ProtocolInjector$PacketTitle$Action");
nmsChatSerializer = getNMSClass("ChatSerializer");
}
/**
* Send the title to a player
*
* @param player Player
*/
public void send(Player player) {
if (getProtocolVersion(player) >= 47 && isSpigot() && packetTitle != null) {
// First reset previous settings
resetTitle(player);
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions, Integer.TYPE, Integer.TYPE, Integer.TYPE).newInstance( actions[2], fadeInTime * (ticks ? 1 : 20), stayTime * (ticks ? 1 : 20), fadeOutTime * (ticks ? 1 : 20));
// Send if set
if (fadeInTime != -1 && fadeOutTime != -1 && stayTime != -1)
Utils.sendPacket(player, packet);
// Send title
Object serialized = getMethod(nmsChatSerializer, "a", String.class).invoke(null, "{text:\"" + ChatColor.translateAlternateColorCodes('&', title) + "\",color:" + titleColor.name().toLowerCase() + "}");
packet = packetTitle.getConstructor(packetActions, getNMSClass("IChatBaseComponent")) .newInstance(actions[0], serialized);
Utils.sendPacket(player, packet);
if (subtitle != null && !subtitle.isEmpty()) {
// Send subtitle if present
serialized = getMethod(nmsChatSerializer, "a", String.class).invoke(null, "{text:\"" + ChatColor.translateAlternateColorCodes('&', subtitle) + "\",color:" + subtitleColor.name().toLowerCase() + "}");
packet = packetTitle.getConstructor(packetActions, getNMSClass("IChatBaseComponent")).newInstance(actions[1], serialized);
Utils.sendPacket(player, packet);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* Clear the title
*
* @param player Player
*/
public void clearTitle(Player player) {
if (getProtocolVersion(player) >= 47 && isSpigot()) {
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions).newInstance(actions[3]);
Utils.sendPacket(player, packet);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* Reset the title settings
*
* @param player Player
*/
public void resetTitle(Player player) {
if (getProtocolVersion(player) >= 47 && isSpigot()) {
try {
// Send timings first
Object[] actions = packetActions.getEnumConstants();
Object packet = packetTitle.getConstructor(packetActions).newInstance(actions[4]);
Utils.sendPacket(player, packet);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* Get the protocol version of the player
*
* @param player Player
* @return Protocol version
*/
private int getProtocolVersion(Player player) {
int version = 0;
try {
Object handle = getHandle(player);
Object connection = getField(handle.getClass(), "playerConnection").get(handle);
Object networkManager = getValue("networkManager", connection);
version = (Integer) getMethod("getVersion", networkManager.getClass()).invoke(networkManager);
return version;
} catch (Exception ex) {
ex.printStackTrace();
}
return version;
}
} | 4,368 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TitleManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/title/TitleManager.java | package me.patothebest.gamecore.title;
import me.patothebest.gamecore.util.Utils;
public class TitleManager {
/**
* Creates a new title
*
* @param title the title string
* @return the title
*/
public static Title newInstance(String title) {
if(Utils.SERVER_VERSION.contains("1_7")) {
return new TitleProtocol1_7(title);
} else if(Utils.SERVER_VERSION.contains("1_8") || Utils.SERVER_VERSION.contains("1_9") || Utils.SERVER_VERSION.contains("1_10")) {
return new Title1_8_1_10(title);
} else if(Utils.SERVER_VERSION.contains("1_11") || Utils.SERVER_VERSION.contains("1_12") || Utils.SERVER_VERSION.contains("1_13") || Utils.SERVER_VERSION.contains("1_14") || Utils.SERVER_VERSION.contains("1_15") || Utils.SERVER_VERSION.contains("1_16")) {
return new Title1_11_1_16(title);
} else {
return new UnsupportedTitle(title);
}
}
}
| 953 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TitleBuilder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/title/TitleBuilder.java | package me.patothebest.gamecore.title;
import org.bukkit.ChatColor;
public final class TitleBuilder {
ChatColor titleColor = ChatColor.WHITE;
/* Subtitle text and color */ String subtitle = "";
ChatColor subtitleColor = ChatColor.WHITE;
/* Title timings */ int fadeInTime = -1;
int stayTime = -1;
int fadeOutTime = -1;
/* Title text and color */ String title = "";
private TitleBuilder() {
}
public static TitleBuilder newTitle() {
return new TitleBuilder();
}
public TitleBuilder withTitleColor(ChatColor titleColor) {
this.titleColor = titleColor;
return this;
}
public TitleBuilder withSubtitle(String subtitle) {
this.subtitle = subtitle;
return this;
}
public TitleBuilder withSubtitleColor(ChatColor subtitleColor) {
this.subtitleColor = subtitleColor;
return this;
}
public TitleBuilder withFadeInTime(int fadeInTime) {
this.fadeInTime = fadeInTime;
return this;
}
public TitleBuilder withStayTime(int stayTime) {
this.stayTime = stayTime;
return this;
}
public TitleBuilder withFadeOutTime(int fadeOutTime) {
this.fadeOutTime = fadeOutTime;
return this;
}
public TitleBuilder withTitle(String title) {
this.title = title;
return this;
}
public Title build() {
Title title = TitleManager.newInstance(this.title);
title.setTitleColor(titleColor);
title.setSubtitle(subtitle);
title.setSubtitleColor(subtitleColor);
title.setFadeInTime(fadeInTime);
title.setStayTime(stayTime);
title.setFadeOutTime(fadeOutTime);
return title;
}
}
| 1,741 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
UnsupportedTitle.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/title/UnsupportedTitle.java | package me.patothebest.gamecore.title;
import org.bukkit.entity.Player;
class UnsupportedTitle extends AbstractTitle {
UnsupportedTitle(String title) {
super(title);
}
@Override
protected void loadClasses() {
}
@Override
public void send(Player player) {
}
@Override
public void clearTitle(Player player) {
}
@Override
public void resetTitle(Player player) {
}
}
| 438 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AnimationManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/animation/AnimationManager.java | package me.patothebest.gamecore.animation;
import me.patothebest.gamecore.scoreboard.ScoreboardEntry;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.modules.Module;
import me.patothebest.gamecore.util.ThrowOnce;
import org.bukkit.ChatColor;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class AnimationManager implements Module {
// -------------------------------------------- //
// CONSTANTS
// -------------------------------------------- //
private final static Pattern animationPattern = Pattern.compile("<(\\w+)( +.+)*>((.*))</\\1>");
private final static Pattern argsPattern = Pattern.compile(" (.*?)=\"(.*?)\"");
private static Set<Animation> animations;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
@Inject public AnimationManager(Set<Animation> animations) {
AnimationManager.animations = animations;
}
// -------------------------------------------- //
// METHODS
// -------------------------------------------- //
public static List<String> parseAnimation(ScoreboardEntry scoreboardEntry, String animationString) {
List<String> finalList = new ArrayList<>();
boolean customScore = false;
int score = 0;
if(animationString.contains("|")) {
String[] split = animationString.split("\\|");
if(Utils.isNumber(split[0])) {
score = Integer.parseInt(split[0]);
customScore = true;
}
animationString = split[1];
}
int finalScore = score;
boolean finalCustomScore = customScore;
Matcher matcher = animationPattern.matcher(animationString);
boolean matched = false;
while(matcher.find()) {
String animationName = matcher.group(1);
String string = matcher.group(matcher.groupCount() - 1);
Map<String, String> arguments = new HashMap<>();
for(int i = 2; i < matcher.groupCount() - 1; i++) {
if(matcher.group(i) == null) {
continue;
}
String argumentWhole = matcher.group(i).trim();
if(!argumentWhole.contains("=")) {
continue;
}
if(argumentWhole.contains("\"")) {
Matcher argsMatcher = argsPattern.matcher(" " + argumentWhole);
while (argsMatcher.find()) {
arguments.put(argsMatcher.group(1), argsMatcher.group(2));
}
} else {
for(String argument1 : argumentWhole.split(" ")) {
arguments.put(argument1.split("=")[0], argument1.split("=")[1]);
}
}
}
Animation animation = animations.stream().filter(animation1 -> animation1.getName().equalsIgnoreCase(animationName)).findFirst().orElse(null);
if(animation == null) {
continue;
}
if(animation.isCondition()) {
scoreboardEntry.setCondition(true);
}
try {
animation.convert(string, arguments, scoreboardEntry).forEach(s -> finalList.add((finalCustomScore ? finalScore + "|" : "") + s));
} catch (Exception e) {
finalList.add(ChatColor.RED + "ERROR");
System.err.println("Error while parsing animation " + animationName);
ThrowOnce.printOnce(e);
}
matched = true;
}
if(!matched) {
finalList.add((finalCustomScore ? finalScore + "|" : "") + animationString);
}
return finalList;
}
}
| 3,979 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CoreAnimationModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/animation/CoreAnimationModule.java | package me.patothebest.gamecore.animation;
import com.google.inject.multibindings.Multibinder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.animation.animations.BlinkAnimation;
import me.patothebest.gamecore.animation.animations.DecisionAnimation;
import me.patothebest.gamecore.animation.animations.DelayAnimation;
import me.patothebest.gamecore.animation.animations.GlowAnimation;
import me.patothebest.gamecore.animation.animations.RainbowAnimation;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
public class CoreAnimationModule extends AbstractBukkitModule<CorePlugin> {
public CoreAnimationModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
Multibinder<Animation> animations = Multibinder.newSetBinder(binder(), Animation.class);
animations.addBinding().to(BlinkAnimation.class);
animations.addBinding().to(DecisionAnimation.class);
animations.addBinding().to(DelayAnimation.class);
animations.addBinding().to(GlowAnimation.class);
animations.addBinding().to(RainbowAnimation.class);
registerModule(AnimationManager.class);
}
} | 1,200 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Animation.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/animation/Animation.java | package me.patothebest.gamecore.animation;
import me.patothebest.gamecore.scoreboard.ScoreboardEntry;
import java.util.List;
import java.util.Map;
public abstract class Animation {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private final String name;
protected boolean condition;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public Animation(String name) {
this.name = name;
}
// -------------------------------------------- //
// ABSTRACT METHODS
// -------------------------------------------- //
public abstract List<String> convert(String animation, Map<String, String> arguments, ScoreboardEntry scoreboardEntry);
// -------------------------------------------- //
// GETTERS
// -------------------------------------------- //
public String getName() {
return name;
}
boolean isCondition() {
return condition;
}
}
| 1,080 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
RainbowAnimation.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/animation/animations/RainbowAnimation.java | package me.patothebest.gamecore.animation.animations;
import me.patothebest.gamecore.scoreboard.ScoreboardEntry;
import me.patothebest.gamecore.animation.Animation;
import org.bukkit.ChatColor;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class RainbowAnimation extends Animation {
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public RainbowAnimation() {
super("rainbow");
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
public List<String> convert(final String animation, final Map<String, String> args, ScoreboardEntry scoreboardEntry) {
// ITS A DOUBLE RAINBOW ALL THE WAY ACROSS
final List<String> converted = new ArrayList<>();
converted.add(ChatColor.DARK_RED + animation);
converted.add(ChatColor.RED + animation);
converted.add(ChatColor.GOLD + animation);
converted.add(ChatColor.YELLOW + animation);
converted.add(ChatColor.DARK_GREEN + animation);
converted.add(ChatColor.GREEN + animation);
converted.add(ChatColor.AQUA + animation);
converted.add(ChatColor.DARK_AQUA + animation);
converted.add(ChatColor.DARK_BLUE + animation);
converted.add(ChatColor.BLUE + animation);
converted.add(ChatColor.LIGHT_PURPLE + animation);
converted.add(ChatColor.DARK_PURPLE + animation);
converted.add(ChatColor.WHITE + animation);
converted.add(ChatColor.GRAY + animation);
converted.add(ChatColor.DARK_GRAY + animation);
return converted;
}
}
| 1,717 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
BlinkAnimation.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/animation/animations/BlinkAnimation.java | package me.patothebest.gamecore.animation.animations;
import me.patothebest.gamecore.scoreboard.ScoreboardEntry;
import me.patothebest.gamecore.animation.Animation;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class BlinkAnimation extends Animation {
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public BlinkAnimation() {
super("blink");
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
@Override
public List<String> convert(String animation, Map<String, String> arguments, ScoreboardEntry scoreboardEntry) {
List<String> converted = new ArrayList<>();
converted.add(animation);
converted.add("");
return converted;
}
}
| 885 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GlowAnimation.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/animation/animations/GlowAnimation.java | package me.patothebest.gamecore.animation.animations;
import me.patothebest.gamecore.scoreboard.ScoreboardEntry;
import me.patothebest.gamecore.animation.Animation;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class GlowAnimation extends Animation {
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public GlowAnimation() {
super("glow");
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
@Override
public List<String> convert(final String s, final Map<String, String> map, ScoreboardEntry scoreboardEntry) {
final ArrayList<String> list = new ArrayList<>();
String normalColor = map.getOrDefault("normalcolor", "&f");
String startGlowColor = map.getOrDefault("startglowcolor", "&e");
String endGlowColor = map.getOrDefault("endglowcolor", "&e");
String glowcolor = map.getOrDefault("glowcolor", "&6");
list.add(normalColor + s);
char[] string = s.toCharArray();
int lastIndex = s.length() - 1;
for (int end = 0; end < s.length() + 2; end++) {
StringBuilder currentLine = new StringBuilder();
int start = end - 2;
int middle = end - 1;
if (start > 0) {
currentLine.append(normalColor).append(string, 0, start);
}
if (start >= 0 && start <= lastIndex) {
currentLine.append(startGlowColor).append(string[start]);
}
if (middle >= 0 && middle <= lastIndex) {
currentLine.append(glowcolor).append(string[middle]);
}
if (end <= lastIndex) {
currentLine.append(endGlowColor).append(string[end]);
}
if (end < lastIndex) {
currentLine.append(normalColor).append(string, end + 1, lastIndex - end);
}
list.add(currentLine.toString());
}
return list;
}
}
| 2,116 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DecisionAnimation.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/animation/animations/DecisionAnimation.java | package me.patothebest.gamecore.animation.animations;
import me.patothebest.gamecore.scoreboard.ScoreboardEntry;
import me.patothebest.gamecore.animation.Animation;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public class DecisionAnimation extends Animation {
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public DecisionAnimation() {
super("decision");
this.condition = true;
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
@Override
public List<String> convert(String animation, Map<String, String> arguments, ScoreboardEntry scoreboardEntry) {
String trueValue = arguments.getOrDefault("whentrue", "true");
String falseValue = arguments.getOrDefault("whenfalse", "false");
String comparison = arguments.getOrDefault("equals", "true");
return Collections.singletonList(animation.equalsIgnoreCase(comparison) ? trueValue : falseValue);
}
}
| 1,110 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DelayAnimation.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/animation/animations/DelayAnimation.java | package me.patothebest.gamecore.animation.animations;
import me.patothebest.gamecore.scoreboard.ScoreboardEntry;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.animation.Animation;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class DelayAnimation extends Animation {
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public DelayAnimation() {
super("delay");
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
@Override
public List<String> convert(String animation, Map<String, String> args, ScoreboardEntry scoreboardEntry) {
final List<String> converted = new ArrayList<>();
int times = 1;
if (args.containsKey("times") && Utils.isNumber(args.get("times"))) {
times = Integer.parseInt(args.get("times"));
}
for (int i = 0; i < times; ++i) {
converted.add(animation);
}
return converted;
}
}
| 1,129 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LeakListener.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/listener/LeakListener.java | package me.patothebest.gamecore.listener;
import com.google.inject.Inject;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import me.patothebest.gamecore.modules.ListenerModule;
import org.bukkit.World;
import org.bukkit.event.EventHandler;
import org.bukkit.event.world.WorldUnloadEvent;
import java.lang.ref.WeakReference;
public class LeakListener implements ListenerModule {
private final PluginScheduler pluginScheduler;
@Inject private LeakListener(PluginScheduler pluginScheduler) {
this.pluginScheduler = pluginScheduler;
}
@EventHandler
public void onWorldUnload(WorldUnloadEvent event) {
WeakReference<World> worldWeakReference = new WeakReference<>(event.getWorld());
pluginScheduler.runTaskLater(() -> {
if(worldWeakReference.get() != null) {
System.err.println("World is still in memory! Attempting to gc...");
System.gc();
}
}, 20*10L);
}
}
| 984 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DevTransformer.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/bytecode/DevTransformer.java | package me.patothebest.gamecore.bytecode;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtField;
import javassist.NotFoundException;
import me.patothebest.gamecore.util.Utils;
import java.io.File;
import java.io.IOException;
public class DevTransformer {
private final ClassPool pool = ClassPool.getDefault();
public static void main(String[] args) throws Exception {
if (args.length != 1) {
throw new IllegalArgumentException("Expected 1 argument: directory with classes to transform");
}
File classesDir = new File(args[0]);
new DevTransformer().instrumentClassesIn(classesDir);
}
private void instrumentClassesIn(File classesDir) throws Exception {
pool.appendClassPath(classesDir.getPath());
CtClass ctClass = modifyConstant(Utils.class.getName(), "USER_ID", "PATO_DEV");
ctClass.writeFile(classesDir.getPath());
System.out.println(">>>" + DevTransformer.class.getSimpleName() + ": Transformation done for "
+ Utils.class.getName());
}
private CtClass modifyConstant(String clazz, String constantName, String value) {
try {
CtClass pt = pool.get(clazz);
CtField field = pt.getField(constantName);
pt.removeField(field);
CtField newField = CtField.make("private static final String " + constantName + "=\"" + value + "\";", pt);
pt.addField(newField);
pt.writeFile();
return pt;
} catch (NotFoundException | CannotCompileException | IOException e) {
e.printStackTrace();
System.exit(-1);
}
return null;
}
} | 1,745 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AddonFile.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/AddonFile.java | package me.patothebest.gamecore.addon;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.file.VersionFile;
import me.patothebest.gamecore.util.Utils;
import java.io.BufferedWriter;
import java.io.IOException;
public class AddonFile extends VersionFile {
@Inject private AddonFile(CorePlugin plugin) {
super(plugin, "addons");
load();
}
@Override
protected void writeFile(BufferedWriter writer) throws IOException {
super.writeFile(writer);
Utils.writeFileToWriter(writer, plugin.getResource("addons.yml"));
}
}
| 625 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AddonManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/AddonManager.java | package me.patothebest.gamecore.addon;
import com.google.inject.Inject;
import me.patothebest.gamecore.logger.InjectLogger;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.gamecore.modules.ModuleName;
import me.patothebest.gamecore.modules.ReloadableModule;
import org.bukkit.configuration.ConfigurationSection;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
@ModuleName("Addon Manager")
public class AddonManager implements ActivableModule, ReloadableModule {
private final AddonFile addonFile;
private final Set<Addon> addons;
@InjectLogger private Logger logger;
@Inject private AddonManager(AddonFile addonFile, Set<Addon> addons) {
this.addonFile = addonFile;
this.addons = addons;
}
@Override
public void onEnable() {
int addonCount = 0;
for (Addon addon : addons) {
if(!addonFile.isSet(addon.getConfigPath())) {
continue;
}
ConfigurationSection addonConfigurationSection = addonFile.getConfigurationSection(addon.getConfigPath());
if(!addonConfigurationSection.getBoolean("enabled")) {
logger.config("Not enabling " + addon.getConfigPath() + " since it's disabled in the config");
continue;
}
logger.log(Level.CONFIG, "Configuring addon {0}", addon.getConfigPath());
try {
addon.configure(addonConfigurationSection);
addon.enable();
logger.log(Level.CONFIG, "Enabled addon {0}", addon.getConfigPath());
addonCount++;
} catch (Throwable t) {
logger.log(Level.SEVERE, "Could not load addon " + addon.getConfigPath() + "!", t);
}
}
logger.log(Level.INFO, "Loaded {0} addons!", addonCount);
}
@Override
public void onReload() {
onDisable();
addonFile.load();
onEnable();
}
@Override
public String getReloadName() {
return "addons";
}
public boolean isAddonEnabled(Class<? extends Addon> addonClass) {
return getAddon(addonClass).isEnabled();
}
public <T extends Addon> T getAddon(Class<T> addonClass) {
for (Addon addon : addons) {
if(addon.getClass() == addonClass) {
return (T) addon;
}
}
throw new IllegalArgumentException("Addon " + addonClass.getSimpleName() + " is not registered!");
}
@Override
public void onDisable() {
for (Addon addon : addons) {
try {
addon.disable();
} catch (Throwable t) {
logger.log(Level.SEVERE, "Could not disable addon " + addon.getConfigPath() + "!", t);
}
}
}
}
| 2,843 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AddonModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/AddonModule.java | package me.patothebest.gamecore.addon;
import com.google.inject.multibindings.Multibinder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.addon.addons.ChatAddon;
import me.patothebest.gamecore.addon.addons.CommandBlockerAddon;
import me.patothebest.gamecore.addon.addons.CustomDeathMessagesAddon;
import me.patothebest.gamecore.addon.addons.HideNametags;
import me.patothebest.gamecore.addon.addons.JoinItemsAddon;
import me.patothebest.gamecore.addon.addons.JoinQuitMessagesAddon;
import me.patothebest.gamecore.addon.addons.KillStreaksAddon;
import me.patothebest.gamecore.addon.addons.MoneyAddon;
import me.patothebest.gamecore.addon.addons.TeamNametags;
import me.patothebest.gamecore.addon.addons.TeleportOnJoinAddon;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
public class AddonModule extends AbstractBukkitModule<CorePlugin> {
public AddonModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
Multibinder<Addon> addonMultibinder = Multibinder.newSetBinder(binder(), Addon.class);
addonMultibinder.addBinding().to(JoinItemsAddon.class);
addonMultibinder.addBinding().to(ChatAddon.class);
addonMultibinder.addBinding().to(HideNametags.class);
addonMultibinder.addBinding().to(TeamNametags.class);
addonMultibinder.addBinding().to(TeleportOnJoinAddon.class);
addonMultibinder.addBinding().to(CustomDeathMessagesAddon.class);
addonMultibinder.addBinding().to(JoinQuitMessagesAddon.class);
addonMultibinder.addBinding().to(MoneyAddon.class);
addonMultibinder.addBinding().to(CommandBlockerAddon.class);
addonMultibinder.addBinding().to(KillStreaksAddon.class);
registerModule(AddonManager.class);
}
}
| 1,808 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Addon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/Addon.java | package me.patothebest.gamecore.addon;
import com.google.inject.Inject;
import me.patothebest.gamecore.event.EventRegistry;
import me.patothebest.gamecore.modules.Module;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.Listener;
public abstract class Addon implements Listener, Module {
private boolean enabled = false;
@Inject private EventRegistry registry;
/**
* Configures a specific addon
* <p>
* This method is called by the {@link AddonManager} when
* reading the values from the {@link AddonFile}.
* <p>
* If the addon is not enabled, this method will not be called.
*
* @param addonConfigSection the configuration section where the extra
* configuration of the addon is located.
*/
public abstract void configure(ConfigurationSection addonConfigSection);
/**
* Gets the config path of the addon
* <p>
* The path is usually the addon name. This path is used when the
* {@link AddonManager} looks in the {@link AddonFile} if the module
* should be enabled or not.
*
* @return the config path.
*/
public abstract String getConfigPath();
/**
* Gets if the addon is enabled or not
*
* @return true if the addon is enabled or not
*/
public boolean isEnabled() {
return enabled;
}
/**
* Enables the module to be active, registers the events
*/
public void enable() {
registry.registerListener(this);
this.enabled = true;
}
/**
* Disables the module, unregisters the events
*/
public void disable() {
if(!enabled) {
return;
}
registry.unRegisterListener(this);
this.enabled = false;
}
}
| 1,811 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
JoinQuitMessagesAddon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/JoinQuitMessagesAddon.java | package me.patothebest.gamecore.addon.addons;
import me.patothebest.gamecore.addon.Addon;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
public class JoinQuitMessagesAddon extends Addon {
private boolean hideJoinMessages;
private boolean hideQuitMessages;
@Override
public void configure(ConfigurationSection addonConfigSection) {
hideJoinMessages = addonConfigSection.getBoolean("hide-join-messages");
hideQuitMessages = addonConfigSection.getBoolean("hide-quit-messages");
}
@EventHandler
public void onJoin(PlayerJoinEvent event) {
if(hideJoinMessages) {
event.setJoinMessage(null);
}
}
@EventHandler
public void onJoin(PlayerQuitEvent event) {
if(hideQuitMessages) {
event.setQuitMessage(null);
}
}
@Override
public String getConfigPath() {
return "join-quit-messages";
}
}
| 1,062 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HideNametags.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/HideNametags.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Inject;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.event.player.ArenaPlayerEvent;
import me.patothebest.gamecore.event.player.GameJoinEvent;
import me.patothebest.gamecore.event.player.LobbyJoinEvent;
import me.patothebest.gamecore.event.player.PlayerStateChangeEvent;
import me.patothebest.gamecore.event.player.SpectateEvent;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.addon.Addon;
import me.patothebest.gamecore.arena.ArenaManager;
import org.bukkit.Bukkit;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.PlayerJoinEvent;
public class HideNametags extends Addon {
private final PlayerManager playerManager;
private final ArenaManager arenaManager;
@Inject private HideNametags(PlayerManager playerManager, ArenaManager arenaManager) {
this.playerManager = playerManager;
this.arenaManager = arenaManager;
}
@Override
public void configure(ConfigurationSection addonConfigSection) { }
@EventHandler(priority = EventPriority.HIGHEST)
public void onJoin(LobbyJoinEvent event) {
handleEvent(event);
}
@EventHandler(priority = EventPriority.HIGHEST)
public void onJoin(GameJoinEvent event) {
handleEvent(event);
}
private void handleEvent(ArenaPlayerEvent event) {
Bukkit.getOnlinePlayers().forEach(o -> {
if (o.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
AbstractArena otherArena = null;
if (playerManager.getPlayer(o).isInArena()) {
otherArena = playerManager.getPlayer(o).getCurrentArena();
}
if (otherArena != event.getArena()) {
event.getPlayer().hidePlayer(o);
} else {
o.showPlayer(event.getPlayer());
}
});
event.getArena().getPlayers().forEach(player -> {
if (player.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
event.getPlayer().showPlayer(player);
player.showPlayer(event.getPlayer());
});
}
@EventHandler
public void onLeave(ArenaLeaveEvent event) {
Bukkit.getOnlinePlayers().forEach(o -> {
if (o.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
event.getPlayer().showPlayer(o);
});
event.getArena().getPlayers().forEach(player -> {
if (player.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
player.hidePlayer(event.getPlayer());
});
event.getArena().getSpectators().forEach(player -> {
if (player.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
player.hidePlayer(event.getPlayer());
});
}
@EventHandler
public void onDeath(SpectateEvent event) {
event.getArena().getSpectators().forEach(spectator -> {
if (spectator.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
event.getPlayer().showPlayer(spectator);
});
event.getArena().getPlayers().forEach(player -> {
if (player.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
player.hidePlayer(event.getPlayer());
});
}
@EventHandler
public void onDeath(PlayerStateChangeEvent event) {
if (event.getPlayerState() != PlayerStateChangeEvent.PlayerState.PLAYER) {
return;
}
event.getArena().getSpectators().forEach(spectator -> {
if (spectator.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
event.getPlayer().hidePlayer(spectator);
});
event.getArena().getPlayers().forEach(player -> {
if (player.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
player.showPlayer(event.getPlayer());
});
}
@EventHandler
public void onJoin(PlayerJoinEvent event) {
for (AbstractArena arena : arenaManager.getArenas().values()) {
for (Player player : arena.getPlayers()) {
player.hidePlayer(event.getPlayer());
}
for (Player player : arena.getSpectators()) {
player.hidePlayer(event.getPlayer());
}
}
}
@Override
public String getConfigPath() {
return "separate-nametags";
}
} | 5,006 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ChatAddon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/ChatAddon.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Provider;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.placeholder.PlaceHolderManager;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.addon.Addon;
import me.patothebest.gamecore.arena.ArenaManager;
import net.milkbowl.vault.chat.Chat;
import net.milkbowl.vault.permission.Permission;
import org.bukkit.ChatColor;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import javax.inject.Inject;
public class ChatAddon extends Addon {
private final ArenaManager arenaManager;
private final PlayerManager playerManager;
// Vault objects
private final Provider<Permission> permissions;
private final Provider<Chat> chat;
// Cache objects
private String globalChat;
private String globalChatTeam;
private String teamChat;
private String soloChat;
private String lobbyChat;
private String preGame;
private String spectator;
private boolean removeWhitespaces;
@Inject private ChatAddon(ArenaManager arenaManager, PlayerManager playerManager, Provider<net.milkbowl.vault.permission.Permission> permissions, Provider<Chat> chat) {
this.arenaManager = arenaManager;
this.playerManager = playerManager;
this.permissions = permissions;
this.chat = chat;
}
@Override
public void configure(ConfigurationSection addonConfigSection) {
globalChat = addonConfigSection.getString("global", "");
globalChatTeam = addonConfigSection.getString("global-team", "");
teamChat = addonConfigSection.getString("team", "");
soloChat = addonConfigSection.getString("solo", "");
preGame = addonConfigSection.getString("pre-game", "");
lobbyChat = addonConfigSection.getString("lobby", "");
spectator = addonConfigSection.getString("spectator", "");
removeWhitespaces = addonConfigSection.getBoolean("remove-double-whitespaces");
}
@EventHandler
public void onChat(AsyncPlayerChatEvent event) {
Player player = event.getPlayer();
if(getPlayer(player) == null) {
return;
}
if(getPlayer(player).isInArena()) {
AbstractArena arena = playerManager.getPlayer(player).getCurrentArena();
if(arena.getArenaState() == ArenaState.WAITING || playerManager.getPlayer(player).getGameTeam() == null) {
event.getRecipients().clear();
if(!arena.getSpectators().contains(player)) {
event.getRecipients().addAll(arena.getPlayers());
event.getRecipients().addAll(arena.getSpectators());
setMessage(event, preGame);
} else {
event.getRecipients().addAll(arena.getSpectators());
setMessage(event, spectator);
}
} else {
event.getRecipients().clear();
AbstractGameTeam gameTeam = playerManager.getPlayer(player).getGameTeam();
if(event.getMessage().startsWith("!") && arena.getTeams().size() > 1) {
event.getRecipients().addAll(arena.getPlayers());
String format;
if(gameTeam.hasTeamChatPrefix()) {
format = globalChatTeam.replace("%teamcolor%", Utils.getColorFromDye(gameTeam.getColor()).toString()).replace("%teamname%", gameTeam.getName());
} else {
format = globalChat;
}
setMessage(event, format);
event.getRecipients().addAll(arena.getSpectators());
} else {
event.getRecipients().addAll(gameTeam.getPlayers());
String format;
if(gameTeam.hasTeamChatPrefix()) {
format = teamChat.replace("%teamcolor%", Utils.getColorFromDye(gameTeam.getColor()).toString()).replace("%teamname%", gameTeam.getName());
} else {
format = soloChat;
event.getRecipients().addAll(arena.getSpectators());
}
setMessage(event, format);
}
}
} else {
for (AbstractArena arena : arenaManager.getArenas().values()) {
event.getRecipients().removeAll(arena.getPlayers());
}
setMessage(event, lobbyChat);
}
}
private void setMessage(AsyncPlayerChatEvent event, String format) {
format = parseMessage(event.getPlayer(), format);
/*
* ^\\s+ replaces all whitespaces from the beginning
* ^ asserts position at start of the string
* \s matches any whitespace character
* + Quantifier — Matches between one and unlimited times, as many times as possible, giving back as needed
*/
format = ChatColor.translateAlternateColorCodes('&', format).replaceAll("^\\s+", "");
if(removeWhitespaces) {
/*
* [ ]{2,} Matches two or more whitespaces
* [ ] matches the character ' ' literally (the space)
* {2,} Quantifier — Matches between 2 and unlimited times, as many times as possible, giving back as needed (greedy)
*/
format = format.replaceAll("[ ]{2,}", " ");
}
if(!format.isEmpty()) {
event.setFormat(format);
}
if(event.getPlayer().hasPermission(me.patothebest.gamecore.permission.Permission.CHAT_COLORS.getBukkitPermission())) {
event.setMessage(ChatColor.translateAlternateColorCodes('&', event.getMessage()).replaceFirst("!", ""));
}
}
private IPlayer getPlayer(Player player) {
return playerManager.getPlayer(player);
}
private String parseMessage(final Player player, String format) {
String group = (permissions.get() == null) ? "" : permissions.get().hasGroupSupport() ? permissions.get().getPrimaryGroup(player) : "";
String groupPrefix = (chat.get() == null) ? "" : chat.get().getGroupPrefix(player.getWorld(), group);
String groupSuffix = (chat.get() == null) ? "" : chat.get().getGroupSuffix(player.getWorld(), group);
String playerName = player.getName();
String modPlayername = player.getDisplayName();
format = format.replace("{group}", group).replace("{permprefix}", groupPrefix).replace("{permsuffix}", groupSuffix).replace("{playername}", playerName).replace("{modplayername}", modPlayername).replace("{msg}", "%2$s").replace("&", "§");
format = PlaceHolderManager.replace(player, format);
return format;
}
@Override
public String getConfigPath() {
return "chat";
}
}
| 7,209 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
KillStreaksAddon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/KillStreaksAddon.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Inject;
import me.patothebest.gamecore.addon.Addon;
import me.patothebest.gamecore.addon.AddonManager;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.logger.InjectParentLogger;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.ChatColor;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerQuitEvent;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
public class KillStreaksAddon extends Addon {
private final Map<Integer, Integer> playerStreaks = new HashMap<>();
private final Map<Integer, KillStreak> killStreaks = new HashMap<>();
private final PlayerManager playerManager;
@InjectParentLogger(parent = AddonManager.class) private Logger logger;
private int smallestStreak = 1000;
private String shutdownMessage = "";
private String shutdownPlayerMessage = "";
private boolean teamColors;
@Inject private KillStreaksAddon(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public void configure(ConfigurationSection addonConfigSection) {
killStreaks.clear();
smallestStreak = 100;
ConfigurationSection streaks = addonConfigSection.getConfigurationSection("streaks");
teamColors = addonConfigSection.getBoolean("team-color");
shutdownMessage = addonConfigSection.getString("shutdown");
shutdownPlayerMessage = addonConfigSection.getString("shutdown-player");
if (streaks == null) {
logger.log(Level.WARNING, "Killstreaks are enabled but there are no configured streaks!");
return;
}
for (String streak : streaks.getKeys(false)) {
if (!Utils.isNumber(streak)) {
Utils.printError("Error while parsing killStreaks. ", streak + " is not a number");
continue;
}
int streakAmount = Integer.parseInt(streak);
killStreaks.put(streakAmount,
new KillStreak(streaks.getString(streak + ".message"), streaks.getInt(streak + ".money"), streaks.getInt(streak + ".game-experience", 0)));
smallestStreak = Math.min(streakAmount, smallestStreak);
}
}
@EventHandler
public void onKill(CombatDeathEvent event) {
IPlayer player = playerManager.getPlayer(event.getPlayer());
IPlayer killerPlayer = null;
if (event.getKillerPlayer() != null) {
killerPlayer = playerManager.getPlayer(event.getKillerPlayer());
}
AbstractArena currentArena = player.getCurrentArena();
if (currentArena == null || player.getGameTeam() == null) {
return;
}
String teamColor = teamColors ? Utils.getColorFromDye(player.getGameTeam().getColor()).toString() : "";
String killerColor = "";
if (teamColors && killerPlayer != null && killerPlayer.getGameTeam() != null) {
killerColor = Utils.getColorFromDye(killerPlayer.getGameTeam().getColor()).toString();
}
int i = playerStreaks.getOrDefault(event.getPlayer().getEntityId(), -1);
if (i >= smallestStreak) {
if (killerPlayer == null) {
String message = ChatColor.translateAlternateColorCodes('&', shutdownMessage.replace("%player_name%", teamColor + player.getName()));
currentArena.sendMessageToArena(locale -> message);
} else {
String message = ChatColor.translateAlternateColorCodes('&', shutdownPlayerMessage
.replace("%player_name%", teamColor + player.getName())
.replace("%killer%", killerColor + killerPlayer.getName()));
currentArena.sendMessageToArena(locale -> message);
}
}
playerStreaks.remove(event.getPlayer().getEntityId());
if (killerPlayer == null) {
return;
}
int killstreakCount = playerStreaks.getOrDefault(killerPlayer.getEntityId(), 0);
playerStreaks.put(killerPlayer.getEntityId(), ++killstreakCount);
KillStreak killstreak = killStreaks.get(killstreakCount);
if (killstreak == null) {
return;
}
if (killstreak.money > 0) {
killerPlayer.giveMoney(killstreak.money);
}
if (killstreak.experience > 0) {
killerPlayer.addExperience(killstreak.experience);
}
String message = ChatColor.translateAlternateColorCodes('&', killstreak.message.replace("%player_name%", killerColor + killerPlayer.getName()));
currentArena.sendMessageToArena(locale -> message);
}
@EventHandler
public void onArenaLeave(ArenaLeaveEvent event) {
playerStreaks.remove(event.getPlayer().getEntityId());
}
@EventHandler
public void onQuit(PlayerQuitEvent event) {
playerStreaks.remove(event.getPlayer().getEntityId());
}
@Override
public String getConfigPath() {
return "killstreaks";
}
private static class KillStreak {
private final String message;
private final int money;
private final int experience;
private KillStreak(String message, int money, int experience) {
this.message = message;
this.money = money;
this.experience = experience;
}
}
}
| 5,765 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeleportOnJoinAddon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/TeleportOnJoinAddon.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Inject;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.addon.Addon;
import org.bukkit.Bukkit;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import org.spigotmc.event.player.PlayerSpawnLocationEvent;
public class TeleportOnJoinAddon extends Addon {
private final CoreConfig coreConfig;
@Inject private TeleportOnJoinAddon(CoreConfig coreConfig) {
this.coreConfig = coreConfig;
}
@Override
public void configure(ConfigurationSection addonConfigSection) { }
@EventHandler
public void onJoin(PlayerSpawnLocationEvent event) {
if(coreConfig.isUseMainLobby() && coreConfig.getMainLobby() != null) {
event.setSpawnLocation(coreConfig.getMainLobby());
return;
}
event.setSpawnLocation(Bukkit.getWorlds().get(0).getSpawnLocation());
}
@Override
public String getConfigPath() {
return "join-teleport";
}
}
| 1,061 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CustomDeathMessagesAddon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/CustomDeathMessagesAddon.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.combat.CombatEntry;
import me.patothebest.gamecore.combat.DamageOption;
import me.patothebest.gamecore.file.DeathMessagesFile;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.addon.Addon;
import org.apache.commons.lang.WordUtils;
import org.bukkit.ChatColor;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Entity;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
@Singleton
public class CustomDeathMessagesAddon extends Addon {
private final PlayerManager playerManager;
private final DeathMessagesFile config;
private boolean setColor = false;
@Inject private CustomDeathMessagesAddon(PlayerManager playerManager, DeathMessagesFile config) {
this.playerManager = playerManager;
this.config = config;
}
@Override
public void configure(ConfigurationSection addonConfigSection) {
config.load();
setColor = config.getBoolean("set-team-color");
}
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerDeath(CombatDeathEvent event) {
CombatEntry reason = event.getLastDamage();
String messagePath = event.getDeathCause().name().toLowerCase();
Entity killer = event.getKiller();
if (killer != null) {
if (reason.hasOption(DamageOption.WHILE_ESCAPING_OPTIONAL) ||
reason.hasOption(DamageOption.ENTITY_NAME_OPTIONAL)) {
messagePath += "-player";
}
if (event.getItemKilledWith() != null && reason.hasOption(DamageOption.ITEM_OPTIONAL)) {
messagePath += "-item";
}
}
String deathMessage = config.getString(messagePath);
if(deathMessage == null) {
Utils.printError("No death message displayed for " + messagePath);
return;
}
ChatColor playerColor = null;
boolean setColorInternal = setColor;
if (setColor) {
IPlayer player = playerManager.getPlayer(event.getPlayer());
AbstractGameTeam gameTeam = player.getGameTeam();
// set only color to team arenas
if (gameTeam != null && player.getCurrentArena() != null && player.getCurrentArena().getTeams().size() > 1) {
playerColor = Utils.getColorFromDye(gameTeam.getColor());
setColorInternal = true;
} else {
setColorInternal = false;
}
}
deathMessage = deathMessage
.replace("%player%", (playerColor != null ? playerColor : "") + event.getPlayer().getName())
.replace("%player_display_name%", (playerColor != null ? playerColor : "") + event.getPlayer().getDisplayName())
.replace("%world", event.getPlayer().getWorld().getName());
deathMessage = ChatColor.translateAlternateColorCodes('&', deathMessage);
if (killer != null) {
ItemStack itemInHand = event.getItemKilledWith();
String materialName = "";
String itemDisplayName = "";
if (itemInHand != null && itemInHand.getType() != Material.AIR.parseMaterial()) {
materialName = WordUtils.capitalizeFully(itemInHand.getType().toString().replace("_", " "));
final ItemMeta im = itemInHand.getItemMeta();
if (im != null && im.hasDisplayName()) {
itemDisplayName = im.getDisplayName();
}
}
if (itemDisplayName.isEmpty()) {
itemDisplayName = materialName;
}
ChatColor killerTeamColor = null;
if (setColorInternal && event.getKillerPlayer() != null) {
AbstractGameTeam gameTeam = playerManager.getPlayer(event.getKillerPlayer()).getGameTeam();
if (gameTeam != null) {
killerTeamColor = Utils.getColorFromDye(gameTeam.getColor());
}
}
deathMessage = deathMessage
.replace("%killer_display_name%", (killerTeamColor != null ? killerTeamColor : "") + (killer.getCustomName() == null ? killer.getName() : killer.getCustomName()))
.replace("%killer%", (killerTeamColor != null ? killerTeamColor : "") + killer.getName())
.replace("%mob_type%", (killerTeamColor != null ? killerTeamColor : "") + WordUtils.capitalizeFully(killer.getType().toString()))
.replace("%weapon_material%", materialName)
.replace("%weapon%", itemDisplayName);
}
event.setDeathMessage(deathMessage);
}
@Override
public String getConfigPath() {
return "death-messages";
}
}
| 5,247 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
MoneyAddon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/MoneyAddon.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Inject;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.event.arena.GameEndEvent;
import me.patothebest.gamecore.permission.PermissionGroup;
import me.patothebest.gamecore.permission.PermissionGroupManager;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.addon.Addon;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import java.util.HashMap;
import java.util.Map;
public class MoneyAddon extends Addon {
// Vault objects
private final PermissionGroupManager permissionGroupManager;
private final Map<PermissionGroup, Double> moneyMultiplier = new HashMap<>();
private final PlayerManager playerManager;
private double moneyToKill;
private double moneyToWin;
@Inject private MoneyAddon(PermissionGroupManager permissionGroupManager, PlayerManager playerManager) {
this.permissionGroupManager = permissionGroupManager;
this.playerManager = playerManager;
}
@Override
public void configure(ConfigurationSection addonConfigSection) {
moneyToKill = addonConfigSection.getDouble("kill");
moneyToWin = addonConfigSection.getDouble("win");
if(addonConfigSection.getBoolean("money-multiplier.enabled")) {
Map<String, Object> limits = addonConfigSection.getConfigurationSection("money-multiplier.multipliers").getValues(true);
limits.forEach((string, limit) -> {
if(!(limit instanceof Double)) {
return;
}
PermissionGroup permissionGroup = permissionGroupManager.getOrCreatePermissionGroup(string);
moneyMultiplier.put(permissionGroup, (Double) limit);
});
}
}
@EventHandler
public void onKill(CombatDeathEvent event) {
if(event.getKillerPlayer() == null) {
return;
}
playerManager.getPlayer(event.getKillerPlayer()).giveMoney(getMultiplier(event.getKillerPlayer()) * moneyToKill);
}
@EventHandler
public void onWin(GameEndEvent event) {
event.getWinners().forEach(player -> {
playerManager.getPlayer(player).giveMoney(getMultiplier(player) * moneyToWin);
});
}
private double getMultiplier(Player player) {
final double[] multiplier = {1.0};
moneyMultiplier.forEach((permissionGroup, multiplierValue) -> {
if(multiplierValue > multiplier[0]) {
if(permissionGroup.hasPermission(player)) {
multiplier[0] = multiplierValue;
}
}
});
return multiplier[0];
}
@Override
public String getConfigPath() {
return "money";
}
} | 2,879 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeamNametags.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/TeamNametags.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Inject;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.event.player.GameJoinEvent;
import me.patothebest.gamecore.ghost.GhostFactory;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.addon.Addon;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.scoreboard.Scoreboard;
import org.bukkit.scoreboard.Team;
public class TeamNametags extends Addon {
private final PlayerManager playerManager;
private final GhostFactory ghostFactory;
private String spectatorPrefix;
@Inject private TeamNametags(PlayerManager playerManager, GhostFactory ghostFactory) {
this.playerManager = playerManager;
this.ghostFactory = ghostFactory;
}
@Override
public void configure(ConfigurationSection addonConfigSection) {
spectatorPrefix = addonConfigSection.getString("spectator-prefix");
ghostFactory.setTeamName(spectatorPrefix);
ghostFactory.setTeamPrefix(true);
}
@EventHandler(priority = EventPriority.HIGHEST)
public void onJoin(GameJoinEvent event) {
Scoreboard scoreboard = event.getPlayer().getScoreboard();
AbstractArena arena = event.getArena();
if(arena.getTeams().size() <= 1) {
return;
}
for (AbstractGameTeam abstractGameTeam : arena.getTeams().values()) {
if(scoreboard.getTeam(abstractGameTeam.getName()) != null) {
scoreboard.getTeam(abstractGameTeam.getName()).unregister();
}
Team team = scoreboard.registerNewTeam(abstractGameTeam.getName());
team.setPrefix(Utils.getColorFromDye(abstractGameTeam.getColor()).toString() + "[" + abstractGameTeam.getName() + "] ");
abstractGameTeam.getPlayers().forEach(player -> team.addEntry(player.getName()));
}
arena.getPlayers().forEach(player -> {
if (player.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
AbstractGameTeam gameTeam = playerManager.getPlayer(event.getPlayer()).getGameTeam();
if (gameTeam == null) {
return;
}
Team team = player.getScoreboard().getTeam(gameTeam.getName());
if (team == null) {
return;
}
team.addEntry(event.getPlayer().getName());
});
}
@EventHandler(priority = EventPriority.LOWEST)
public void onLeave(ArenaLeaveEvent event) {
AbstractArena arena = event.getArena();
if(arena.getTeams().size() <= 1) {
return;
}
if (event.getLastGameTeam() == null) {
return;
}
arena.getPlayers().forEach(player -> {
if (player.getName().equalsIgnoreCase(event.getPlayer().getName())) {
return;
}
Team team = player.getScoreboard().getTeam(event.getLastGameTeam().getName());
if (team == null) {
return;
}
team.removeEntry(event.getPlayer().getName());
});
}
@Override
public String getConfigPath() {
return "team-nametags";
}
} | 3,534 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CommandBlockerAddon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/CommandBlockerAddon.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Inject;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.addon.Addon;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import java.util.ArrayList;
import java.util.List;
public class CommandBlockerAddon extends Addon {
protected final List<String> commands = new ArrayList<>();
private final PlayerManager playerManager;
@Inject private CommandBlockerAddon(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public void configure(ConfigurationSection addonConfigSection) {
commands.addAll(addonConfigSection.getStringList("allowed-commands"));
}
@EventHandler
private void blockCommands(final PlayerCommandPreprocessEvent event) {
if(getPlayer(event.getPlayer()) == null) {
return;
}
if(!getPlayer(event.getPlayer()).isInArena()) {
return;
}
if(event.getPlayer().hasPermission(Permission.ADMIN.getBukkitPermission())) {
return;
}
if(commands.stream().filter(command -> event.getMessage().toLowerCase().startsWith("/" + command.toLowerCase())).findAny().orElse(null) != null) {
return;
}
event.setCancelled(true);
CoreLang.YOU_CANNOT_EXECUTE_COMMANDS.sendMessage(event.getPlayer());
}
private IPlayer getPlayer(Player player) {
return playerManager.getPlayer(player);
}
@Override
public String getConfigPath() {
return "command-blocker";
}
}
| 1,893 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
JoinItemsAddon.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/addon/addons/JoinItemsAddon.java | package me.patothebest.gamecore.addon.addons;
import com.google.inject.Inject;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.file.InventoryItem;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.addon.Addon;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.Action;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import java.util.HashMap;
import java.util.Map;
public class JoinItemsAddon extends Addon {
private final Map<Integer, InventoryItem> inventoryItems = new HashMap<>();
private final PlayerManager playerManager;
@Inject private JoinItemsAddon(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public void configure(ConfigurationSection addonConfigSection) {
// read all items from config
addonConfigSection.getConfigurationSection("items").getKeys(false).forEach(s -> {
if (addonConfigSection.getConfigurationSection("items." + s) == null) {
return;
}
// create the item by using the Map<String, Object>
// constructor and add it to the map
InventoryItem inventoryItem = new InventoryItem(s, addonConfigSection.getConfigurationSection("items." + s).getValues(true));
inventoryItems.put(inventoryItem.getSlot(), inventoryItem);
});
}
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event) {
if (playerManager.getPlayer(event.getPlayer()) == null) {
return;
}
if (playerManager.getPlayer(event.getPlayer()).isInArena()) {
return;
}
if (event.getAction() != Action.RIGHT_CLICK_AIR && event.getAction() != Action.RIGHT_CLICK_BLOCK) {
return;
}
int heldItemSlot = event.getPlayer().getInventory().getHeldItemSlot();
InventoryItem inventoryItem = inventoryItems.get(heldItemSlot);
if (inventoryItem == null) {
return;
}
if (!inventoryItem.getItemStack().isSimilar(event.getPlayer().getItemInHand())) {
return;
}
if (inventoryItem.getCommand() == null) {
return;
}
event.getPlayer().chat("/" + inventoryItem.getCommand());
}
@EventHandler
public void onInventoryClick(InventoryClickEvent event) {
if (!(event.getWhoClicked() instanceof Player)) {
return;
}
IPlayer player = playerManager.getPlayer((Player) event.getWhoClicked());
if (player == null) {
return;
}
if (player.isInArena()) {
return;
}
if(event.getCurrentItem() == null) {
return;
}
if(event.getClickedInventory().getType() != InventoryType.PLAYER) {
return;
}
int clickedSlot = event.getSlot();
InventoryItem inventoryItem = inventoryItems.get(clickedSlot);
if (inventoryItem == null) {
return;
}
if (!inventoryItem.getItemStack().isSimilar(event.getWhoClicked().getInventory().getItem(clickedSlot))) {
return;
}
if (inventoryItem.getCommand() == null) {
return;
}
player.getPlayer().chat("/" + inventoryItem.getCommand());
event.setCancelled(true);
}
@EventHandler
public void onJoin(PlayerJoinEvent event) {
Player player = event.getPlayer();
inventoryItems.forEach((key, value) -> player.getInventory().setItem(key, value.getItemStack()));
}
@EventHandler
public void onLeave(ArenaLeaveEvent event) {
Player player = event.getPlayer();
inventoryItems.forEach((key, value) -> player.getInventory().setItem(key, value.getItemStack()));
}
@Override
public String getConfigPath() {
return "join-items";
}
} | 4,242 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
NMS.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/nms/NMS.java | package me.patothebest.gamecore.nms;
import me.patothebest.gamecore.hologram.Hologram;
import me.patothebest.gamecore.itemstack.Material;
import org.bukkit.Location;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.EnderDragon;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.FallingBlock;
import org.bukkit.entity.LivingEntity;
import org.bukkit.inventory.ItemStack;
import java.util.UUID;
/**
* The Interface NMS.
*/
public interface NMS {
/**
* Makes a pet.
*
* @param entity the entity
* @param toFollow the player to follow
* @param name the name of the pet
*/
void makePet(LivingEntity entity, UUID toFollow, String name);
/**
* Gets the entity type from an egg.
*
* @param itemStack the monster egg item
* @return the entity from egg
*/
EntityType getEntityFromEgg(ItemStack itemStack);
EnderDragon spawnEnderdragon(Location location);
default void setPosition(Entity entity, Location location) {
setPositionAndRotation(entity, location.getX(), location.getY(), location.getZ(), location.getPitch(), location.getYaw());
}
default void setPosition(Entity entity, double posX, double posY, double posZ) {
setPositionAndRotation(entity, posX, posY, posZ, 0, 0);
}
ArmorStand spawnProvisionalArmorStand(Location location);
default Hologram createHologram(Location location) {
return new Hologram(spawnProvisionalArmorStand(location));
}
void setPositionAndRotation(Entity entity, double posX, double posY, double posZ, float pitch, float yaw);
void playChestAction(Block b, boolean open);
org.bukkit.entity.Entity spawnItem(ItemStack itemStack, Location blockLocation);
void setBlock(Block block, ItemStack itemStack);
Block getBlockAttachedToSign(Block sign);
Enchantment getGlowEnchant();
void setDirectionalBlockData(Block block, BlockFace dir, boolean upsidedown);
FallingBlock spawnFallingBlock(Location location, Material material);
}
| 2,193 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
NullNMSImpl.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/nms/NullNMSImpl.java | package me.patothebest.gamecore.nms;
import me.patothebest.gamecore.itemstack.Material;
import org.bukkit.Location;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.EnderDragon;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.FallingBlock;
import org.bukkit.entity.LivingEntity;
import org.bukkit.inventory.ItemStack;
import java.util.UUID;
public class NullNMSImpl implements NMS {
public void makePet(LivingEntity entity, UUID toFollow, String name) {
// empty method to prevent null errors
}
@Override
public EntityType getEntityFromEgg(ItemStack itemStack) {
return null;
}
@Override
public EnderDragon spawnEnderdragon(Location location) {
return location.getWorld().spawn(location, EnderDragon.class);
}
@Override
public ArmorStand spawnProvisionalArmorStand(Location location) {
return null;
}
@Override
public void setPositionAndRotation(Entity entity, double posX, double posY, double posZ, float pitch, float yaw) {
}
@Override
public void playChestAction(Block b, boolean open) {
}
@Override
public Entity spawnItem(ItemStack itemStack, Location blockLocation) {
return null;
}
@Override
public void setBlock(Block block, ItemStack itemStack) {
}
@Override
public Block getBlockAttachedToSign(Block sign) {
return null;
}
@Override
public Enchantment getGlowEnchant() {
return null;
}
@Override
public void setDirectionalBlockData(Block block, BlockFace dir, boolean upsidedown) {
}
@Override
public FallingBlock spawnFallingBlock(Location location, Material material) {
return null;
}
}
| 1,900 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
NMSManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/nms/NMSManager.java | package me.patothebest.gamecore.nms;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.gamecore.modules.ModuleName;
import me.patothebest.gamecore.logger.InjectLogger;
import me.patothebest.gamecore.util.EnchantGlow;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import java.util.logging.Level;
import java.util.logging.Logger;
@Singleton
@ModuleName("NMS Manager")
public class NMSManager implements ActivableModule {
// -------------------------------------------- //
// FIELD
// -------------------------------------------- //
private final CorePlugin corePlugin;
private NMS nmsImplementation;
@InjectLogger private Logger logger;
@Inject private NMSManager(CorePlugin corePlugin) {
this.corePlugin = corePlugin;
}
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
@Override
public void onEnable() {
String packageName = Bukkit.getServer().getClass().getPackage().getName();
// Get full package string of CraftServer.
// org.bukkit.craftbukkit.version
String version = packageName.substring(packageName.lastIndexOf('.') + 1);
// Get the last element of the package
logger.info("Server version " + version + " detected!");
logger.fine(ChatColor.YELLOW + "Attempting to load NMS...");
try {
final Class<?> clazz = Class.forName("me.patothebest.gamecore.nms." + version + ".NMSImpl");
// Check if we have a NMSHandler class at that location.
if (NMS.class.isAssignableFrom(clazz)) { // Make sure it actually implements NMS
this.nmsImplementation = (NMS) clazz.getConstructor().newInstance(); // Set our handler
} else {
// class is not instance of NMS
logger.severe(ChatColor.RED + "Could not instantiate NMS classes for version " + version + "!");
nmsImplementation = new NullNMSImpl();
return;
}
EnchantGlow.setGlow(nmsImplementation.getGlowEnchant());
logger.info("Successfully instantiated NMS classes!");
} catch (final Exception e) {
logger.log(Level.SEVERE, ChatColor.RED + "Could not instantiate NMS classes for version " + version + "!", e);
nmsImplementation = new NullNMSImpl();
}
}
// -------------------------------------------- //
// GETTER
// -------------------------------------------- //
NMS getImplementation() {
return nmsImplementation;
}
}
| 2,754 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
NMSModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/nms/NMSModule.java | package me.patothebest.gamecore.nms;
import com.google.inject.Provides;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
public class NMSModule extends AbstractBukkitModule<CorePlugin> {
public NMSModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
registerModule(NMSManager.class);
}
@Provides NMS getNMSImplementation(NMSManager nmsManager) {
return nmsManager.getImplementation();
}
}
| 533 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TimingsManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/timings/TimingsManager.java | package me.patothebest.gamecore.timings;
import me.patothebest.gamecore.PluginConfig;
import java.util.Map;
public class TimingsManager {
public static boolean debug = false;
private TimingsManager() {
}
public static TimingsData create(String timing) {
return new TimingsData(timing);
}
public static void stop(TimingsData timings) {
stop(timings, -1L);
}
public static void stop(TimingsData timings, long threshold) {
long totalTime = calculateTime(timings.getStartTime(), timings.getStopTime());
if (totalTime >= threshold && threshold != -1) {
System.out.println("[" + PluginConfig.LOGGER_PREFIX + "] WARNING: " + timings.getTimingName() + " took " + totalTime + "ms to process!");
}
if (debug) {
System.out.println("=== TIMINGS (" + timings.getTimingName() + ") ===");
long time = timings.getStartTime();
for (Map.Entry<String, Long> stringLongEntry : timings.getActionsMap().entrySet()) {
System.out.println(stringLongEntry.getKey() + " - " + calculateTime(time, stringLongEntry.getValue()) + "ms");
time = stringLongEntry.getValue();
}
System.out.println("End - " + calculateTime(time, timings.getStopTime()) + "ms");
System.out.println("Total time - " + totalTime + "ms");
System.out.println("=================================");
}
}
private static long calculateTime(long start, long end) {
return (end - start) / 1000000L;
}
} | 1,587 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TimingsData.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/timings/TimingsData.java | package me.patothebest.gamecore.timings;
import java.util.LinkedHashMap;
import java.util.Map;
public class TimingsData {
private final Map<String, Long> actionsMap = new LinkedHashMap<>();
private final long startTime;
private String timing;
private long stopTime;
public TimingsData(String timing) {
this.timing = timing;
this.startTime = System.nanoTime();
}
public void trackAction(String action) {
actionsMap.put(action, System.nanoTime());
}
public Map<String, Long> getActionsMap() {
return actionsMap;
}
TimingsData end() {
stopTime = System.nanoTime();
return this;
}
public void stop() {
stop(-1);
}
public boolean end(long threshhold) {
stopTime = System.nanoTime();
return (stopTime - startTime) / 1000000L > threshhold;
}
public void print() {
TimingsManager.stop(this, -1);
}
public void stop(long threshold) {
stopTime = System.nanoTime();
TimingsManager.stop(this, threshold);
}
public void setTiming(String timing) {
this.timing = timing;
}
public String getTimingName() {
return timing;
}
public long getStartTime() {
return startTime;
}
public long getStopTime() {
return stopTime;
}
}
| 1,360 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
StorageException.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/StorageException.java | package me.patothebest.gamecore.storage;
/**
* A class representing an exception that could happen
* in the storage module.
*/
public class StorageException extends RuntimeException {
/**
* Constructs a new runtime exception with the specified detail message.
* The cause is not initialized, and may subsequently be initialized by a
* call to {@link #initCause}.
*
* @param message the detail message. The detail message is saved for
s * later retrieval by the {@link #getMessage()} method.
*/
public StorageException(String message) {
super(message);
}
}
| 630 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
StorageModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/StorageModule.java | package me.patothebest.gamecore.storage;
import com.google.inject.multibindings.Multibinder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import me.patothebest.gamecore.storage.flatfile.FlatFileEntity;
import me.patothebest.gamecore.storage.mysql.MySQLEntity;
public abstract class StorageModule extends AbstractBukkitModule<CorePlugin> {
public StorageModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
Multibinder<MySQLEntity> mySQLEntityMultibinder = Multibinder.newSetBinder(binder(), MySQLEntity.class);
mySQLEntityMultibinder.addBinding().to(getSQLEntity());
Multibinder<FlatFileEntity> flatFileEntityMultibinder = Multibinder.newSetBinder(binder(), FlatFileEntity.class);
flatFileEntityMultibinder.addBinding().to(getFlatFileEntity());
}
protected abstract Class<? extends FlatFileEntity> getFlatFileEntity();
protected abstract Class<? extends MySQLEntity> getSQLEntity();
}
| 1,050 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CoreStorageModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/CoreStorageModule.java | package me.patothebest.gamecore.storage;
import com.google.inject.multibindings.Multibinder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.cosmetics.shop.ShopModule;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import me.patothebest.gamecore.storage.converter.ConverterCommand;
import me.patothebest.gamecore.storage.flatfile.FlatFileEntity;
import me.patothebest.gamecore.storage.flatfile.FlatFileStorage;
import me.patothebest.gamecore.storage.flatfile.IFlatFileStorage;
import me.patothebest.gamecore.storage.mysql.IMySQLStorage;
import me.patothebest.gamecore.storage.mysql.MySQLEntity;
import me.patothebest.gamecore.storage.mysql.MySQLStorage;
import me.patothebest.gamecore.kit.KitModule;
import me.patothebest.gamecore.leaderboards.LeaderboardModule;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.stats.StatsModule;
public class CoreStorageModule extends AbstractBukkitModule<CorePlugin> {
public CoreStorageModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
// core storage implementations
Multibinder.newSetBinder(binder(), MySQLEntity.class);
Multibinder.newSetBinder(binder(), FlatFileEntity.class);
bind(IMySQLStorage.class).to(MySQLStorage.class);
bind(IFlatFileStorage.class).to(FlatFileStorage.class);
install(new KitModule(plugin));
install(new StatsModule(plugin));
install(new ShopModule(plugin));
install(new LeaderboardModule(plugin));
registerModule(StorageManager.class);
registerModule(ConverterCommand.class);
registerModule(PlayerManager.class);
}
}
| 1,722 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
StorageEntity.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/StorageEntity.java | package me.patothebest.gamecore.storage;
import me.patothebest.gamecore.player.CorePlayer;
/**
* /**
* Class representing a storage entity
* <p>
* A storage entity is an interface which can't be
* implemented directly, each storage type has its
* own implementation such as MySQLEntity and that
* interface must be implemented.
* <p>
* The storage entity is used to load additional player
* information such as cage type, mystery boxes, etc
*
* @param <LoadData> the data needed for loading the
* extra information
* @param <SaveData> the data needed for saving the
* extra information
*/
public interface StorageEntity<LoadData, SaveData, T extends Throwable> {
/**
* Loads a player's extra information
*
* @param player the player loaded
* @param loadData the extra data needed
*/
void loadPlayer(CorePlayer player, LoadData loadData) throws T;
/**
* Saves a player's extra information
*
* @param player the player to save
* @param saveData the extra data needed
*/
void savePlayer(CorePlayer player, SaveData saveData) throws T;
} | 1,160 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Storage.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/Storage.java | package me.patothebest.gamecore.storage;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.player.CorePlayer;
import me.patothebest.gamecore.util.Callback;
import org.bukkit.inventory.PlayerInventory;
import java.util.Map;
public interface Storage {
void loadPlayers(Callback<CorePlayer> playerCallback);
void load(CorePlayer player, boolean async);
void save(CorePlayer player);
void unCache(CorePlayer player);
void delete(CorePlayer player);
void loadKits(Map<String, Kit> kitMap);
void saveKits(Map<String, Kit> kitMap);
Kit createKit(String name, PlayerInventory playerInventory);
void saveKit(Kit kit);
void deleteKit(Kit kit);
void enableStorage();
default void postEnable() {}
default void preDisableStorage() {}
void disableStorage();
}
| 841 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
StorageManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/StorageManager.java | package me.patothebest.gamecore.storage;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Provider;
import com.google.inject.Singleton;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.modules.ModuleName;
import me.patothebest.gamecore.storage.flatfile.IFlatFileStorage;
import me.patothebest.gamecore.storage.mysql.IMySQLStorage;
import me.patothebest.gamecore.storage.mysql.MySQLStorage;
import me.patothebest.gamecore.storage.none.NullStorage;
import me.patothebest.gamecore.storage.split.SplitStorage;
import me.patothebest.gamecore.storage.split.SplitType;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.logger.InjectLogger;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.gamecore.modules.ModulePriority;
import me.patothebest.gamecore.modules.ReloadableModule;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Priority;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
@Singleton
@ModulePriority(priority = Priority.HIGH)
@ModuleName("Storage Manager")
public class StorageManager implements ActivableModule, ReloadableModule {
private final CorePlugin plugin;
private final CoreConfig coreConfig;
private final Provider<PlayerManager> playerManager;
private final Provider<Injector> injector;
@InjectLogger private Logger logger;
private Storage storage;
private boolean useUUIDs;
@Inject private StorageManager(CorePlugin plugin, CoreConfig coreConfig, Provider<PlayerManager> playerManagerProvider, Provider<Injector> injector) {
this.plugin = plugin;
this.coreConfig = coreConfig;
this.playerManager = playerManagerProvider;
this.injector = injector;
}
@Override
public void onPreEnable() {
StorageType storageType = Utils.getEnumValueFromString(StorageType.class, coreConfig.getString("storage.type"));
useUUIDs = coreConfig.getBoolean("storage.use-uuids");
if (storageType == null) {
// unknown storage type
// fallback into no storage type
storageType = StorageType.NONE;
}
switch (storageType) {
case FLATFILE:
storage = injector.get().getInstance(IFlatFileStorage.class);
break;
case MYSQL:
storage = injector.get().getInstance(IMySQLStorage.class);
break;
case SPLIT:
storage = injector.get().getInstance(SplitStorage.class);
break;
case NONE:
storage = new NullStorage();
break;
}
}
@Override
public void onEnable() {
storage.enableStorage();
Bukkit.getOnlinePlayers().forEach(playerManager.get()::loadPlayer); // reload fix
}
@Override
public void onPostEnable() {
storage.postEnable();
}
@Override
public void onDisable() {
storage.preDisableStorage();
Bukkit.getOnlinePlayers().forEach(playerManager.get()::destroyPlayer); // reload fix
storage.disableStorage();
}
@Override
public void onReload() {
reloadStorage();
}
@Override
public String getReloadName() {
return "storage";
}
public void reloadStorage() {
reloadStorage(false);
}
public void reloadStorage(boolean becauseOfFailSafe) {
Map<Player, IPlayer> tempMap = new HashMap<>();
Bukkit.getOnlinePlayers().forEach(player -> tempMap.put(player, playerManager.get().getPlayer(player)));
onDisable();
if(becauseOfFailSafe) {
storage = new NullStorage();
} else {
onPreEnable();
}
onEnable();
for (Player player : Bukkit.getOnlinePlayers()) {
IPlayer oldPlayer = tempMap.get(player);
IPlayer newPlayer = playerManager.get().getPlayer(player);
if(oldPlayer == null) {
continue;
}
if (oldPlayer.getKit() != null) {
newPlayer.setKit(oldPlayer.getKit());
}
if (oldPlayer.getCurrentArena() != null) {
newPlayer.setCurrentArena(oldPlayer.getCurrentArena());
if (oldPlayer.getGameTeam() != null) {
newPlayer.setGameTeam(oldPlayer.getGameTeam());
}
newPlayer.reinitializeAfterReload();
}
}
onPostEnable();
}
/**
* This boolean will return true for players that need saving when
* they leave the server.
* <p>
* If the storage engine is a database (mysql), all the data is being
* saved live, meaning all changes are saved instantly on the database,
* so there will be no need in saving the data again. This is for many
* reasons, the big one is to prevent race conditions with other servers.
* For example, player joins Server A, the data is loaded on join. If the
* data was to be saved on quit, sometimes, if the player joins Server B,
* the data would load before it was saved from Server A, which led to data
* loss.
* <p>
* If the storage engine is flatfile, then there is no need to worry about
* race conditions, so we can safely load the data on join and save the data
* on quit.
*
* @return true if the player needs saving
*/
public boolean doPlayersNeedSaving() {
if(storage instanceof IFlatFileStorage) {
return true;
}
if(storage instanceof SplitStorage) {
return ((SplitStorage) storage).getSplitTypeStorageMap().get(SplitType.PLAYERS) instanceof IFlatFileStorage;
}
return false;
}
public boolean arePlayersOnDatabase() {
return !doPlayersNeedSaving();
}
public Storage getStorage() {
return storage;
}
public MySQLStorage getMySQLStorage() {
if(storage instanceof MySQLStorage) {
return (MySQLStorage) storage;
}
if(storage instanceof SplitStorage) {
if(((SplitStorage)storage).getSplitTypeStorageMap().get(SplitType.PLAYERS) instanceof MySQLStorage) {
return (MySQLStorage) ((SplitStorage)storage).getSplitTypeStorageMap().get(SplitType.PLAYERS);
}
if(((SplitStorage)storage).getSplitTypeStorageMap().get(SplitType.KITS) instanceof MySQLStorage) {
return (MySQLStorage) ((SplitStorage)storage).getSplitTypeStorageMap().get(SplitType.KITS);
}
}
return null;
}
public boolean isUseUUIDs() {
return useUUIDs;
}
public CorePlugin getPlugin() {
return plugin;
}
}
| 7,004 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
StorageType.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/StorageType.java | package me.patothebest.gamecore.storage;
public enum StorageType {
FLATFILE,
MYSQL,
SPLIT,
NONE
}
| 117 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SQLCallBack.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/mysql/SQLCallBack.java | package me.patothebest.gamecore.storage.mysql;
import me.patothebest.gamecore.util.ThrowableCallback;
import java.sql.SQLException;
public interface SQLCallBack<T> extends ThrowableCallback<T, SQLException> {
} | 214 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LoadSynchronously.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/mysql/LoadSynchronously.java | package me.patothebest.gamecore.storage.mysql;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface LoadSynchronously {
}
| 209 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
MySQLStorage.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/mysql/MySQLStorage.java | package me.patothebest.gamecore.storage.mysql;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.lang.CoreLocaleManager;
import me.patothebest.gamecore.timings.TimingsData;
import me.patothebest.gamecore.timings.TimingsManager;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.KitFactory;
import me.patothebest.gamecore.kit.WrappedPotionEffect;
import me.patothebest.gamecore.logger.InjectParentLogger;
import me.patothebest.gamecore.player.CorePlayer;
import me.patothebest.gamecore.player.PlayerFactory;
import me.patothebest.gamecore.player.PlayerIdentity;
import me.patothebest.gamecore.player.modifiers.GeneralModifier;
import me.patothebest.gamecore.player.modifiers.PlayerModifier;
import me.patothebest.gamecore.storage.StorageManager;
import me.patothebest.gamecore.util.Callback;
import me.patothebest.gamecore.util.PlayerObserver;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.inventory.PlayerInventory;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.function.Consumer;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
@Singleton
public final class MySQLStorage implements IMySQLStorage, PlayerObserver {
private final CorePlugin plugin;
private final MySQLConnectionHandler connectionHandler;
private final List<MySQLEntity> syncCoreSQLEntities;
private final List<MySQLEntity> asyncCoreSQLEntities;
private final PlayerFactory playerFactory;
private final StorageManager storageManager;
private final KitFactory kitFactory;
private volatile boolean async = false;
@InjectParentLogger(parent = StorageManager.class) private Logger logger;
@Inject private MySQLStorage(CorePlugin plugin, CoreConfig coreConfig, StorageManager storageManager, Set<MySQLEntity> coreSQLEntities, PlayerFactory playerFactory, StorageManager storageManager1, KitFactory kitFactory) {
this.plugin = plugin;
this.playerFactory = playerFactory;
this.storageManager = storageManager1;
this.kitFactory = kitFactory;
this.connectionHandler = new MySQLConnectionHandler(plugin, coreConfig, storageManager, this);
syncCoreSQLEntities = Collections.unmodifiableList(coreSQLEntities.stream().filter(entity -> entity.getClass().isAnnotationPresent(LoadSynchronously.class)).collect(Collectors.toList()));
asyncCoreSQLEntities = Collections.unmodifiableList(coreSQLEntities.stream().filter(entity -> !entity.getClass().isAnnotationPresent(LoadSynchronously.class)).collect(Collectors.toList()));
}
@Override
public void loadPlayers(Callback<CorePlayer> playerCallback) {
connectionHandler.executeSQLQuery(connection -> {
PreparedStatement selectUser = connection.prepareStatement(PlayerQueries.SELECT_ALL);
ResultSet resultSet = selectUser.executeQuery();
int loadedPlayers = 0;
while (resultSet.next()) {
String name = resultSet.getString("name");
UUID uuid = UUID.fromString(resultSet.getString("UUID"));
PlayerIdentity playerIdentity = new PlayerIdentity(name, uuid);
CorePlayer player = playerFactory.create(CoreLocaleManager.DEFAULT_LOCALE);
player.setPlayerIdentity(playerIdentity);
load(player, false);
playerCallback.call(player);
loadedPlayers++;
if(loadedPlayers % 1000 == 0) {
logger.info("Converted " + loadedPlayers + " players so far");
}
if(loadedPlayers % 200 == 0) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
logger.info("Converted " + loadedPlayers + " players!");
resultSet.close();
selectUser.close();
}, false);
}
@Override
public final void load(CorePlayer player, boolean async) {
boolean lockThread = !async && plugin.isEnabled() && this.async;
final CountDownLatch countDownLatch = new CountDownLatch(1);
connectionHandler.executeSQLQuery(connection -> {
TimingsData timings = TimingsManager.create("Load " + player.getName());
PreparedStatement selectUser = connection.prepareStatement(storageManager.isUseUUIDs() ? PlayerQueries.SELECT_UUID : PlayerQueries.SELECT_NAME);
selectUser.setString(1, storageManager.isUseUUIDs() ? player.getUniqueId().toString() : player.getName());
ResultSet resultSet = selectUser.executeQuery();
timings.trackAction("Select user from database");
if (!resultSet.next()) {
PreparedStatement createUser = connection.prepareStatement(PlayerQueries.INSERT_RECORD);
createUser.setString(1, player.getName());
createUser.setString(2, player.getUniqueId().toString());
createUser.setString(3, player.getLocale().getName());
createUser.executeUpdate();
createUser.close();
resultSet.close();
timings.trackAction("Create new user");
// re-query database to obtain player id
resultSet = selectUser.executeQuery();
resultSet.next();
timings.trackAction("Re-select user from database");
}
player.setPlayerId(resultSet.getInt("id"));
player.setLocale(CoreLocaleManager.getOrDefault(resultSet.getString("locale"), player.getLocale()));
if (storageManager.isUseUUIDs() && !resultSet.getString("name").equalsIgnoreCase(player.getName())) {
updatePlayerName(player);
}
resultSet.close();
selectUser.close();
for (MySQLEntity coreSQLEntity : syncCoreSQLEntities) {
coreSQLEntity.loadPlayer(player, connection);
timings.trackAction("Load data from " + coreSQLEntity.getClass().getSimpleName());
}
if(lockThread) {
countDownLatch.countDown();
}
for (MySQLEntity coreSQLEntity : asyncCoreSQLEntities) {
coreSQLEntity.loadPlayer(player, connection);
timings.trackAction("Load data from " + coreSQLEntity.getClass().getSimpleName());
}
player.addObserver(this);
player.setAllDataLoaded(true);
timings.stop();
}, error -> {
if(countDownLatch.getCount() == 1) {
countDownLatch.countDown();
}
}, plugin.isEnabled() && this.async);
if(lockThread) {
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void update(CorePlayer player, PlayerModifier modifiedValue, Object... args) {
connectionHandler.executeSQLQuery(connection -> {
if(modifiedValue == GeneralModifier.LOCALE) {
PreparedStatement preparedStatement = connection.prepareStatement(PlayerQueries.UPDATE_LOCALE);
preparedStatement.setString(1, player.getLocale().getName());
preparedStatement.setInt(2, player.getPlayerId());
preparedStatement.executeUpdate();
preparedStatement.close();
}
for (MySQLEntity coreSQLEntity : syncCoreSQLEntities) {
coreSQLEntity.updatePlayer(player, connection, modifiedValue, args);
}
for (MySQLEntity coreSQLEntity : asyncCoreSQLEntities) {
coreSQLEntity.updatePlayer(player, connection, modifiedValue, args);
}
}, plugin.isEnabled() && async);
}
@Override
public final void save(CorePlayer player) {
connectionHandler.executeSQLQuery(connection -> {
PreparedStatement updateUser = connection.prepareStatement(PlayerQueries.UPDATE);
updateUser.setString(1, player.getName());
updateUser.setString(2, player.getLocale().getName());
updateUser.setInt(3, player.getPlayerId());
updateUser.executeUpdate();
updateUser.close();
for (MySQLEntity coreSQLEntity : syncCoreSQLEntities) {
coreSQLEntity.savePlayer(player, connection);
}
for (MySQLEntity coreSQLEntity : asyncCoreSQLEntities) {
coreSQLEntity.savePlayer(player, connection);
}
}, plugin.isEnabled() && async);
}
private void updatePlayerName(CorePlayer player) {
executeUpdate(PlayerQueries.UPDATE, preparedStatement -> {
preparedStatement.setString(1, player.getName());
preparedStatement.setInt(2, player.getPlayerId());
});
}
private void executeUpdate(String update, SQLCallBack<PreparedStatement> preparedStatementCallback) {
connectionHandler.executeSQLQuery(connection -> {
PreparedStatement preparedStatement = connection.prepareStatement(update);
preparedStatementCallback.call(preparedStatement);
preparedStatement.executeUpdate();
preparedStatement.close();
}, plugin.isEnabled() && async);
}
@Override
public void unCache(CorePlayer player) {
player.deleteObservers();
}
@Override
public void delete(CorePlayer player) {
// TODO: delete player
unCache(player);
}
@Override
public void loadKits(Map<String, Kit> kitMap) {
connectionHandler.executeSQLQuery(connection -> {
PreparedStatement updateUser = connection.prepareStatement(KitQueries.SELECT);
ResultSet resultSet = updateUser.executeQuery();
while (resultSet.next()) {
try {
Kit kit = kitFactory.createKit(resultSet);
kitMap.put(kit.getKitName(), kit);
logger.config("Loaded kit " + kit.getKitName());
} catch (Throwable t) {
logger.log(Level.SEVERE, ChatColor.RED + "Could not load kit " + resultSet.getString("name"), t);
}
}
updateUser.close();
}, plugin.isEnabled() && async);
}
@Override
public void saveKits(Map<String, Kit> kitMap) {
if(kitMap.isEmpty()) {
return;
}
connectionHandler.executeSQLQuery(connection -> {
PreparedStatement insertKit = connection.prepareStatement(KitQueries.INSERT);
for (Kit kit : kitMap.values()) {
insertKit.setString(1, kit.getKitName());
insertKit.setString(2, StringUtils.join(kit.getDescription(), "%delimiter%"));
insertKit.setString(3, Utils.itemStackToString(kit.getDisplayItem()));
insertKit.setString(4, Utils.itemStackArrayToBase64(kit.getInventoryItems()));
insertKit.setString(5, Utils.itemStackArrayToBase64(kit.getArmorItems()));
insertKit.setString(6, Utils.potionEffectArrayToBase64(kit.getPotionEffects().toArray(new WrappedPotionEffect[kit.getPotionEffects().size()])));
insertKit.setString(7, kit.getPermissionGroup().getName());
insertKit.setInt(8, kit.isOneTimeKit() ? 1 : 0);
insertKit.setDouble(9, kit.getCost());
insertKit.setInt(10, kit.isEnabled() ? 1 : 0);
insertKit.addBatch();
}
insertKit.executeBatch();
}, plugin.isEnabled() && async);
}
@Override
public Kit createKit(String name, PlayerInventory playerInventory) {
Kit kit = kitFactory.createKit(name, playerInventory);
connectionHandler.executeSQLQuery(connection -> {
PreparedStatement insertKit = connection.prepareStatement(KitQueries.INSERT);
insertKit.setString(1, name);
insertKit.setString(2, StringUtils.join(kit.getDescription(), "%delimiter%"));
insertKit.setString(3, Utils.itemStackToString(kit.getDisplayItem()));
insertKit.setString(4, Utils.itemStackArrayToBase64(kit.getInventoryItems()));
insertKit.setString(5, Utils.itemStackArrayToBase64(kit.getArmorItems()));
insertKit.setString(6, Utils.potionEffectArrayToBase64(kit.getPotionEffects().toArray(new WrappedPotionEffect[kit.getPotionEffects().size()])));
insertKit.setString(7, kit.getPermissionGroup().getName());
insertKit.setInt(8, kit.isOneTimeKit() ? 1 : 0);
insertKit.setDouble(9, kit.getCost());
insertKit.setInt(10, kit.isEnabled() ? 1 : 0);
insertKit.executeUpdate();
}, plugin.isEnabled() && async);
return kit;
}
@Override
public void saveKit(Kit kit) {
connectionHandler.executeSQLQuery(connection -> {
PreparedStatement insertKit = connection.prepareStatement(KitQueries.UPDATE);
insertKit.setString(1, StringUtils.join(kit.getDescription(), "%delimiter%"));
insertKit.setString(2, Utils.itemStackToString(kit.getDisplayItem()));
insertKit.setString(3, Utils.itemStackArrayToBase64(kit.getInventoryItems()));
insertKit.setString(4, Utils.itemStackArrayToBase64(kit.getArmorItems()));
insertKit.setString(5, Utils.potionEffectArrayToBase64(kit.getPotionEffects().toArray(new WrappedPotionEffect[kit.getPotionEffects().size()])));
insertKit.setString(6, kit.getPermissionGroup().getName());
insertKit.setInt(7, kit.isOneTimeKit() ? 1 : 0);
insertKit.setDouble(8, kit.getCost());
insertKit.setInt(9, kit.isEnabled() ? 1 : 0);
insertKit.setString(10, kit.getKitName());
insertKit.executeUpdate();
}, plugin.isEnabled() && async);
}
@Override
public void deleteKit(Kit kit) {
connectionHandler.executeSQLQuery(connection -> {
PreparedStatement insertKit = connection.prepareStatement(KitQueries.DELETE);
insertKit.setString(1, kit.getKitName());
insertKit.executeUpdate();
}, plugin.isEnabled() && async);
}
@Override
public final void enableStorage() {
connectionHandler.setupHikari();
}
@Override
public void postEnable() {
async = true;
}
@Override
public final void preDisableStorage() {
async = false;
}
@Override
public final void disableStorage() {
connectionHandler.closeHikari();
}
@Override
public List<String> getCreateTableQueries() {
List<String> statements = new ArrayList<>();
Consumer<MySQLEntity> consumer = sqlEntity -> {
statements.addAll(Arrays.asList(sqlEntity.getCreateTableStatements()));
};
syncCoreSQLEntities.forEach(consumer);
asyncCoreSQLEntities.forEach(consumer);
statements.add(PlayerQueries.CREATE_TABLE);
statements.add(KitQueries.CREATE_TABLE);
return statements;
}
final CorePlugin getPlugin() {
return plugin;
}
public final MySQLConnectionHandler getConnectionHandler() {
return connectionHandler;
}
Logger getLogger() {
return logger;
}
}
| 15,984 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
MySQLEntity.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/mysql/MySQLEntity.java | package me.patothebest.gamecore.storage.mysql;
import me.patothebest.gamecore.player.CorePlayer;
import me.patothebest.gamecore.player.modifiers.PlayerModifier;
import me.patothebest.gamecore.storage.StorageEntity;
import java.sql.Connection;
import java.sql.SQLException;
/**
* The interface used for all MySQL entities
* <p>
* The entity ony requires a connection for
* loading and saving the player
*/
public interface MySQLEntity extends StorageEntity<Connection, Connection, SQLException> {
/**
* Updates a player specific part. This takes a string as the
* part. The string can be anything, such as stats, kills, deaths,
* etc.
* <p>
* This method will be handled by each {@link MySQLEntity} accordingly,
* Usually only one of the entities will update.
*
* @param player the player
* @param connection the connection to use
* @param updatedType the updated part
* @param args the extra args
*
* @throws SQLException in case any exceptions occur
*/
void updatePlayer(CorePlayer player, Connection connection, PlayerModifier updatedType, Object... args) throws SQLException;
/**
* Gets all the statements needed to create the
* table(s) for the specific entity.
*
* @return the create table statements
*/
String[] getCreateTableStatements();
} | 1,383 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
MySQLConnectionHandler.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/storage/mysql/MySQLConnectionHandler.java | package me.patothebest.gamecore.storage.mysql;
import com.zaxxer.hikari.HikariDataSource;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.storage.StorageManager;
import me.patothebest.gamecore.util.Callback;
import org.bukkit.ChatColor;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class MySQLConnectionHandler {
private final CorePlugin plugin;
private final StorageManager storageManager;
private final CoreConfig coreConfig;
private final MySQLStorage IMySQLStorage;
private String dataSourceClassName = null;
private HikariDataSource hikari;
public MySQLConnectionHandler(CorePlugin plugin, CoreConfig coreConfig, StorageManager storageManager, MySQLStorage IMySQLStorage) {
this.coreConfig = coreConfig;
this.plugin = plugin;
this.storageManager = storageManager;
this.IMySQLStorage = IMySQLStorage;
}
public void setupHikari() {
// has to be one of these, right?...
if (dataSourceClassName == null) tryDataSource("org.mariadb.jdbc.MariaDbDataSource");
if (dataSourceClassName == null) tryDataSource("com.mysql.cj.jdbc.MysqlDataSource");
if (dataSourceClassName == null) tryDataSource("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
if (dataSourceClassName == null) {
throw new IllegalStateException("Could not find driver for MySQL!");
}
hikari = new HikariDataSource();
hikari.setMaximumPoolSize(8);
hikari.setPoolName(PluginConfig.PLUGIN_NAME + " Connection Pool");
hikari.setDataSourceClassName(dataSourceClassName);
hikari.addDataSourceProperty("serverName", coreConfig.getString("storage.host"));
hikari.addDataSourceProperty("port", coreConfig.getString("storage.port"));
hikari.addDataSourceProperty("databaseName", coreConfig.getString("storage.database"));
hikari.addDataSourceProperty("user", coreConfig.getString("storage.username"));
hikari.addDataSourceProperty("password", coreConfig.getString("storage.password"));
hikari.addDataSourceProperty("cachePrepStmts", "true");
hikari.addDataSourceProperty("prepStmtCacheSize", "250");
hikari.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
IMySQLStorage.getLogger().info(ChatColor.YELLOW + "Attempting to connect to database...");
try (Connection connection = getConnection()) {
for (String createTableStatement : IMySQLStorage.getCreateTableQueries()) {
PreparedStatement statement = connection.prepareStatement(createTableStatement);
statement.execute();
statement.close();
}
IMySQLStorage.getLogger().info("Successfully connected to mysql database");
} catch (Exception e) {
e.printStackTrace();
IMySQLStorage.getLogger().severe(ChatColor.RED + "Failed to connected to mysql database");
IMySQLStorage.getLogger().severe(ChatColor.RED + "Please fix database credentials and reload storage with /" + PluginConfig.BASE_COMMAND + " admin reload files");
storageManager.reloadStorage(true);
}
}
private void tryDataSource(String className) {
try {
Class.forName(className);
dataSourceClassName = className;
} catch (ClassNotFoundException ignored) {}
}
public void closeHikari() {
hikari.close();
}
public boolean isClosed() {
return hikari == null || hikari.isClosed();
}
public Connection getConnection() throws SQLException {
return hikari != null ? hikari.getConnection() : null;
}
public void executeSQLQuery(SQLCallBack<Connection> callback, boolean async) {
executeSQLQuery(callback, null, async);
}
public void executeSQLQuery(SQLCallBack<Connection> callback, Callback<Throwable> errorCallback, boolean async) {
SQLTask task = new SQLTask(this, callback, errorCallback);
if(async) {
task.executeAsync();
} else {
task.run();
}
}
public CorePlugin getPlugin() {
return plugin;
}
} | 4,335 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.