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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
EloModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/elo/EloModule.java | package me.patothebest.gamecore.elo;
import me.patothebest.gamecore.elo.entities.EloFlatFileEntity;
import me.patothebest.gamecore.elo.entities.EloMySQLEntity;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.storage.StorageModule;
import me.patothebest.gamecore.storage.flatfile.FlatFileEntity;
import me.patothebest.gamecore.storage.mysql.MySQLEntity;
public class EloModule extends StorageModule {
public EloModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
super.configure();
registerModule(EloManager.class);
}
@Override
protected Class<? extends FlatFileEntity> getFlatFileEntity() {
return EloFlatFileEntity.class;
}
@Override
protected Class<? extends MySQLEntity> getSQLEntity() {
return EloMySQLEntity.class;
}
}
| 873 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EloMySQLEntity.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/elo/entities/EloMySQLEntity.java | package me.patothebest.gamecore.elo.entities;
import me.patothebest.gamecore.player.CorePlayer;
import me.patothebest.gamecore.player.modifiers.EloModifier;
import me.patothebest.gamecore.player.modifiers.PlayerModifier;
import me.patothebest.gamecore.player.types.EloPlayer;
import me.patothebest.gamecore.storage.mysql.MySQLEntity;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class EloMySQLEntity implements MySQLEntity {
/**
* Loads the player's elo
* <p>
* A record is inserted if the record doesn't
* exist.
*
* @param player the player loaded
* @param connection the database connection
*/
@Override
public void loadPlayer(CorePlayer player, Connection connection) throws SQLException {
PreparedStatement selectUser = connection.prepareStatement(Queries.SELECT);
selectUser.setInt(1, player.getPlayerId());
ResultSet resultSet = selectUser.executeQuery();
if (!resultSet.next()) {
PreparedStatement createUser = connection.prepareStatement(Queries.INSERT_RECORD);
createUser.setInt(1, player.getPlayerId());
createUser.executeUpdate();
} else {
((EloPlayer)player).setElo(resultSet.getInt("elo"));
}
resultSet.close();
selectUser.close();
}
/**
* Updates the player's elo in the database
*
* @param player the player to save
* @param connection the database connection
*/
@Override
public void savePlayer(CorePlayer player, Connection connection) throws SQLException {
PreparedStatement updateUser = connection.prepareStatement(Queries.UPDATE);
updateUser.setInt(1, ((EloPlayer)player).getElo());
updateUser.setInt(2, player.getPlayerId());
updateUser.executeUpdate();
updateUser.close();
}
@Override
public void updatePlayer(CorePlayer player, Connection connection, PlayerModifier updatedType, Object... args) throws SQLException {
if(updatedType != EloModifier.MODIFY) {
return;
}
savePlayer(player, connection);
}
/**
* Gets all the statements needed to create the
* table(s) for the specific entity.
*
* @return the create table statements
*/
@Override
public String[] getCreateTableStatements() {
return new String[]{Queries.CREATE_TABLE};
}
} | 2,503 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Queries.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/elo/entities/Queries.java | package me.patothebest.gamecore.elo.entities;
import me.patothebest.gamecore.PluginConfig;
class Queries {
static final String CREATE_TABLE =
"CREATE TABLE IF NOT EXISTS `" + PluginConfig.SQL_PREFIX + "_elo` (\n" +
" `player_id` int(11) NOT NULL,\n" +
" `elo` int(11) NOT NULL,\n" +
" PRIMARY KEY (`player_id`),\n" +
" UNIQUE KEY `player_id` (`player_id`)\n" +
") ENGINE=InnoDB DEFAULT CHARSET=latin1;\n";
final static String INSERT_RECORD = "INSERT INTO " + PluginConfig.SQL_PREFIX + "_elo VALUES (?, '0')";
final static String SELECT = "SELECT * FROM " + PluginConfig.SQL_PREFIX + "_elo WHERE player_id=?";
final static String DELETE = "DELETE FROM " + PluginConfig.SQL_PREFIX + "_elo WHERE player_id=?";
final static String UPDATE = "UPDATE " + PluginConfig.SQL_PREFIX + "_elo SET elo=? WHERE player_id=?;";
}
| 954 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EloFlatFileEntity.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/elo/entities/EloFlatFileEntity.java | package me.patothebest.gamecore.elo.entities;
import me.patothebest.gamecore.player.CorePlayer;
import me.patothebest.gamecore.player.types.EloPlayer;
import me.patothebest.gamecore.storage.StorageException;
import me.patothebest.gamecore.storage.flatfile.FlatFileEntity;
import me.patothebest.gamecore.storage.flatfile.PlayerProfileFile;
public class EloFlatFileEntity implements FlatFileEntity {
/**
* Loads the player's elo
*
* @param player the player loaded
* @param file the player's profile file
*/
@Override
public void loadPlayer(CorePlayer player, PlayerProfileFile file) throws StorageException {
((EloPlayer)player).setElo(file.getInt("elo"));
}
/**
* Saves the player's elo
*
* @param player the player being saved
* @param file the player's profile file
*/
@Override
public void savePlayer(CorePlayer player, PlayerProfileFile file) throws StorageException {
file.set("elo", ((EloPlayer)player).getElo());
}
}
| 1,030 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
BlockRestorer.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/block/BlockRestorer.java | package me.patothebest.gamecore.block;
import com.google.inject.Inject;
import com.google.inject.Provider;
import com.google.inject.Singleton;
import me.patothebest.gamecore.block.impl.Post1_13RestoringBlock;
import me.patothebest.gamecore.block.impl.Pre1_13RestoringBlock;
import me.patothebest.gamecore.block.impl.RestoringBlock;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.modules.ModuleName;
import me.patothebest.gamecore.nms.NMS;
import me.patothebest.gamecore.util.WrappedBukkitRunnable;
import org.bukkit.block.Block;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.Plugin;
import javax.annotation.Nullable;
import java.util.HashMap;
@Singleton
@ModuleName("Block Restorer")
public class BlockRestorer extends WrappedBukkitRunnable implements ListenerModule, ActivableModule, Runnable {
private final Provider<NMS> nmsProvider;
private final HashMap<Block, RestoringBlock> blocks = new HashMap<>();
private final Plugin plugin;
@Inject private BlockRestorer(Provider<NMS> nmsProvider, Plugin plugin) {
this.nmsProvider = nmsProvider;
this.plugin = plugin;
}
@Override
public void onEnable() {
runTaskTimer(plugin, 0L, 1L);
}
@Override
public void run() {
blocks.values().removeIf(RestoringBlock::checkExpiration);
}
@Override
public void onDisable() {
cancel();
for (RestoringBlock value : blocks.values()) {
value.restore();
}
blocks.clear();
}
public void restore(final Block block) {
if (!contains(block)) {
return;
}
blocks.remove(block).restore();
}
public void changeBlockTemporarily(final Block block, @Nullable ItemStack toItem, long changeTimeInMillis) {
if (Material.isNewVersion()) {
blocks.put(block, new Post1_13RestoringBlock(nmsProvider.get(), block, toItem, changeTimeInMillis));
} else {
blocks.put(block, new Pre1_13RestoringBlock(nmsProvider.get(), block, toItem, changeTimeInMillis));
}
}
public boolean contains(final Block block) {
return getBlocks().containsKey(block);
}
public HashMap<Block, RestoringBlock> getBlocks() {
return blocks;
}
} | 2,423 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Post1_13RestoringBlock.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/block/impl/Post1_13RestoringBlock.java | package me.patothebest.gamecore.block.impl;
import me.patothebest.gamecore.nms.NMS;
import org.bukkit.block.Block;
import org.bukkit.block.data.BlockData;
import org.bukkit.inventory.ItemStack;
import javax.annotation.Nullable;
public class Post1_13RestoringBlock extends RestoringBlock {
private final BlockData blockData;
public Post1_13RestoringBlock(NMS nms, Block block, @Nullable ItemStack toItem, long expireDelay) {
super(nms, block, toItem, expireDelay);
this.blockData = block.getBlockData().clone();
}
@Override
public void restore() {
nms.setBlock(block, originalItem);
block.setBlockData(blockData);
block.getState().update();
}
}
| 714 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
RestoringBlock.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/block/impl/RestoringBlock.java | package me.patothebest.gamecore.block.impl;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.nms.NMS;
import org.bukkit.block.Block;
import org.bukkit.inventory.ItemStack;
import javax.annotation.Nullable;
public abstract class RestoringBlock {
protected final NMS nms;
protected final Block block;
protected final long expireTime;
protected final ItemStack originalItem;
public RestoringBlock(NMS nms, Block block, @Nullable ItemStack toItem, long expireDelay) {
this.nms = nms;
this.block = block;
this.expireTime = expireDelay + System.currentTimeMillis();
this.originalItem = new ItemStackBuilder(block.getType()).data(block.getData());
if (toItem != null) {
nms.setBlock(block, toItem);
}
}
public boolean checkExpiration() {
if (System.currentTimeMillis() < this.expireTime) {
return false;
}
this.restore();
return true;
}
public abstract void restore();
} | 1,053 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Pre1_13RestoringBlock.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/block/impl/Pre1_13RestoringBlock.java | package me.patothebest.gamecore.block.impl;
import me.patothebest.gamecore.nms.NMS;
import org.bukkit.block.Block;
import org.bukkit.inventory.ItemStack;
import org.bukkit.material.MaterialData;
import javax.annotation.Nullable;
public class Pre1_13RestoringBlock extends RestoringBlock {
private final MaterialData originalData;
public Pre1_13RestoringBlock(NMS nms, Block block, @Nullable ItemStack toItem, long expireDelay) {
super(nms, block, toItem, expireDelay);
this.originalData = block.getState().getData().clone();
}
@Override
public void restore() {
nms.setBlock(block, originalItem);
block.getState().setData(originalData);
block.getState().update();
}
}
| 737 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AdminGUIFactory.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/AdminGUIFactory.java | package me.patothebest.gamecore.guis;
import me.patothebest.gamecore.guis.admin.AdminChooseTeamUI;
import me.patothebest.gamecore.guis.admin.AdminJoinArenaGUI;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.player.IPlayer;
import org.bukkit.entity.Player;
public interface AdminGUIFactory {
AdminChooseTeamUI createMenu(IPlayer player, AbstractArena abstractArena);
AdminJoinArenaGUI createMenu(Player player);
}
| 462 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GUIModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/GUIModule.java | package me.patothebest.gamecore.guis;
import com.google.inject.assistedinject.FactoryModuleBuilder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.cosmetics.shop.ShopFactory;
import me.patothebest.gamecore.cosmetics.shop.ShopFactoryImpl;
import me.patothebest.gamecore.guis.grouppermissible.PermissionGroupUIFactory;
import me.patothebest.gamecore.guis.kit.KitUIFactory;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import me.patothebest.gamecore.feature.features.gameoptions.GameOptionsGUIFactory;
public class GUIModule extends AbstractBukkitModule<CorePlugin> {
public GUIModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
install(new FactoryModuleBuilder().build(UserGUIFactory.class));
install(new FactoryModuleBuilder().build(AdminGUIFactory.class));
install(new FactoryModuleBuilder().build(KitUIFactory.class));
install(new FactoryModuleBuilder().build(PermissionGroupUIFactory.class));
install(new FactoryModuleBuilder().build(GameOptionsGUIFactory.class));
bind(ShopFactory.class).to(ShopFactoryImpl.class);
}
}
| 1,179 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
UserGUIFactory.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/UserGUIFactory.java | package me.patothebest.gamecore.guis;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.feature.features.gameoptions.GameOptionsFeature;
import me.patothebest.gamecore.guis.user.ChooseTeamUI;
import me.patothebest.gamecore.guis.user.GameOptionsUI;
import me.patothebest.gamecore.guis.user.JoinArenaGUI;
import me.patothebest.gamecore.guis.user.kit.BuyKitUsesUI;
import me.patothebest.gamecore.guis.user.kit.KitLayoutUI;
import me.patothebest.gamecore.guis.user.kit.KitOptionsUI;
import me.patothebest.gamecore.guis.user.kit.KitShopUI;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.util.Callback;
import org.bukkit.entity.Player;
import javax.annotation.Nullable;
import java.util.function.Predicate;
public interface UserGUIFactory {
ChooseTeamUI createTeamUI(Player player, AbstractArena arena, @Nullable Callback<Player> callback);
BuyKitUsesUI createBuyKitUsesUI(IPlayer player, Kit kit, Runnable onBack);
KitOptionsUI openKitOptions(IPlayer player, Kit kit, Runnable onBack);
KitShopUI openKitShop(Player player);
KitLayoutUI openKitLayoutEditor(IPlayer player, Kit kit, Runnable onBack);
GameOptionsUI openGameOptions(Player player, GameOptionsFeature gameOptionsFeature);
JoinArenaGUI createJoinArenaUI(Player player);
JoinArenaGUI createJoinArenaUI(Player player, Predicate<AbstractArena> filter);
}
| 1,456 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PotionEffectUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/kit/PotionEffectUI.java | package me.patothebest.gamecore.guis.kit;
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.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.button.BackButton;
import me.patothebest.gamecore.gui.inventory.button.IncrementingButton;
import me.patothebest.gamecore.gui.inventory.button.IncrementingButtonAction;
import me.patothebest.gamecore.gui.inventory.button.PlaceHolder;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.WrappedPotionEffect;
import org.bukkit.entity.Player;
public class PotionEffectUI extends GUIPage {
private final Kit kit;
private final WrappedPotionEffect potionEffect;
private final KitUIFactory kitUIFactory;
@Inject private PotionEffectUI(CorePlugin plugin, @Assisted Player player, @Assisted Kit kit, @Assisted WrappedPotionEffect potionEffect, KitUIFactory kitUIFactory) {
super(plugin, player, CoreLang.GUI_EDIT_POTION_EFFECT_TITLE.getMessage(player), 45);
this.kit = kit;
this.potionEffect = potionEffect;
this.kitUIFactory = kitUIFactory;
if (!kit.getPotionEffects().contains(potionEffect)) {
kit.getPotionEffects().add(potionEffect);
}
build();
}
@Override
protected void buildPage() {
IncrementingButtonAction incrementingAmplifier = (amount) -> {
potionEffect.setAmplifier(potionEffect.getAmplifier() + amount);
kit.save();
refresh();
};
IncrementingButtonAction incrementingDuration = (amount) -> {
potionEffect.setDuration(potionEffect.getDuration() + (amount*20));
kit.save();
refresh();
};
addButton(new IncrementingButton(-1, incrementingAmplifier), 10);
addButton(new IncrementingButton(-5, incrementingAmplifier), 19);
addButton(new IncrementingButton(-10, incrementingAmplifier), 28);
addButton(new IncrementingButton(1, incrementingAmplifier), 12);
addButton(new IncrementingButton(5, incrementingAmplifier), 21);
addButton(new IncrementingButton(10, incrementingAmplifier), 30);
addButton(new IncrementingButton(-1, incrementingDuration), 14);
addButton(new IncrementingButton(-5, incrementingDuration), 23);
addButton(new IncrementingButton(-10, incrementingDuration), 32);
addButton(new IncrementingButton(1, incrementingDuration), 16);
addButton(new IncrementingButton(5, incrementingDuration), 25);
addButton(new IncrementingButton(10, incrementingDuration), 34);
addButton(new PlaceHolder(new ItemStackBuilder().material(Material.REPEATER).name(getPlayer(), CoreLang.GUI_EDIT_POTION_EFFECT_AMPLIFIER_ITEM).lore(CoreLang.GUI_EDIT_POTION_EFFECT_AMPLIFIER_LORE.replace(getPlayer(), potionEffect.getAmplifier()))), 20);
addButton(new PlaceHolder(new ItemStackBuilder().material(Material.CLOCK).name(getPlayer(), CoreLang.GUI_EDIT_POTION_EFFECT_DURATION_ITEM).lore(CoreLang.GUI_EDIT_POTION_EFFECT_DURATION_LORE.replace(getPlayer(), (potionEffect.getDuration() / 20)))), 24);
addButton(new BackButton(getPlayer(), () -> kitUIFactory.createChoosePotionEffectUI(player, kit)), 36);
addButton(new SimpleButton(new ItemStackBuilder().material(Material.BARRIER).name(getPlayer(), CoreLang.KIT_DELETE), () -> {
kit.getPotionEffects().remove(potionEffect);
kit.save();
kitUIFactory.createEditKitGUI(player, kit);
}), 44);
}
}
| 3,828 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ChoosePotionEffect.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/kit/ChoosePotionEffect.java | package me.patothebest.gamecore.guis.kit;
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.itemstack.PotionBuilder;
import me.patothebest.gamecore.lang.CoreLang;
import net.md_5.bungee.api.ChatColor;
import me.patothebest.gamecore.gui.inventory.button.BackButton;
import me.patothebest.gamecore.gui.inventory.page.GUIMultiPage;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.WrappedPotionEffect;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
import org.bukkit.potion.PotionType;
import java.util.Arrays;
import java.util.Objects;
import java.util.stream.Stream;
public class ChoosePotionEffect extends GUIMultiPage {
private final Kit kit;
private final KitUIFactory kitUIFactory;
@Inject private ChoosePotionEffect(CorePlugin plugin, @Assisted Player player, @Assisted Kit kit, KitUIFactory kitUIFactory) {
super(plugin, player, CoreLang.GUI_CHOOSE_POTION_EFFECT_TITLE.getMessage(player), 54);
this.kit = kit;
this.kitUIFactory = kitUIFactory;
build();
}
@Override
protected void buildContent() {
final int[] slot = {0};
Arrays.stream(PotionEffectType.values()).filter(Objects::nonNull).skip(pageSize * currentPage).limit(pageSize).forEach(potionEffectType -> {
WrappedPotionEffect potionEffect = kit.getPotionEffects().stream().filter(wrappedPotionEffect -> wrappedPotionEffect.getType() == potionEffectType).findFirst().orElse(null);
addButton(new SimpleButton(new ItemStackBuilder(new PotionBuilder()
.effect(getPotionType(potionEffectType))
.toItemStack(1))
.name(ChatColor.GOLD + potionEffectType.getName())
.lore(potionEffect == null ? CoreLang.GUI_CHOOSE_POTION_EFFECT_ADD.getMessage(getPlayer()) : CoreLang.GUI_CHOOSE_POTION_EFFECT_LORE.replace(getPlayer(), potionEffect.getDuration()/20, potionEffect.getAmplifier())))
.action(() -> kitUIFactory.createPotionEffectUI(player, kit, potionEffect == null ? new WrappedPotionEffect(potionEffectType, 0, 0) : potionEffect)), slot[0]);
slot[0]++;
});
addButton(new BackButton(getPlayer(), () -> kitUIFactory.createEditKitGUI(player, kit)), 47);
}
@SuppressWarnings("deprecation")
private PotionType getPotionType(PotionEffectType effectType) {
return Stream.of(PotionType.values()).filter(potionType -> potionType.getEffectType() != null).filter(potionType -> potionType.getEffectType().getId() == effectType.getId()).findFirst().orElse(PotionType.WATER);
}
@Override
protected int getListCount() {
return PotionEffectType.values().length;
}
}
| 2,965 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
KitUIFactory.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/kit/KitUIFactory.java | package me.patothebest.gamecore.guis.kit;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.WrappedPotionEffect;
import org.bukkit.entity.Player;
public interface KitUIFactory {
ChooseKitToEditGUI createChooseKitToEditGUI(Player player);
EditKitUI createEditKitGUI(Player player, Kit kit);
PotionEffectUI createPotionEffectUI(Player player, Kit kit, WrappedPotionEffect wrappedPotionEffect);
ChoosePotionEffect createChoosePotionEffectUI(Player player, Kit kit);
EditPriceUI createEditPriceUI(Player player, Kit kit);
KitPreview createKitPreview(Player player, Kit kit, boolean addReceiveItemsButton, Runnable onBack);
}
| 678 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EditKitUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/kit/EditKitUI.java | package me.patothebest.gamecore.guis.kit;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.gui.anvil.AnvilSlot;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.button.AnvilButton;
import me.patothebest.gamecore.gui.inventory.button.AnvilButtonAction;
import me.patothebest.gamecore.gui.inventory.button.BackButton;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.gui.inventory.descriptioneditor.DescriptionEdition;
import me.patothebest.gamecore.gui.inventory.descriptioneditor.DescriptionEditorMainPage;
import me.patothebest.gamecore.gui.inventory.itemeditor.ItemMainPage;
import me.patothebest.gamecore.gui.inventory.itemeditor.UpdateAction;
import me.patothebest.gamecore.guis.grouppermissible.PermissionGroupUIFactory;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.itemstack.PotionBuilder;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.KitManager;
import me.patothebest.gamecore.lang.CoreLang;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.Plugin;
import org.bukkit.potion.PotionType;
import java.util.List;
public class EditKitUI extends GUIPage {
private final Kit kit;
private final KitUIFactory kitUIFactory;
private final KitManager kitManager;
private final PermissionGroupUIFactory permissionGroupUIFactory;
@Inject private EditKitUI(Plugin plugin, KitUIFactory kitUIFactory, PermissionGroupUIFactory permissionGroupUIFactory, KitManager kitManager, @Assisted Player player, @Assisted Kit kit) {
super(plugin, player, CoreLang.GUI_EDIT_KIT_TITLE.replace(player, kit.getKitName()), 36);
this.permissionGroupUIFactory = permissionGroupUIFactory;
this.kit = kit;
this.kitUIFactory = kitUIFactory;
this.kitManager = kitManager;
build();
}
@Override
protected void buildPage() {
ItemStackBuilder renameItem = new ItemStackBuilder().material(Material.NAME_TAG).name(getPlayer(), CoreLang.GUI_EDIT_KIT_RENAME);
ItemStackBuilder enabledSlimeball = new ItemStackBuilder().createTogglableItem(getPlayer(), kit.isOneTimeKit()).lore(CoreLang.GUI_EDIT_KIT_ONE_TIME.getMessage(getPlayer()));
ItemStackBuilder preview = new ItemStackBuilder().material(Material.PAINTING).name(getPlayer(), CoreLang.GUI_EDIT_KIT_PREVIEW);
ItemStackBuilder priceItem = new ItemStackBuilder().material(Material.EMERALD).name(getPlayer(), CoreLang.GUI_EDIT_KIT_PRICE);
ItemStackBuilder permission = new ItemStackBuilder().material(Material.BLAZE_POWDER).name(getPlayer(), CoreLang.GUI_EDIT_KIT_SET_PERMISSION);
ItemStackBuilder changeItems = new ItemStackBuilder().material(Material.DIAMOND_CHESTPLATE).name(getPlayer(), CoreLang.GUI_EDIT_KIT_CHANGE_ITEMS);
ItemStackBuilder enabled = new ItemStackBuilder().createTogglableItem(getPlayer(), kit.isEnabled());
ItemStackBuilder setPotionEffects = new ItemStackBuilder(new PotionBuilder().effect(PotionType.WATER).toItemStack(1)).name(getPlayer(), CoreLang.GUI_EDIT_KIT_POTION_EFFECTS);
ItemStackBuilder descriptionItem = new ItemStackBuilder().material(Material.WRITABLE_BOOK).name(getPlayer(), CoreLang.GUI_EDIT_KIT_DESCRIPTION);
ItemStackBuilder itemFrame = new ItemStackBuilder().material(Material.ITEM_FRAME).name(getPlayer(), CoreLang.GUI_EDIT_KIT_DISPLAY_ITEM);
ItemStackBuilder barrier = new ItemStackBuilder().material(Material.BARRIER).name(getPlayer(), CoreLang.GUI_EDIT_KIT_DELETE);
addButton(new SimpleButton(enabledSlimeball).action(() -> {
kit.setOneTimeKit(!kit.isOneTimeKit());
kit.save();
refresh();
}), 2);
addButton(new AnvilButton(renameItem).action(new AnvilButtonAction() {
@Override
public void onConfirm(String output) {
kit.setKitName(output);
kit.save();
player.sendMessage(CoreLang.GUI_EDIT_KIT_KIT_RENAMED.getMessage(player));
new EditKitUI(plugin, kitUIFactory, permissionGroupUIFactory, kitManager, player, kit);
}
@Override
public void onCancel() {
new EditKitUI(plugin, kitUIFactory, permissionGroupUIFactory, kitManager, player, kit);
}
}).slot(AnvilSlot.INPUT_LEFT, new ItemStackBuilder().material(Material.NAME_TAG).name(kit.getKitName())), 4);
addButton(new SimpleButton(preview).action(() -> kitUIFactory.createKitPreview(player, kit, true, () -> {
new EditKitUI(plugin, kitUIFactory, permissionGroupUIFactory, kitManager, player, kit);
})), 6);
addButton(new SimpleButton(priceItem).action(() -> kitUIFactory.createEditPriceUI(player, kit)), 12);
addButton(new SimpleButton(permission).action(() -> permissionGroupUIFactory.create(player, kit, () -> new EditKitUI(plugin, kitUIFactory, permissionGroupUIFactory, kitManager, player, kit))), 14);
addButton(new SimpleButton(changeItems).action(() -> {
kit.setArmorItems(player.getInventory().getArmorContents());
kit.setInventoryItems(player.getInventory().getContents());
kit.save();
player.sendMessage(CoreLang.GUI_EDIT_KIT_ITEMS_UPDATED.getMessage(player));
}), 20);
addButton(new SimpleButton(enabled).action(() -> {
kit.setEnabled(!kit.isEnabled());
kit.save();
refresh();
}), 22);
addButton(new SimpleButton(setPotionEffects).action(() -> kitUIFactory.createChoosePotionEffectUI(player, kit)), 24);
addButton(new BackButton(getPlayer()).action(() -> kitUIFactory.createChooseKitToEditGUI(player)), 27);
addButton(new SimpleButton(itemFrame, () -> new ItemMainPage(plugin, player, (kit.getDisplayItem() == null ? Material.REDSTONE_BLOCK.parseItem() : kit.getDisplayItem()), new UpdateAction() {
@Override
public void onUpdate(ItemStack itemStack) {
kit.setDisplayItem(itemStack);
kit.save();
}
@Override
public void onBack() {
new EditKitUI(plugin, kitUIFactory, permissionGroupUIFactory, kitManager, player, kit);
}
})), 30);
addButton(new SimpleButton(descriptionItem).action(() -> new DescriptionEditorMainPage(plugin, player, new DescriptionEdition() {
@Override
public void onBack() {
new EditKitUI(plugin, kitUIFactory, permissionGroupUIFactory, kitManager, player, kit);
}
@Override
public void onUpdate() {
kit.save();
}
@Override
public List<String> getDescription() {
return kit.getDescription();
}
})), 32);
addButton(new SimpleButton(barrier, () -> {
kitManager.getKits().remove(kit.getKitName());
kit.delete();
player.sendMessage(CoreLang.GUI_EDIT_KIT_KIT_DELETED.getMessage(player));
player.closeInventory();
}), 35);
}
} | 7,364 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
KitPreview.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/kit/KitPreview.java | package me.patothebest.gamecore.guis.kit;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.button.BackButton;
import me.patothebest.gamecore.gui.inventory.button.PlaceHolder;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class KitPreview extends GUIPage {
private final Kit kit;
private final PlayerManager playerManager;
private final boolean addReceiveItemsButton;
private final Runnable onBack;
@Inject private KitPreview(CorePlugin plugin, @Assisted Player player, @Assisted Kit kit, PlayerManager playerManager, @Assisted boolean addReceiveItemsButton, @Assisted Runnable onBack) {
super(plugin, player, CoreLang.GUI_PREVIEW_KIT_TITLE.replace(player, kit.getKitName()), 54);
this.kit = kit;
this.playerManager = playerManager;
this.addReceiveItemsButton = addReceiveItemsButton;
this.onBack = onBack;
build();
}
@Override
protected void buildPage() {
for (int i = 0; i < kit.getArmorItems().length + kit.getInventoryItems().length; i++) {
setItem(i);
}
addButton(new BackButton(getPlayer()).action(onBack::run), 45);
if (addReceiveItemsButton) {
addButton(new SimpleButton(new ItemStackBuilder(kit.finalDisplayItem(playerManager.getPlayer(getPlayer()), false)).name(getPlayer(), CoreLang.GUI_PREVIEW_KIT_COPY)).action(() -> kit.applyKit(playerManager.getPlayer(player))), 53);
}
}
private void setItem(int i) {
int slot = i;
ItemStack[] is = kit.getInventoryItems();
if (i >= is.length) {
i -= is.length;
is = kit.getArmorItems();
} else {
i = this.getReversedItemSlotNum(i);
}
if (i >= is.length) {
i -= is.length;
is = null;
} else if (is == kit.getArmorItems()) {
i = this.getReversedArmorSlotNum(i);
}
if (is == null) {
return;
}
addButton(new PlaceHolder(is[i]), slot);
}
private int getReversedItemSlotNum(final int i) {
return (i >= 27) ? (i - 27) : (i + 9);
}
private int getReversedArmorSlotNum(final int i) {
if (i == 0) {
return 3;
}
if (i == 1) {
return 2;
}
if (i == 2) {
return 1;
}
if (i == 3) {
return 0;
}
return i;
}
}
| 2,905 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EditPriceUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/kit/EditPriceUI.java | package me.patothebest.gamecore.guis.kit;
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.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.button.BackButton;
import me.patothebest.gamecore.gui.inventory.button.IncrementingButton;
import me.patothebest.gamecore.gui.inventory.button.IncrementingButtonAction;
import me.patothebest.gamecore.gui.inventory.button.PlaceHolder;
import me.patothebest.gamecore.kit.Kit;
import org.bukkit.entity.Player;
public class EditPriceUI extends GUIPage {
private final Kit kit;
private final KitUIFactory kitUIFactory;
@Inject private EditPriceUI(CorePlugin plugin, @Assisted Player player, @Assisted Kit kit, KitUIFactory kitUIFactory) {
super(plugin, player, CoreLang.GUI_EDIT_PRICE_TITLE.getMessage(player), 9);
this.kit = kit;
this.kitUIFactory = kitUIFactory;
build();
}
@Override
public void buildPage() {
IncrementingButtonAction onUpdateCost = (amount) -> {
kit.setCost(kit.getCost() + amount < 0 ? 0 : kit.getCost() + amount);
kit.save();
refresh();
};
addButton(new IncrementingButton(-100, onUpdateCost), 1);
addButton(new IncrementingButton(-10, onUpdateCost), 2);
addButton(new IncrementingButton(-1, onUpdateCost), 3);
addButton(new IncrementingButton(1, onUpdateCost), 5);
addButton(new IncrementingButton(10, onUpdateCost), 6);
addButton(new IncrementingButton(100, onUpdateCost), 7);
addButton(new BackButton(getPlayer(), () -> kitUIFactory.createEditKitGUI(player, kit)), 0);
addButton(new PlaceHolder(new ItemStackBuilder(kit.getDisplayItem()).name(CoreLang.GUI_EDIT_PRICE_KIT_ITEM.replace(getPlayer(), kit.getKitName())).lore(CoreLang.GUI_EDIT_PRICE_LORE.replace(getPlayer(), kit.getCost()))), 4);
addButton(new SimpleButton(new ItemStackBuilder().material(Material.TNT).name(getPlayer(), CoreLang.GUI_EDIT_PRICE_RESET), () -> {
kit.setCost(0);
kit.save();
refresh();
}), 8);
}
} | 2,419 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ChooseKitToEditGUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/kit/ChooseKitToEditGUI.java | package me.patothebest.gamecore.guis.kit;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
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.gui.anvil.AnvilSlot;
import me.patothebest.gamecore.gui.inventory.button.AnvilButton;
import me.patothebest.gamecore.gui.inventory.button.AnvilButtonAction;
import me.patothebest.gamecore.gui.inventory.page.GUIMultiPage;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.KitManager;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.Plugin;
public class ChooseKitToEditGUI extends GUIMultiPage {
private final KitManager kitManager;
private final PlayerManager playerManager;
private final KitUIFactory kitUIFactory;
@Inject private ChooseKitToEditGUI(Plugin plugin, @Assisted Player player, KitManager kitManager, PlayerManager playerManager, KitUIFactory kitUIFactory) {
super(plugin, player, CoreLang.GUI_CHOOSE_KIT_TITLE.getMessage(player), 54);
this.kitManager = kitManager;
this.playerManager = playerManager;
this.kitUIFactory = kitUIFactory;
build();
}
@Override
protected void buildContent() {
final int[] slot = {0};
kitManager.getKits().values().stream().skip(currentPage * pageSize).limit(pageSize).forEach(kit -> {
ItemStack item = new ItemStackBuilder(kit.finalDisplayItem(playerManager.getPlayer(getPlayer()), false)).name(CoreLang.GUI_CHOOSE_KIT_EDIT_ITEM.getMessage(getPlayer()).replace("%kit%", kit.getKitName()));
addButton(new SimpleButton(item, () -> kitUIFactory.createEditKitGUI(player, kit)), slot[0]);
slot[0]++;
});
addButton(new AnvilButton(new ItemStackBuilder().material(Material.EMERALD).name(CoreLang.GUI_CHOOSE_KIT_CREATE_ITEM.getMessage(getPlayer()))).action(new AnvilButtonAction() {
@Override
public void onConfirm(String output) {
if (kitManager.kitExists(output)) {
player.sendMessage(CoreLang.KIT_ALREADY_EXISTS.getMessage(getPlayer()));
return;
}
Kit kit = kitManager.createKit(output, player.getInventory());
player.sendMessage(CoreLang.KIT_CREATED.getMessage(getPlayer()));
kitUIFactory.createEditKitGUI(player, kit);
}
@Override
public void onCancel() {
new ChooseKitToEditGUI(plugin, player, kitManager, playerManager, kitUIFactory);
}
}).slot(AnvilSlot.INPUT_LEFT, new ItemStackBuilder().material(Material.NAME_TAG).name("Kit")), 51);
}
@Override
protected int getListCount() {
return kitManager.getKits().size();
}
} | 3,049 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ChoosePermissionGroup.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/grouppermissible/ChoosePermissionGroup.java | package me.patothebest.gamecore.guis.grouppermissible;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.gui.anvil.AnvilSlot;
import me.patothebest.gamecore.gui.inventory.button.AnvilButton;
import me.patothebest.gamecore.gui.inventory.button.AnvilButtonAction;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.gui.inventory.page.GUIMultiPage;
import me.patothebest.gamecore.gui.inventory.page.GenericGUI;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.permission.GroupPermissible;
import me.patothebest.gamecore.permission.PermissionGroupManager;
import org.bukkit.ChatColor;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
public class ChoosePermissionGroup extends GUIMultiPage {
private final GroupPermissible groupPermissible;
private final GenericGUI genericGUI;
private final PermissionGroupManager permissionGroupManager;
@Inject public ChoosePermissionGroup(Plugin plugin, @Assisted Player player, @Assisted GroupPermissible groupPermissible, @Assisted GenericGUI genericGUI, PermissionGroupManager permissionGroupManager) {
super(plugin, player, "Choose permission group");
this.groupPermissible = groupPermissible;
this.genericGUI = genericGUI;
this.permissionGroupManager = permissionGroupManager;
build();
}
@Override
protected void buildContent() {
final int[] i = new int[]{0};
permissionGroupManager.getPermissionGroups().values().stream().skip(currentPage * pageSize).limit(pageSize).forEach(permissionGroup -> {
ItemStackBuilder itemStack = new ItemStackBuilder().material(Material.PAPER).name(ChatColor.GREEN + permissionGroup.getName());
if (groupPermissible.getPermissionGroup().getName().equalsIgnoreCase(permissionGroup.getName())) {
itemStack.enchant(Enchantment.WATER_WORKER, 1);
}
addButton(new SimpleButton(itemStack).action(() -> {
groupPermissible.setPermissionGroup(permissionGroup);
refresh();
}), i[0]);
i[0]++;
});
addButton(new SimpleButton(new ItemStackBuilder().createBackItem(getPlayer()), genericGUI::onBack), 47);
addButton(new AnvilButton(new ItemStackBuilder().material(Material.EMERALD).name(ChatColor.GREEN + "Add permission group")).action(new AnvilButtonAction() {
@Override
public void onConfirm(String output) {
permissionGroupManager.createGroup(output);
new ChoosePermissionGroup(plugin, player, groupPermissible, genericGUI, permissionGroupManager);
}
@Override
public void onCancel() {
new ChoosePermissionGroup(plugin, player, groupPermissible, genericGUI, permissionGroupManager);
}
}).slot(AnvilSlot.INPUT_LEFT, new ItemStackBuilder().material(Material.PAPER).name("permission")), 51);
}
@Override
protected int getListCount() {
return permissionGroupManager.getPermissionGroups().values().size();
}
}
| 3,314 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PermissionGroupUIFactory.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/grouppermissible/PermissionGroupUIFactory.java | package me.patothebest.gamecore.guis.grouppermissible;
import me.patothebest.gamecore.gui.inventory.page.GenericGUI;
import me.patothebest.gamecore.permission.GroupPermissible;
import org.bukkit.entity.Player;
public interface PermissionGroupUIFactory {
ChoosePermissionGroup create(Player player, GroupPermissible groupPermissible, GenericGUI genericGUI);
}
| 367 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AdminUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/admin/AdminUI.java | package me.patothebest.gamecore.guis.admin;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.feature.features.other.CountdownFeature;
import me.patothebest.gamecore.gui.inventory.GUIPage;
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.ChatColor;
import org.bukkit.entity.Player;
public class AdminUI extends GUIPage {
private final AbstractArena arena;
public AdminUI(CorePlugin plugin, Player player, AbstractArena arena) {
super(plugin, player, CoreLang.GUI_ADMIN_TITLE.getMessage(player), 9);
this.arena = arena;
build();
}
@Override
protected void buildPage() {
CountdownFeature countdown = arena.getFeature(CountdownFeature.class);
ItemStackBuilder start = new ItemStackBuilder().material(Material.EMERALD_BLOCK).name(getPlayer(), CoreLang.GUI_ADMIN_START_COUNTDOWN);
ItemStackBuilder enabled = new ItemStackBuilder().createTogglableItem(getPlayer(), countdown.isOverrideRunning()).lore(ChatColor.GRAY + "Countdown override");
ItemStackBuilder stop = new ItemStackBuilder().material(Material.REDSTONE_BLOCK).name(getPlayer(), CoreLang.GUI_ADMIN_STOP_COUNTDOWN);
addButton(new SimpleButton(start).action(countdown::startCountdown), 1);
addButton(new SimpleButton(enabled).action(() -> {
countdown.setOverrideRunning(!countdown.isOverrideRunning());
refresh();
}), 4);
addButton(new SimpleButton(stop).action(() -> countdown.setRunning(false)), 7);
}
interface Factory {
void create(Player player, AbstractArena arena);
}
}
| 1,859 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AdminJoinArenaGUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/admin/AdminJoinArenaGUI.java | package me.patothebest.gamecore.guis.admin;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.guis.AdminGUIFactory;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import java.util.Comparator;
import java.util.stream.Collectors;
public class AdminJoinArenaGUI extends GUIPage {
private final PlayerManager playerManager;
private final ArenaManager arenaManager;
private final AdminGUIFactory adminGUIFactory;
@Inject private AdminJoinArenaGUI(CorePlugin plugin, ArenaManager arenaManager, PlayerManager playerManager, @Assisted Player player, AdminGUIFactory adminGUIFactory) {
super(plugin, player, "Arenas", ((int) Math.ceil((arenaManager.getArenas().values().stream().filter(AbstractArena::isEnabled)).count() / 9.0))*9);
this.arenaManager = arenaManager;
this.playerManager = playerManager;
this.adminGUIFactory = adminGUIFactory;
build();
}
@Override
public void buildPage() {
final int[] slot = {0};
Comparator<AbstractArena> comparator = Comparator.comparingInt(arena2 -> -arena2.getPlayers().size());
for (AbstractArena arena : arenaManager.getArenas().values().stream().filter(AbstractArena::isEnabled).sorted(comparator).collect(Collectors.toList())) {
addButton(new SimpleButton(new ItemStackBuilder().material(Material.WHITE_WOOL).color(arena.getArenaState().getData()).name(arena.getArenaState().getColor() + arena.getWorldName()).lore(arena.getArenaState().getColor() + arena.getArenaState().getName(), "", ChatColor.WHITE + "Players: " + ChatColor.RED + arena.getPlayers().size() + "/" + arena.getMaxPlayers()).amount(arena.getPlayers().size())).action(() -> {
adminGUIFactory.createMenu(playerManager.getPlayer(player), arena);
}), slot[0]);
slot[0]++;
}
}
}
| 2,346 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AdminChooseTeamUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/admin/AdminChooseTeamUI.java | package me.patothebest.gamecore.guis.admin;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.gui.inventory.GUIPage;
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.player.IPlayer;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class AdminChooseTeamUI extends GUIPage {
private final AbstractArena arena;
private final IPlayer player;
@Inject private AdminChooseTeamUI(CorePlugin plugin, @Assisted IPlayer player, @Assisted AbstractArena arena) {
super(plugin, player.getPlayer(), CoreLang.GUI_USER_CHOOSE_TEAM_TITLE, ((int) Math.ceil(arena.getTeams().size() / 9.0))*9);
this.player = player;
this.arena = arena;
build();
}
@Override
public void buildPage() {
final int[] slot = {0};
for (AbstractGameTeam gameTeam : arena.getTeams().values()) {
addButton(new SimpleButton(new ItemStackBuilder()
.material(Material.WHITE_WOOL)
.name(Utils.getColorFromDye(gameTeam.getColor()) + gameTeam.getName()).color(gameTeam.getColor())
.amount(arena.getTeamPreferences().containsKey(gameTeam) ? arena.getTeamPreferences().get(gameTeam).size() : 0)
.lore(Utils.orderListForLore("Players", gameTeam.getPlayers().stream().map(Player::getName).collect(Collectors.toList())))).action(() -> {
Location oldLocation = null;
if(player.isInArena()) {
if(player.getGameTeam() != null) {
if(player.getGameTeam() == gameTeam) {
CoreLang.GUI_USER_CHOOSE_TEAM_YOU_ARE_ALREADY_IN.sendMessage(player);
return;
}
}
oldLocation = player.getLocation();
arena.removePlayer(super.player, true);
}
List<Player> players = arena.getTeamPreferences().getOrDefault(gameTeam, new ArrayList<>());
players.add(player.getPlayer());
arena.getTeamPreferences().putIfAbsent(gameTeam, players);
player.sendMessage(CoreLang.GUI_USER_CHOOSE_TEAM_YOU_JOINED.replace(player, Utils.getColorFromDye(gameTeam.getColor()), gameTeam.getName()));
arena.addPlayer(super.player);
if(oldLocation != null) {
super.player.teleport(oldLocation);
}
super.player.closeInventory();
}), slot[0]);
slot[0]++;
}
}
} | 3,108 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameOptionsUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/GameOptionsUI.java | package me.patothebest.gamecore.guis.user;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.feature.features.gameoptions.GameOptionsFeature;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import org.bukkit.entity.Player;
public class GameOptionsUI extends GUIPage {
private final GameOptionsFeature gameOptionsFeature;
@Inject private GameOptionsUI(CorePlugin plugin, @Assisted Player player, @Assisted GameOptionsFeature gameOptionsFeature) {
super(plugin, player, CoreLang.GUI_GAME_OPTIONS_TITLE.getMessage(player), 27);
this.gameOptionsFeature = gameOptionsFeature;
build();
}
@Override
protected void buildPage() {
gameOptionsFeature.getButtonsInMenu().forEach((slot, gameOption) -> addButton(gameOption.getButton(getPlayer()), slot));
}
}
| 966 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
JoinArenaGUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/JoinArenaGUI.java | package me.patothebest.gamecore.guis.user;
import com.google.inject.assistedinject.Assisted;
import com.google.inject.assistedinject.AssistedInject;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.gui.inventory.GUIButton;
import me.patothebest.gamecore.gui.inventory.page.DynamicPaginatedUI;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitTask;
import java.util.function.Predicate;
public class JoinArenaGUI extends DynamicPaginatedUI<AbstractArena> implements Runnable {
private final BukkitTask task;
private final PlayerManager playerManager;
private final Predicate<AbstractArena> filter;
private final ArenaManager arenaManager;
@AssistedInject private JoinArenaGUI(CorePlugin plugin, PluginScheduler pluginScheduler, ArenaManager arenaManager, PlayerManager playerManager, @Assisted Player player) {
super(plugin, player, CoreLang.GUI_USER_JOIN_ARENA_TITLE, () -> arenaManager.getAvailableArenas(player, abstractArena -> true));
this.arenaManager = arenaManager;
this.playerManager = playerManager;
filter = abstractArena -> true;
task = pluginScheduler.runTaskTimer(this, 20L, 20L);
build();
}
@AssistedInject private JoinArenaGUI(CorePlugin plugin, PluginScheduler pluginScheduler, ArenaManager arenaManager, PlayerManager playerManager, @Assisted Player player, @Assisted Predicate<AbstractArena> filter) {
super(plugin, player, CoreLang.GUI_USER_JOIN_ARENA_TITLE, () -> arenaManager.getAvailableArenas(player, filter));
this.arenaManager = arenaManager;
this.playerManager = playerManager;
this.filter = filter;
task = pluginScheduler.runTaskTimer(this, 20L, 20L);
build();
}
@Override
protected GUIButton createButton(AbstractArena arena) {
ItemStackBuilder displayItem = new ItemStackBuilder().
material(Material.WHITE_WOOL)
.color(arena.getArenaState().getData())
.glowing(arena.isPrivateArena())
.name(arena.getArenaState().getColor() + arena.getDisplayName())
.lore(arena.getArenaState().getColor() + arena.getArenaState().getName(),
"",
ChatColor.WHITE + "Players: " + ChatColor.RED + arena.getPlayers().size() + "/" + arena.getMaxPlayers(),
"")
.amount(arena.getPlayers().size());
if(arena.getPhase().canJoin() && arena.canJoin(getPlayer())) {
if(arena.isFull()) {
displayItem.addLore(CoreLang.GUI_USER_JOIN_ARENA_ARENA_FULL.getMessage(getPlayer()));
} else {
displayItem.addLore(CoreLang.GUI_USER_JOIN_ARENA_CLICK_TO_JOIN.getMessage(getPlayer()));
}
} else if(arena.canJoinArena()) {
displayItem.addLore(CoreLang.GUI_USER_JOIN_ARENA_CLICK_TO_SPECTATE.getMessage(getPlayer()));
}
return new SimpleButton(displayItem).action(() -> {
if(playerManager.getPlayer(player.getName()).getCurrentArena() != null) {
player.sendMessage(CoreLang.ALREADY_IN_ARENA.getMessage(player));
return;
}
if(!arena.isEnabled()) {
player.sendMessage(CoreLang.ARENA_IS_NOT_PLAYABLE.getMessage(player));
return;
}
if(arena.getPhase().canJoin() && arena.canJoin(player)) {
if(arena.isFull()) {
player.sendMessage(CoreLang.ARENA_IS_FULL.getMessage(player));
return;
}
arena.addPlayer(player);
} else if(arena.canJoinArena()) {
arena.addSpectator(player);
} else {
player.sendMessage(CoreLang.ARENA_IS_RESTARTING.getMessage(player));
}
});
}
@Override
public void run() {
refresh();
}
@Override
public void destroy() {
task.cancel();
}
}
| 4,508 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ChooseLocale.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/ChooseLocale.java | package me.patothebest.gamecore.guis.user;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.lang.CoreLocaleManager;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
public class ChooseLocale extends GUIPage {
private final PlayerManager playerManager;
public ChooseLocale(CorePlugin plugin, PlayerManager playerManager, Player player) {
super(plugin, player, CoreLang.GUI_CHOOSE_LOCALE_TITLE.getMessage(player), 9);
this.playerManager = playerManager;
build();
}
@Override
protected void buildPage() {
final int[] slot = {0};
CoreLocaleManager.getLocales().values().forEach(locale -> {
ItemStackBuilder itemStackBuilder = new ItemStackBuilder().customSkull(CoreLang.SKIN.getMessage(locale)).name(ChatColor.GREEN + CoreLang.NAME.getMessage(locale));
if(playerManager.getPlayer(getPlayer()).getLocale().getName().equalsIgnoreCase(locale.getName())) {
itemStackBuilder.lore(CoreLang.GUI_CHOOSE_LOCALE_SELECTED.getMessage(locale));
itemStackBuilder.glowing(true);
}
addButton(new SimpleButton(itemStackBuilder).action(() -> {
if(playerManager.getPlayer(player).getLocale().getName().equalsIgnoreCase(locale.getName())) {
player.sendMessage(CoreLang.GUI_CHOOSE_LOCALE_NOT_CHANGED.getMessage(player));
return;
}
playerManager.getPlayer(player).setLocale(locale);
player.sendMessage(CoreLang.GUI_CHOOSE_LOCALE_CHANGED.getMessage(player));
setTitle(CoreLang.GUI_CHOOSE_LOCALE_TITLE.getMessage(getPlayer()));
}), slot[0]);
slot[0]++;
});
}
}
| 2,052 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ChooseTeamUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/ChooseTeamUI.java | package me.patothebest.gamecore.guis.user;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.Material;
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.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.GUIUpdater;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.util.Callback;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ChooseTeamUI extends GUIPage {
private final AbstractArena arena;
private final GUIUpdater guiUpdater;
private final Callback<Player> callback;
@Inject private ChooseTeamUI(CorePlugin plugin, @Assisted Player player, @Assisted AbstractArena arena, GUIUpdater guiUpdater, @Nullable @Assisted Callback<Player> callback) {
super(plugin, player, CoreLang.GUI_USER_CHOOSE_TEAM_TITLE.getMessage(player), ((int) Math.ceil(arena.getTeams().size() / 9.0))*9);
this.arena = arena;
this.guiUpdater = guiUpdater;
this.callback = callback;
guiUpdater.register(this);
build();
}
@Override
public void buildPage() {
final int[] slot = {0};
int maxPerTeam = (int) Math.ceil(arena.getMaxPlayers()/arena.getTeams().size());
arena.getTeams().values().forEach((AbstractGameTeam gameTeam) -> {
int onTeam = (arena.getTeamPreferences().containsKey(gameTeam) ? arena.getTeamPreferences().get(gameTeam).size() : 0) + gameTeam.getPlayers().size();
List<String> playersOnTeam = new ArrayList<>();
if (arena.getTeamPreferences().containsKey(gameTeam)) {
playersOnTeam.addAll(arena.getTeamPreferences().get(gameTeam).stream().map(Player::getName).collect(Collectors.toList()));
}
playersOnTeam.addAll(gameTeam.getPlayers().stream().map(Player::getName).collect(Collectors.toList()));
addButton(new SimpleButton(new ItemStackBuilder()
.material(Material.WHITE_WOOL)
.name(Utils.getColorFromDye(gameTeam.getColor()) + gameTeam.getName() + " (" + onTeam + "/" + maxPerTeam + ")")
.color(gameTeam.getColor())
.amount(onTeam)
.lore(Utils.orderListForLore("Players", playersOnTeam))).action(() -> {
AbstractGameTeam otherTeam = arena.getTeamPreference(player);
if(otherTeam != null && otherTeam.equals(gameTeam)) {
player.sendMessage(CoreLang.GUI_USER_CHOOSE_TEAM_YOU_ARE_ALREADY_IN.replace(player, Utils.getColorFromDye(gameTeam.getColor()), gameTeam.getName()));
return;
}
if(onTeam >= maxPerTeam) {
player.sendMessage(CoreLang.GUI_USER_CHOOSE_TEAM_FULL.replace(player, Utils.getColorFromDye(gameTeam.getColor()), gameTeam.getName()));
return;
}
if(otherTeam != null) {
arena.getTeamPreferences().get(otherTeam).remove(player);
}
List<Player> players = arena.getTeamPreferences().computeIfAbsent(gameTeam, k -> new ArrayList<>());
players.add(player);
arena.getTeamPreferences().putIfAbsent(gameTeam, players);
player.sendMessage(CoreLang.GUI_USER_CHOOSE_TEAM_YOU_JOINED.replace(player, Utils.getColorFromDye(gameTeam.getColor()), gameTeam.getName()));
if (callback != null) {
callback.call(player);
} else {
guiUpdater.refresh(this);
}
}), slot[0]);
slot[0]++;
});
}
@Override
public void destroy() {
guiUpdater.unregister(this);
}
} | 4,187 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SpectatorUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/SpectatorUI.java | package me.patothebest.gamecore.guis.user;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.event.player.PlayerStateChangeEvent;
import me.patothebest.gamecore.gui.inventory.page.GUIMultiPage;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
public class SpectatorUI extends GUIMultiPage {
private final AbstractArena arena;
public SpectatorUI(CorePlugin plugin, Player player, AbstractArena arena) {
super(plugin, player, "Spectate", Math.min(54, Utils.transformToInventorySize(arena.getPlayers().size())));
this.arena = arena;
build();
}
@Override
protected void buildContent() {
final int[] slot = {0};
arena.getPlayers().stream().skip(45*currentPage).limit(45).forEach(gamePlayer -> {
ItemStackBuilder itemStack = new ItemStackBuilder().skullOwner(gamePlayer.getName()).name(ChatColor.GREEN + gamePlayer.getName());
addButton(new SimpleButton(itemStack).action(() -> {
player.teleport(gamePlayer);
}), slot[0]);
slot[0]++;
});
}
@Override
protected int getListCount() {
if(arena.getPlayers().size() <= 45) {
return -1;
}
return arena.getPlayers().size();
}
@EventHandler
public void onPlayerStateChange(PlayerStateChangeEvent event) {
if(event.getArena() == arena) {
refresh();
}
}
}
| 1,716 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
KitShopUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/kit/KitShopUI.java | package me.patothebest.gamecore.guis.user.kit;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.gui.inventory.button.ClickTypeButton;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.gui.inventory.page.GUIMultiPage;
import me.patothebest.gamecore.guis.UserGUIFactory;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.KitManager;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;
import java.util.stream.Collectors;
public class KitShopUI extends GUIMultiPage {
private final static EnumSet<ClickType> LEFT_CLICK_TYPES = EnumSet.copyOf(
Arrays.stream(ClickType.values())
.filter(clickType -> clickType.name().contains("LEFT"))
.collect(Collectors.toSet())
);
private final PlayerManager playerManager;
private final KitManager kitManager;
private final UserGUIFactory userGUIFactory;
@Inject
private KitShopUI(CorePlugin plugin, KitManager kitManager, PlayerManager playerManager, UserGUIFactory userGUIFactory, @Assisted Player player) {
super(plugin, player, CoreLang.GUI_USER_CHOOSE_TITLE.getMessage(player), Math.min(((int) Math.ceil((kitManager.getEnabledKits().size() + 1) / 9.0)) * 9, 54));
this.kitManager = kitManager;
this.playerManager = playerManager;
this.userGUIFactory = userGUIFactory;
build();
}
@Override
protected void buildContent() {
final int[] slot = {0};
List<Kit> enabledKits = new ArrayList<>(kitManager.getEnabledKits());
IPlayer corePlayer = playerManager.getPlayer(getPlayer());
enabledKits.add(0, kitManager.getDefaultKit());
enabledKits.stream().skip(currentPage * pageSize).limit(pageSize).forEach(kit -> {
if (kit.getPermissionGroup().hasPermission(getPlayer())) {
addButton(new ClickTypeButton(kit.finalDisplayItem(corePlayer, true, true)).action((clickType) -> {
if (LEFT_CLICK_TYPES.contains(clickType) && corePlayer.canUseKit(kit)) {
if (corePlayer.getKit() == kit) {
corePlayer.sendMessage(CoreLang.GUI_KIT_SHOP_ALREADY_SELECTED_KIT);
return;
}
corePlayer.setKit(kit);
refresh();
CoreLang.GUI_KIT_SHOP_YOU_CHOSE_KIT.replaceAndSend(player, kit.getKitName());
} else {
userGUIFactory.openKitOptions(corePlayer, kit, () -> {
userGUIFactory.openKitShop(player);
});
}
}), slot[0]);
} else {
addButton(new SimpleButton(kit.finalDisplayItem(corePlayer, true)), slot[0]);
}
slot[0]++;
});
}
@Override
protected int getListCount() {
if (kitManager.getEnabledKits().size() <= 45) {
return -1;
}
return kitManager.getEnabledKits().size();
}
}
| 3,473 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
BuyKitUsesUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/kit/BuyKitUsesUI.java | package me.patothebest.gamecore.guis.user.kit;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.button.IncrementingButton;
import me.patothebest.gamecore.gui.inventory.button.IncrementingButtonAction;
import me.patothebest.gamecore.gui.inventory.button.PlaceHolder;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.itemstack.StainedGlassPane;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.player.IPlayer;
import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.economy.EconomyResponse;
import org.bukkit.ChatColor;
import javax.inject.Inject;
import javax.inject.Provider;
public class BuyKitUsesUI extends GUIPage {
private final Kit kit;
private final Runnable onBack;
private final IPlayer iPlayer;
private final Provider<Economy> economy;
private int kitUses = 1;
private final static int[] GRAY_STAINED_PANES = new int[]{3, 5, 28, 29, 30, 32, 33, 34, 37, 39, 41, 43, 46, 47, 48, 50, 51, 52};
@Inject
private BuyKitUsesUI(CorePlugin plugin, Provider<Economy> economy, @Assisted Runnable onBack, @Assisted IPlayer iPlayer, @Assisted Kit kit) {
super(plugin, iPlayer.getPlayer(), CoreLang.GUI_CHANGE_AMOUNT_TITLE.getMessage(iPlayer), 54);
this.onBack = onBack;
this.iPlayer = iPlayer;
this.kit = kit;
this.economy = economy;
build();
}
@Override
public void buildPage() {
if (economy.get() == null) {
CoreLang.GUI_USER_CHOOSE_ECONOMY_PLUGIN_ERROR.sendMessage(iPlayer);
getPlayer().closeInventory();
return;
}
if (kit.isOneTimeKit()) {
IncrementingButtonAction onUpdateItemSize = (amount) -> {
kitUses = Math.max(Math.min(kitUses + amount, 64), 1);
refresh();
};
addButton(new IncrementingButton(-10, onUpdateItemSize), 19);
addButton(new IncrementingButton(-5, onUpdateItemSize), 20);
addButton(new IncrementingButton(-1, onUpdateItemSize), 21);
addButton(new IncrementingButton(1, onUpdateItemSize), 23);
addButton(new IncrementingButton(5, onUpdateItemSize), 24);
addButton(new IncrementingButton(10, onUpdateItemSize), 25);
}
addButton(new SimpleButton(new ItemStackBuilder(Material.EMERALD).name(ChatColor.GREEN + (economy.get() != null ? economy.get().currencyNamePlural() : "")).lore(ChatColor.GRAY.toString() + (kit.getCost() * kitUses) + (economy.get() != null ? " " + economy.get().currencyNamePlural() : "") + " will be deducted from your account")), 4);
addButton(new PlaceHolder(kit.finalDisplayItem(iPlayer, true).amount(kitUses)), 22);
addButton(new SimpleButton(new ItemStackBuilder().createCancelItem()).action(onBack::run), 38);
if (iPlayer.getMoney() >= kit.getCost() * kitUses) {
addButton(new SimpleButton(new ItemStackBuilder().createConfirmItem()).action(() -> {
EconomyResponse economyResponse = economy.get().withdrawPlayer(player, kit.getCost() * kitUses);
if (!economyResponse.transactionSuccess()) {
player.sendMessage(CoreLang.GUI_USER_CHOOSE_ERROR_OCCURRED.getMessage(player));
player.sendMessage(ChatColor.RED + "ERROR: " + economyResponse.errorMessage);
return;
}
if (!kit.isOneTimeKit()) {
iPlayer.buyPermanentKit(kit);
player.sendMessage(CoreLang.GUI_USER_CHOOSE_YOU_PURCHASED_PERMANENT_KIT.replace(player, kit.getKitName()));
} else {
iPlayer.addKitUses(kit, kitUses);
player.sendMessage(CoreLang.GUI_USER_CHOOSE_YOU_PURCHASED_KIT_USES.replace(player, kitUses, kit.getKitName()));
}
iPlayer.setKit(kit);
CoreLang.GUI_KIT_SHOP_YOU_CHOSE_KIT.replaceAndSend(player, kit.getKitName());
onBack.run();
}), 42);
} else {
addPlaceholder(new ItemStackBuilder().material(Material.BARRIER).name(iPlayer, CoreLang.GUI_KIT_SHOP_NOT_ENOUGH_MONEY), 42);
}
for (int grayStainedPane : GRAY_STAINED_PANES) {
addPlaceholder(new ItemStackBuilder(StainedGlassPane.GRAY).name(""), grayStainedPane);
}
for (int i = 0; i < 54; i++) {
if (isFree(i)) {
addPlaceholder(new ItemStackBuilder(StainedGlassPane.WHITE).name(""), i);
}
}
}
}
| 4,890 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
KitOptionsUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/kit/KitOptionsUI.java | package me.patothebest.gamecore.guis.user.kit;
import com.google.inject.assistedinject.Assisted;
import com.google.inject.assistedinject.AssistedInject;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.button.PlaceHolder;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.guis.UserGUIFactory;
import me.patothebest.gamecore.guis.kit.KitUIFactory;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.modifiers.KitModifier;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.Plugin;
public class KitOptionsUI extends GUIPage {
private final KitUIFactory kitUIFactory;
private final UserGUIFactory guiFactory;
private final IPlayer player;
private final Kit kit;
private final Runnable mainBack;
@AssistedInject
private KitOptionsUI(Plugin plugin, KitUIFactory kitUIFactory, UserGUIFactory guiFactory, @Assisted IPlayer player, @Assisted Kit kit, @Assisted Runnable mainBack) {
super(plugin, player.getPlayer(), CoreLang.GUI_KIT_SHOP_OPTIONS_TITLE.replace(player, kit.getKitName()), 27);
this.kitUIFactory = kitUIFactory;
this.guiFactory = guiFactory;
this.player = player;
this.kit = kit;
this.mainBack = mainBack;
build();
}
@Override
protected void buildPage() {
boolean isSelected = player.getKit() == kit;
boolean permanentKit = !kit.isOneTimeKit() || player.isPermanentKit(kit);
Runnable onBack = () -> guiFactory.openKitOptions(player, kit, mainBack);
ItemStackBuilder select = new ItemStackBuilder();
ItemStack display = kit.finalDisplayItem(player, true, true, false);
if (player.canUseKit(kit)) {
select.material(Material.SLIME_BALL);
if (isSelected) {
select.glowing(true).name(CoreLang.GUI_SHOP_SELECTED.getMessage(player));
} else {
select.name(CoreLang.GUI_KIT_SHOP_CLICK_DEFAULT.getMessage(player));
}
} else {
select.material(Material.DIAMOND)
.name((permanentKit ? CoreLang.GUI_KIT_SHOP_CLICK_BUY_PERMANENT : CoreLang.GUI_KIT_SHOP_CLICK_BUY).getMessage(player));
}
ItemStack preview = new ItemStackBuilder(Material.ITEM_FRAME)
.name(CoreLang.GUI_KIT_OPTIONS_PREVIEW.getMessage(player));
ItemStack layout = new ItemStackBuilder(Material.WRITABLE_BOOK)
.name(CoreLang.GUI_KIT_OPTIONS_LAYOUT.getMessage(player));
ItemStack buy = new ItemStackBuilder(Material.EMERALD)
.name(CoreLang.GUI_KIT_SHOP_CLICK_BUY.getMessage(player));
ItemStack back = new ItemStackBuilder().createBackItem(player.getPlayer());
addButton(new PlaceHolder(display), 4);
addButton(new SimpleButton(select).action(() -> {
if (isSelected) {
CoreLang.GUI_KIT_SHOP_ALREADY_SELECTED.sendMessage(player);
return;
}
if (player.canUseKit(kit)) {
player.setKit(kit);
player.notifyObservers(KitModifier.SET_DEFAULT, kit);
refresh();
CoreLang.GUI_KIT_SHOP_YOU_CHOSE_KIT_DEFAULT.replaceAndSend(player, kit.getKitName());
} else {
guiFactory.createBuyKitUsesUI(player, kit, onBack);
}
}), permanentKit ? 11 : 10);
addButton(new SimpleButton(preview).action(() -> {
kitUIFactory.createKitPreview(player.getPlayer(), kit, false, onBack);
}), permanentKit ? 13 : 12);
addButton(new SimpleButton(layout).action(() -> {
guiFactory.openKitLayoutEditor(player, kit, onBack);
}), permanentKit ? 15 : 14);
if (!permanentKit) {
addButton(new SimpleButton(buy).action(() -> {
guiFactory.createBuyKitUsesUI(player, kit, onBack);
}), 16);
}
addButton(new SimpleButton(back).action(mainBack::run), 26);
}
}
| 4,285 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
KitLayoutUI.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/guis/user/kit/KitLayoutUI.java | package me.patothebest.gamecore.guis.user.kit;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.gui.inventory.GUIPage;
import me.patothebest.gamecore.gui.inventory.button.NullButton;
import me.patothebest.gamecore.gui.inventory.button.SimpleButton;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.KitLayout;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import org.bukkit.ChatColor;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
public class KitLayoutUI extends GUIPage {
private ItemStack[] playerInvItems;
private final PluginScheduler pluginScheduler;
private final IPlayer player;
private final Runnable onBack;
private final Kit kit;
@Inject private KitLayoutUI(CorePlugin plugin, @Assisted IPlayer player, PluginScheduler pluginScheduler, @Assisted Kit kit, @Assisted Runnable onBack) {
super(plugin, player.getPlayer(), CoreLang.GUI_USER_EDIT_KIT_LAYOUT_TITLE.replace(player, kit.getKitName()), 27);
this.pluginScheduler = pluginScheduler;
this.kit = kit;
this.player = player;
this.onBack = onBack;
this.blockInventoryMovement = false;
build();
}
@Override
protected void buildPage() {
playerInvItems = getPlayer().getInventory().getContents();
getPlayer().getInventory().clear();
ItemStack[] inventoryItemsCopy = new ItemStack[36];
System.arraycopy(kit.getInventoryItems().clone(), 0, inventoryItemsCopy, 0, 36);
for (int i = 0; i < inventoryItemsCopy.length; ++i) {
ItemStack item = inventoryItemsCopy[i];
if (item != null) {
inventoryItemsCopy[i] = new ItemStackBuilder(item).lore(hideTag(String.valueOf(i))).amount(1);
}
}
getPlayer().getInventory().setContents(inventoryItemsCopy);
addButton(new SimpleButton(new ItemStackBuilder(Material.BOOK)
.name(CoreLang.GUI_USER_EDIT_KIT_LAYOUT_SAVE.getMessage(player)))
.action(() -> {
int[] slotsRemapped = new int[36];
Arrays.fill(slotsRemapped, -1);
Queue<Integer> freeSlots = new ArrayBlockingQueue<>(37);
List<Integer> takenSlots = new ArrayList<>();
for (int i = 0; i < 36; i++) {
ItemStack itemStack = getPlayer().getInventory().getItem(i);
if (itemStack == null ||
itemStack.getItemMeta() == null ||
itemStack.getItemMeta().getLore() == null ||
itemStack.getItemMeta().getLore().isEmpty()) {
freeSlots.add(i);
continue;
}
String oldInd = itemStack.getItemMeta().getLore().get(0);
int oldIndex = Integer.parseInt(oldInd.replace(ChatColor.COLOR_CHAR + "", ""));
slotsRemapped[i] = oldIndex;
takenSlots.add(oldIndex);
}
int newIndex = 0;
while (!freeSlots.isEmpty()) {
Integer poll = freeSlots.poll();
while (takenSlots.contains(newIndex)) {
newIndex++;
}
slotsRemapped[poll] = newIndex++;
}
KitLayout kitLayout = new KitLayout(slotsRemapped);
player.modifyKitLayout(kit, kitLayout);
onBack.run();
CoreLang.GUI_USER_EDIT_KIT_LAYOUT_SAVED.replaceAndSend(player, kit.getKitName());
}), 14);
addButton(new SimpleButton(new ItemStackBuilder().createCancelItem()).action(onBack::run), 12);
for(int i = 0; i < 27; i++) {
if (!isFree(i)) {
continue;
}
addButton(new NullButton(), i);
}
}
private static String hideTag(String s) {
StringBuilder hidden = new StringBuilder();
for (char c : s.toCharArray()) hidden.append(ChatColor.COLOR_CHAR + "").append(c);
return hidden.toString();
}
@Override
public void destroy() {
getPlayer().setItemOnCursor(null);
getPlayer().getInventory().clear();
getPlayer().getInventory().setContents(playerInvItems);
pluginScheduler.runTaskLater(()-> getPlayer().updateInventory(), 3L);
}
}
| 4,988 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerFactory.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/PlayerFactory.java | package me.patothebest.gamecore.player;
import me.patothebest.gamecore.lang.Locale;
public interface PlayerFactory {
CorePlayer create(Locale defaultLocale);
}
| 168 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerSkinCache.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/PlayerSkinCache.java | package me.patothebest.gamecore.player;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.inject.Inject;
import me.patothebest.gamecore.modules.Module;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import me.patothebest.gamecore.util.Callback;
import javax.inject.Singleton;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
@Singleton
public class PlayerSkinCache implements Module {
private static final String FALLBACK_STEVE = "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZWI3YWY5ZTQ0MTEyMTdjN2RlOWM2MGFjYmQzYzNmZDY1MTk3ODMzMzJhMWIzYmM1NmZiZmNlOTA3MjFlZjM1In19fQ==";
private final Map<String, String> HEAD_CACHE = new ConcurrentHashMap<>();
private final Map<String, Queue<Callback<String>>> HEAD_CACHE_CALLBACK = new ConcurrentHashMap<>();
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private final Lock readLock = lock.readLock();
private final Lock writeLock = lock.writeLock();
private final PluginScheduler pluginScheduler;
@Inject private PlayerSkinCache(PluginScheduler pluginScheduler) {
this.pluginScheduler = pluginScheduler;
}
public void getPlayerSkin(String playerName, Callback<String> callback) {
try {
readLock.lock();
if (HEAD_CACHE.containsKey(playerName)) {
callback.call(HEAD_CACHE.get(playerName));
} else {
if (HEAD_CACHE_CALLBACK.containsKey(playerName)) {
HEAD_CACHE_CALLBACK.get(playerName).add(callback);
} else {
HEAD_CACHE_CALLBACK.put(playerName, new ConcurrentLinkedQueue<>());
HEAD_CACHE_CALLBACK.get(playerName).add(callback);
cacheHead(playerName);
}
}
} finally {
readLock.unlock();
}
}
private void cacheHead(String playerName) {
pluginScheduler.runTaskAsynchronously(() -> {
String headValue = getHeadValue(playerName);
try {
writeLock.lock();
HEAD_CACHE.put(playerName, headValue);
} finally {
writeLock.unlock();
}
Queue<Callback<String>> callbacks = HEAD_CACHE_CALLBACK.remove(playerName);
pluginScheduler.runTask(() -> {
while (!callbacks.isEmpty()) {
callbacks.poll().call(headValue);
}
});
});
}
private String getHeadValue(String name) {
try {
String result = getURLContent("https://api.mojang.com/users/profiles/minecraft/" + name);
Gson g = new Gson();
JsonObject obj = g.fromJson(result, JsonObject.class);
String uid = obj.get("id").toString().replace("\"", "");
String signature = getURLContent("https://sessionserver.mojang.com/session/minecraft/profile/" + uid);
obj = g.fromJson(signature, JsonObject.class);
String value = obj.getAsJsonArray("properties").get(0).getAsJsonObject().get("value").getAsString();
String decoded = new String(Base64.getDecoder().decode(value));
obj = g.fromJson(decoded, JsonObject.class);
String skinURL = obj.getAsJsonObject("textures").getAsJsonObject("SKIN").get("url").getAsString();
byte[] skinByte = ("{\"textures\":{\"SKIN\":{\"url\":\"" + skinURL + "\"}}}").getBytes();
return new String(Base64.getEncoder().encode(skinByte));
} catch (Exception e) {
return FALLBACK_STEVE;
}
}
private String getURLContent(String urlStr) throws MalformedURLException {
StringBuilder sb = new StringBuilder();
URL url = new URL(urlStr);
try (BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream(), StandardCharsets.UTF_8))) {
String str;
while ((str = in.readLine()) != null) {
sb.append(str);
}
} catch (Exception ignored) { }
return sb.toString();
}
}
| 4,540 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/PlayerManager.java | package me.patothebest.gamecore.player;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.modules.ModuleName;
import me.patothebest.gamecore.storage.StorageManager;
import org.apache.commons.lang.Validate;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerLoginEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.spigotmc.event.player.PlayerSpawnLocationEvent;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Singleton
@ModuleName("Player Manager")
public class PlayerManager implements ListenerModule, ActivableModule {
private static PlayerManager instance;
private final Map<String, CorePlayer> players = new HashMap<>();
private final List<String> dupedPlayers = new ArrayList<>();
private final StorageManager storageManager;
private final CoreConfig coreConfig;
private final PlayerFactory playerFactory;
@Inject private PlayerManager(CoreConfig coreConfig, PlayerFactory playerFactory, StorageManager storageManager) {
if(instance != null) {
throw new RuntimeException("Cannot redefine PlayerManager");
}
instance = this;
this.coreConfig = coreConfig;
this.playerFactory = playerFactory;
this.storageManager = storageManager;
}
@EventHandler(priority = EventPriority.LOWEST)
public void dupeCheck(AsyncPlayerPreLoginEvent event) {
if(!players.containsKey(event.getName())) {
return;
}
if (Bukkit.getPlayerExact(event.getName()) == null) {
players.remove(event.getName());
return;
}
event.setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
event.setKickMessage("You are already connected to this server!");
dupedPlayers.add(event.getName());
}
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerPreLoginEvent(AsyncPlayerPreLoginEvent event) {
if(event.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
return;
}
CorePlayer player = playerFactory.create(coreConfig.getDefaultLocale());
player.setPlayerIdentity(new PlayerIdentity(event.getName(), event.getUniqueId()));
players.put(player.getName(), player);
storageManager.getStorage().load(player, false);
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLogin(AsyncPlayerPreLoginEvent event) {
if(event.getLoginResult() == AsyncPlayerPreLoginEvent.Result.ALLOWED) {
return;
}
if(dupedPlayers.contains(event.getName())) {
dupedPlayers.remove(event.getName());
return;
}
players.remove(event.getName());
}
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerLoginEarly(PlayerLoginEvent event) {
if(!players.containsKey(event.getPlayer().getName())) {
event.setResult(PlayerLoginEvent.Result.KICK_OTHER);
event.setKickMessage("Server is still starting up!");
return;
}
players.get(event.getPlayer().getName()).setPlayer(event.getPlayer());
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLogin(PlayerLoginEvent event) {
if(event.getResult() == PlayerLoginEvent.Result.ALLOWED) {
players.get(event.getPlayer().getName()).loginPrepare();
return;
}
players.remove(event.getPlayer().getName());
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerJoin(PlayerJoinEvent event) {
players.get(event.getPlayer().getName()).joinPrepare();
}
@EventHandler
public void onSpawn(PlayerSpawnLocationEvent event) {
Location joinLocation = players.get(event.getPlayer().getName()).getJoinLocation();
if(joinLocation != null) {
event.setSpawnLocation(joinLocation);
}
}
public void loadPlayer(Player bukkitPlayer) {
if(bukkitPlayer == null || !bukkitPlayer.isOnline()) {
return;
}
CorePlayer player = playerFactory.create(coreConfig.getDefaultLocale());
player.setPlayerIdentity(new PlayerIdentity(bukkitPlayer.getName(), bukkitPlayer.getUniqueId()));
players.put(bukkitPlayer.getName(), player);
storageManager.getStorage().load(player, false);
player.setPlayer(bukkitPlayer);
player.loginPrepare();
player.joinPrepare();
}
public IPlayer getOfflinePlayer(String name) {
if (players.containsKey(name)) {
throw new IllegalStateException("Player is online!");
}
OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(name);
CorePlayer player = playerFactory.create(coreConfig.getDefaultLocale());
player.setPlayerIdentity(new PlayerIdentity(offlinePlayer.getName(), offlinePlayer.getUniqueId()));
players.put(offlinePlayer.getName(), player);
storageManager.getStorage().load(player, false);
return player;
}
@EventHandler
public void onPlayerLeave(PlayerQuitEvent event) {
removePlayer(event.getPlayer());
}
@EventHandler
public void onPlayerLeave(PlayerKickEvent event) {
removePlayer(event.getPlayer());
}
public void removePlayer(Player bukkitPlayer) {
CorePlayer player = players.get(bukkitPlayer.getName());
if(player == null) {
return;
}
if(player.getCurrentArena() != null) {
player.getCurrentArena().removePlayer(bukkitPlayer, true);
}
destroyPlayer(bukkitPlayer);
}
public void destroyPlayer(Player bukkitPlayer) {
CorePlayer player = players.get(bukkitPlayer.getName());
if(player == null) {
return;
}
players.remove(bukkitPlayer.getName());
if(storageManager.doPlayersNeedSaving()) {
storageManager.getStorage().save(player);
}
storageManager.getStorage().unCache(player);
player.destroy();
}
public IPlayer getPlayer(String name) {
return players.get(name);
}
public IPlayer getPlayer(Player player) {
Validate.notNull(player, "Player must not be null!");
return getPlayer(player.getName());
}
@Override
public void onDisable() {
// save players
Bukkit.getOnlinePlayers().forEach(this::removePlayer);
}
public Collection<CorePlayer> getPlayers() {
return players.values();
}
public static PlayerManager get() {
return instance;
}
} | 7,214 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
IPlayer.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/IPlayer.java | package me.patothebest.gamecore.player;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.cosmetics.shop.ShopItem;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.KitLayout;
import me.patothebest.gamecore.lang.Locale;
import me.patothebest.gamecore.lang.interfaces.ILang;
import me.patothebest.gamecore.quests.ActiveQuest;
import me.patothebest.gamecore.quests.Quest;
import me.patothebest.gamecore.quests.QuestType;
import me.patothebest.gamecore.scoreboard.CustomScoreboard;
import me.patothebest.gamecore.scoreboard.ScoreboardType;
import me.patothebest.gamecore.stats.Statistic;
import me.patothebest.gamecore.stats.TrackedStatistic;
import me.patothebest.gamecore.treasure.type.TreasureType;
import me.patothebest.gamecore.util.Callback;
import me.patothebest.gamecore.util.ObservablePlayer;
import me.patothebest.gamecore.util.SerializableObject;
import me.patothebest.gamecore.util.Sounds;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Player;
import javax.annotation.Nullable;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
/**
* The Interface IPlayer.
*
*/
public interface IPlayer extends SerializableObject, ObservablePlayer {
/**
* Prepares a player, this is where the PlayerLoadEvent
* is called.
*/
void loginPrepare();
/**
* Prepares a player, this is where the PlayerLoadEvent
* is called.
*/
void joinPrepare();
/**
* Executes a callback when the player is fully loaded.
* <p>
* If the player is not loaded completely, it will add the callback
* to a queue and execute it when the player loads. If the player is
* already loaded, it will be executed immediately.
*
* @param callback the callback
*/
void executeWhenFullyLoaded(Callback<IPlayer> callback);
/**
* @return true if the player has fully joined the server and isn't on
* the "login" state
*/
boolean isFullyJoined();
/**
* @return true if the player has all the data loaded. Some data may be
* loaded a bit late like stats as it's not crucial information
*/
boolean isAllDataLoaded();
/**
* The method's only use right now is to reinitialize
* the scoreboard after a plugin reload.
*/
void reinitializeAfterReload();
/**
* Destroy's the player information, scoreboard, kits from the cache.
*/
void destroy();
/**
* Gets the locale.
*
* @return the player's locale
*/
Locale getLocale();
/**
* Sets the player's locale.
*
* @param locale the locale to set
*/
void setLocale(Locale locale);
/**
* Gets the current {@link AbstractArena} the player is in.
*
* @return null if the player is not in an arena,
* otherwise returns the arena the player is in
*/
@Nullable
AbstractArena getCurrentArena();
/**
* Set's the {@link AbstractArena} the player is in.
*
* @param currentArena the arena the player is in
*/
void setCurrentArena(AbstractArena currentArena);
/**
* Gets the {@link AbstractGameTeam}.
*
* @return the team the player is on
*/
@Nullable
AbstractGameTeam getGameTeam();
/**
* Sets the {@link AbstractGameTeam} the player is in.
*
* @param gameTeam the game team the player is in
*/
void setGameTeam(AbstractGameTeam gameTeam);
/**
* Checks if the player is currently in an arena.
*
* @return true if the player is in an arena
*/
boolean isInArena();
/**
* Gets the game kills.
*
* @return the amount of kills a player has in a game
*/
int getGameKills();
/**
* Gets the game deaths.
*
* @return the amount of deaths a player has in a game
*/
int getGameDeaths();
/**
* Gets the {@link PlayerInventory}.
*
* @return the player inventory
*/
PlayerInventory getPlayerInventory();
/**
* Gets the {@link Kit} the player has.
*
* @return the kit the player has
*/
Kit getKit();
/**
* Gets the {@link Player}.
*
* @return the bukkit player
*/
Player getPlayer();
/**
* Checks if the player is playing.
*
* @return true, if the player is playing
*/
boolean isPlaying();
/**
* Sets the {@link Kit} the player is using.
*
* @param kit the kit the player is/will use
*/
void setKit(Kit kit);
/**
* Gets the player id (for mysql).
*
* @return the player id
*/
int getPlayerId();
/**
* Sets the player id (for mysql).
*
* @param playerId the new player id
*/
void setPlayerId(int playerId);
/**
* Shows a specific scoreboard type to the player.
*
* @param scoreboardToShow the scoreboard to show
*/
void show(ScoreboardType scoreboardToShow);
/**
* Destroy the scoreboard type.
*
* @param scoreboardToShow the scoreboard to show
*/
void destroy(ScoreboardType scoreboardToShow);
/**
* Gets the player scoreboards.
*
* @return the scoreboards
*/
Map<ScoreboardType, CustomScoreboard> getScoreboards();
/**
* Gets the scoreboard to show.
*
* @return the scoreboard to show
*/
ScoreboardType getScoreboardToShow();
/**
* Sets the scoreboard to show.
*
* @param scoreboardToShow the new scoreboard to show
*/
void setScoreboardToShow(ScoreboardType scoreboardToShow);
/**
* Sends a message to the player.
*
* @param message the message
*/
void sendMessage(String message);
/**
* Sends a localized message to the player
*
* @param lang the localized message
*/
default void sendMessage(ILang lang) {
lang.sendMessage(this);
}
/**
* Checks if a player can use the specified kit.
*
* @param kit the kit to use
* @return true if the player can use it
*/
boolean canUseKit(Kit kit);
/**
* Consumes a use on the kit (only if the kit is not
* permanent, aka -1).
*
* @param kit the kit to use
* @return true if it was successful
*/
boolean useKit(Kit kit);
/**
* Removes a set amount of kit uses
*
* @param kit the kit
* @param amount the amount of items to remove
*/
boolean removeKit(Kit kit, int amount);
/**
* Removes a kit completely
*
* @param kit the kit
*/
boolean removeKit(Kit kit);
/**
* This returns an {@link java.util.Collections.UnmodifiableMap} of {@link Kit}
* and {@link Integer} which is the amount. Not all the kits are in this maps,
* only the kits that have uses remaining or the kits that had previous
* uses but ran out. This map cannot be modified, if you wish to modify
* any value, you must use {@link IPlayer#addKitUses(Kit, int)}}
*
* @return kit uses the player has
*/
Map<Kit, Integer> getKitUses();
/**
* This returns true if the kit is a permanent kit or not. The way this checks
* is by checking its uses remaining is equal to -1
*
* @param kit the kit
* @return true if kit is permanent
*/
default boolean isPermanentKit(Kit kit) {
return getKitUses().containsKey(kit) && getKitUses().get(kit) == -1;
}
/**
* Buys a specific kit permanently.
*
* @param kit the kit
*/
void buyPermanentKit(Kit kit);
/**
* Buys a single kit use for the specified kit.
*
* @param kit the kit
*/
void buyKitSingleKitUse(Kit kit);
/**
* Buys kit uses for the specified kit.
*
* @param kit the kit
* @param amount the kit uses to buy
*/
void addKitUses(Kit kit, int amount);
/**
* Sets kit uses for the specified kit.
*
* @param kit the kit
* @param amount the kit uses
*/
void setKitUses(Kit kit, int amount);
/**
* Modifies a kit layout for the player
*
* @param kit the kit
* @param kitLayout the layout
*/
void modifyKitLayout(Kit kit, KitLayout kitLayout);
/**
* Returns a layout for the specified kit. If there is no
* custom layout, null will be returned
*
* @param kit the lot
* @return the layout if any, null if there's no custom layout
*/
KitLayout getLayout(Kit kit);
/**
* Gets all the custom layouts the player has
*
* @return the layouts map
*/
Map<Kit, KitLayout> getKitLayouts();
/**
* Gets the owned shop items the player has
*
* @param shopItemClass the item class
* @param <Type> the shop item
* @return a list of all the shop items the player owns
* of the specified type
*/
<Type extends ShopItem> Map<Type, Integer> getShopItems(Class<Type> shopItemClass);
/**
* Checks whether or not the item is in the map
* <p>
* This shouldn't be used normally, more for internal use
*
* @param shopItem the shop item item
* @param <Type> the shop item type
* @return true if the item is in the map
*/
default <Type extends ShopItem> boolean isItemInMap(Type shopItem) {
return getShopItems(shopItem.getClass()).containsKey(shopItem);
}
/**
* Gets the remaining uses of that shop item
*
* @param shopItem the shop item item
* @param <Type> the shop item type
* @return the amount of uses remaining
*/
default <Type extends ShopItem> int getRemainingUses(Type shopItem) {
return getShopItems(shopItem.getClass()).getOrDefault(shopItem, 0);
}
/**
* Checks whether or not a player has the amount of that item
*
* @param shopItem the shop item item
* @param amount the amount of minimum uses to have
* @param <Type> the shop item type
* @return true if the player has enough of that item
*/
default <Type extends ShopItem> boolean hasEnough(Type shopItem, int amount) {
return isItemInMap(shopItem) && (isPermanent(shopItem) || getRemainingUses(shopItem) >= amount);
}
/**
* Checks whether or not a player can use that item
*
* @param shopItem the shop item item
* @param <Type> the shop item type
* @return true if the player can use the item
*/
default <Type extends ShopItem> boolean canUse(Type shopItem) {
return hasEnough(shopItem, 1);
}
/**
* Checks whether or not the player has unlocked the item permanently
*
* @param shopItem the shop item item
* @param <Type> the shop item type
* @return true if the player has the item permanently
*/
default <Type extends ShopItem> boolean isPermanent(Type shopItem) {
return getRemainingUses(shopItem) == -1;
}
/**
* Buys the specified item permanently
*
* @param shopItem the shop item
* @param <Type> the item type
*/
default <Type extends ShopItem> void buyItemPermanently(Type shopItem) {
buyItemUses(shopItem, -1);
}
/**
* Buys the specified uses for the item
*
* @param shopItem the shop item
* @param <Type> the item type
*/
<Type extends ShopItem> void buyItemUses(Type shopItem, int uses);
/**
* Checks whether or not the item is currently selected
*
* @param shopItem the shop item item
* @param <Type> the shop item type
* @return true if the player has the item permanently
*/
default <Type extends ShopItem> boolean isSelected(Type shopItem) {
return getSelectedItem(shopItem.getClass()) == shopItem;
}
/**
* Uses an item
*
* @param shopItem the shop item to use
* @param <Type> the shop item type
*/
<Type extends ShopItem> boolean useItem(Type shopItem);
/**
* Removes an item set amount
*
* @param shopItem the shop item to use
* @param <Type> the shop item type
* @param amount the amount of items to use
*/
<Type extends ShopItem> boolean removeItem(Type shopItem, int amount);
/**
* Removes an item completely
*
* @param shopItem the shop item to use
* @param <Type> the shop item type
*/
<Type extends ShopItem> boolean removeItem(Type shopItem);
/**
* Set the item amount
*
* @param shopItem the shop item to use
* @param <Type> the shop item type
* @param amount the amount of items to use
*/
<Type extends ShopItem> boolean setItemAmount(Type shopItem, int amount);
/**
* Gets the selected shop item for the shop type
* <p>
* This is to have persistent items, have the players be able
* to select the items in the lobby and switch to the other server
* while having the last item selected
*
* @param shopItemClass the shop item class
* @param <Type> the shop item type
* @return the selected item, null if nothing is selected
*/
@Nullable
<Type extends ShopItem> Type getSelectedItem(Class<Type> shopItemClass);
/**
* Gets the selected shop item for the shop type
* <p>
* This is to have persistent items, have the players be able
* to select the items in the lobby and switch to the other server
* while having the last item selected
*
* @param shopItemClass the shop item class
* @param <Type> the shop item type
* @return the selected item, null if nothing is selected
*/
default <Type extends ShopItem> Type getSelectedItemOrDefault(Class<Type> shopItemClass, Type defaultObject) {
return getSelectedItem(shopItemClass) == null ? defaultObject : getSelectedItem(shopItemClass);
}
/**
* Selects the item
* <p>
* This selection is persistent, so if a player logs off
* and logs back on, the item will continue to be selected
*
* @param shopItem the shop item to select
* @param <Type> the shop item type
*/
<Type extends ShopItem> void selectItem(Type shopItem);
/**
* Checks whether or not a player can use thae selected item
*
* @param shopItemClass the shop item class
* @param <Type> the shop item type
* @return true if the player can use the item
*/
default <Type extends ShopItem> boolean canUseSelectedItem(Class<Type> shopItemClass) {
return getSelectedItem(shopItemClass) != null && canUse(getSelectedItem(shopItemClass));
}
/**
* Deselects a selected item
*
* @param shopItem the shop item to deselect
* @param <Type> the shop item type
*/
<Type extends ShopItem> void deSelectItem(Type shopItem);
/**
* Deselects a selected item
*
* @param shopItemClass the class to deselect
* @param <Type> the shop item type
*/
default <Type extends ShopItem> void deSelectItem(Class<Type> shopItemClass) {
deSelectItem(getSelectedItem(shopItemClass));
}
/**
* Gets the player location
*
* @return the player location
*/
Location getLocation();
/**
* Gets the treasure keys map
*
* @return the treasure keys map
*/
Map<TreasureType, Integer> getTreasureKeyMap();
/**
* Gets the amount of keys the player has of that specific
* treasure chest type
*
* @param treasureType the treasure chest type
* @return the amount of keys
*/
int getKeys(TreasureType treasureType);
/**
* Set the amount of keys for the specified treasure type
*
* @param treasureType the treasure type
* @param amount the amount of keys
*/
void setKeys(TreasureType treasureType, int amount);
/**
* Gets an active quest by the quest object
*
* @param quest the core quest
* @return the ActiveQuest
*/
@Nullable
ActiveQuest getActiveQuest(Quest quest);
void activateQuest(ActiveQuest quest);
void removeQuest(ActiveQuest quest);
Set<ActiveQuest> getActiveQuests(QuestType questType);
/**
* Gets the player's experience
*
* @return the player's experience
*/
long getExperience();
/**
* Sets the player's experience
*
* @param experience the experience to set
*/
void setExperience(long experience);
/**
* Adds experience to the current player's experience
*
* @param experience the experience to add
*/
void addExperience(long experience);
/**
* Removes experience from the current player's experience
*
* @param experience the experience to remove
*/
void removeExperience(long experience);
/**
* Gets the money the player has
* <p>
* In case vault is not present or vault is present but
* no economy plugin was found, meaning the economy provider
* returns null, the player will display an amount of 0
*
* @return the amount of money the player has
*/
double getMoney();
/**
* Gives the player money
* <p>
* This will return false if there's no economy plugin present
* or if the transaction was a failure for any reason. If it is
* successful, it will send the player a notification in chat
*
* @param amount the amount to give
* @return true if successful
*/
boolean giveMoney(double amount);
/**
* Gets the points from the player
*
* @return the points
*/
int getPoints();
/**
* Sets the player points
*
* @param newPoints the new points
*/
void setPoints(int newPoints);
/**
* Gets the statistics map
* <p>
* The map contains the statistics the player has all time and
* of this month. They are separated into weekly stats from this
* month.
* <p>
* A new player will have this map empty, since there will be no
* statistic in the database. This is done on purpose, so that the
* database doesn't get filled up with a lot of records. Only stats
* that have a value of 1 or more will get saved into the database,
* so if a player joins a game, kills a player and wins, the only
* stats that will save in the database are kills and wins, since the
* payer has 0 loses and 0 deaths, this is of course if the individual
* statistic is enabled in the configuration.
*
* @return the statistics map
*/
Map<Class<? extends Statistic>, TrackedStatistic> getStatistics();
/**
* Gets the player name
*
* @return the player name
*/
String getName();
/**
* Sets the player's identity
*
* @param playerIdentity the player's identity
*/
void setPlayerIdentity(PlayerIdentity playerIdentity);
/**
* Returns a unique and persistent id for this player
*
* @return unique id
*/
UUID getUniqueId();
/**
* Gets the join location of the player
*
* @return the join location
*/
@Nullable Location getJoinLocation();
/**
* Sets the join location for the player
*
* @param joinLocation the location
*/
void setJoinLocation(Location joinLocation);
/**
* Play a sound for a player at their location
* <p>
* The sound will have a pitch of 1f and the max volume
* which is of 10f
*
* @param sound the sound to play for the player
*/
void playSound(Sounds sound);
/**
* Play a sound for a player at their location
*
* @param sound the sound to play for the player
* @param volume The volume of the sound
* @param pitch The pitch of the sound
*/
void playSound(Sounds sound, float volume, float pitch);
/**
* Gets the current world this player is in
*
* @return World
*/
World getWorld();
/**
* Gets the player entity id in the world
*
* @return the entity id of the player
*/
int getEntityId();
}
| 20,258 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerInventory.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/PlayerInventory.java | package me.patothebest.gamecore.player;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.GameMode;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.PotionEffect;
import java.util.Collection;
public class PlayerInventory {
private final Player player;
private ItemStack[] armor;
private ItemStack[] inventory;
private GameMode gameMode;
private float xp;
private int xpLevel;
private int foodLevel;
private double maxHealth;
private double health;
private boolean flight;
private Collection<PotionEffect> potionEffects;
PlayerInventory(Player player) {
this.player = player;
}
public void savePlayer() {
armor = player.getInventory().getArmorContents();
inventory = player.getInventory().getContents();
gameMode = player.getGameMode();
xp = player.getExp();
xpLevel = player.getLevel();
foodLevel = player.getFoodLevel();
maxHealth = player.getMaxHealth();
health = player.getHealth();
flight = player.getAllowFlight();
potionEffects = player.getActivePotionEffects();
clearPlayer();
}
public void restoreInventory() {
clearPlayer();
// TODO: Config option?
/* player.getInventory().setArmorContents(armor);
player.getInventory().setContents(inventory);
player.setGameMode(gameMode);
player.setExp(xp);
player.setLevel(xpLevel);
player.setFoodLevel(foodLevel);
player.setMaxHealth(maxHealth);
player.setHealth(health);
player.setAllowFlight(flight);
player.addPotionEffects(potionEffects);*/
}
public void clearPlayer() {
Utils.clearPlayer(player);
}
}
| 1,797 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerIdentity.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/PlayerIdentity.java | package me.patothebest.gamecore.player;
import java.util.UUID;
/**
* Class used to identify the player in a conversion or in an offline
* value update
*/
public class PlayerIdentity {
private final String name;
private final UUID uuid;
public PlayerIdentity(String name, UUID uuid) {
this.name = name;
this.uuid = uuid;
}
/**
* Gets the player's name
*
* @return the name
*/
public String getName() {
return name;
}
/**
* Gets the player's uuid
*
* @return the uuid
*/
public UUID getUuid() {
return uuid;
}
}
| 631 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CorePlayer.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/CorePlayer.java | package me.patothebest.gamecore.player;
import com.google.common.collect.ImmutableMap;
import com.google.inject.Inject;
import com.google.inject.Provider;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.cosmetics.shop.ShopItem;
import me.patothebest.gamecore.event.EventRegistry;
import me.patothebest.gamecore.event.player.PlayerDeSelectItemEvent;
import me.patothebest.gamecore.event.player.PlayerExperienceUpdateEvent;
import me.patothebest.gamecore.event.player.PlayerJoinPrepareEvent;
import me.patothebest.gamecore.event.player.PlayerLoginPrepareEvent;
import me.patothebest.gamecore.event.player.PlayerSelectItemEvent;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.KitLayout;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.lang.Locale;
import me.patothebest.gamecore.player.modifiers.ExperienceModifier;
import me.patothebest.gamecore.player.modifiers.GeneralModifier;
import me.patothebest.gamecore.player.modifiers.KitModifier;
import me.patothebest.gamecore.player.modifiers.PointsModifier;
import me.patothebest.gamecore.player.modifiers.QuestModifier;
import me.patothebest.gamecore.player.modifiers.ShopModifier;
import me.patothebest.gamecore.player.modifiers.TreasureModifier;
import me.patothebest.gamecore.quests.ActiveQuest;
import me.patothebest.gamecore.quests.Quest;
import me.patothebest.gamecore.quests.QuestType;
import me.patothebest.gamecore.scoreboard.CoreScoreboardType;
import me.patothebest.gamecore.scoreboard.CustomScoreboard;
import me.patothebest.gamecore.scoreboard.ScoreboardFile;
import me.patothebest.gamecore.scoreboard.ScoreboardType;
import me.patothebest.gamecore.stats.Statistic;
import me.patothebest.gamecore.stats.TrackedStatistic;
import me.patothebest.gamecore.treasure.type.TreasureType;
import me.patothebest.gamecore.util.Callback;
import me.patothebest.gamecore.util.ObservablePlayerImpl;
import me.patothebest.gamecore.util.Sounds;
import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.economy.EconomyResponse;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Player;
import javax.annotation.Nullable;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.stream.Collectors;
public class CorePlayer extends ObservablePlayerImpl implements IPlayer {
private final Map<ScoreboardType, CustomScoreboard> scoreboards = new HashMap<>();
private final ScoreboardFile scoreboardFile;
// Guice inject
@Inject private Provider<Economy> economyProvider;
@Inject private CorePlugin plugin;
@Inject private EventRegistry eventRegistry;
private PlayerIdentity playerIdentity;
private PlayerInventory playerInventory;
private Player player;
protected Locale locale;
private AbstractArena currentArena;
private AbstractGameTeam gameTeam;
private Kit kit;
private boolean fullyJoined = false;
private boolean allDataLoaded = false;
private Location joinLocation;
private final Map<Class<? extends Statistic>, TrackedStatistic> statistics = new HashMap<>();
private final Queue<Callback<IPlayer>> callbackQueue = new ConcurrentLinkedQueue<>();
/**
* Shop stuff
* To save resources we unify all the shoppable items (except kits) in
* a big table, so when we need to add a new shop type (particles, cages,
* etc.) we don't need to create a new table
*/
private final Map<Class<? extends ShopItem>, Map<ShopItem, Integer>> ownedItems = new HashMap<>();
private final Map<Class<? extends ShopItem>, ShopItem> selectedShopItems = new HashMap<>();
/**
* The experience from our internal system
*/
private long experience;
private int points;
private int gameKills;
private int gameDeaths;
/**
* Field representing the player id inside the database. This
* field will not be assigned if a database storage type is not
* selected.
*/
private int playerId = -1;
/**
* Field representing how many kit uses does a player have. If the kit
* is permanent, the amount will be -1
*/
private final Map<Kit, Integer> kitUses = new HashMap<>();
private final Map<Kit, KitLayout> kitLayouts = new HashMap<>();
/**
* Treasure keys map, doesn't matter if the treasure type is disabled or
* not, it will be loaded into memory
*/
private final Map<TreasureType, Integer> treasureKeys = new HashMap<>();
/**
* Map of all the current quests
*/
private final Map<Quest, ActiveQuest> quests = new HashMap<>();
private final Map<QuestType, Set<ActiveQuest>> questsTypeLookup = new HashMap<>();
/**
* Scoreboard to show on prepare, used in case storage is being reloaded
* while player is still inside an arena or in the waiting lobby.
*/
private ScoreboardType scoreboardToShow = CoreScoreboardType.LOBBY;
@Inject public CorePlayer(ScoreboardFile scoreboardFile, @Assisted Locale defaultLocale) {
this.locale = defaultLocale;
this.scoreboardFile = scoreboardFile;
}
@Override
public void loginPrepare() {
if(player == null) {
return;
}
plugin.getServer().getPluginManager().callEvent(new PlayerLoginPrepareEvent(this));
}
@Override
public void joinPrepare() {
if(player == null) {
return;
}
plugin.getServer().getPluginManager().callEvent(new PlayerJoinPrepareEvent(this));
callbackQueue.forEach(corePlayerCallback -> corePlayerCallback.call(this));
callbackQueue.clear();
fullyJoined = true;
}
@Override
public void executeWhenFullyLoaded(Callback<IPlayer> corePlayerCallback) {
if(fullyJoined) {
corePlayerCallback.call(this);
return;
}
callbackQueue.add(corePlayerCallback);
}
@Override
public boolean isFullyJoined() {
return fullyJoined;
}
@Override
public boolean isAllDataLoaded() {
return allDataLoaded;
}
public void setAllDataLoaded(boolean allDataLoaded) {
this.allDataLoaded = allDataLoaded;
}
@Override
public void reinitializeAfterReload() {
if(player == null || !player.isOnline()) {
return;
}
if (currentArena.isInGame()) {
getScoreboards().put(CoreScoreboardType.GAME, new CustomScoreboard(plugin, getPlayer(), "game", scoreboardFile.getConfigurationSection("game-scoreboard")));
setScoreboardToShow(CoreScoreboardType.GAME);
} else {
setScoreboardToShow(CoreScoreboardType.WAITING);
}
}
@Override
public void destroy() {
scoreboards.forEach((scoreboardType, customScoreboard) -> {
customScoreboard.cancel();
customScoreboard.destroy();
});
scoreboards.clear();
}
private void resetGameStats() {
gameKills = 0;
gameDeaths = 0;
}
@Override
public Locale getLocale() {
return locale;
}
@Override
public void setLocale(Locale locale) {
this.locale = locale;
notifyObservers(GeneralModifier.LOCALE);
}
@Override
public AbstractArena getCurrentArena() {
return currentArena;
}
@Override
public void setCurrentArena(AbstractArena currentArena) {
this.currentArena = currentArena;
resetGameStats();
}
@Override
public AbstractGameTeam getGameTeam() {
return gameTeam;
}
@Override
public void setGameTeam(AbstractGameTeam gameTeam) {
this.gameTeam = gameTeam;
}
@Override
public boolean isInArena() {
return currentArena != null;
}
@Override
public int getGameKills() {
return gameKills;
}
@Override
public int getGameDeaths() {
return gameDeaths;
}
public void addGameKills(int gameKills) {
this.gameKills += gameKills;
}
public void addGameDeaths(int gameDeaths) {
this.gameDeaths += gameDeaths;
}
@Override
public PlayerInventory getPlayerInventory() {
return playerInventory;
}
@Override
public Kit getKit() {
return kit;
}
@Override
public Player getPlayer() {
return player;
}
@Override
public boolean isPlaying() {
return isInArena();
}
@Override
public void setKit(Kit kit) {
this.kit = kit;
}
@Override
public int getPlayerId() {
return playerId;
}
@Override
public void setPlayerId(int playerId) {
this.playerId = playerId;
}
@Override
public void show(ScoreboardType scoreboardToShow) {
scoreboards.forEach((scoreboardType, customScoreboard) -> {
if (!customScoreboard.hasBeenScheduled()) {
return;
}
customScoreboard.cancel();
});
if (!scoreboards.containsKey(scoreboardToShow)) {
return;
}
if (!scoreboardToShow.isEnabled()) {
return;
}
scoreboards.get(scoreboardToShow).show();
}
@Override
public void destroy(ScoreboardType scoreboardToShow) {
scoreboards.get(scoreboardToShow).destroy();
scoreboards.remove(scoreboardToShow);
}
@Override
public Map<ScoreboardType, CustomScoreboard> getScoreboards() {
return scoreboards;
}
@Override
public ScoreboardType getScoreboardToShow() {
return scoreboardToShow;
}
@Override
public void setScoreboardToShow(ScoreboardType scoreboardToShow) {
this.scoreboardToShow = scoreboardToShow;
}
@Override
public void sendMessage(String message) {
player.sendMessage(message);
}
@Override
public boolean canUseKit(Kit kit) {
return kit.isEnabled() && kit.getPermissionGroup().hasPermission(this) && (kit.getCost() < 1.0 || (kitUses.containsKey(kit) && (kitUses.get(kit) > 0 || kitUses.get(kit) == -1)));
}
@Override
public boolean useKit(Kit kit) {
if (!canUseKit(kit)) {
return false;
}
if(isPermanentKit(kit)) {
return true;
}
return removeKit(kit, 1);
}
@Override
public boolean removeKit(Kit kit) {
if (!canUseKit(kit)) {
return false;
}
kitUses.remove(kit);
notifyObservers(KitModifier.REMOVE_KIT, kit);
return true;
}
@Override
public boolean removeKit(Kit kit, int amount) {
if (!canUseKit(kit)) {
return false;
}
if(isPermanentKit(kit)) {
return false;
}
int currAmount = kitUses.remove(kit);
if(currAmount <= 0) {
return false;
}
currAmount-= amount;
if(currAmount > 0) {
kitUses.put(kit, currAmount);
notifyObservers(KitModifier.MODIFY_KIT, kit, currAmount);
} else {
notifyObservers(KitModifier.REMOVE_KIT, kit);
}
return false;
}
@Override
public Map<Kit, Integer> getKitUses() {
return ImmutableMap.copyOf(kitUses);
}
@Override
public void buyPermanentKit(Kit kit) {
if(!kitUses.containsKey(kit)) {
kitUses.put(kit, -1);
notifyObservers(KitModifier.ADD_KIT, kit, -1);
return;
}
if(kitUses.get(kit) == -1) {
return;
}
kitUses.remove(kit);
kitUses.put(kit, -1);
notifyObservers(KitModifier.MODIFY_KIT, kit, -1);
}
@Override
public void buyKitSingleKitUse(Kit kit) {
addKitUses(kit, 1);
}
@Override
public void addKitUses(Kit kit, int amount) {
if(isPermanentKit(kit) || kit.isFree()) {
return;
}
if(kitUses.containsKey(kit)) {
int newAmount = kitUses.remove(kit) + amount;
kitUses.put(kit, newAmount);
notifyObservers(KitModifier.MODIFY_KIT, kit, newAmount);
return;
}
kitUses.put(kit, amount);
notifyObservers(KitModifier.ADD_KIT, kit, amount);
}
@Override
public void setKitUses(Kit kit, int amount) {
if (isPermanentKit(kit) || kit.isFree()) {
return;
}
if (kitUses.containsKey(kit)) {
if (kitUses.get(kit) == amount) {
return;
}
kitUses.put(kit, amount);
notifyObservers(KitModifier.MODIFY_KIT, kit, amount);
return;
}
kitUses.put(kit, amount);
notifyObservers(KitModifier.ADD_KIT, kit, amount);
}
@Override
public void modifyKitLayout(Kit kit, KitLayout kitLayout) {
if (kitLayouts.containsKey(kit)) {
kitLayouts.put(kit, kitLayout);
notifyObservers(KitModifier.MODIFY_LAYOUT, kit, kitLayout);
} else {
kitLayouts.put(kit, kitLayout);
notifyObservers(KitModifier.SET_LAYOUT, kit, kitLayout);
}
}
@Override
public KitLayout getLayout(Kit kit) {
return kitLayouts.get(kit);
}
@Override
public Map<Kit, KitLayout> getKitLayouts() {
return kitLayouts;
}
@Override
@SuppressWarnings("unchecked")
public <Type extends ShopItem> Map<Type, Integer> getShopItems(Class<Type> shopItemClass) {
if(!ownedItems.containsKey(shopItemClass)) {
ownedItems.put(shopItemClass, new HashMap<>());
}
return (Map<Type, Integer>) Collections.unmodifiableMap(ownedItems.get(shopItemClass));
}
@Override
public <Type extends ShopItem> void buyItemUses(Type shopItem, int amount) {
if(getShopItems(shopItem.getClass()).containsKey(shopItem)) {
if(!isPermanent(shopItem)) {
if(amount == -1) {
ownedItems.get(shopItem.getClass()).put(shopItem, amount);
notifyObservers(ShopModifier.BOUGHT_ITEM_USES, shopItem, amount);
} else {
int oldAmount = ownedItems.get(shopItem.getClass()).get(shopItem);
ownedItems.get(shopItem.getClass()).put(shopItem, oldAmount + amount);
notifyObservers(ShopModifier.BOUGHT_ITEM_USES, shopItem, oldAmount + amount);
}
}
} else {
ownedItems.get(shopItem.getClass()).put(shopItem, amount);
notifyObservers(ShopModifier.BOUGHT_ITEM, shopItem, amount);
}
}
@Override
public <Type extends ShopItem> boolean useItem(Type shopItem) {
if (!canUse(shopItem)) {
return false;
}
if(isPermanent(shopItem)) {
return true;
}
int amount = getRemainingUses(shopItem);
if(amount <= 0) {
return false;
}
return removeItem(shopItem, 1);
}
@Override
public <Type extends ShopItem> boolean removeItem(Type shopItem) {
if (!canUse(shopItem)) {
return false;
}
ownedItems.get(shopItem.getClass()).remove(shopItem);
notifyObservers(ShopModifier.DEPLETED_ITEM, shopItem);
return true;
}
@Override
public <Type extends ShopItem> boolean removeItem(Type shopItem, int amount) {
if (!canUse(shopItem)) {
return false;
}
if(isPermanent(shopItem)) {
return false;
}
int currAmount = getRemainingUses(shopItem);
if(currAmount <= 0) {
return false;
}
currAmount-= amount;
ownedItems.get(shopItem.getClass()).remove(shopItem);
if(currAmount > 0) {
ownedItems.get(shopItem.getClass()).put(shopItem, currAmount);
notifyObservers(ShopModifier.USED_ITEM, shopItem, currAmount);
} else {
notifyObservers(ShopModifier.DEPLETED_ITEM, shopItem);
}
return false;
}
@Override
public <Type extends ShopItem> boolean setItemAmount(Type shopItem, int amount) {
if(getShopItems(shopItem.getClass()).containsKey(shopItem)) {
if(!isPermanent(shopItem)) {
ownedItems.get(shopItem.getClass()).put(shopItem, amount);
notifyObservers(ShopModifier.BOUGHT_ITEM_USES, shopItem, amount);
}
} else {
ownedItems.get(shopItem.getClass()).put(shopItem, amount);
notifyObservers(ShopModifier.BOUGHT_ITEM, shopItem, amount);
}
return false;
}
@Override
@SuppressWarnings("unchecked")
public <Type extends ShopItem> Type getSelectedItem(Class<Type> shopItemClass) {
return (Type) selectedShopItems.get(shopItemClass);
}
@Override
public <Type extends ShopItem> void selectItem(Type shopItem) {
if(selectedShopItems.containsKey(shopItem.getClass())) {
selectedShopItems.put(shopItem.getClass(), shopItem);
notifyObservers(ShopModifier.UPDATE_SELECT_DEFAULT, shopItem);
} else {
selectedShopItems.put(shopItem.getClass(), shopItem);
notifyObservers(ShopModifier.SELECT_DEFAULT, shopItem);
}
if(!fullyJoined) {
return;
}
plugin.callEvent(new PlayerSelectItemEvent(this, shopItem));
}
@Override
public <Type extends ShopItem> void deSelectItem(Type shopItem) {
if(!selectedShopItems.containsKey(shopItem.getClass())) {
return;
}
selectedShopItems.remove(shopItem.getClass());
notifyObservers(ShopModifier.REMOVE_SELECTED_ITEM, shopItem);
plugin.callEvent(new PlayerDeSelectItemEvent(this, shopItem));
}
@Override
public Location getLocation() {
return player.getLocation();
}
@Override
public Map<TreasureType, Integer> getTreasureKeyMap() {
return treasureKeys;
}
@Override
public int getKeys(TreasureType treasureType) {
return treasureKeys.get(treasureType);
}
@Override
public void setKeys(TreasureType treasureType, int amount) {
treasureKeys.put(treasureType, amount);
notifyObservers(TreasureModifier.MODIFY, treasureType);
}
public @Nullable ActiveQuest getActiveQuest(Quest quest) {
return quests.get(quest);
}
@Override
public void activateQuest(ActiveQuest activeQuest) {
ActiveQuest oldQues = quests.remove(activeQuest.getQuest());
if (oldQues != null) {
removeQuest(activeQuest);
}
this.quests.put(activeQuest.getQuest(), activeQuest);
this.questsTypeLookup.computeIfAbsent(activeQuest.getQuest().getQuestType(), k -> new HashSet<>());
this.questsTypeLookup.get(activeQuest.getQuest().getQuestType()).add(activeQuest);
notifyObservers(QuestModifier.START_QUEST, activeQuest);
}
@Override
public void removeQuest(ActiveQuest quest) {
this.quests.remove(quest.getQuest());
this.questsTypeLookup.get(quest.getQuest().getQuestType()).remove(quest);
}
@Override
public Set<ActiveQuest> getActiveQuests(QuestType questType) {
return questsTypeLookup.getOrDefault(questType, Collections.emptySet());
}
@Override
public long getExperience() {
return experience;
}
@Override
public void setExperience(long experience) {
long oldExp = this.experience;
this.experience = experience;
notifyObservers(ExperienceModifier.SET_EXPERIENCE, experience);
eventRegistry.callSyncEvent(new PlayerExperienceUpdateEvent(this, PlayerExperienceUpdateEvent.UpdateType.SET, oldExp, this.experience));
}
@Override
public void addExperience(long experience) {
if (experience == 0) {
return;
}
long oldExp = this.experience;
this.experience = oldExp + experience;
notifyObservers(ExperienceModifier.ADD_EXPERIENCE, experience);
CoreLang.EXPERIENCE_EARNED.replaceAndSend(player, experience);
eventRegistry.callSyncEvent(new PlayerExperienceUpdateEvent(this, PlayerExperienceUpdateEvent.UpdateType.ADD, oldExp, this.experience));
}
@Override
public void removeExperience(long experience) {
long oldExp = this.experience;
this.experience = oldExp - experience;
notifyObservers(ExperienceModifier.REMOVE_EXPERIENCE, experience);
eventRegistry.callSyncEvent(new PlayerExperienceUpdateEvent(this, PlayerExperienceUpdateEvent.UpdateType.SUBTRACT, oldExp, this.experience));
}
@Override
public double getMoney() {
return economyProvider.get() != null ? economyProvider.get().getBalance(player) : 0;
}
@Override
public boolean giveMoney(double amount) {
if (amount == 0) {
return false;
}
if (economyProvider.get() == null) {
return false;
}
EconomyResponse economyResponse = economyProvider.get().depositPlayer(player, amount);
if (economyResponse.type != EconomyResponse.ResponseType.SUCCESS) {
return false;
}
CoreLang.MONEY_GIVEN.replaceAndSend(player, amount);
return true;
}
@Override
public int getPoints() {
return points;
}
@Override
public void setPoints(int newPoints) {
if(points == newPoints) {
return;
}
this.points = newPoints;
notifyObservers(PointsModifier.MODIFY);
}
@Override
public Map<Class<? extends Statistic>, TrackedStatistic> getStatistics() {
return statistics;
}
@Override
public String getName() {
return player == null ? playerIdentity.getName() : player.getName();
}
@Override
public UUID getUniqueId() {
return player == null ? playerIdentity.getUuid() : player.getUniqueId();
}
@Override
public void setPlayerIdentity(PlayerIdentity playerIdentity) {
this.playerIdentity = playerIdentity;
}
@Override
public Location getJoinLocation() {
return joinLocation;
}
@Override
public void setJoinLocation(Location joinLocation) {
this.joinLocation = joinLocation;
}
/**
* Sets the player
*/
public void setPlayer(Player player) {
if(this.player != null) {
throw new UnsupportedOperationException("Cannot re-define player object.");
}
this.player = player;
this.playerInventory = new PlayerInventory(player);
}
@Override
public void serialize(Map<String, Object> data) {
data.put("locale", locale);
data.put("keys", treasureKeys.entrySet().stream().collect(Collectors.toMap(data1 -> data1.getKey().name(), Map.Entry::getValue)));
}
@Override
public void playSound(Sounds sound) {
sound.play(player);
}
@Override
public void playSound(Sounds sound, float volume, float pitch) {
sound.play(player, volume, pitch);
}
@Override
public World getWorld() {
return player.getWorld();
}
@Override
public int getEntityId() {
return player.getEntityId();
}
@Deprecated // internal use
public Map<Class<? extends ShopItem>, Map<ShopItem, Integer>> getOwnedItems() {
return ownedItems;
}
@Deprecated // internal use
public Map<Class<? extends ShopItem>, ShopItem> getSelectedShopItems() {
return selectedShopItems;
}
} | 24,001 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EloPlayer.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/types/EloPlayer.java | package me.patothebest.gamecore.player.types;
import me.patothebest.gamecore.player.IPlayer;
public interface EloPlayer extends IPlayer {
/**
* Gets the elo from the player
*
* @return the elo
*/
int getElo();
/**
* Sets the player elo
*
* @param newElo the new elo
*/
void setElo(int newElo);
}
| 357 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EloModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/EloModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum EloModifier implements PlayerModifier {
MODIFY
}
| 118 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GeneralModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/GeneralModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum GeneralModifier implements PlayerModifier {
LOCALE
}
| 122 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ShopModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/ShopModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum ShopModifier implements PlayerModifier {
BOUGHT_ITEM,
BOUGHT_ITEM_USES,
USED_ITEM,
DEPLETED_ITEM,
SELECT_DEFAULT,
UPDATE_SELECT_DEFAULT,
REMOVE_SELECTED_ITEM,
}
| 254 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
QuestModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/QuestModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum QuestModifier implements PlayerModifier {
START_QUEST,
UPDATE_PROGRESS,
UPDATE_STATUS
}
| 165 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CageModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/CageModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum CageModifier implements PlayerModifier {
MODIFY_CAGES,
MODIFY_CAGE
}
| 142 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
KitModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/KitModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum KitModifier implements PlayerModifier {
ADD_KIT,
REMOVE_KIT,
MODIFY_KIT,
SET_LAYOUT,
MODIFY_LAYOUT,
SET_DEFAULT
} | 202 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ExperienceModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/ExperienceModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum ExperienceModifier implements PlayerModifier {
SET_EXPERIENCE,
ADD_EXPERIENCE,
REMOVE_EXPERIENCE
}
| 176 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointsModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/PointsModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum PointsModifier implements PlayerModifier {
MODIFY
}
| 121 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TreasureModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/TreasureModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum TreasureModifier implements PlayerModifier {
MODIFY
}
| 123 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
StatsModifier.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/player/modifiers/StatsModifier.java | package me.patothebest.gamecore.player.modifiers;
public enum StatsModifier implements PlayerModifier {
INSERT,
UPDATE_ADD
}
| 136 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointsStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/points/PointsStatistic.java | package me.patothebest.gamecore.points;
import me.patothebest.gamecore.leaderboards.TopEntry;
import me.patothebest.gamecore.points.entities.PointsQueries;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.stats.Statistic;
import org.bukkit.entity.Player;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.LinkedList;
public class PointsStatistic implements Statistic {
private boolean enabled;
@Override
public void updateStat(Player player, int amount) { }
@Override
public void updateStat(IPlayer player, int amount) { }
@Override
public LinkedList<TopEntry> getTop10Monthly(Connection connection) throws SQLException {
return null;
}
@Override
public LinkedList<TopEntry> getTop10Weekly(Connection connection) throws SQLException {
return null;
}
@Override
public LinkedList<TopEntry> getTop10AllTime(Connection connection) throws SQLException {
PreparedStatement selectTop10AllTime = connection.prepareStatement(PointsQueries.SELECT_TOP_10_POINTS);
ResultSet selectTop10AllTimeResults = selectTop10AllTime.executeQuery();
LinkedList<TopEntry> top10AllTime = new LinkedList<>();
while (selectTop10AllTimeResults.next()) {
top10AllTime.add(new TopEntry(selectTop10AllTimeResults.getString("name"), selectTop10AllTimeResults.getInt("points")));
}
selectTop10AllTimeResults.close();
selectTop10AllTime.close();
return top10AllTime;
}
@Override
public boolean hasWeeklyAndMonthlyStats() {
return false;
}
@Override
public boolean isEnabled() {
return enabled;
}
@Override
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
@Override
public String getStatName() {
return "points";
}
}
| 1,959 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointsModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/points/PointsModule.java | package me.patothebest.gamecore.points;
import com.google.inject.multibindings.Multibinder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import me.patothebest.gamecore.points.entities.PointsFlatFileEntity;
import me.patothebest.gamecore.points.entities.PointsMySQLEntity;
import me.patothebest.gamecore.storage.flatfile.FlatFileEntity;
import me.patothebest.gamecore.storage.mysql.MySQLEntity;
import me.patothebest.gamecore.stats.Statistic;
public class PointsModule extends AbstractBukkitModule<CorePlugin> {
public PointsModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
Multibinder<MySQLEntity> mySQLEntityMultibinder = Multibinder.newSetBinder(binder(), MySQLEntity.class);
mySQLEntityMultibinder.addBinding().to(PointsMySQLEntity.class);
Multibinder<FlatFileEntity> flatFileEntityMultibinder = Multibinder.newSetBinder(binder(), FlatFileEntity.class);
flatFileEntityMultibinder.addBinding().to(PointsFlatFileEntity.class);
Multibinder<Statistic> statisticMultibinder = Multibinder.newSetBinder(binder(), Statistic.class);
statisticMultibinder.addBinding().to(PointsStatistic.class);
registerModule(PointsManager.class);
}
}
| 1,315 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointsManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/points/PointsManager.java | package me.patothebest.gamecore.points;
import com.google.inject.Inject;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.modules.ModuleName;
import me.patothebest.gamecore.permission.PermissionGroup;
import me.patothebest.gamecore.permission.PermissionGroupManager;
import me.patothebest.gamecore.event.player.ArenaLeaveMidGameEvent;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.stats.StatsUpdateEvent;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import java.util.HashMap;
import java.util.Map;
@ModuleName("Points Manager")
public class PointsManager implements ListenerModule, ActivableModule {
private final CoreConfig config;
private final PlayerManager playerManager;
private final PermissionGroupManager permissionGroupManager;
private final Map<PermissionGroup, Integer> pointsMultipliers = new HashMap<>();
private boolean enabled;
private int wins;
private int kills;
private int deaths;
private int loses;
private int leaveGame;
@Inject private PointsManager(CoreConfig config, PlayerManager playerManager, PermissionGroupManager permissionGroupManager) {
this.config = config;
this.playerManager = playerManager;
this.permissionGroupManager = permissionGroupManager;
}
@Override
public void onPostEnable() {
ConfigurationSection pointsSection = config.getConfigurationSection("points");
enabled = pointsSection.getBoolean("enabled");
kills = pointsSection.getInt("kill");
wins = pointsSection.getInt("win");
deaths = pointsSection.getInt("death");
loses = pointsSection.getInt("lose");
leaveGame = pointsSection.getInt("leave-game");
if(config.getBoolean("points-multiplier.enabled")) {
Map<String, Object> limits = config.getConfigurationSection("points-multiplier.multipliers").getValues(true);
limits.forEach((string, limit) -> {
if(!(limit instanceof Integer)) {
return;
}
PermissionGroup permissionGroup = permissionGroupManager.getOrCreatePermissionGroup(string);
pointsMultipliers.put(permissionGroup, (Integer) limit);
});
}
}
@EventHandler
public void onPlayerPrepare(ArenaLeaveMidGameEvent event) {
if(!enabled) {
return;
}
playerManager.getPlayer(event.getPlayer()).setPoints(playerManager.getPlayer(event.getPlayer()).getPoints() + leaveGame);
}
@EventHandler
public void onStatUpdate(StatsUpdateEvent event) {
if(!enabled) {
return;
}
final int[] multiplier = {1};
IPlayer player = event.getPlayer();
pointsMultipliers.forEach((permissionGroup, multiplierValue) -> {
if(multiplierValue > multiplier[0]) {
if(permissionGroup.hasPermission(player)) {
multiplier[0] = multiplierValue;
}
}
});
switch (event.getStatistic().getStatName()) {
case "wins":
player.setPoints(player.getPoints() + getTotalPoints(wins, multiplier[0]));
break;
case "kills":
player.setPoints(player.getPoints() + getTotalPoints(kills, multiplier[0]));
break;
case "loses":
player.setPoints(player.getPoints() + getTotalPoints(loses, multiplier[0]));
break;
case "deaths":
player.setPoints(player.getPoints() + getTotalPoints(deaths, multiplier[0]));
break;
}
}
public boolean isEnabled() {
return enabled;
}
private int getTotalPoints(int points, int multiplier) {
return points > 0 ? points * multiplier : points;
}
}
| 4,103 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointsFlatFileEntity.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/points/entities/PointsFlatFileEntity.java | package me.patothebest.gamecore.points.entities;
import me.patothebest.gamecore.storage.StorageException;
import me.patothebest.gamecore.storage.flatfile.FlatFileEntity;
import me.patothebest.gamecore.storage.flatfile.PlayerProfileFile;
import me.patothebest.gamecore.player.CorePlayer;
public class PointsFlatFileEntity implements FlatFileEntity {
/**
* Loads the player's points
*
* @param player the player loaded
* @param file the player's profile file
*/
@Override
public void loadPlayer(CorePlayer player, PlayerProfileFile file) throws StorageException {
player.setPoints(file.getInt("points"));
}
/**
* Saves the player's points
*
* @param player the player being saved
* @param file the player's profile file
*/
@Override
public void savePlayer(CorePlayer player, PlayerProfileFile file) throws StorageException {
file.set("points", player.getPoints());
}
}
| 973 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointsMySQLEntity.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/points/entities/PointsMySQLEntity.java | package me.patothebest.gamecore.points.entities;
import me.patothebest.gamecore.storage.mysql.MySQLEntity;
import me.patothebest.gamecore.player.CorePlayer;
import me.patothebest.gamecore.player.modifiers.PlayerModifier;
import me.patothebest.gamecore.player.modifiers.PointsModifier;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class PointsMySQLEntity implements MySQLEntity {
/**
* Loads the player's points
* <p>
* A record is inserted if the record doesn't
* exist.
*
* @param player the player loaded
* @param connection the database connection
*/
@Override
public void loadPlayer(CorePlayer player, Connection connection) throws SQLException {
PreparedStatement selectUser = connection.prepareStatement(PointsQueries.SELECT);
selectUser.setInt(1, player.getPlayerId());
ResultSet resultSet = selectUser.executeQuery();
if (!resultSet.next()) {
PreparedStatement createUser = connection.prepareStatement(PointsQueries.INSERT_RECORD);
createUser.setInt(1, player.getPlayerId());
createUser.executeUpdate();
} else {
player.setPoints(resultSet.getInt("points"));
}
resultSet.close();
selectUser.close();
}
/**
* Updates the player's points in the database
*
* @param player the player to save
* @param connection the database connection
*/
@Override
public void savePlayer(CorePlayer player, Connection connection) throws SQLException {
PreparedStatement updateUser = connection.prepareStatement(PointsQueries.UPDATE);
updateUser.setInt(1, player.getPoints());
updateUser.setInt(2, player.getPlayerId());
updateUser.executeUpdate();
updateUser.close();
}
@Override
public void updatePlayer(CorePlayer player, Connection connection, PlayerModifier updatedType, Object... args) throws SQLException {
if (updatedType != PointsModifier.MODIFY) {
return;
}
savePlayer(player, connection);
}
/**
* Gets all the statements needed to create the
* table(s) for the specific entity.
*
* @return the create table statements
*/
@Override
public String[] getCreateTableStatements() {
return new String[]{PointsQueries.CREATE_TABLE};
}
} | 2,474 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointsQueries.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/points/entities/PointsQueries.java | package me.patothebest.gamecore.points.entities;
import me.patothebest.gamecore.PluginConfig;
public class PointsQueries {
static final String CREATE_TABLE =
"CREATE TABLE IF NOT EXISTS `" + PluginConfig.SQL_PREFIX + "_points` (\n" +
" `player_id` int(11) NOT NULL,\n" +
" `points` int(11) NOT NULL,\n" +
" PRIMARY KEY (`player_id`),\n" +
" UNIQUE KEY `player_id` (`player_id`)\n" +
") ENGINE=InnoDB DEFAULT CHARSET=latin1;\n";
final static String INSERT_RECORD = "INSERT INTO " + PluginConfig.SQL_PREFIX + "_points VALUES (?, '0')";
final static String SELECT = "SELECT * FROM " + PluginConfig.SQL_PREFIX + "_points WHERE player_id=?";
final static String DELETE = "DELETE FROM " + PluginConfig.SQL_PREFIX + "_points WHERE player_id=?";
final static String UPDATE = "UPDATE " + PluginConfig.SQL_PREFIX + "_points SET points=? WHERE player_id=?;";
public final static String SELECT_TOP_10_POINTS = "SELECT players.name, " + PluginConfig.SQL_PREFIX + "_points.points FROM " + PluginConfig.SQL_PREFIX + "_points INNER JOIN players ON players.id = " + PluginConfig.SQL_PREFIX + "_points.player_id ORDER BY points DESC LIMIT 10";
}
| 1,274 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PluginHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/PluginHook.java | package me.patothebest.gamecore.pluginhooks;
import org.bukkit.configuration.ConfigurationSection;
public abstract class PluginHook {
private boolean lodaded = false;
public final void load(ConfigurationSection pluginHookSection) {
onHook(pluginHookSection);
lodaded = true;
}
protected abstract void onHook(ConfigurationSection pluginHookSection);
public abstract String getPluginName();
public final boolean isLodaded() {
return lodaded;
}
} | 502 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PluginHookProvider.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/PluginHookProvider.java | package me.patothebest.gamecore.pluginhooks;
public class PluginHookProvider {
private final Class<? extends PluginHook> pluginHookClass;
public PluginHookProvider(Class<? extends PluginHook> pluginHookClass) {
this.pluginHookClass = pluginHookClass;
}
public Class<? extends PluginHook> getPluginHookClass() {
return pluginHookClass;
}
}
| 379 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PluginHookManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/PluginHookManager.java | package me.patothebest.gamecore.pluginhooks;
import com.google.inject.Singleton;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.modules.ModuleName;
import me.patothebest.gamecore.file.PluginHookFile;
import me.patothebest.gamecore.logger.InjectLogger;
import me.patothebest.gamecore.modules.ActivableModule;
import org.bukkit.ChatColor;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
@Singleton
@ModuleName("Plugin Hook Manager")
public class PluginHookManager implements ActivableModule {
private final CorePlugin plugin;
private final PluginHookFile pluginHookFile;
private final Map<String, PluginHookProvider> pluginHookClasses;
private final List<PluginHook> pluginHooks;
@InjectLogger private Logger logger;
@Inject public PluginHookManager(CorePlugin plugin, PluginHookFile pluginHookFile, Map<String, PluginHookProvider> pluginHookClasses) {
this.plugin = plugin;
this.pluginHookFile = pluginHookFile;
this.pluginHooks = new ArrayList<>();
this.pluginHookClasses = pluginHookClasses;
}
@Override
public void onEnable() {
logger.info(ChatColor.YELLOW + "Attempting to hook into supported plugins...");
pluginHookClasses.forEach((key, value) -> {
if (!plugin.getServer().getPluginManager().isPluginEnabled(key)) {
return;
}
if (!pluginHookFile.getBoolean(key + ".enabled")) {
logger.log(Level.CONFIG, "Not enabling " + key + " because it's disabled in the config");
return;
}
try {
logger.log(Level.FINE, "Attempting to hook into " + key + "...");
PluginHook pluginHook = plugin.getInjector().getInstance(value.getPluginHookClass());
pluginHooks.add(pluginHook);
pluginHook.onHook(pluginHookFile.getConfigurationSection(key + ".configuration"));
logger.info("Hooked into " + pluginHook.getPluginName() + "!");
} catch (Throwable t) {
logger.log(Level.SEVERE, "Unable to hook into " + key, t);
}
});
}
public boolean isHookLoaded(Class<? extends PluginHook> clazz) {
return pluginHooks.stream().filter(pluginHook -> pluginHook.getClass().equals(clazz)).findFirst().orElse(null) != null;
}
@SuppressWarnings("unchecked")
public <T extends PluginHook> T getHook(Class<T> clazz) {
return (T) pluginHooks.stream().filter(pluginHook -> pluginHook.getClass().equals(clazz)).findFirst().orElseThrow(() -> new IllegalArgumentException(clazz + " is not found! Custom hook?"));
}
} | 2,793 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PluginHooksModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/PluginHooksModule.java | package me.patothebest.gamecore.pluginhooks;
import com.google.inject.Provides;
import com.google.inject.multibindings.MapBinder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.pluginhooks.hooks.FastAsyncWorldEditHook;
import me.patothebest.gamecore.pluginhooks.hooks.FeatherBoardHook;
import me.patothebest.gamecore.pluginhooks.hooks.MVdWPlaceholderAPIHook;
import me.patothebest.gamecore.pluginhooks.hooks.PlaceholderAPIHook;
import me.patothebest.gamecore.pluginhooks.hooks.SlimeWorldManagerHook;
import me.patothebest.gamecore.pluginhooks.hooks.VaultHook;
import me.patothebest.gamecore.pluginhooks.hooks.WorldEditHook;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import me.patothebest.gamecore.pluginhooks.hooks.CitizensPluginHook;
import me.patothebest.gamecore.pluginhooks.hooks.HolographicDisplaysHook;
import net.milkbowl.vault.chat.Chat;
import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.permission.Permission;
public class PluginHooksModule extends AbstractBukkitModule<CorePlugin> {
public PluginHooksModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
MapBinder<String, PluginHookProvider> pluginHooks = MapBinder.newMapBinder(binder(), String.class, PluginHookProvider.class);
registerHook("MVdWPlaceholderAPI", MVdWPlaceholderAPIHook.class, pluginHooks);
registerHook("PlaceholderAPI", PlaceholderAPIHook.class, pluginHooks);
registerHook("WorldEdit", WorldEditHook.class, pluginHooks);
registerHook("FastAsyncWorldEdit", FastAsyncWorldEditHook.class, pluginHooks);
registerHook("SlimeWorldManager", SlimeWorldManagerHook.class, pluginHooks);
registerHook("Vault", VaultHook.class, pluginHooks);
registerHook("FeatherBoard", FeatherBoardHook.class, pluginHooks);
registerHook("Citizens", CitizensPluginHook.class, pluginHooks);
registerHook("HolographicDisplays", HolographicDisplaysHook.class, pluginHooks);
registerModule(PluginHookManager.class);
}
private void registerHook(String pluginHookName, Class<? extends PluginHook> pluginHookClass, MapBinder<String, PluginHookProvider> pluginHooks) {
pluginHooks.addBinding(pluginHookName).toInstance(new PluginHookProvider(pluginHookClass));
}
@Provides private Economy getEconomy(PluginHookManager pluginHookManager) {
if(!pluginHookManager.isHookLoaded(VaultHook.class)) {
return null;
}
return pluginHookManager.getHook(VaultHook.class).getEconomy();
}
@Provides private Chat getChat(PluginHookManager pluginHookManager) {
if(!pluginHookManager.isHookLoaded(VaultHook.class)) {
return null;
}
return pluginHookManager.getHook(VaultHook.class).getChat();
}
@Provides private Permission getPermissions(PluginHookManager pluginHookManager) {
if(!pluginHookManager.isHookLoaded(VaultHook.class)) {
return null;
}
return pluginHookManager.getHook(VaultHook.class).getPermissions();
}
} | 3,119 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
MVdWPlaceholderAPIHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/MVdWPlaceholderAPIHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import be.maximvdw.placeholderapi.PlaceholderAPI;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.placeholder.PlaceHolderManager;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
public class MVdWPlaceholderAPIHook extends PluginHook {
private final CorePlugin plugin;
private final PlaceHolderManager placeHolderManager;
@Inject public MVdWPlaceholderAPIHook(CorePlugin plugin, PlaceHolderManager placeHolderManager) {
this.plugin = plugin;
this.placeHolderManager = placeHolderManager;
}
@Override
public void onHook(ConfigurationSection pluginHookSection) {
placeHolderManager.registerMDWPlaceholder();
}
public void registerPlaceholder(PlaceHolder placeHolder) {
PlaceholderAPI.registerPlaceholder(plugin, PluginConfig.PLACEHOLDER_PREFIX + "_" + placeHolder.getPlaceholderName(), placeholderReplaceEvent -> placeHolder.replace(placeholderReplaceEvent.getPlayer(), null));
}
@Override
public String getPluginName() {
return "MVdWPlaceholderAPI";
}
public String replace(Player player, String string) {
return PlaceholderAPI.replacePlaceholders(player, string);
}
} | 1,483 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
FeatherBoardHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/FeatherBoardHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import be.maximvdw.featherboard.api.FeatherBoardAPI;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.event.player.LobbyJoinEvent;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import javax.inject.Inject;
public class FeatherBoardHook extends PluginHook implements ListenerModule {
private final CorePlugin plugin;
private String leaveScoreboard;
private String lobbyScoreboard;
@Inject public FeatherBoardHook(CorePlugin plugin) {
this.plugin = plugin;
}
@Override
public void onHook(ConfigurationSection pluginHookSection) {
plugin.getServer().getPluginManager().registerEvents(this, plugin);
leaveScoreboard = pluginHookSection.getString("lobby");
lobbyScoreboard = pluginHookSection.getString("pre-game");
}
@EventHandler
public void onLeaveArena(ArenaLeaveEvent event) {
showScoreboard(event.getPlayer(), leaveScoreboard);
}
@EventHandler
public void onJoinLobby(LobbyJoinEvent event) {
showScoreboard(event.getPlayer(), lobbyScoreboard);
}
private void showScoreboard(Player player, String scoreboardName) {
/*if(scoreboardName == null || scoreboardName.isEmpty() || scoreboardName.equalsIgnoreCase("default")) {
FeatherBoardAPI.resetDefaultScoreboard(player);
return;
}*/
FeatherBoardAPI.showScoreboard(player, scoreboardName);
}
@Override
public String getPluginName() {
return "FeatherBoard";
}
} | 1,823 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
FastAsyncWorldEditHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/FastAsyncWorldEditHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import com.boydti.fawe.bukkit.wrapper.AsyncWorld;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.WorldCreator;
import org.bukkit.configuration.ConfigurationSection;
import javax.inject.Inject;
public class FastAsyncWorldEditHook extends PluginHook {
private final CorePlugin plugin;
@Inject public FastAsyncWorldEditHook(CorePlugin plugin) {
this.plugin = plugin;
}
@Override
public void onHook(ConfigurationSection pluginHookSection) {
//plugin.setWorldHandler(this);
}
@Override
public String getPluginName() {
return "FastAsyncWorldEdit";
}
public World createWorld(WorldCreator creator) {
AsyncWorld asyncWorld = AsyncWorld.create(creator);
// When you are done
asyncWorld.commit();
Bukkit.getWorlds().add(asyncWorld);
return asyncWorld.getBukkitWorld();
}
public boolean hasAsyncSupport() {
return true;
}
}
| 1,119 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WorldEditHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/WorldEditHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import com.sk89q.worldedit.bukkit.WorldEditPlugin;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.logger.InjectParentLogger;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import me.patothebest.gamecore.pluginhooks.PluginHookManager;
import me.patothebest.gamecore.pluginhooks.hooks.worldedit.WorldEdit6SelectionManager;
import me.patothebest.gamecore.pluginhooks.hooks.worldedit.WorldEdit7SelectionManager;
import me.patothebest.gamecore.selection.SelectionManager;
import org.bukkit.Bukkit;
import org.bukkit.configuration.ConfigurationSection;
import javax.inject.Inject;
import java.util.logging.Logger;
public class WorldEditHook extends PluginHook {
private final CorePlugin plugin;
@InjectParentLogger(parent = PluginHookManager.class) private Logger logger;
@Inject public WorldEditHook(CorePlugin plugin) {
this.plugin = plugin;
}
@Override
public void onHook(ConfigurationSection pluginHookSection) {
WorldEditPlugin worldEdit = (WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit");
CoreLang.SELECT_AN_AREA.transferMessage(CoreLang.SELECT_AN_AREA_WORLDEDIT);
SelectionManager selectionManager = null;
try {
selectionManager = new WorldEdit6SelectionManager(worldEdit);
logger.info("Detected WorldEdit version 6!");
} catch (Throwable ignored) {}
if (selectionManager == null) {
try {
selectionManager = new WorldEdit7SelectionManager(worldEdit);
logger.info("Detected WorldEdit version 7!");
} catch (Throwable throwable) {
logger.severe("Could not hook into WorldEdit! (Supported WE versions 6.x and 7.x)");
throwable.printStackTrace();
}
}
plugin.setSelectionManager(selectionManager);
}
@Override
public String getPluginName() {
return "WorldEdit";
}
} | 2,065 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SlimeWorldManagerHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/SlimeWorldManagerHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import com.grinderwolf.swm.api.SlimePlugin;
import com.grinderwolf.swm.api.exceptions.CorruptedWorldException;
import com.grinderwolf.swm.api.exceptions.InvalidWorldException;
import com.grinderwolf.swm.api.exceptions.NewerFormatException;
import com.grinderwolf.swm.api.exceptions.UnknownWorldException;
import com.grinderwolf.swm.api.exceptions.WorldAlreadyExistsException;
import com.grinderwolf.swm.api.exceptions.WorldInUseException;
import com.grinderwolf.swm.api.exceptions.WorldLoadedException;
import com.grinderwolf.swm.api.exceptions.WorldTooBigException;
import com.grinderwolf.swm.api.loaders.SlimeLoader;
import com.grinderwolf.swm.api.world.SlimeWorld;
import com.grinderwolf.swm.api.world.properties.SlimeProperties;
import com.grinderwolf.swm.api.world.properties.SlimePropertyMap;
import me.patothebest.gamecore.event.arena.ArenaDisableEvent;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.world.WorldHandler;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import javax.inject.Inject;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.file.NotDirectoryException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
public class SlimeWorldManagerHook extends PluginHook implements WorldHandler, Listener {
private static final FilenameFilter WORLD_FILE_FILTER = (dir, name) -> name.endsWith(".slime");
private final static File SLIME_WORLD_DIRECTORY = new File(Utils.PLUGIN_DIR, "slime-worlds");
private final CorePlugin corePlugin;
private final PluginScheduler pluginScheduler;
private SlimePlugin slimePlugin;
private FileLoader slimeLoader;
@Inject public SlimeWorldManagerHook(CorePlugin plugin, PluginScheduler pluginScheduler) {
this.corePlugin = plugin;
this.pluginScheduler = pluginScheduler;
}
@Override
public void onHook(ConfigurationSection pluginHookSection) {
if (!SLIME_WORLD_DIRECTORY.exists()) {
SLIME_WORLD_DIRECTORY.mkdirs();
}
corePlugin.setWorldHandler(this);
slimePlugin = (SlimePlugin) Bukkit.getPluginManager().getPlugin("SlimeWorldManager");
slimeLoader = new FileLoader(SLIME_WORLD_DIRECTORY);
slimePlugin.registerLoader(PluginConfig.PLUGIN_NAME, slimeLoader);
corePlugin.registerListener(this);
}
@Override
public String getPluginName() {
return "SlimeWorldManager";
}
@EventHandler
public void onDisable(ArenaDisableEvent event) {
try {
slimeLoader.deleteWorld(event.getArena().getName());
} catch (UnknownWorldException e) {
e.printStackTrace();
}
}
@Override
public boolean decompressWorld(AbstractArena arena, File worldZipFile, File tempWorld) {
if (slimeLoader.worldExists(arena.getName())) {
return true;
}
Utils.unZip(worldZipFile.getPath(), tempWorld.getPath());
new File(tempWorld, "uid.dat").delete();
try {
slimePlugin.importWorld(tempWorld, arena.getName(), slimeLoader);
Utils.deleteFolder(tempWorld);
return true;
} catch (WorldAlreadyExistsException | InvalidWorldException | WorldLoadedException | WorldTooBigException | IOException e) {
e.printStackTrace();
}
return false;
}
@Override
public void deleteWorld(File tempWorld) {
File file = new File("temp_" + tempWorld.getName());
if (file.exists()) {
Utils.deleteFolder(file);
}
}
@Override
public boolean unloadWorld(World world) {
return Bukkit.unloadWorld(world, false);
}
@Override
/* Note that this method should be called asynchronously */
public synchronized CompletableFuture<World> loadWorld(AbstractArena arena, String worldName, World.Environment environment) {
CompletableFuture<World> completableFuture = new CompletableFuture<>();
try {
SlimePropertyMap slimePropertyMap = createDefaultProperties(environment);
slimeLoader.realWorldNames.put(worldName.toLowerCase(), arena.getName());
SlimeWorld world = slimePlugin.loadWorld(slimeLoader, worldName.toLowerCase(), true, slimePropertyMap);
pluginScheduler.ensureSync(() -> {
try {
// This method must be called synchronously
slimePlugin.generateWorld(world);
completableFuture.complete(Bukkit.getWorld(worldName.toLowerCase()));
} catch (Throwable t) {
completableFuture.completeExceptionally(t);
}
});
} catch (UnknownWorldException | IOException | CorruptedWorldException | NewerFormatException | WorldInUseException ex) {
completableFuture.completeExceptionally(ex);
}
return completableFuture;
}
public SlimePropertyMap createDefaultProperties(World.Environment environment) {
SlimePropertyMap slimePropertyMap = new SlimePropertyMap();
slimePropertyMap.setString(SlimeProperties.DIFFICULTY, "hard");
slimePropertyMap.setInt(SlimeProperties.SPAWN_X, 0);
slimePropertyMap.setInt(SlimeProperties.SPAWN_Y, 101);
slimePropertyMap.setInt(SlimeProperties.SPAWN_Z, 0);
slimePropertyMap.setBoolean(SlimeProperties.ALLOW_MONSTERS, false);
slimePropertyMap.setBoolean(SlimeProperties.ALLOW_ANIMALS, false);
slimePropertyMap.setBoolean(SlimeProperties.PVP, true);
slimePropertyMap.setString(SlimeProperties.ENVIRONMENT, environment.name().toLowerCase());
return slimePropertyMap;
}
@Override
public boolean hasAsyncSupport() {
return true;
}
public static class FileLoader implements SlimeLoader {
private final Map<String, RandomAccessFile> worldFiles = new HashMap<>();
private final Map<String, String> realWorldNames = new HashMap<>();
private final File worldDir;
public FileLoader(File worldDir) {
this.worldDir = worldDir;
worldDir.mkdirs();
}
@Override
// All worlds will be readOnly
public byte[] loadWorld(String worldName, boolean readOnly) throws UnknownWorldException, IOException {
String realWorldName = realWorldNames.getOrDefault(worldName, worldName);
if (!worldExists(realWorldName)) {
throw new UnknownWorldException(realWorldName);
}
RandomAccessFile file = worldFiles.computeIfAbsent(worldName, (world) -> {
try {
return new RandomAccessFile(new File(worldDir, realWorldName + ".slime"), "rw");
} catch (FileNotFoundException ex) {
return null; // This is never going to happen as we've just checked if the world exists
}
});
if (file.length() > Integer.MAX_VALUE) {
throw new IndexOutOfBoundsException("World is too big!");
}
byte[] serializedWorld = new byte[(int) file.length()];
file.seek(0); // Make sure we're at the start of the file
file.readFully(serializedWorld);
return serializedWorld;
}
@Override
public boolean worldExists(String worldName) {
return new File(worldDir, realWorldNames.getOrDefault(worldName, worldName) + ".slime").exists();
}
@Override
public List<String> listWorlds() throws NotDirectoryException {
String[] worlds = worldDir.list(WORLD_FILE_FILTER);
if(worlds == null) {
throw new NotDirectoryException(worldDir.getPath());
}
return Arrays.stream(worlds).map((c) -> c.substring(0, c.length() - 6)).collect(Collectors.toList());
}
@Override
public void saveWorld(String worldName, byte[] serializedWorld, boolean lock) throws IOException {
RandomAccessFile worldFile = worldFiles.get(worldName);
boolean tempFile = worldFile == null;
if (tempFile) {
worldFile = new RandomAccessFile(new File(worldDir, worldName + ".slime"), "rw");
}
worldFile.seek(0); // Make sure we're at the start of the file
worldFile.setLength(0); // Delete old data
worldFile.write(serializedWorld);
if (tempFile) {
worldFile.close();
}
}
@Override
public void unlockWorld(String worldName) throws UnknownWorldException {
if (!worldExists(worldName)) {
throw new UnknownWorldException(worldName);
}
worldFiles.remove(worldName);
realWorldNames.remove(worldName);
}
@Override
public boolean isWorldLocked(String worldName) {
return false;
}
@Override
public void deleteWorld(String worldName) throws UnknownWorldException {
if (!worldExists(worldName)) {
throw new UnknownWorldException(worldName);
}
new File(worldDir, worldName + ".slime").delete();
}
}
public SlimePlugin getSlimePlugin() {
return slimePlugin;
}
public FileLoader getSlimeLoader() {
return slimeLoader;
}
}
| 10,077 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
VaultHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/VaultHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import net.milkbowl.vault.chat.Chat;
import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.permission.Permission;
import org.bukkit.Bukkit;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.plugin.RegisteredServiceProvider;
import javax.inject.Inject;
public class VaultHook extends PluginHook implements ListenerModule {
private final CorePlugin plugin;
// Vault objects
private Economy economy;
private Permission permissions;
private Chat chat;
@Inject public VaultHook(CorePlugin plugin) {
this.plugin = plugin;
}
@Override
public void onHook(ConfigurationSection pluginHookSection) {
RegisteredServiceProvider<Economy> economyRegisteredServiceProvider = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
if(economyRegisteredServiceProvider != null && pluginHookSection.getBoolean("economy")) {
economy = economyRegisteredServiceProvider.getProvider();
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}
RegisteredServiceProvider<Permission> permissionRegisteredServiceProvider = Bukkit.getServer().getServicesManager().getRegistration(Permission.class);
if(permissionRegisteredServiceProvider != null && pluginHookSection.getBoolean("permissions")) {
permissions = permissionRegisteredServiceProvider.getProvider();
}
RegisteredServiceProvider<Chat> chatRegisteredServiceProvider = Bukkit.getServer().getServicesManager().getRegistration(Chat.class);
if(chatRegisteredServiceProvider != null && pluginHookSection.getBoolean("chat")) {
chat = chatRegisteredServiceProvider.getProvider();
}
}
public Economy getEconomy() {
return economy;
}
public Permission getPermissions() {
return permissions;
}
public Chat getChat() {
return chat;
}
@Override
public String getPluginName() {
return "Vault";
}
} | 2,232 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
MultiArenaBungeeModeHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/MultiArenaBungeeModeHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.modes.bungee.BungeeMode;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.event.arena.ArenaLoadEvent;
import me.patothebest.gamecore.event.arena.ArenaUnLoadEvent;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import net.megaplanet.multiarenabungeemode.IArena;
import net.megaplanet.multiarenabungeemode.MultiArenaBungeeMode;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
public class MultiArenaBungeeModeHook extends PluginHook implements Listener {
private final ArenaManager arenaManager;
private final CorePlugin plugin;
private final BungeeMode bungeeMode;
@Inject private MultiArenaBungeeModeHook(ArenaManager arenaManager, CorePlugin plugin, BungeeMode bungeeMode) {
this.arenaManager = arenaManager;
this.plugin = plugin;
this.bungeeMode = bungeeMode;
}
@Override
protected void onHook(ConfigurationSection pluginHookSection) {
plugin.getServer().getPluginManager().registerEvents(this, plugin);
for (AbstractArena abstractArena : arenaManager.getArenas().values()) {
MultiArenaBungeeMode.registerArena(abstractArena.getName(), new ArenaWrapper(abstractArena));
}
}
@EventHandler
public void onArenaLoad(ArenaLoadEvent event) {
MultiArenaBungeeMode.registerArena(event.getArena().getName(), new ArenaWrapper(event.getArena()));
}
@EventHandler
public void onArenaUnLoad(ArenaUnLoadEvent event) {
MultiArenaBungeeMode.unregisterArena(event.getArena().getName());
}
@Override
public String getPluginName() {
return "MultiArenaBungeeMode";
}
private class ArenaWrapper implements IArena {
private final AbstractArena arena;
private ArenaWrapper(AbstractArena arena) {
this.arena = arena;
}
@Override
public String getName() {
return arena.getName();
}
@Override
public void queuePlayerToJoin(String playerName) {
bungeeMode.getPlayerQueue().put(playerName, arena);
}
@Override
public int getMaxPlayers() {
return arena.getMaxPlayers();
}
@Override
public int getPlayers() {
return arena.getPlayers().size();
}
@Override
public String getStatus() {
return arena.getArenaState().getName();
}
@Override
public boolean canJoin() {
return arena.getPhase().canJoin();
}
}
} | 2,838 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HolographicDisplaysHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/HolographicDisplaysHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import com.gmail.filoghost.holographicdisplays.api.Hologram;
import com.gmail.filoghost.holographicdisplays.api.HologramsAPI;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import org.bukkit.Location;
import org.bukkit.configuration.ConfigurationSection;
public class HolographicDisplaysHook extends PluginHook {
private final CorePlugin plugin;
@Inject private HolographicDisplaysHook(CorePlugin plugin) {
this.plugin = plugin;
}
@Override
protected void onHook(ConfigurationSection pluginHookSection) { }
@Override
public String getPluginName() {
return "HolographicDisplays";
}
public Hologram createHologram(Location location) {
return HologramsAPI.createHologram(plugin, location);
}
}
| 897 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CitizensPluginHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/CitizensPluginHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import net.citizensnpcs.api.CitizensAPI;
import net.citizensnpcs.api.npc.NPC;
import org.bukkit.Location;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.EntityType;
public class CitizensPluginHook extends PluginHook {
@Override
protected void onHook(ConfigurationSection pluginHookSection) { }
@Override
public String getPluginName() {
return "Citizens";
}
public NPC createNPC(String name, Location location) {
NPC npc = CitizensAPI.getNPCRegistry().createNPC(EntityType.PLAYER, name);
npc.spawn(location);
npc.setUseMinecraftAI(false);
npc.setProtected(true);
return npc;
}
public NPC getNPC(int id) {
return CitizensAPI.getNPCRegistry().getById(id);
}
}
| 893 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlaceholderAPIHook.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/PlaceholderAPIHook.java | package me.patothebest.gamecore.pluginhooks.hooks;
import me.clip.placeholderapi.PlaceholderAPI;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.placeholder.EzPlaceholderWrapper;
import me.patothebest.gamecore.placeholder.PlaceHolderManager;
import me.patothebest.gamecore.pluginhooks.PluginHook;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import javax.inject.Inject;
public class PlaceholderAPIHook extends PluginHook {
private final PlaceHolderManager placeHolderManager;
@Inject public PlaceholderAPIHook(PlaceHolderManager placeHolderManager) {
this.placeHolderManager = placeHolderManager;
}
@Override
public void onHook(ConfigurationSection pluginHookSection) {
placeHolderManager.registerClipsPlaceholders();
}
public String replaceString(Player player, String string) {
if(PlaceholderAPI.containsBracketPlaceholders(string)) {
string = PlaceholderAPI.setBracketPlaceholders(player, string);
}
if(PlaceholderAPI.containsPlaceholders(string)) {
string = PlaceholderAPI.setPlaceholders(player, string);
}
return string;
}
@Override
public String getPluginName() {
return "PlaceholderAPI";
}
public void register(CorePlugin plugin, EzPlaceholderWrapper ezPlaceholderWrapper) {
ezPlaceholderWrapper.register();
}
}
| 1,447 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WorldEdit7SelectionManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/worldedit/WorldEdit7SelectionManager.java | package me.patothebest.gamecore.pluginhooks.hooks.worldedit;
import com.sk89q.worldedit.LocalSession;
import com.sk89q.worldedit.bukkit.WorldEditPlugin;
import com.sk89q.worldedit.math.BlockVector3;
import com.sk89q.worldedit.regions.Region;
import me.patothebest.gamecore.selection.Selection;
import me.patothebest.gamecore.selection.SelectionManager;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Player;
public class WorldEdit7SelectionManager implements SelectionManager {
private final WorldEditPlugin worldEdit;
public WorldEdit7SelectionManager(WorldEditPlugin worldEdit) throws ClassNotFoundException {
Class.forName("com.sk89q.worldedit.math.BlockVector3");
this.worldEdit = worldEdit;
}
@Override
public Selection getSelection(Player player) {
Region selection;
try {
LocalSession session = worldEdit.getSession(player);
selection = session.getSelection(session.getSelectionWorld());
} catch(Exception e) {
return new Selection();
}
if(selection == null) {
return new Selection();
}
BlockVector3 maximumPoint = selection.getMaximumPoint();
BlockVector3 minimumPoint = selection.getMinimumPoint();
return new Selection().setPointA(toLocation(player.getWorld(), maximumPoint)).setPointB(toLocation(player.getWorld(), minimumPoint));
}
private Location toLocation(World world, BlockVector3 point) {
return new Location(world, point.getBlockX(), point.getBlockY(), point.getBlockZ());
}
}
| 1,612 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
WorldEdit6SelectionManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/pluginhooks/hooks/worldedit/WorldEdit6SelectionManager.java | package me.patothebest.gamecore.pluginhooks.hooks.worldedit;
import com.sk89q.worldedit.bukkit.WorldEditPlugin;
import me.patothebest.gamecore.selection.Selection;
import me.patothebest.gamecore.selection.SelectionManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
public class WorldEdit6SelectionManager implements SelectionManager {
private final WorldEditPlugin worldEdit;
public WorldEdit6SelectionManager(WorldEditPlugin worldEdit) throws ClassNotFoundException {
Class.forName("com.sk89q.worldedit.Vector");
this.worldEdit = worldEdit;
}
@Override
public Selection getSelection(Player player) {
com.sk89q.worldedit.bukkit.selections.Selection selection;
try {
selection = (com.sk89q.worldedit.bukkit.selections.Selection) Utils.invokeMethod(worldEdit, "getSelection", new Class[]{Player.class}, player);
} catch(Exception e) {
return new Selection();
}
if(selection == null) {
return new Selection();
}
return new Selection().setPointA(selection.getMaximumPoint()).setPointB(selection.getMinimumPoint());
}
}
| 1,189 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ModelPiece.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/model/ModelPiece.java | package me.patothebest.gamecore.model;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.Location;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.EntityType;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.EulerAngle;
import org.bukkit.util.Vector;
public class ModelPiece {
private final ArmorStand armorStand;
private final AbstractModel abstractModel;
private final Vector offset;
private final ItemStack blockType;
public ModelPiece(AbstractModel abstractModel, Vector offset, ItemStack blockType) {
this.abstractModel = abstractModel;
this.offset = offset.multiply(0.6);
this.blockType = blockType;
armorStand = (ArmorStand) abstractModel.originLocation.getWorld().spawnEntity(abstractModel.getLocation(), EntityType.ARMOR_STAND);
armorStand.setGravity(false);
armorStand.setVisible(false);
// armorStand.setInvulnerable(true);
armorStand.setHelmet(blockType);
Utils.setAiEnabled(armorStand, false);
updateLocation();
}
public void updateLocation() {
Location location = abstractModel.getLocation();
Vector tmpOffset = offset.clone();
Utils.rotateX(tmpOffset, Math.toRadians(-location.getPitch()));
Utils.rotateY(tmpOffset, Math.toRadians(-location.getYaw()));
location.add(tmpOffset).add(0, -0.75, 0);
armorStand.setHeadPose(new EulerAngle(Math.toRadians(abstractModel.getLocation().getPitch()), 0, 0));
abstractModel.nms.setPositionAndRotation(armorStand, location.getX(), location.getY(), location.getZ(), location.getYaw(), 0);
}
public void destroy() {
armorStand.remove();
}
}
| 1,721 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AbstractModel.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/model/AbstractModel.java | package me.patothebest.gamecore.model;
import me.patothebest.gamecore.nms.NMS;
import org.bukkit.Location;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.Vector;
import java.util.ArrayList;
import java.util.List;
public abstract class AbstractModel {
private final List<ModelPiece> modelPieces = new ArrayList<>();
protected Location originLocation;
protected NMS nms;
public abstract void spawn();
public void addPiece(Vector offset, ItemStack blockType) {
modelPieces.add(new ModelPiece(this, offset, blockType));
}
public Location getLocation() {
return originLocation.clone();
}
public void updateRotation(Location location) {
originLocation.setPitch(location.getPitch());
originLocation.setYaw(location.getYaw());
// originLocation = location;
modelPieces.forEach(ModelPiece::updateLocation);
}
public void destroy() {
modelPieces.forEach(ModelPiece::destroy);
}
}
| 998 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EventRegistry.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/EventRegistry.java | package me.patothebest.gamecore.event;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.modules.Module;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import org.bukkit.Bukkit;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.plugin.RegisteredListener;
import java.util.logging.Level;
public class EventRegistry implements Module {
private final CorePlugin plugin;
private final PluginScheduler pluginScheduler;
@Inject private EventRegistry(CorePlugin plugin, PluginScheduler pluginScheduler) {
this.plugin = plugin;
this.pluginScheduler = pluginScheduler;
}
public void registerListener(Listener listener) {
if(listener instanceof ListenerModule) {
throw new IllegalArgumentException("Listener " + listener + " cannot be a ListenerModule!");
}
plugin.registerListener(listener);
}
public void unRegisterListener(Listener listener) {
HandlerList.unregisterAll(listener);
}
public <T extends Event> T callEvent(T event) {
plugin.getServer().getPluginManager().callEvent(event);
return event;
}
public void callSyncEvent(Event event) {
pluginScheduler.ensureSync(() -> plugin.getServer().getPluginManager().callEvent(event));
}
public void callAsyncEvent(Event event) {
pluginScheduler.ensureAsync(() -> plugin.getServer().getPluginManager().callEvent(event));
}
public <T extends Event> T callEventOnlyOnPlugin(T event) {
HandlerList handlers = event.getHandlers();
RegisteredListener[] listeners = handlers.getRegisteredListeners();
for (RegisteredListener registration : listeners) {
if (!registration.getPlugin().isEnabled()) {
continue;
}
if(!(registration.getPlugin() instanceof CorePlugin)) {
continue;
}
try {
registration.callEvent(event);
} catch (Throwable ex) {
Bukkit.getServer().getLogger().log(Level.SEVERE, "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName(), ex);
}
}
return event;
}
}
| 2,419 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LeaderboardUpdateEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/other/LeaderboardUpdateEvent.java | package me.patothebest.gamecore.event.other;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class LeaderboardUpdateEvent extends Event {
private static final HandlerList handlers = new HandlerList();
public LeaderboardUpdateEvent() {
super(true);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 456 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/ArenaEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.event.Event;
public abstract class ArenaEvent extends Event {
private final AbstractArena arena;
public ArenaEvent(AbstractArena arena) {
this.arena = arena;
}
public AbstractArena getArena() {
return arena;
}
} | 367 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaDisableEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/ArenaDisableEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.event.HandlerList;
public class ArenaDisableEvent extends ArenaEvent {
private static final HandlerList handlers = new HandlerList();
public ArenaDisableEvent(AbstractArena arena) {
super(arena);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 492 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CountdownStartEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/CountdownStartEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.event.HandlerList;
public class CountdownStartEvent extends ArenaEvent {
private static final HandlerList handlers = new HandlerList();
public CountdownStartEvent(AbstractArena arena) {
super(arena);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 496 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameEndEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/GameEndEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.util.PlayerList;
import org.bukkit.event.HandlerList;
public class GameEndEvent extends ArenaEvent {
private static final HandlerList handlers = new HandlerList();
private final PlayerList winners;
private final PlayerList losers;
public GameEndEvent(AbstractArena arena, PlayerList winners, PlayerList losers) {
super(arena);
this.winners = winners;
this.losers = losers;
}
public PlayerList getWinners() {
return winners;
}
public PlayerList getLosers() {
return losers;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 839 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaPhaseChangeEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/ArenaPhaseChangeEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.phase.Phase;
import org.bukkit.event.HandlerList;
public class ArenaPhaseChangeEvent extends ArenaEvent {
private static final HandlerList handlers = new HandlerList();
private final Phase<?> oldPhase;
private final Phase<?> newPhase;
public ArenaPhaseChangeEvent(AbstractArena arena, Phase<?> oldPhase, Phase<?> newPhase) {
super(arena);
this.oldPhase = oldPhase;
this.newPhase = newPhase;
}
/**
* Gets the old phase
*
* @return the old phase
*/
public Phase<?> getOldPhase() {
return oldPhase;
}
/**
* Gets the new phase
*
* @return the new phase
*/
public Phase<?> getNewPhase() {
return newPhase;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 1,016 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaUnLoadEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/ArenaUnLoadEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.event.HandlerList;
public class ArenaUnLoadEvent extends ArenaEvent {
private static final HandlerList handlers = new HandlerList();
public ArenaUnLoadEvent(AbstractArena arena) {
super(arena);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 490 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaPreRegenEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/ArenaPreRegenEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
public class ArenaPreRegenEvent extends ArenaEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancelled;
public ArenaPreRegenEvent(AbstractArena arena) {
super(arena);
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancel) {
this.cancelled = cancel;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 767 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaPrePhaseChangeEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/ArenaPrePhaseChangeEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.phase.Phase;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
public class ArenaPrePhaseChangeEvent extends ArenaEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final Phase<?> oldPhase;
private final Phase<?> newPhase;
private boolean cancelled;
public ArenaPrePhaseChangeEvent(AbstractArena arena, Phase<?> oldPhase, Phase<?> newPhase) {
super(arena);
this.oldPhase = oldPhase;
this.newPhase = newPhase;
}
/**
* Gets the old phase
*
* @return the old phase
*/
public Phase<?> getOldPhase() {
return oldPhase;
}
/**
* Gets the new phase
*
* @return the new phase
*/
public Phase<?> getNewPhase() {
return newPhase;
}
/**
* Gets if the event is cancelled
*
* @return true if cancelled
*/
@Override
public boolean isCancelled() {
return cancelled;
}
/**
* Sets if the phase change is cancelled
*/
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 1,456 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaLoadEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/arena/ArenaLoadEvent.java | package me.patothebest.gamecore.event.arena;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.event.HandlerList;
public class ArenaLoadEvent extends ArenaEvent {
private static final HandlerList handlers = new HandlerList();
public ArenaLoadEvent(AbstractArena arena) {
super(arena);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 486 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaLeaveMidGameEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/ArenaLeaveMidGameEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import javax.annotation.Nullable;
public class ArenaLeaveMidGameEvent extends ArenaPlayerEvent {
private static final HandlerList handlers = new HandlerList();
private final AbstractGameTeam lastGameTeam;
public ArenaLeaveMidGameEvent(Player player, AbstractArena arena, AbstractGameTeam lastGameTeam) {
super(player, arena);
this.lastGameTeam = lastGameTeam;
}
@Nullable
public AbstractGameTeam getLastGameTeam() {
return lastGameTeam;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 874 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerDeSelectItemEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/PlayerDeSelectItemEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.cosmetics.shop.ShopItem;
import me.patothebest.gamecore.player.IPlayer;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class PlayerDeSelectItemEvent extends Event {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private static final HandlerList handlers = new HandlerList();
private final IPlayer player;
private final ShopItem shopItem;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public PlayerDeSelectItemEvent(IPlayer player, ShopItem shopItem) {
this.player = player;
this.shopItem = shopItem;
}
// -------------------------------------------- //
// GETTERS
// -------------------------------------------- //
/**
* Get's the player that has been loaded
*
* @return the player object
*/
public IPlayer getPlayer() {
return player;
}
/**
* Gets the shopItem
*
* @return the shopItem
*/
public ShopItem getShopItem() {
return shopItem;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 1,397 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerJoinPrepareEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/PlayerJoinPrepareEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.player.CorePlayer;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class PlayerJoinPrepareEvent extends Event {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private static final HandlerList handlers = new HandlerList();
private final CorePlayer player;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public PlayerJoinPrepareEvent(CorePlayer player) {
this.player = player;
}
// -------------------------------------------- //
// GETTERS
// -------------------------------------------- //
/**
* Get's the player that has been loaded
*
* @return the player object
*/
public CorePlayer getPlayer() {
return player;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 1,117 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaPreLeaveEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/ArenaPreLeaveEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
public class ArenaPreLeaveEvent extends ArenaPlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancelled;
private boolean cancelTeleport = false;
public ArenaPreLeaveEvent(Player player, AbstractArena arena) {
super(player, arena);
}
/**
* Gets the cancelled state
*
* @return true if event is cancelled
*/
@Override
public boolean isCancelled() {
return cancelled;
}
/**
* Sets the cancelled state
*/
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
public boolean isCancelTeleport() {
return cancelTeleport;
}
public void setCancelTeleport(boolean cancelTeleport) {
this.cancelTeleport = cancelTeleport;
}
}
| 1,216 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerLoginPrepareEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/PlayerLoginPrepareEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.player.CorePlayer;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class PlayerLoginPrepareEvent extends Event {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private static final HandlerList handlers = new HandlerList();
private final CorePlayer player;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public PlayerLoginPrepareEvent(CorePlayer player) {
this.player = player;
}
// -------------------------------------------- //
// GETTERS
// -------------------------------------------- //
/**
* Get's the player that has been loaded
*
* @return the player object
*/
public CorePlayer getPlayer() {
return player;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 1,119 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LobbyJoinEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/LobbyJoinEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
public class LobbyJoinEvent extends ArenaPlayerEvent {
private static final HandlerList handlers = new HandlerList();
public LobbyJoinEvent(Player player, AbstractArena arena) {
super(player, arena);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 547 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerSelectItemEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/PlayerSelectItemEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.cosmetics.shop.ShopItem;
import me.patothebest.gamecore.player.IPlayer;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class PlayerSelectItemEvent extends Event {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private static final HandlerList handlers = new HandlerList();
private final IPlayer player;
private final ShopItem shopItem;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
public PlayerSelectItemEvent(IPlayer player, ShopItem shopItem) {
this.player = player;
this.shopItem = shopItem;
}
// -------------------------------------------- //
// GETTERS
// -------------------------------------------- //
/**
* Get's the player that has been loaded
*
* @return the player object
*/
public IPlayer getPlayer() {
return player;
}
/**
* Gets the shopItem
*
* @return the shopItem
*/
public ShopItem getShopItem() {
return shopItem;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 1,393 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerExperienceUpdateEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/PlayerExperienceUpdateEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.player.IPlayer;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class PlayerExperienceUpdateEvent extends Event {
private static final HandlerList handlers = new HandlerList();
private final IPlayer player;
private final UpdateType updateType;
private final long oldExperience;
private final long newExperience;
public PlayerExperienceUpdateEvent(IPlayer player, UpdateType updateType, long oldExperience, long newExperience) {
this.player = player;
this.updateType = updateType;
this.oldExperience = oldExperience;
this.newExperience = newExperience;
}
public IPlayer getPlayer() {
return player;
}
public HandlerList getHandlers() {
return handlers;
}
public long getOldExperience() {
return oldExperience;
}
public long getNewExperience() {
return newExperience;
}
public UpdateType getUpdateType() {
return updateType;
}
public static HandlerList getHandlerList() {
return handlers;
}
public enum UpdateType {
ADD,
SUBTRACT,
SET
}
}
| 1,242 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaLeaveEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/ArenaLeaveEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import javax.annotation.Nullable;
public class ArenaLeaveEvent extends ArenaPlayerEvent {
private static final HandlerList handlers = new HandlerList();
private final AbstractGameTeam lastGameTeam;
public ArenaLeaveEvent(Player player, AbstractArena arena, AbstractGameTeam lastGameTeam) {
super(player, arena);
this.lastGameTeam = lastGameTeam;
}
@Nullable
public AbstractGameTeam getLastGameTeam() {
return lastGameTeam;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 860 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaPlayerEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/ArenaPlayerEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
public abstract class ArenaPlayerEvent extends Event {
private final AbstractArena arena;
private final Player player;
public ArenaPlayerEvent(Player player, AbstractArena arena) {
this.player = player;
this.arena = arena;
}
public Player getPlayer() {
return player;
}
public AbstractArena getArena() {
return arena;
}
}
| 554 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerLooseEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/PlayerLooseEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
public class PlayerLooseEvent extends ArenaPlayerEvent {
private static final HandlerList handlers = new HandlerList();
public PlayerLooseEvent(Player player, AbstractArena arena) {
super(player, arena);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 553 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
RandomArenaJoinEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/RandomArenaJoinEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
public class RandomArenaJoinEvent extends ArenaPlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancelled;
public RandomArenaJoinEvent(Player player, AbstractArena arena) {
super(player, arena);
}
/**
* Gets the cancelled state
*
* @return true if event is cancelled
*/
@Override
public boolean isCancelled() {
return cancelled;
}
/**
* Sets the cancelled state
*/
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 985 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SpectateEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/SpectateEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
public class SpectateEvent extends ArenaPlayerEvent {
private static final HandlerList handlers = new HandlerList();
public SpectateEvent(Player player, AbstractArena arena) {
super(player, arena);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 546 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameJoinEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/GameJoinEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
public class GameJoinEvent extends ArenaPlayerEvent {
private static final HandlerList handlers = new HandlerList();
public GameJoinEvent(Player player, AbstractArena arena) {
super(player, arena);
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
| 545 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerStateChangeEvent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/GameCore/src/main/java/me/patothebest/gamecore/event/player/PlayerStateChangeEvent.java | package me.patothebest.gamecore.event.player;
import me.patothebest.gamecore.arena.AbstractArena;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
public class PlayerStateChangeEvent extends ArenaPlayerEvent {
private static final HandlerList handlers = new HandlerList();
private final PlayerState playerState;
public PlayerStateChangeEvent(Player player, AbstractArena arena, PlayerState playerState) {
super(player, arena);
this.playerState = playerState;
}
public PlayerState getPlayerState() {
return playerState;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
public enum PlayerState {
SPECTATOR,
PLAYER,
NONE
}
}
| 834 | 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.