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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
IsTopStarsPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/stars/IsTopStarsPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.stars;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
public class IsTopStarsPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private IsTopStarsPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "is_top_stars";
}
@Override
public final String replace(Player player, String args) {
if (args == null || !Utils.isNumber(args)) {
return "Usage e.g: {is_top_stars:5}";
}
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
int compareTo = Integer.parseInt(args);
return arena.getStarCount().getPosition(player) + 1 <= compareTo ? "true" : "false";
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,433 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameStarsNamePlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/stars/GameStarsNamePlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.stars;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
public class GameStarsNamePlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private GameStarsNamePlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "game_stars_name";
}
@Override
public final String replace(Player player, String args) {
if (args == null) {
return "USAGE eg. {game_stars_name:1}";
}
String placeString;
String padding = null;
if (args.contains("_")) {
placeString = args.substring(0, args.indexOf("_"));
padding = args.substring(args.indexOf("_") + 1);
} else {
placeString = args;
}
if (!Utils.isNumber(placeString)) {
return "USAGE eg. {game_stars_name:1}";
}
int place = Integer.parseInt(placeString) - 1;
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
if (arena.getStarCount().size() <= place) {
return "#N/A";
}
String playerName = arena.getStarCount().get(place).getPlayer().getName();
if (padding != null) {
if (!Utils.isNumber(padding)) {
return "USAGE e.g: game_stars_name:1_16";
}
return String.format("%-" + Integer.parseInt(padding) + "s", playerName);
}
return playerName;
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 2,163 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
StarsPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/stars/StarsPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.stars;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class StarsPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private StarsPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "stars";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
return arena.getStarCount().getPoints(player) + "";
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,178 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameStarsCountPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/stars/GameStarsCountPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.stars;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
public class GameStarsCountPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private GameStarsCountPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "game_stars_count";
}
@Override
public final String replace(Player player, String args) {
if (args == null) {
return "USAGE eg. {game_stars_count:1}";
}
if (!Utils.isNumber(args)) {
return "USAGE eg. {game_stars_name:1}";
}
int place = Integer.parseInt(args) - 1;
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
if (arena.getStarCount().size() <= place) {
return "#N/A";
}
return arena.getStarCount().get(place).getPoints() + "";
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,585 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GamePointsPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/points/GamePointsPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.points;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.goal.PointGoal;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class GamePointsPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private GamePointsPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "game_points";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
Game game = arena.getCurrentGame();
if (game == null) {
return "NOT IN GAME";
}
if (!(game.getGoal() instanceof PointGoal)) {
return "GAME IS NOT POINT GAME";
}
PointGoal pointGoal = (PointGoal) game.getGoal();
return pointGoal.getPointList().getPoints(player) + "";
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,575 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PlayerPlacePointsPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/points/PlayerPlacePointsPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.points;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.goal.PointGoal;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class PlayerPlacePointsPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private PlayerPlacePointsPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "player_place_points";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
Game game = arena.getCurrentGame();
if (game == null) {
return "NOT IN GAME";
}
if (!(game.getGoal() instanceof PointGoal)) {
return "GAME IS NOT POINT GAME";
}
PointGoal pointGoal = (PointGoal) game.getGoal();
return pointGoal.getPointList().getPosition(player) + "";
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,599 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GamePointsNamePlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/points/GamePointsNamePlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.points;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.goal.PointGoal;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
public class GamePointsNamePlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private GamePointsNamePlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "game_points_name";
}
@Override
public final String replace(Player player, String args) {
if (args == null) {
return "USAGE eg. {game_stars_name:1}";
}
String placeString;
String padding = null;
if (args.contains("_")) {
placeString = args.substring(0, args.indexOf("_"));
padding = args.substring(args.indexOf("_") + 1);
} else {
placeString = args;
}
if (!Utils.isNumber(placeString)) {
return "USAGE eg. {game_stars_name:1}";
}
int place = Integer.parseInt(placeString) - 1;
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
Game game = arena.getCurrentGame();
if (game == null) {
return "NOT IN GAME";
}
if (!(game.getGoal() instanceof PointGoal)) {
return "GAME IS NOT POINT GAME";
}
PointGoal pointGoal = (PointGoal) game.getGoal();
if (pointGoal.getPointList().size() <= place) {
return "#N/A";
}
String playerName = pointGoal.getPointList().get(place).getPlayer().getName();
if (padding != null) {
if (!Utils.isNumber(padding)) {
return "USAGE e.g: game_stars_name:1_16";
}
return String.format("%-" + Integer.parseInt(padding) + "s", playerName);
}
return playerName;
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 2,551 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GamePointsCountPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/points/GamePointsCountPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.points;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.goal.PointGoal;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
public class GamePointsCountPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private GamePointsCountPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "game_points_count";
}
@Override
public final String replace(Player player, String args) {
if (args == null) {
return "USAGE eg. {game_points_count:1}";
}
if (!Utils.isNumber(args)) {
return "USAGE eg. {game_points_name:1}";
}
int place = Integer.parseInt(args) - 1;
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
Game game = arena.getCurrentGame();
if (game == null) {
return "NOT IN GAME";
}
if (!(game.getGoal() instanceof PointGoal)) {
return "GAME IS NOT POINT GAME";
}
PointGoal pointGoal = (PointGoal) game.getGoal();
if (pointGoal.getPointList().size() <= place) {
return "#N/A";
}
return pointGoal.getPointList().get(place).getPoints() + "";
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,975 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointGoalNamePlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/points/PointGoalNamePlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.points;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.goal.PointGoal;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class PointGoalNamePlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private PointGoalNamePlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "point_goal_name";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
Game game = arena.getCurrentGame();
if (game == null) {
return "NOT IN GAME";
}
if (!(game.getGoal() instanceof PointGoal)) {
return "GAME IS NOT POINT GAME";
}
PointGoal pointGoal = (PointGoal) game.getGoal();
return pointGoal.getPointGoalName();
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,566 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointGoalPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/points/PointGoalPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.points;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.goal.PointGoal;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class PointGoalPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private PointGoalPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "point_goal";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
Game game = arena.getCurrentGame();
if (game == null) {
return "NOT IN GAME";
}
if (!(game.getGoal() instanceof PointGoal)) {
return "GAME IS NOT POINT GAME";
}
PointGoal pointGoal = (PointGoal) game.getGoal();
return pointGoal.getPointsToWin() + "";
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,556 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
IsTopPointsPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/player/points/IsTopPointsPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.player.points;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.goal.PointGoal;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
public class IsTopPointsPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private IsTopPointsPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "is_top_points";
}
@Override
public final String replace(Player player, String args) {
if (args == null || !Utils.isNumber(args)) {
return "Usage e.g: {is_top_points:5}";
}
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
Game game = arena.getCurrentGame();
if (game == null) {
return "NOT IN GAME";
}
if (!(game.getGoal() instanceof PointGoal)) {
return "GAME IS NOT POINT GAME";
}
PointGoal pointGoal = (PointGoal) game.getGoal();
int compareTo = Integer.parseInt(args);
return pointGoal.getPointList().getPosition(player) + 1 <= compareTo ? "true" : "false";
}
@Override
public final String replace(AbstractArena arena) {
throw new IllegalArgumentException("Not supported");
}
}
| 1,818 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TotalGamesPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/all/TotalGamesPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.all;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class TotalGamesPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private TotalGamesPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "total_games";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
return replace(arena);
}
@Override
public final String replace(AbstractArena arena) {
return ((Arena) arena).getTotalGames() + "";
}
}
| 1,148 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TypePlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/all/TypePlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.all;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
import javax.inject.Inject;
public class TypePlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject public TypePlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "type";
}
@Override
public String replace(Player player, String args) {
return replace(playerManager.getPlayer(player).getCurrentArena());
}
@Override
public String replace(AbstractArena arena) {
return arena == null ? "None" : ((Arena)arena).getArenaType().name();
}
}
| 933 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameCountPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/all/GameCountPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.all;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class GameCountPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private GameCountPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "game_count";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
return replace(arena);
}
@Override
public final String replace(AbstractArena arena) {
return ((Arena) arena).getGameIndex() + "";
}
}
| 1,144 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameNamePlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/all/GameNamePlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.all;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class GameNamePlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private GameNamePlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "game_name";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
return replace(arena);
}
@Override
public final String replace(AbstractArena arena) {
Game currentGame = ((Arena) arena).getCurrentGame();
return currentGame == null ? "Not in a game" : currentGame.getName();
}
}
| 1,268 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TotalPlayersPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/placeholder/placeholders/all/TotalPlayersPlaceholder.java | package me.patothebest.arcade.placeholder.placeholders.all;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.entity.Player;
public class TotalPlayersPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject private TotalPlayersPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "total_players";
}
@Override
public final String replace(Player player, String args) {
IPlayer arcadePlayer = playerManager.getPlayer(player);
Arena arena = (Arena) arcadePlayer.getCurrentArena();
if (arena == null) {
return "NOT IN ARENA";
}
return replace(arena);
}
@Override
public final String replace(AbstractArena arena) {
return ((Arena) arena).getTotalPlayers() + "";
}
}
| 1,156 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Game.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/Game.java | package me.patothebest.arcade.game;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.components.GameComponent;
import me.patothebest.arcade.game.goal.Goal;
import me.patothebest.arcade.game.helpers.GamePhase;
import me.patothebest.arcade.lang.Lang;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.util.NameableObject;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.gamecore.vector.Cuboid;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public abstract class Game extends AbstractPhase<Arcade, Arena> implements NameableObject, ConfigurationSerializable, GamePhase {
private String name;
protected final List<GameComponent> gameComponents = new ArrayList<>();
private final List<ArenaLocation> spawns = new ArrayList<>();
private ArenaLocation spectatorLocation;
private Cuboid area;
private boolean enabled;
public Game(Arcade plugin) {
super(plugin);
}
public void setArena(Arena arena) {
this.arena = arena;
}
@SuppressWarnings("unchecked")
public void parse(Map<String, Object> data) {
name = (String) data.get("name");
enabled = (boolean) data.get("enabled");
// get the spawn location if present
if(data.get("spectator-location") != null) {
spectatorLocation = ArenaLocation.deserialize((Map<String, Object>) data.get("spectator-location"), arena);
}
if (data.get("area") != null) {
area = new Cuboid((Map<String, Object>) data.get("area"), arena);
}
if(data.containsKey("spawns")) {
List<Map<String, Object>> spawnList = (List<Map<String, Object>>) data.get("spawns");
spawnList.forEach(stringObjectMap -> {
spawns.add(ArenaLocation.deserialize(stringObjectMap, arena));
});
}
for (GameComponent gameComponent : gameComponents) {
gameComponent.parse(this, data);
}
}
@Override
public Map<String, Object> serialize() {
Map<String, Object> objectMap = new HashMap<>();
objectMap.put("name", name);
objectMap.put("enabled", enabled);
if(spectatorLocation != null) {
objectMap.put("spectator-location", spectatorLocation.serialize());
}
if (area != null) {
objectMap.put("area", area.serialize());
}
objectMap.put("spawns", serializeSpawns());
objectMap.put("type", GameType.getFromClass(getClass()).getConfigName());
for (GameComponent gameComponent : gameComponents) {
gameComponent.serialize(objectMap);
}
return objectMap;
}
private List<Map<String, Object>> serializeSpawns() {
List<Map<String, Object>> serializedSpawns = new ArrayList<>();
spawns.forEach(spawn -> serializedSpawns.add(spawn.serialize()));
return serializedSpawns;
}
public boolean canArenaBeEnabled(CommandSender sender) {
if (!enabled){
return false;
}
boolean canBeEnabled = true;
// check if the arena area is set
if (area == null) {
canBeEnabled = false;
sender.sendMessage(Lang.SETUP_ERROR_SET_AREA.getMessage(sender));
}
// check if the spectator location is set
if (spectatorLocation == null) {
canBeEnabled = false;
sender.sendMessage(Lang.SETUP_ERROR_SPECTATOR_LOCATION.getMessage(sender));
}
if (spawns.isEmpty()) {
canBeEnabled = false;
}
for (GameComponent gameComponent : gameComponents) {
if (!gameComponent.canBeEnabled(sender)) {
canBeEnabled = false;
}
}
return canBeEnabled;
}
@Override
public void start() {
getGoal().setGame(this);
arena.getEventRegistry().registerListener(getGoal());
super.start();
}
@Override
public void stop() {
super.stop();
arena.getEventRegistry().unRegisterListener(getGoal());
getGoal().reset();
}
public List<ArenaLocation> getSpawns() {
return spawns;
}
@Override
public ArenaState getArenaState() {
return ArenaState.IN_GAME;
}
public Arena getArena() {
return arena;
}
public ArenaLocation getSpectatorLocation() {
return spectatorLocation;
}
public abstract Goal getGoal();
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public void setSpectatorLocation(ArenaLocation spectatorLocation) {
this.spectatorLocation = spectatorLocation;
}
public void setArea(Cuboid area) {
this.area = area;
}
@Override
public Game getGame() {
return this;
}
public Cuboid getArea() {
return area;
}
public abstract GameType getGameType();
public <T extends GameComponent> T getComponent(Class<? extends T> gameComponentClass) {
for (GameComponent gameComponent : gameComponents) {
if (gameComponent.getClass() == gameComponentClass) {
return (T) gameComponent;
}
}
return null;
}
}
| 5,613 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameType.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/GameType.java | package me.patothebest.arcade.game;
import me.patothebest.arcade.game.games.oitc.OneInTheChamber;
import me.patothebest.arcade.game.games.snake.Snake;
import me.patothebest.arcade.game.games.splegg.Splegg;
import me.patothebest.arcade.game.games.tntrun.TNTRun;
import me.patothebest.arcade.game.scoreboard.ArcadeScoreboardType;
import me.patothebest.gamecore.modules.ParentCommandModule;
public enum GameType {
SPLEGG("splegg", "splegg", ArcadeScoreboardType.LAST_ALIVE, Splegg.class, Splegg.Command.class),
TNTRUN("tntrun", "tntrun", ArcadeScoreboardType.LAST_ALIVE, TNTRun.class, TNTRun.Command.class),
OITC("oitc", "oitc", ArcadeScoreboardType.POINTS_GOAL, OneInTheChamber.class, OneInTheChamber.Command.class),
SNAKE("snake", "snake", ArcadeScoreboardType.LAST_ALIVE, Snake.class, Snake.Command.class)
;
private final String configName;
private final String commandName;
private final ArcadeScoreboardType scoreboardType;
private final Class<? extends Game> gameClass;
private final Class<? extends ParentCommandModule> commandClass;
GameType(String configName, String commandName, ArcadeScoreboardType scoreboardType, Class<? extends Game> gameClass, Class<? extends ParentCommandModule> commandClass) {
this.configName = configName;
this.commandName = commandName;
this.scoreboardType = scoreboardType;
this.gameClass = gameClass;
this.commandClass = commandClass;
}
public static GameType getGameType(String name) {
for (GameType itr : GameType.values()) {
if(itr.getConfigName().equalsIgnoreCase(name)) {
return itr;
}
}
return null;
}
public static GameType getGameTypeFromCommand(String name) {
for (GameType itr : GameType.values()) {
if(itr.getCommandName().equalsIgnoreCase(name)) {
return itr;
}
}
return null;
}
public static GameType getFromClass(Class<? extends Game> gameClass) {
for (GameType value : GameType.values()) {
if (value.getGameClass() == gameClass) {
return value;
}
}
throw new IllegalArgumentException("Game " + gameClass + " is not registered!");
}
public String getConfigName() {
return configName;
}
public Class<? extends Game> getGameClass() {
return gameClass;
}
public Class<? extends ParentCommandModule> getCommandClass() {
return commandClass;
}
public String getCommandName() {
return commandName;
}
public ArcadeScoreboardType getScoreboardType() {
return scoreboardType;
}
}
| 2,722 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SnakeFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/games/snake/SnakeFeature.java | package me.patothebest.arcade.game.games.snake;
import com.google.inject.Inject;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.components.floor.FloorComponent;
import me.patothebest.gamecore.combat.CombatManager;
import me.patothebest.gamecore.event.player.PlayerStateChangeEvent;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.util.Sounds;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.Cuboid;
import org.bukkit.DyeColor;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.Sheep;
import org.bukkit.entity.Slime;
import org.bukkit.event.EventHandler;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
public class SnakeFeature extends AbstractRunnableFeature {
private final Map<Player, SnakeNode> tails = new HashMap<>();
private final Map<Player, List<Integer>> headBits = new HashMap<>(); // Map of player and List of entity ids
private final List<Location> spawnableSlimeLocations = new ArrayList<>();
private final Arcade plugin;
private final CombatManager combatManager;
private World world;
private int ticks = 0;
@Inject private SnakeFeature(Arcade plugin, CombatManager combatManager) {
this.plugin = plugin;
this.combatManager = combatManager;
}
@Override
public void initializeFeature() {
ticks = 0;
int colorIndex = 0;
this.world = arena.getWorld();
Cuboid floor = ((Arena) arena).getCurrentGame().getComponent(FloorComponent.class).getFloor();
for (Block block : floor.getBlocks()) {
if (block.getRelative(BlockFace.UP).getType() == Material.AIR.parseMaterial()) {
spawnableSlimeLocations.add(block.getRelative(BlockFace.UP).getLocation());
}
}
runTaskTimer(plugin, 1L, 1L);
for (Player player : arena.getPlayers()) {
tails.put(player, new SnakeNode(player, null, DyeColor.values()[colorIndex++ % DyeColor.values().length]));
headBits.put(player, new LinkedList<>());
for (int i = 0; i <= 3; i++) {
addTailPart(player);
}
}
}
@Override
public void stopFeature() {
tails.clear();
headBits.clear();
cancel();
}
private void addTailPart(Player player) {
SnakeNode snakeNode = tails.get(player);
Sheep sheep = world.spawn(snakeNode.entity.getLocation(), Sheep.class);
sheep.setColor(snakeNode.color);
Utils.setAiEnabled(sheep, false);
tails.put(player, new SnakeNode(sheep, snakeNode, snakeNode.color));
if (headBits.get(player).size() < 5) {
headBits.get(player).add(sheep.getEntityId());
}
}
@EventHandler
public void onPlayerOut(PlayerStateChangeEvent event) {
if (event.getPlayerState() != PlayerStateChangeEvent.PlayerState.SPECTATOR) {
return;
}
SnakeNode tailPart = tails.remove(event.getPlayer());
headBits.remove(event.getPlayer());
while (tailPart != null) {
if (!(tailPart.entity instanceof Player)) {
tailPart.entity.remove();
}
tailPart = tailPart.next;
}
}
@Override
public void run() {
// move
for (Player player : arena.getPlayers()) {
if (ticks % 3 != 0) {SnakeNode snakeNode = tails.get(player);
while (snakeNode.next != null) {
Sheep sheep = (Sheep) snakeNode.entity;
sheep.teleport(snakeNode.next.entity.getLocation());
snakeNode = snakeNode.next;
}
}
player.setVelocity(player.getLocation().getDirection().setY(0).normalize().multiply(0.4));
}
ticks++;
if (ticks < 40 || ticks % 3 != 0) {
return;
}
// check collisions
for (Player player : arena.getPlayers()) {
List<Integer> snakeHead = headBits.get(player);
for (Entity nearbyEntity : player.getNearbyEntities(0.5, 0.5, 0.5)) {
if (snakeHead.contains(nearbyEntity.getEntityId())) {
continue;
}
if (nearbyEntity.getType() == EntityType.SHEEP) {
//((Sheep)nearbyEntity).setBaby();
combatManager.killPlayer(player, false);
}
if (nearbyEntity.getType() == EntityType.SLIME) {
nearbyEntity.remove();
addTailPart(player);
Sounds.ENTITY_GENERIC_EAT.play(player, 10, 1);
}
}
}
// 3% chance of spawning a slime randomly every 3 ticks
// ~18% chance per second
// We expect a slime spawning every 100 ticks, around every 5 seconds
if (Utils.random(100) > 96) {
Location randomLocation = Utils.getRandomElementFromList(spawnableSlimeLocations);
Slime slime = world.spawn(randomLocation, Slime.class);
slime.setSize(1);
Utils.setAiEnabled(slime, false);
}
}
private static class SnakeNode {
private final Entity entity;
private final DyeColor color;
private final SnakeNode next;
private SnakeNode(Entity entity, SnakeNode next, DyeColor color) {
this.entity = entity;
this.next = next;
this.color = color;
}
}
} | 5,903 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Snake.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/games/snake/Snake.java | package me.patothebest.arcade.game.games.snake;
import com.google.inject.Inject;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.game.commands.BasicGameSetupCommands;
import me.patothebest.arcade.game.commands.GameCommand;
import me.patothebest.arcade.game.commands.SpawnsCommand;
import me.patothebest.arcade.game.components.floor.FloorCommand;
import me.patothebest.arcade.game.components.floor.FloorComponent;
import me.patothebest.arcade.game.goal.Goal;
import me.patothebest.arcade.game.goal.LastAliveGoal;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.feature.features.other.DeathMessageFeature;
import me.patothebest.gamecore.feature.features.protection.NoBorderTrespassingFeature;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.DeathSpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.permission.Permission;
import org.bukkit.command.CommandSender;
public class Snake extends Game {
private final Goal goal = new LastAliveGoal();
@Inject private Snake(Arcade plugin) {
super(plugin);
gameComponents.add(new FloorComponent());
}
@Override
public void configure() {
registerFeature(DeathMessageFeature.class);
registerFeature(NoBorderTrespassingFeature.class);
registerFeature(DeathSpectatorFeature.class);
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
registerFeature(PlayerProtectionFeature.class);
registerFeature(SnakeFeature.class);
}
@Override
public String getName() {
return "Snake";
}
@Override
public Goal getGoal() {
return goal;
}
@Override
public GameType getGameType() {
return GameType.SNAKE;
}
@ChildOf(GameCommand.class)
public static class Command implements ParentCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Command(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@me.patothebest.gamecore.command.Command(
aliases = "snake",
langDescription = @LangDescription(
langClass = CoreLang.class,
element = "SETUP_COMMAND_DESCRIPTION"
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(value = {
SpawnsCommand.class,
BasicGameSetupCommands.class,
FloorCommand.class
},
defaultToBody = true
)
public void splegg(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
}
| 3,671 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SpleggFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/games/splegg/SpleggFeature.java | package me.patothebest.arcade.game.games.splegg;
import me.patothebest.gamecore.feature.AbstractFeature;
import me.patothebest.gamecore.itemstack.ItemStackBuilder;
import me.patothebest.gamecore.itemstack.Material;
import org.bukkit.ChatColor;
import org.bukkit.Sound;
import org.bukkit.block.Block;
import org.bukkit.entity.Egg;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.ProjectileHitEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.BlockIterator;
import org.bukkit.util.Vector;
public class SpleggFeature extends AbstractFeature {
private static final ItemStack SPLEGG_ITEM = new ItemStackBuilder().material(Material.IRON_SHOVEL).name(ChatColor.GREEN + "Splegger").lore(ChatColor.GREEN + "Click derecho para disparar huevos");
@Override
public void initializeFeature() {
super.initializeFeature();
for (Player player : getArena().getPlayers()) {
player.getInventory().setItem(0, SPLEGG_ITEM);
}
}
@EventHandler
public void onRightClick(PlayerInteractEvent event) {
Player cur = event.getPlayer();
final Vector offset = cur.getLocation().getDirection();
if (offset.getY() < 0.0) {
offset.setY(0);
}
final Egg egg = cur.getWorld().spawn(cur.getLocation().add(0.0, 0.5, 0.0).add(offset), Egg.class);
egg.setVelocity(cur.getLocation().getDirection().add(new Vector(0.0, 0.2, 0.0)));
egg.setShooter(cur);
cur.getWorld().playSound(cur.getLocation(), Sound.ENTITY_CHICKEN_EGG, 0.5f, 1.0f);
}
@EventHandler
public void onEggLand(ProjectileHitEvent event) {
if(!(event.getEntity().getShooter() instanceof Player)) {
return;
}
Player player = (Player) event.getEntity().getShooter();
if (!isPlayingInArena(player)) {
return;
}
Block hitBlock = null;
BlockIterator blockIterator = new BlockIterator(event.getEntity().getLocation().getWorld(), event.getEntity().getLocation().toVector(), event.getEntity().getVelocity().normalize(), 0.0D, 4);
while (blockIterator.hasNext()) {
hitBlock = blockIterator.next();
if (hitBlock.getType() != Material.AIR.parseMaterial()) {
break;
}
}
event.getEntity().remove();
if (hitBlock == null || hitBlock.getType() == Material.AIR.parseMaterial()) {
return;
}
// hitBlock.getWorld().playEffect(hitBlock.getLocation(), Effect.STEP_SOUND, hitBlock.getTypeId());
hitBlock.setType(Material.AIR.parseMaterial());
}
} | 2,731 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Splegg.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/games/splegg/Splegg.java | package me.patothebest.arcade.game.games.splegg;
import com.google.inject.Inject;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.game.commands.BasicGameSetupCommands;
import me.patothebest.arcade.game.commands.GameCommand;
import me.patothebest.arcade.game.commands.SpawnsCommand;
import me.patothebest.arcade.game.goal.Goal;
import me.patothebest.arcade.game.goal.LastAliveGoal;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.feature.features.other.DeathMessageFeature;
import me.patothebest.gamecore.feature.features.protection.NoBorderTrespassingFeature;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.DeathSpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.permission.Permission;
import org.bukkit.command.CommandSender;
public class Splegg extends Game {
private final Goal goal = new LastAliveGoal();
@Inject private Splegg(Arcade plugin) {
super(plugin);
}
@Override
public void configure() {
registerFeature(DeathMessageFeature.class);
registerFeature(NoBorderTrespassingFeature.class);
registerFeature(DeathSpectatorFeature.class);
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
registerFeature(PlayerProtectionFeature.class);
registerFeature(SpleggFeature.class);
}
@Override
public String getName() {
return "Splegg";
}
@Override
public Goal getGoal() {
return goal;
}
@Override
public GameType getGameType() {
return GameType.SPLEGG;
}
@ChildOf(GameCommand.class)
public static class Command implements ParentCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Command(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@me.patothebest.gamecore.command.Command(
aliases = "splegg",
langDescription = @LangDescription(
langClass = CoreLang.class,
element = "SETUP_COMMAND_DESCRIPTION"
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(value = {
SpawnsCommand.class,
BasicGameSetupCommands.class,
},
defaultToBody = true
)
public void splegg(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
}
| 3,461 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
OITCFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/games/oitc/OITCFeature.java | package me.patothebest.arcade.game.games.oitc;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.combat.CombatManager;
import me.patothebest.gamecore.feature.AbstractFeature;
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.Arrow;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
public class OITCFeature extends AbstractFeature {
private final static ItemStack BOW = new ItemStackBuilder().material(Material.BOW).name(ChatColor.YELLOW + "OITC Bow").lore(ChatColor.WHITE + "One hit kill");
private final static ItemStack ARROW = new ItemStackBuilder().material(Material.ARROW).name(ChatColor.YELLOW + "OITC Arrow");
private final static ItemStack SWORD = new ItemStackBuilder().material(Material.IRON_SWORD);
private final PlayerManager playerManager;
private final CombatManager combatManager;
private Game game;
private int spawnIndex = 0;
private int maxSpawns = 0;
@Inject private OITCFeature(PlayerManager playerManager, CombatManager combatManager) {
this.playerManager = playerManager;
this.combatManager = combatManager;
}
@Override
public void initializeFeature() {
super.initializeFeature();
this.game = ((Arena)arena).getCurrentGame();
for (Player player : arena.getPlayers()) {
player.getInventory().setItem(0, BOW);
player.getInventory().setItem(1, SWORD);
player.getInventory().setItem(8, ARROW);
}
maxSpawns = game.getSpawns().size();
spawnIndex = arena.getPlayers().size();
}
@EventHandler(priority = EventPriority.HIGH)
public void onArrowDamage(EntityDamageByEntityEvent event) {
if (!(event.getDamager() instanceof Arrow) || !(event.getEntity() instanceof Player)) {
return;
}
Player damaged = (Player) event.getEntity();
Arrow damager = (Arrow) event.getDamager();
if (!(damager.getShooter() instanceof Player)) {
return;
}
Player damageSource = (Player) damager.getShooter();
if (!isPlayingInArena(damaged) || !isPlayingInArena(damageSource)) {
return;
}
giveArrow(damageSource);
event.setCancelled(false);
event.setDamage(Integer.MAX_VALUE);
}
@EventHandler
public void onDeath(CombatDeathEvent event) {
if (!isPlayingInArena(event)) {
return;
}
Player player = event.getPlayer();
event.setCancelled(true);
event.getDrops().clear();
playerManager.getPlayer(player).getPlayerInventory().clearPlayer();
player.getInventory().setItem(0, BOW);
player.getInventory().setItem(1, SWORD);
player.getInventory().setItem(8, ARROW);
player.teleport(game.getSpawns().get(spawnIndex++ % maxSpawns));
if (event.getKillerPlayer() != null) {
giveArrow(event.getKillerPlayer());
}
}
private void giveArrow(Player player) {
if (player.getInventory().contains(Material.ARROW.parseItem())) {
player.getInventory().addItem(ARROW);
} else {
player.getInventory().setItem(8, ARROW);
}
}
} | 3,669 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
OneInTheChamber.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/games/oitc/OneInTheChamber.java | package me.patothebest.arcade.game.games.oitc;
import com.google.inject.Inject;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.game.commands.BasicGameSetupCommands;
import me.patothebest.arcade.game.commands.GameCommand;
import me.patothebest.arcade.game.commands.SpawnsCommand;
import me.patothebest.arcade.game.goal.Goal;
import me.patothebest.arcade.game.goal.KillGoal;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.feature.features.other.DeathMessageFeature;
import me.patothebest.gamecore.feature.features.protection.NoBorderTrespassingFeature;
import me.patothebest.gamecore.feature.features.protection.NoFallDamage;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.permission.Permission;
import org.bukkit.command.CommandSender;
public class OneInTheChamber extends Game {
private final Goal goal = new KillGoal(6);
@Inject private OneInTheChamber(Arcade plugin) {
super(plugin);
}
@Override
public void configure() {
registerFeature(DeathMessageFeature.class);
registerFeature(NoBorderTrespassingFeature.class);
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
registerFeature(NoFallDamage.class);
registerFeature(OITCFeature.class);
}
@Override
public String getName() {
return "OITC";
}
@Override
public Goal getGoal() {
return goal;
}
@Override
public GameType getGameType() {
return GameType.OITC;
}
@ChildOf(GameCommand.class)
public static class Command implements ParentCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Command(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@me.patothebest.gamecore.command.Command(
aliases = "oitc",
langDescription = @LangDescription(
langClass = CoreLang.class,
element = "SETUP_COMMAND_DESCRIPTION"
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(value = {
SpawnsCommand.class,
BasicGameSetupCommands.class,
},
defaultToBody = true
)
public void oitc(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
}
| 3,301 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TNTRunFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/games/tntrun/TNTRunFeature.java | package me.patothebest.arcade.game.games.tntrun;
import com.google.inject.Inject;
import me.patothebest.arcade.Arcade;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import me.patothebest.gamecore.itemstack.Material;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.Player;
import org.bukkit.util.NumberConversions;
import java.util.ArrayList;
import java.util.List;
public class TNTRunFeature extends AbstractRunnableFeature {
private final Arcade plugin;
private final static int MAX_TICKS = 6;
@SuppressWarnings("unchecked")
private final List<Block>[] blocks = new ArrayList[MAX_TICKS];
private int tick = 0;
@Inject private TNTRunFeature(Arcade plugin) {
this.plugin = plugin;
for (int i = 0; i < MAX_TICKS; i++) {
blocks[i] = new ArrayList<>();
}
}
@Override
public void initializeFeature() {
runTaskTimer(plugin, 0L, 1L);
}
@Override
public void stopFeature() {
for (List<Block> block : blocks) {
block.clear();
}
cancel();
}
@Override
public void run() {
for (Player player : arena.getPlayers()) {
Block blockBelow = getBlockBelow(player);
if (blockBelow != null) {
blocks[tick].add(blockBelow);
}
}
tick++;
tick%= MAX_TICKS;
for (Block block : blocks[tick]) {
if (block.getType() != Material.AIR.parseMaterial()) {
block.setType(Material.AIR.parseMaterial(), false);
block.getRelative(BlockFace.DOWN).setType(Material.AIR.parseMaterial(), false);
}
}
blocks[tick].clear();
}
private final static double[] OFFSETS = {0.3, -0.3};
private Block getBlockBelow(Player player) {
Location location = player.getLocation();
double x = location.getX();
double z = location.getZ();
int flooredX = NumberConversions.floor(x);
int flooredZ = NumberConversions.floor(z);
World world = player.getWorld();
double yBelow = player.getLocation().getY() - 0.0001;
Block block = new Location(world, x, yBelow, z).getBlock();
if (block.getType() != Material.AIR.parseMaterial()) {
return block;
}
for (double offsetX : OFFSETS) {
for (double offsetZ : OFFSETS) {
if (NumberConversions.floor(x + offsetX) != flooredX ||
NumberConversions.floor(z + offsetZ) != flooredZ) {
Block block2 = new Location(world, x + offsetX, yBelow, z + offsetZ).getBlock();
if (block2.getType() != Material.AIR.parseMaterial()) {
return block2;
}
}
}
}
return null;
}
} | 2,956 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TNTRun.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/games/tntrun/TNTRun.java | package me.patothebest.arcade.game.games.tntrun;
import com.google.inject.Inject;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.game.commands.BasicGameSetupCommands;
import me.patothebest.arcade.game.commands.GameCommand;
import me.patothebest.arcade.game.commands.SpawnsCommand;
import me.patothebest.arcade.game.goal.Goal;
import me.patothebest.arcade.game.goal.LastAliveGoal;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.feature.features.other.DeathMessageFeature;
import me.patothebest.gamecore.feature.features.protection.NoBorderTrespassingFeature;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.DeathSpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.permission.Permission;
import org.bukkit.command.CommandSender;
public class TNTRun extends Game {
private final Goal goal = new LastAliveGoal();
@Inject private TNTRun(Arcade plugin) {
super(plugin);
}
@Override
public void configure() {
registerFeature(DeathMessageFeature.class);
registerFeature(NoBorderTrespassingFeature.class);
registerFeature(DeathSpectatorFeature.class);
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
registerFeature(PlayerProtectionFeature.class);
registerFeature(TNTRunFeature.class);
}
@Override
public String getName() {
return "TNTRun";
}
@Override
public Goal getGoal() {
return goal;
}
@Override
public GameType getGameType() {
return GameType.TNTRUN;
}
@ChildOf(GameCommand.class)
public static class Command implements ParentCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Command(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@me.patothebest.gamecore.command.Command(
aliases = "tntrun",
langDescription = @LangDescription(
langClass = CoreLang.class,
element = "SETUP_COMMAND_DESCRIPTION"
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(value = {
SpawnsCommand.class,
BasicGameSetupCommands.class,
},
defaultToBody = true
)
public void tntrun(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
}
| 3,461 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Goal.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/goal/Goal.java | package me.patothebest.arcade.game.goal;
import me.patothebest.arcade.game.Game;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import java.util.LinkedList;
public interface Goal extends Listener {
LinkedList<Player> getPlacement();
void setGame(Game game);
void reset();
}
| 312 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
KillGoal.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/goal/KillGoal.java | package me.patothebest.arcade.game.goal;
import me.patothebest.arcade.arena.PointList;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import java.util.LinkedList;
public class KillGoal extends AbstractGoal implements PointGoal {
private final PointList kills = new PointList();
private final int maxKills;
public KillGoal(int maxKills) {
this.maxKills = maxKills;
}
@EventHandler
public void onCombatDeath(CombatDeathEvent event) {
if (event.getKillerPlayer() == null) {
return;
}
if (!kills.containsPlayer(event.getKillerPlayer())) {
kills.addPlayer(event.getKillerPlayer());
}
kills.addPoints(event.getKillerPlayer(), 1);
if (kills.getPoints(event.getKillerPlayer()) >= maxKills) {
arena.getGameStarCount().clear();
for (int i = 0; i < kills.size(); i++) {
Player player = kills.get(i).getPlayer();
arena.getStarCount().addPoints(player, (arena.getMaxPointsPerGame() - i));
arena.getGameStarCount().addPlayer(player);
arena.getGameStarCount().addPoints(player, (arena.getMaxPointsPerGame() - i));
}
arena.nextPhase();
}
}
@Override
public LinkedList<Player> getPlacement() {
return kills.getPlayersOrdered();
}
@Override
public void reset() {
kills.clear();
}
@Override
public int getPointsToWin() {
return maxKills;
}
@Override
public String getPointGoalName() {
return "Kills";
}
@Override
public PointList getPointList() {
return kills;
}
}
| 1,769 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AbstractGoal.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/goal/AbstractGoal.java | package me.patothebest.arcade.game.goal;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.arena.Arena;
public abstract class AbstractGoal implements Goal {
protected Arena arena;
protected Game game;
@Override
public void setGame(Game game) {
this.game = game;
this.arena = game.getArena();
}
}
| 355 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LastAliveGoal.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/goal/LastAliveGoal.java | package me.patothebest.arcade.game.goal;
import me.patothebest.gamecore.event.player.PlayerStateChangeEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import java.util.LinkedList;
public class LastAliveGoal extends AbstractGoal {
private final LinkedList<Player> places = new LinkedList<>();
@EventHandler
public void onPlayerOut(PlayerStateChangeEvent event) {
if (event.getPlayerState() != PlayerStateChangeEvent.PlayerState.SPECTATOR) {
return;
}
if (event.getArena() != arena) {
return;
}
places.add(0, event.getPlayer());
if (arena.getPlayers().size() > 1) {
return;
}
places.add(0, arena.getPlayers().iterator().next());
arena.getGameStarCount().clear();
for (int i = 0; i < places.size(); i++) {
Player player = places.get(i);
arena.getStarCount().addPoints(player, (arena.getMaxPointsPerGame() - i));
arena.getGameStarCount().addPlayer(player);
arena.getGameStarCount().addPoints(player, (arena.getMaxPointsPerGame() - i));
}
arena.nextPhase();
}
@Override
public LinkedList<Player> getPlacement() {
return places;
}
@Override
public void reset() {
places.clear();
}
}
| 1,355 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointGoal.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/goal/PointGoal.java | package me.patothebest.arcade.game.goal;
import me.patothebest.arcade.arena.PointList;
public interface PointGoal extends Goal {
int getPointsToWin();
String getPointGoalName();
PointList getPointList();
}
| 224 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArcadeScoreboardType.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/scoreboard/ArcadeScoreboardType.java | package me.patothebest.arcade.game.scoreboard;
import me.patothebest.gamecore.scoreboard.ScoreboardType;
public enum ArcadeScoreboardType implements ScoreboardType {
STAR_SUMMARY("star-summary"),
LAST_ALIVE("last-alive-game"),
POINTS_GOAL("points-game"),
;
private boolean enabled;
private final String configName;
ArcadeScoreboardType(String configName) {
this.configName = configName;
}
@Override
public boolean isEnabled() {
return enabled;
}
@Override
public String getConfigName() {
return configName;
}
@Override
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
}
| 699 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArcadeScoreboardManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/scoreboard/ArcadeScoreboardManager.java | package me.patothebest.arcade.game.scoreboard;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.game.helpers.EndGamePhase;
import me.patothebest.arcade.game.helpers.IntroduceGamePhase;
import me.patothebest.gamecore.event.EventRegistry;
import me.patothebest.gamecore.event.arena.ArenaPhaseChangeEvent;
import me.patothebest.gamecore.event.player.ArenaLeaveEvent;
import me.patothebest.gamecore.event.player.GameJoinEvent;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.gamecore.modules.ModuleName;
import me.patothebest.gamecore.modules.ReloadableModule;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.pluginhooks.PluginHookManager;
import me.patothebest.gamecore.pluginhooks.hooks.FeatherBoardHook;
import me.patothebest.gamecore.scoreboard.CustomScoreboard;
import me.patothebest.gamecore.scoreboard.ScoreboardFile;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
@Singleton
@ModuleName("Arcade Scoreboard Manager")
public class ArcadeScoreboardManager implements Listener, ActivableModule, ReloadableModule {
private final Arcade plugin;
private final ScoreboardFile scoreboardFile;
private final PlayerManager playerManager;
private final PluginHookManager pluginHookManager;
private final EventRegistry eventRegistry;
@Inject private ArcadeScoreboardManager(Arcade plugin, ScoreboardFile scoreboardFile, PlayerManager playerManager, PluginHookManager pluginHookManager, EventRegistry eventRegistry) {
this.plugin = plugin;
this.scoreboardFile = scoreboardFile;
this.playerManager = playerManager;
this.pluginHookManager = pluginHookManager;
this.eventRegistry = eventRegistry;
}
@Override
public void onPreEnable() {
for (ArcadeScoreboardType scoreboardType : ArcadeScoreboardType.values()) {
scoreboardType.setEnabled(scoreboardFile.getBoolean(scoreboardType.getConfigName() + ".enabled"));
}
}
@Override
public void onPostEnable() {
if(pluginHookManager.isHookLoaded(FeatherBoardHook.class)) {
return;
}
eventRegistry.registerListener(this);
}
@EventHandler
public void onJoinGame(GameJoinEvent event) {
for (ArcadeScoreboardType scoreboardType : ArcadeScoreboardType.values()) {
playerManager.getPlayer(event.getPlayer()).getScoreboards().put(scoreboardType,
new CustomScoreboard(plugin,
event.getPlayer().getPlayer(),
scoreboardType.name(),
scoreboardFile.getConfigurationSection(scoreboardType.getConfigName())));
}
}
@EventHandler
public void onPhaseChange(ArenaPhaseChangeEvent event) {
if (event.getNewPhase() instanceof IntroduceGamePhase) {
GameType gameType = ((IntroduceGamePhase) event.getNewPhase()).getGame().getGameType();
for (Player player : event.getArena().getPlayers()) {
playerManager.getPlayer(player).show(gameType.getScoreboardType());
}
for (Player player : event.getArena().getSpectators()) {
playerManager.getPlayer(player).show(gameType.getScoreboardType());
}
}
if (event.getNewPhase() instanceof EndGamePhase) {
for (Player player : event.getArena().getPlayers()) {
playerManager.getPlayer(player).show(ArcadeScoreboardType.STAR_SUMMARY);
}
for (Player player : event.getArena().getSpectators()) {
playerManager.getPlayer(player).show(ArcadeScoreboardType.STAR_SUMMARY);
}
}
}
@EventHandler
public void onLeaveArena(ArenaLeaveEvent event) {
IPlayer player = playerManager.getPlayer(event.getPlayer());
for (ArcadeScoreboardType value : ArcadeScoreboardType.values()) {
if (player.getScoreboards().containsKey(value)) {
player.getScoreboards().remove(value).destroy();
}
}
}
@Override
public void onReload() {
onPreEnable();
onPostEnable();
}
@Override
public String getReloadName() {
return "arcade-board";
}
}
| 4,504 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArcadeTeamAssignPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/helpers/ArcadeTeamAssignPhase.java | package me.patothebest.arcade.game.helpers;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.event.player.GameJoinEvent;
import me.patothebest.gamecore.event.player.PlayerStateChangeEvent;
import me.patothebest.gamecore.phase.phases.TeamAssignPhase;
import org.bukkit.entity.Player;
public class ArcadeTeamAssignPhase extends TeamAssignPhase {
@Inject private ArcadeTeamAssignPhase(CorePlugin plugin) {
super(plugin);
}
@Override
public void start() {
for (Player player : arena.getPlayers()) {
((Arena)arena).getStarCount().addPlayer(player);
callJoinEvent(player);
}
((Arena)arena).setMaxPointsPerGame(arena.getPlayers().size());
super.start();
}
protected void callJoinEvent(Player player) {
plugin.getServer().getPluginManager().callEvent(new GameJoinEvent(player, arena));
plugin.getServer().getPluginManager().callEvent(new PlayerStateChangeEvent(player, arena, PlayerStateChangeEvent.PlayerState.PLAYER));
}
}
| 1,131 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EndGamePhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/helpers/EndGamePhase.java | package me.patothebest.arcade.game.helpers;
import com.google.inject.Inject;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.arena.PointList;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.feature.features.other.LimitedTimePhaseFeature;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
public class EndGamePhase extends AbstractPhase<Arcade, Arena> implements GamePhase {
private Game game;
@Inject private EndGamePhase(Arcade plugin) {
super(plugin);
}
public void setGame(Game game) {
this.game = game;
}
@Override
public void configure() {
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
registerFeature(PlayerProtectionFeature.class);
registerFeature(IntroduceGameFeature.class);
LimitedTimePhaseFeature limitedTimePhaseFeature = registerFeature(LimitedTimePhaseFeature.class);
limitedTimePhaseFeature.setTimeUntilNextStage(5);
}
@Override
public void start() {
super.start();
for (Player player : arena.getPlayers()) {
sendEndGame(player);
}
for (Player player : arena.getSpectators()) {
sendEndGame(player);
}
}
private void sendEndGame(Player player) {
Utils.sendCenteredMessage(player, CoreLang.LINE_SEPARATOR.getMessage(player));
player.sendMessage("");
Utils.sendCenteredMessage(player, ChatColor.WHITE.toString() + ChatColor.BOLD + game.getName());
player.sendMessage("");
for (int i = 0; i < arena.getGameStarCount().size(); i++) {
PointList.Entry entry = arena.getGameStarCount().get(i);
player.sendMessage(" " + ChatColor.WHITE + (i + 1) + ". " + ChatColor.GREEN + (entry.getPlayer() == player ? ChatColor.BOLD : "") + entry.getPlayer().getName() + " " + entry.getPoints() + "⭑");
}
player.sendMessage("");
Utils.sendCenteredMessage(player, CoreLang.LINE_SEPARATOR.getMessage(player));
}
@Override
public ArenaState getArenaState() {
return ArenaState.IN_GAME;
}
@Override
public Game getGame() {
return game;
}
}
| 2,725 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
CelebrationFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/helpers/CelebrationFeature.java | package me.patothebest.arcade.game.helpers;
import com.google.inject.Inject;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.arena.PointList;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Firework;
import org.bukkit.entity.Player;
import org.bukkit.inventory.meta.FireworkMeta;
public class CelebrationFeature extends AbstractRunnableFeature {
private final CorePlugin plugin;
private int stage;
@Inject private CelebrationFeature(CorePlugin plugin) {
this.plugin = plugin;
}
@Override
public void run() {
if(stage == 11) {
cancel();
return;
}
PointList pointList = ((Arena)arena).getStarCount();
for (int i = 0; i < 3 && i < pointList.size(); i++) {
Player player = pointList.get(i).getPlayer();
Firework firework = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
FireworkMeta fireworkMeta = firework.getFireworkMeta();
fireworkMeta.addEffect(Utils.getRandomEffect());
firework.setFireworkMeta(fireworkMeta);
}
stage++;
}
@Override
public void initializeFeature() {
stage = 0;
runTaskTimer(plugin, 0L, 10L);
for (Player player : arena.getPlayers()) {
player.setAllowFlight(true);
player.setFlying(true);
}
}
}
| 1,581 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EndArenaPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/helpers/EndArenaPhase.java | package me.patothebest.arcade.game.helpers;
import com.google.inject.Inject;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.arena.PointList;
import me.patothebest.arcade.lang.Lang;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.feature.features.other.LimitedTimePhaseFeature;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
public class EndArenaPhase extends AbstractPhase<Arcade, Arena> {
private final static Lang[] PLACE_MESSAGES = {Lang.FIRST_PLACE, Lang.SECOND_PLACE, Lang.THIRD_PLACE};
@Inject private EndArenaPhase(Arcade plugin) {
super(plugin);
}
@Override
public void configure() {
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
registerFeature(PlayerProtectionFeature.class);
registerFeature(CelebrationFeature.class);
LimitedTimePhaseFeature limitedTimePhaseFeature = registerFeature(LimitedTimePhaseFeature.class);
limitedTimePhaseFeature.setTimeUntilNextStage(5);
}
@Override
public void start() {
super.start();
arena.revivePlayers();
for (Player player : arena.getPlayers()) {
sendEndGame(player);
}
for (Player player : arena.getSpectators()) {
sendEndGame(player);
}
}
private void sendEndGame(Player player) {
player.teleport(arena.getLobbyLocation());
Utils.sendCenteredMessage(player, CoreLang.LINE_SEPARATOR.getMessage(player));
Utils.sendCenteredMessage(player, ChatColor.WHITE.toString() + ChatColor.BOLD + PluginConfig.GAME_TITLE);
player.sendMessage("");
for (int i = 0; i < 3 && i < arena.getStarCount().size(); i++) {
PointList.Entry entry = arena.getStarCount().get(i);
PLACE_MESSAGES[i].replaceAndSend(player, entry.getPlayer().getName(), entry.getPoints());
}
player.sendMessage("");
Utils.sendCenteredMessage(player, CoreLang.LINE_SEPARATOR.getMessage(player));
}
@Override
public ArenaState getArenaState() {
return ArenaState.IN_GAME;
}
}
| 2,647 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
IntroduceGamePhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/helpers/IntroduceGamePhase.java | package me.patothebest.arcade.game.helpers;
import com.google.inject.Inject;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.feature.features.protection.PlayerProtectionFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
public class IntroduceGamePhase extends AbstractPhase<Arcade, Arena> implements GamePhase {
private Game game;
@Inject private IntroduceGamePhase(Arcade plugin) {
super(plugin);
}
public void setGame(Game game) {
this.game = game;
}
@Override
public void configure() {
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
registerFeature(PlayerProtectionFeature.class);
registerFeature(IntroduceGameFeature.class);
}
@Override
public void start() {
super.start();
arena.revivePlayers();
int i = 0;
int n = game.getSpawns().size();
for (Player player : arena.getPlayers()) {
introduceGame(player);
player.getInventory().clear();
player.teleport(game.getSpawns().get(i++ % n));
}
for (Player player : arena.getSpectators()) {
introduceGame(player);
player.getInventory().clear();
player.teleport(game.getSpectatorLocation());
}
}
private void introduceGame(Player player) {
Utils.sendCenteredMessage(player, CoreLang.LINE_SEPARATOR.getMessage(player));
player.sendMessage("");
Utils.sendCenteredMessage(player, ChatColor.WHITE.toString() + ChatColor.BOLD + game.getName());
// player.sendMessage("");
// player.sendMessage("");
// player.sendMessage("");
// player.sendMessage("");
// player.sendMessage("");
player.sendMessage("");
Utils.sendCenteredMessage(player, CoreLang.LINE_SEPARATOR.getMessage(player));
}
@Override
public ArenaState getArenaState() {
return ArenaState.IN_GAME;
}
@Override
public Game getGame() {
return game;
}
}
| 2,554 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GamePhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/helpers/GamePhase.java | package me.patothebest.arcade.game.helpers;
import me.patothebest.arcade.game.Game;
public interface GamePhase {
Game getGame();
}
| 139 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
IntroduceGameFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/helpers/IntroduceGameFeature.java | package me.patothebest.arcade.game.helpers;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import me.patothebest.gamecore.util.Sounds;
import javax.inject.Inject;
public class IntroduceGameFeature extends AbstractRunnableFeature {
private final CorePlugin plugin;
private int time = 5;
@Inject public IntroduceGameFeature(CorePlugin plugin) {
this.plugin = plugin;
}
@Override
public void run() {
time--;
if(time == 0) {
arena.nextPhase();
cancel();
return;
}
arena.getPlayers().forEach(player -> {
player.setLevel(time);
Sounds.UI_BUTTON_CLICK.play(player);
});
}
@Override
public void initializeFeature() {
time = 5;
runTaskTimer(plugin, 0L, 20L);
}
}
| 888 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SpawnsCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/commands/SpawnsCommand.java | package me.patothebest.arcade.game.commands;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.lang.Lang;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.chat.Pagination;
import me.patothebest.gamecore.command.ChatColor;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.ArenaLocation;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.List;
@Singleton
public class SpawnsCommand extends AbstractGameCommand {
@Inject
private SpawnsCommand(ArenaManager arenaManager) {
super(arenaManager);
}
// public static class Parent implements Module {
//
// private final CommandsManager<CommandSender> commandsManager;
//
// @Inject
// private Parent(CommandsManager<CommandSender> commandsManager) {
// this.commandsManager = commandsManager;
// }
//
// @Command(
// aliases = {"spawns"},
// langDescription = @LangDescription(
// element = "SPAWNS_DESC",
// langClass = Lang.class
// )
// )
// @CommandPermissions(permission = Permission.SETUP)
// @NestedCommand(value = SpawnsCommand.class)
// public void spawns(CommandContext args, CommandSender sender) throws CommandException {
// new CommandPagination(commandsManager, "spawns", "spawns", args).display(sender);
// }
// }
@Command(
aliases = {"add", "addspawn"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "ADD_SPAWN",
langClass = Lang.class
)
)
public List<String> addSpawn(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
return completeArena(args);
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
Game game = getGame(args, arena);
game.getSpawns().add(new ArenaLocation(arena, player.getLocation()));
player.sendMessage(Lang.SPAWN_ADDED.replace(player, game.getSpawns().size()));
return null;
}
@Command(
aliases = {"remove", "delete"},
usage = "<arena> <id>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "REMOVE_SPAWN",
langClass = Lang.class
)
)
public List<String> removeSpawn(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
return completeArena(args);
}
Game game = getGame(args);
int index = args.getInteger(1);
CommandUtils.validateTrue(index <= game.getSpawns().size() && index > 0, CoreLang.OUT_OF_BOUNDS);
game.getSpawns().remove(index-1);
Lang.SPAWN_REMOVED.replaceAndSend(player, index);
return null;
}
@Command(
aliases = {"list", "ls"},
usage = "<arena> [page]",
min = 1,
max = 2,
langDescription = @LangDescription(
element = "LIST_SPAWN",
langClass = Lang.class
)
)
public List<String> listSpawns(CommandContext args, CommandSender sender) throws CommandException {
CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
return completeArena(args);
}
Game game = getGame(args);
int page = args.getInteger(1, 1);
new Pagination<ArenaLocation>() {
@Override
protected String title() {
return "Spawns for " + game.getName();
}
@Override
protected String entry(ArenaLocation entry, int index, CommandSender commandSender) {
return ChatColor.GRAY + "* " + ChatColor.GOLD.toString() + (index+1) + ". " + ChatColor.BLUE + "Spawn "
+ ChatColor.YELLOW + " Location: " + Utils.locationToCoords(entry, sender);
}
}.display(sender, game.getSpawns(), page);
return null;
}
@Command(
aliases = {"clear", "cl"},
usage = "<arena>",
min = 1,
langDescription = @LangDescription(
element = "CLEAR_SPAWNS",
langClass = Lang.class
)
)
public List<String> clearSpawns(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
return completeArena(args);
}
Game game = getGame(args);
game.getSpawns().clear();
Lang.CLEARED_SPAWNS.sendMessage(player);
return null;
}
}
| 5,527 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
BasicGameSetupCommands.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/commands/BasicGameSetupCommands.java | package me.patothebest.arcade.game.commands;
import com.google.inject.Inject;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.lang.Lang;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.selection.Selection;
import me.patothebest.gamecore.selection.SelectionManager;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.vector.ArenaLocation;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Provider;
import java.util.List;
public class BasicGameSetupCommands extends AbstractGameCommand {
private final Provider<SelectionManager> selectionManagerProvider;
@Inject private BasicGameSetupCommands(ArenaManager arenaManager, Provider<SelectionManager> selectionManagerProvider) {
super(arenaManager);
this.selectionManagerProvider = selectionManagerProvider;
}
@Command(
aliases = {"enable"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "ENABLE_GAME",
langClass = Lang.class
)
)
public List<String> enable(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
return completeArena(args);
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
String gameName = args.getWholeArgs()[args.getLevel() - 1];
GameType gameType = GameType.getGameTypeFromCommand(gameName);
Game game;
if (arena.getGames().containsKey(gameType)) {
game = arena.getGames().get(gameType);
} else {
game = arena.createGame(gameType);
}
game.setEnabled(true);
player.sendMessage(Lang.ENABLED_GAME.replace(player, game.getName(), arena.getName()));
return null;
}
@Command(
aliases = {"disable"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "DISABLE_GAME",
langClass = Lang.class
)
)
public List<String> disable(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
return completeArena(args);
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
Game game = getGame(args, arena);
game.setEnabled(false);
player.sendMessage(Lang.DISABLED_GAME.replace(player, game.getName(), arena.getName()));
return null;
}
@Command(
aliases = {"setspec", "setspectator"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "SET_SPECTATOR_LOCATION",
langClass = CoreLang.class
)
)
public List<String> setSpectatorLocation(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
Game game = getGame(args, arena);
// set the lobby location of the arena
game.setSpectatorLocation(new ArenaLocation(arena, player.getLocation()));
player.sendMessage(CoreLang.SPECTATOR_LOCATION_SET.getMessage(player));
arena.save();
return null;
}
@Command(
aliases = {"teleport", "tp"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "TELEPORT_TO_GAME",
langClass = Lang.class
)
)
public List<String> teleport(CommandContext args, CommandSender sender) throws CommandException {
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Player player = CommandUtils.getPlayer(sender);
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
Game game = getGame(args, arena);
CommandUtils.validateTrue(!game.getSpawns().isEmpty(), Lang.NO_SPAWNS);
player.teleport(game.getSpawns().get(0));
player.sendMessage(Lang.TELEPORTED_TO_GAME.getMessage(player));
return null;
}
@Command(
aliases = {"setarea", "setgamearea"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "SET_GAME_AREA",
langClass = Lang.class
)
)
public List<String> setArenaArea(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
Game game = getGame(args, arena);
Selection selection = selectionManagerProvider.get().getSelection(player);
CommandUtils.validateTrue(selection != null && selection.arePointsSet(), CoreLang.SELECT_AN_AREA);
// set the arena area
game.setArea(selection.toCubiod(arena.getName(), arena));
player.sendMessage(Lang.GAME_AREA_SET.getMessage(player));
arena.save();
return null;
}
}
| 6,525 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/commands/GameCommand.java | package me.patothebest.arcade.game.commands;
import com.google.inject.Inject;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.RegisteredCommandModule;
import me.patothebest.gamecore.permission.Permission;
import org.bukkit.command.CommandSender;
public class GameCommand implements RegisteredCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private GameCommand(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@Command(
aliases = "games",
langDescription = @LangDescription(
langClass = CoreLang.class,
element = "COMMAND_DESC"
)
)
@NestedCommand(defaultToBody = true)
@CommandPermissions(permission = Permission.SETUP)
public void games(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
} | 1,458 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AbstractGameCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/commands/AbstractGameCommand.java | package me.patothebest.arcade.game.commands;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.game.Game;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.util.CommandUtils;
import java.util.List;
public abstract class AbstractGameCommand {
protected final ArenaManager arenaManager;
protected AbstractGameCommand(ArenaManager arenaManager) {
this.arenaManager = arenaManager;
}
protected List<String> completeArena(CommandContext args) {
assert args.getSuggestionContext() != null;
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
protected Game getGame(CommandContext args) throws CommandException {
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
return getGame(args, arena);
}
protected Game getGame(CommandContext args, Arena arena) throws CommandException {
String gameName = args.getWholeArgs()[args.getLevel() - 1];
GameType gameType = GameType.getGameTypeFromCommand(gameName);
CommandUtils.validateNotNull(gameType, "Game type does not exist");
CommandUtils.validateTrue(arena.getGames().containsKey(gameType), "That game is not enabled for this arena! Type /arcade games " + gameName + " enable");
return arena.getGames().get(gameType);
}
}
| 1,608 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameComponent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/components/GameComponent.java | package me.patothebest.arcade.game.components;
import me.patothebest.arcade.game.Game;
import me.patothebest.gamecore.util.SerializableObject;
import org.bukkit.command.CommandSender;
import java.util.Map;
public interface GameComponent extends SerializableObject {
void parse(Game game, Map<String, Object> data);
boolean canBeEnabled(CommandSender commandSender);
}
| 381 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
FloorComponent.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/components/floor/FloorComponent.java | package me.patothebest.arcade.game.components.floor;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.components.GameComponent;
import me.patothebest.gamecore.vector.Cuboid;
import org.bukkit.command.CommandSender;
import java.util.Map;
public class FloorComponent implements GameComponent {
private Cuboid floor;
@Override
public void parse(Game game, Map<String, Object> data) {
if (data.containsKey("floor")) {
floor = new Cuboid((Map<String, Object>) data.get("floor"), game.getArena());
}
}
@Override
public boolean canBeEnabled(CommandSender commandSender) {
return floor != null;
}
@Override
public void serialize(Map<String, Object> data) {
if (floor != null) {
data.put("floor", floor.serialize());
}
}
public Cuboid getFloor() {
return floor;
}
public void setFloor(Cuboid floor) {
this.floor = floor;
}
}
| 986 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
FloorCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/game/components/floor/FloorCommand.java | package me.patothebest.arcade.game.components.floor;
import com.google.inject.Inject;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.commands.AbstractGameCommand;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.lang.Lang;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.selection.Selection;
import me.patothebest.gamecore.selection.SelectionManager;
import me.patothebest.gamecore.util.CommandUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Provider;
import java.util.List;
public class FloorCommand extends AbstractGameCommand {
private final Provider<SelectionManager> selectionManagerProvider;
@Inject private FloorCommand(ArenaManager arenaManager, Provider<SelectionManager> selectionManagerProvider) {
super(arenaManager);
this.selectionManagerProvider = selectionManagerProvider;
}
@Command(
aliases = "setfloor",
langDescription = @LangDescription(
langClass = CoreLang.class,
element = "SET_FLOOR"
)
)
public List<String> setFloor(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
Game game = getGame(args, arena);
Selection selection = selectionManagerProvider.get().getSelection(player);
CommandUtils.validateTrue(selection != null && selection.arePointsSet(), CoreLang.SELECT_AN_AREA);
// set the arena area
game.getComponent(FloorComponent.class).setFloor(selection.toCubiod(arena.getName(), arena));
player.sendMessage(Lang.FLOOR_SET.getMessage(player));
arena.save();
return null;
}
}
| 2,385 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Config.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/config/Config.java | package me.patothebest.arcade.config;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.arcade.Arcade;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.modules.ActivableModule;
@Singleton
public class Config extends CoreConfig implements ActivableModule {
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
@Inject private Config(Arcade plugin) {
super(plugin, "config");
this.header = "Arcade Configuration";
load();
}
// -------------------------------------------- //
// ON ENABLE
// -------------------------------------------- //
@Override
public void onEnable() {
readConfig();
}
// -------------------------------------------- //
// CACHE
// -------------------------------------------- //
@Override
public void readConfig() {
super.readConfig();
}
} | 1,012 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeamSetupCommands.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/commands/TeamSetupCommands.java | package me.patothebest.arcade.commands;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.arena.ArenaType;
import me.patothebest.arcade.lang.Lang;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.DyeColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import java.util.List;
public class TeamSetupCommands {
private final ArenaManager arenaManager;
@Inject private TeamSetupCommands(ArenaManager arenaManager) {
this.arenaManager = arenaManager;
}
@ChildOf(SetupCommand.class)
public static class Parent implements ParentCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Parent(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@Command(
aliases = "teams",
langDescription = @LangDescription(
element = "TEAMS_COMMAND_DESCRIPTION",
langClass = CoreLang.class
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(
value = TeamSetupCommands.class,
defaultToBody = true
)
public void teams(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
@Command(
aliases = {"create", "add", "new"},
usage = "<arena> <team name> <team color>",
min = 3,
max = 3,
langDescription = @LangDescription(
element = "NEW_TEAM",
langClass = CoreLang.class
)
)
public List<String> addGameTeam(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
switch(args.getSuggestionContext().getIndex()) {
case 0:
return CommandUtils.complete(args.getString(0), arenaManager);
case 2:
return CommandUtils.complete(args.getString(2), DyeColor.values());
default:
return null;
}
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.TEAM, Lang.ARENA_MUST_BE_TEAM);
DyeColor dyeColor = Utils.getEnumValueFromString(DyeColor.class, args.getString(2));
CommandUtils.validateNotNull(dyeColor, CoreLang.TEAM_COLOR_NOT_FOUND);
CommandUtils.validateTrue(!arena.containsTeam(args.getString(0)), CoreLang.TEAM_COLOR_ALREADY_EXIST);
// create and add the game team
arena.createTeam(args.getString(1), dyeColor);
player.sendMessage(CoreLang.TEAM_CREATED.getMessage(player));
arena.save();
return null;
}
@Command(
aliases = {"setspawn", "setteamspawn"},
usage = "<arena> <team name>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "NEW_TEAM_SPAWN",
langClass = CoreLang.class
)
)
public List<String> setTeamSpawn(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
switch(args.getSuggestionContext().getIndex()) {
case 0:
return CommandUtils.complete(args.getString(0), arenaManager);
case 1:
return CommandUtils.completeNameable(args.getString(1), CommandUtils.getDisabledArena(args, 0, arenaManager).getTeams().values());
default:
return null;
}
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.TEAM, Lang.ARENA_MUST_BE_TEAM);
AbstractGameTeam gameTeam = CommandUtils.getTeam(arena, args, 1);
gameTeam.setSpawn(player.getLocation());
player.sendMessage(CoreLang.TEAM_SPAWN_SET.getMessage(player));
arena.save();
return null;
}
}
| 5,313 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArcadeCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/commands/ArcadeCommand.java | package me.patothebest.arcade.commands;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.arcade.Arcade;
import me.patothebest.arcade.lang.Lang;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.BaseCommand;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.commands.DebugCommand;
import me.patothebest.gamecore.commands.admin.AdminCommand;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.commands.user.ArenaUserCommands;
import me.patothebest.gamecore.commands.user.LocaleCommand;
import me.patothebest.gamecore.modules.RegisteredCommandModule;
import org.bukkit.command.CommandSender;
@Singleton
public class ArcadeCommand implements RegisteredCommandModule, BaseCommand {
private final Arcade plugin;
@Inject private ArcadeCommand(Arcade plugin) {
this.plugin = plugin;
}
@Command(
aliases = {"arcade", "sw"},
langDescription = @LangDescription(
element = "COMMAND_DESC",
langClass = Lang.class
)
)
@NestedCommand(
defaultToBody = true,
value = {
ArenaUserCommands.class,
LocaleCommand.class,
SetupCommand.class,
DebugCommand.class,
AdminCommand.class,
}
)
public void skyWars(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(plugin.getCommandManager().getCommandManager(), args).showAdminInFooter(true).display(sender);
}
}
| 1,918 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SetupArenaCommands.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/commands/SetupArenaCommands.java | package me.patothebest.arcade.commands;
import me.patothebest.arcade.arena.Arena;
import me.patothebest.arcade.arena.ArenaType;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.Location;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import java.io.File;
@ChildOf(SetupCommand.class)
public class SetupArenaCommands implements ParentCommandModule {
private final ArenaManager arenaManager;
@Inject private SetupArenaCommands(ArenaManager arenaManager) {
this.arenaManager = arenaManager;
}
@Command(
aliases = {"createarena", "newarena"},
usage = "<arena> <mode>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "NEW_ARENA",
langClass = CoreLang.class
)
)
public void createArena(CommandContext args, CommandSender sender) throws CommandException {
String arenaName = args.getString(0);
ArenaType arenaType = Utils.getEnumValueFromString(ArenaType.class, args.getString(1));
// requirements
CommandUtils.validateTrue(arenaManager.getArena(arenaName) == null, CoreLang.ARENA_ALREADY_EXIST);
// create the arena
Arena arena = (Arena) arenaManager.createArena(arenaName);
arena.setArenaType(arenaType);
arena.initializePhase();
CoreLang.ARENA_CREATED.sendMessage(sender);
if(sender instanceof Player) {
Player player = CommandUtils.getPlayer(sender);
player.teleport(new Location(arena.getWorld(), 0, 100, 0));
}
}
@Command(
aliases = {"import", "importarena"},
usage = "<arena> <mode>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "IMPORT_ARENA",
langClass = CoreLang.class
)
)
public void importArena(CommandContext args, CommandSender sender) throws CommandException {
String arenaName = args.getString(0);
ArenaType arenaType = Utils.getEnumValueFromString(ArenaType.class, args.getString(1));
// requirements
CommandUtils.validateTrue(arenaManager.getArena(arenaName) == null, CoreLang.ARENA_ALREADY_EXIST);
File worldFolder = new File(arenaName + File.separatorChar);
CommandUtils.validateTrue(worldFolder.exists(), CoreLang.FOLDER_DOESNT_EXIST);
CommandUtils.validateTrue(worldFolder.isDirectory(), CoreLang.ARENA_IS_FILE);
CommandUtils.validateTrue(worldFolder.renameTo(new File(PluginConfig.WORLD_PREFIX + arenaName + File.separatorChar)), CoreLang.SOMETHING_WENT_WRONG_IMPORTING);
// requirements
CommandUtils.validateTrue(arenaManager.getArena(arenaName) == null, CoreLang.ARENA_ALREADY_EXIST);
// create the arena
Arena arena = (Arena) arenaManager.createArena(arenaName);
arena.setArenaType(arenaType);
arena.initializePhase();
CoreLang.ARENA_IMPORTED.sendMessage(sender);
if(sender instanceof Player) {
Player player = CommandUtils.getPlayer(sender);
player.teleport(new Location(arena.getWorld(), 0, 100, 0));
}
}
} | 3,871 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LocaleManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/lang/LocaleManager.java | package me.patothebest.arcade.lang;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.arcade.Arcade;
import me.patothebest.gamecore.lang.CoreLocaleManager;
import me.patothebest.gamecore.modules.Module;
@Singleton
public class LocaleManager extends CoreLocaleManager implements Module {
@Inject private LocaleManager(Arcade plugin) {
super(plugin, Lang.values());
}
} | 427 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Lang.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/lang/Lang.java | package me.patothebest.arcade.lang;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.lang.CommentType;
import me.patothebest.gamecore.lang.CoreComments;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.lang.CoreLocaleManager;
import me.patothebest.gamecore.lang.LangComment;
import me.patothebest.gamecore.lang.Locale;
import me.patothebest.gamecore.lang.interfaces.IComment;
import me.patothebest.gamecore.lang.interfaces.ILang;
import org.bukkit.ChatColor;
import java.util.HashMap;
import java.util.Map;
public enum Lang implements ILang {
// -----------------------------------
// General Messages
// -----------------------------------
HEADER(CommentType.HEADER, "Arcade Messages"),
GENERAL(CommentType.SUBHEADER_NOT_SPACED, "General Messages"),
COMMAND_DESC("Command for general arcade commands"),
// -------------------------------------------- //
// Setup messages
// -------------------------------------------- //
SETUP(CommentType.HEADER, "Setup messages"),
SETUP_COMMAND_DESCRIPTIONS(CommentType.SUBHEADER_NOT_SPACED, "Command descriptions"),
ADD_SPAWN("Adds a spawn to a game"),
REMOVE_SPAWN("Removes a spawn from a game"),
LIST_SPAWN("List all the spawns from a game"),
CLEAR_SPAWNS("Clears all the spawns from a game"),
ENABLE_GAME("Enables a game for the arena"),
DISABLE_GAME("Disables a game for the arena"),
TELEPORT_TO_GAME("Teleports to the game's spawn"),
SET_GAME_AREA("Sets the game area"),
SET_FLOOR("Sets the game's floor"),
SETUP_SUCCESSFUL_MESSAGES(CommentType.SUBHEADER_SPACED, "Successful messages"),
CLEARED_SPAWNS(true, "&cCleared all spawns"),
ADD_STOP_SPAWNS(true, "&aStopped adding spawns"),
SPAWN_ADDED(true, "&aSpawn %id% added", "id"),
SPAWN_REMOVED(true, "&7Spawn %id% removed", "id"),
ENABLED_GAME(true, "&6%game% &aenabled for arena %6%arena%", "game", "arena"),
DISABLED_GAME(true, "&6%game% &aenabled for arena %6%arena%", "game", "arena"),
TELEPORTED_TO_GAME(true, "&aYou have been teleported to the game."),
GAME_AREA_SET(true, "&aGame's area has been set!"),
FLOOR_SET(true, "&aGame's floor has been set!"),
SETUP_ERRORS(CommentType.SUBHEADER_SPACED, "Error messages"),
ARENA_MUST_BE_SOLO(true, "&cArena must be solo arena"),
ARENA_MUST_BE_TEAM(true, "&cArena must be team arena"),
SETUP_ERROR_SET_AREA("&cMissing area! Use &e/%base_command% setup setarenaarea &cto set it"),
SETUP_ERROR_LOBBY_LOCATION("&cMissing lobby location! Use &e/games setup %game% setlobby"),
SETUP_ERROR_SPECTATOR_LOCATION("&cMissing spectator location! Use &e/games %game% setspec"),
SETUP_ERROR_SPAWN("&cMissing at least 1 spawn! Use &e/games %game% addspawn"),
SETUP_ERROR_FLOOR("&cMissing floor! Use &e/games %game% setfloor"),
NO_SPAWNS("There are no spawns set for the game."),
FIRST_PLACE("&e1st Place &7- &7%winner% &7- %stars% &e⭑", "winner", "stars"),
SECOND_PLACE("&62nd Place &7- &7%winner% &7- %stars% &e⭑", "winner", "stars"),
THIRD_PLACE("&c3rd Place &7- &7%winner% &7- %stars% &e⭑", "winner", "stars"),
;
private String defaultMessage;
private Map<Locale, String> message;
private Map<Locale, String> rawMessage;
private boolean prefix;
private IComment comment;
private String[] arguments;
Lang(CoreComments CoreComments) {
this.comment = CoreComments;
}
Lang(CommentType commentType, String title) {
this.comment = new LangComment(commentType, title);
}
Lang(String defaultMessage, String... arguments) {
this(false, defaultMessage, arguments);
}
Lang(boolean prefix, String defaultMessage, String... arguments) {
this.defaultMessage = defaultMessage;
this.prefix = prefix;
this.message = new HashMap<>();
this.rawMessage = new HashMap<>();
this.arguments = arguments;
setMessage(CoreLocaleManager.getLocale("en"), defaultMessage);
}
@Override
public String getMessage(Locale locale) {
return (prefix ? CoreLang.PREFIX.getMessage(locale) : "") + message.get(locale);
}
@Override
public String getRawMessage(Locale locale) {
return rawMessage.get(locale);
}
@Override
public void setMessage(Locale locale, String message) {
this.message.put(locale, ChatColor.translateAlternateColorCodes('&', message).replace("%newline%", "\n").replace("%plugin_prefix%", PluginConfig.LANG_PREFIX).replace("%game_title%", PluginConfig.GAME_TITLE));
this.rawMessage.put(locale, message);
}
public void transferMessage(Lang lang) {
message = lang.message;
rawMessage = lang.rawMessage;
}
@Override
public String getDefaultMessage() {
return defaultMessage;
}
@Override
public boolean isComment() {
return comment != null;
}
@Override
public IComment getComment() {
return comment;
}
@Override
public String[] getArguments() {
return arguments;
}
} | 5,120 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameTeam.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/arena/GameTeam.java | package me.patothebest.arcade.arena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import org.bukkit.DyeColor;
import java.util.Map;
public class GameTeam extends AbstractGameTeam {
public GameTeam(Arena arena, String name, DyeColor color) {
super(arena, name, color);
}
public GameTeam(Arena arena, Map<String, Object> data) {
super(arena, data);
}
@Override
public Map<String, Object> serialize() {
return super.serialize();
}
@Override
public String toString() {
return "GameTeam{" +
"arena=" + arena.getName() +
", players=" + players +
", name='" + name + '\'' +
", color=" + color +
", teamChatPrefix=" + teamChatPrefix +
", spawn=" + spawn +
'}';
}
}
| 858 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PointList.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/arena/PointList.java | package me.patothebest.arcade.arena;
import org.bukkit.entity.Player;
import javax.annotation.Nonnull;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
public class PointList extends AbstractList<PointList.Entry> {
private final ArrayList<Entry> internalList = new ArrayList<>();
public void sort() {
internalList.sort((o1, o2) -> Integer.compare(o2.points, o1.points));
}
public boolean containsPlayer(Player player) {
for (Entry entry : internalList) {
if (entry.player == player) {
return true;
}
}
return false;
}
@Override
public Entry get(int index) {
return internalList.get(index);
}
@Override
public int size() {
return internalList.size();
}
public void addPlayer(Player player) {
internalList.add(new Entry(player));
sort();
}
@Override
public void clear() {
internalList.clear();
}
public void addPoints(Player player, int points) {
for (Entry entry : internalList) {
if (entry.player == player) {
entry.points += points;
return;
}
}
throw new IllegalArgumentException(player.getName() + " is not on the list!");
}
public int getPoints(Player player) {
for (Entry entry : internalList) {
if (entry.player == player) {
return entry.points;
}
}
return -1;
}
public int getPosition(Player player) {
for (int i = 0; i < internalList.size(); i++) {
if (internalList.get(i).player == player) {
return i;
}
}
return -1;
}
public LinkedList<Player> getPlayersOrdered() {
LinkedList<Player> linkedList = new LinkedList<>();
for (Entry entry : internalList) {
linkedList.add(entry.getPlayer());
}
return linkedList;
}
@Override
@Nonnull
public Iterator<Entry> iterator() {
return internalList.iterator();
}
public static class Entry {
private final Player player;
private int points;
private Entry(Player player) {
this.player = player;
this.points = 0;
}
public int getPoints() {
return points;
}
public Player getPlayer() {
return player;
}
}
}
| 2,543 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/arena/ArenaModule.java | package me.patothebest.arcade.arena;
import com.google.inject.assistedinject.FactoryModuleBuilder;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.game.commands.GameCommand;
import me.patothebest.arcade.game.scoreboard.ArcadeScoreboardManager;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaFactory;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
public class ArenaModule extends AbstractBukkitModule<CorePlugin> {
public ArenaModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
install(new FactoryModuleBuilder().implement(AbstractArena.class, Arena.class).build(ArenaFactory.class));
registerModule(ArenaManager.class);
registerModule(GameCommand.class);
for (GameType value : GameType.values()) {
registerModule(value.getCommandClass());
}
registerModule(ArcadeScoreboardManager.class);
}
}
| 1,102 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Arena.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/arena/Arena.java | package me.patothebest.arcade.arena;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Provider;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.arcade.game.Game;
import me.patothebest.arcade.game.GameType;
import me.patothebest.arcade.game.helpers.ArcadeTeamAssignPhase;
import me.patothebest.arcade.game.helpers.EndArenaPhase;
import me.patothebest.arcade.game.helpers.EndGamePhase;
import me.patothebest.arcade.game.helpers.GamePhase;
import me.patothebest.arcade.game.helpers.IntroduceGamePhase;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaGroup;
import me.patothebest.gamecore.event.player.PlayerStateChangeEvent;
import me.patothebest.gamecore.event.player.SpectateEvent;
import me.patothebest.gamecore.phase.Phase;
import me.patothebest.gamecore.phase.phases.EndPhase;
import me.patothebest.gamecore.phase.phases.LobbyPhase;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.gamecore.vector.Cuboid;
import org.apache.commons.lang.Validate;
import org.bukkit.DyeColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
public class Arena extends AbstractArena {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private ArenaType arenaType = ArenaType.SOLO;
private final List<Player> inGameSpectators = new CopyOnWriteArrayList<>();
private final Map<GameType, Game> games = new HashMap<>();
private final LinkedList<Game> playingGames = new LinkedList<>();
private final PointList starCount = new PointList();
private final PointList gameStarCount = new PointList();
private int maxPointsPerGame = 0;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
@Inject private Arena(@Assisted("name") String name, @Assisted("worldName") String worldName, Provider<Injector> injector) {
super(name, worldName, injector.get());
needsSpectatorLocation = false;
needsArenaArea = false;
arenaGroup = ArenaGroup.DEFAULT_GROUP;
}
@SuppressWarnings("unchecked")
@Override
protected void parseData(Map<String, Object> map) {
super.parseData(map);
arenaGroup = ArenaGroup.DEFAULT_GROUP;
this.arenaType = Utils.getEnumValueFromString(ArenaType.class, (String) map.get("arenatype"));
if(map.containsKey("games")) {
List<Map<String, Object>> games = (List<Map<String, Object>>) map.get("games");
games.forEach(gameMap -> {
GameType gameType = GameType.getGameType((String) gameMap.get("type"));
if(gameType == null) {
Utils.printError("Unknown game type " + gameMap.get("type"));
return;
}
Game game = createGame(gameType);
game.parse(gameMap);
});
}
}
@Override
public void initializePhase() {
if(arenaType == null) {
return;
}
currentPhase = firstPhase = null;
LobbyPhase lobbyPhase = addPhase(LobbyPhase.class);
addPhase(ArcadeTeamAssignPhase.class);
playingGames.clear();
for (Game game : games.values()) {
game.setNextPhase(null);
if (!game.isEnabled()) {
continue;
}
IntroduceGamePhase phase = createPhase(IntroduceGamePhase.class);
phase.setGame(game);
addPhase(phase);
game.configure();
addPhase(game);
EndGamePhase endGame = createPhase(EndGamePhase.class);
endGame.setGame(game);
addPhase(endGame);
playingGames.add(game);
}
Phase previousPhase = firstPhase;
while (previousPhase.getNextPhase().getNextPhase() != null) {
previousPhase = previousPhase.getNextPhase();
}
previousPhase.setNextPhase(null);
EndArenaPhase endPhase = createPhase(EndArenaPhase.class);
previousPhase.setNextPhase(endPhase);
addPhase(EndPhase.class);
teams.clear();
teamPreferences.clear();
createTeam("Players", DyeColor.YELLOW).setTeamChatPrefix(false);
}
public void revivePlayers() {
for (Player player : inGameSpectators) {
IPlayer corePlayer = getPlayerManager().getPlayer(player);
// clear inventory
corePlayer.getPlayerInventory().clearPlayer();
players.add(player);
spectators.remove(player);
inGameSpectators.remove(player);
plugin.getServer().getPluginManager().callEvent(new PlayerStateChangeEvent(player, this, PlayerStateChangeEvent.PlayerState.PLAYER));
ghostFactory.removePlayer(player);
}
}
@Override
public void checkWin() {
}
@Override
public void endArena(boolean regen) {
super.endArena(regen);
starCount.clear();
gameStarCount.clear();
for (Game playingGame : playingGames) {
playingGame.getGoal().reset();
}
}
// -------------------------------------------- //
// SAVING
// -------------------------------------------- //
@Override
public boolean canArenaBeEnabled(CommandSender commandSender) {
boolean canBeEnabled = super.canArenaBeEnabled(commandSender);
boolean atLeastOneGame = false;
for (Game game : games.values()) {
if (game.isEnabled()) {
atLeastOneGame = true;
canBeEnabled &= game.canArenaBeEnabled(commandSender);
}
}
return canBeEnabled & atLeastOneGame;
}
@Override
public Map<String, Object> serialize() {
Map<String, Object> dataMap = super.serialize();
dataMap.put("arenatype", arenaType.name());
dataMap.put("games", serializeGames());
return dataMap;
}
@Override
protected List<Map<String, Object>> serializeTeams() {
return arenaType == ArenaType.SOLO ? null : super.serializeTeams();
}
private List<Map<String, Object>> serializeGames() {
List<Map<String, Object>> serializedGames = new ArrayList<>();
games.values().forEach(game -> serializedGames.add(game.serialize()));
return serializedGames;
}
// -------------------------------------------- //
// TEAMS
// -------------------------------------------- //
@Override
public GameTeam createTeam(String name, DyeColor color) {
Validate.isTrue(!teams.containsKey(name), "Team already exists!");
GameTeam gameTeam = new GameTeam(this, name, color);
addTeam(gameTeam);
return gameTeam;
}
@Override
public GameTeam createTeam(Map<String, Object> data) {
return new GameTeam(this, data);
}
@Override
public int getMinimumRequiredPlayers() {
return 2;
}
@Override
public void enableArena() {
super.enableArena();
if (currentPhase != null) {
currentPhase.stop();
}
initializePhase();
currentPhase = firstPhase;
currentPhase.start();
}
@Override
public void removePlayer(Player player, boolean offline) {
inGameSpectators.remove(player);
super.removePlayer(player, offline);
}
@Override
public void changeToSpectator(Player player, boolean shouldTeleport) {
// NoBorderTrespassingFeature calls this method again, so we check if it isn't called twice
if(spectators.contains(player)) {
if(shouldTeleport) {
// teleport the player and give items
player.teleport(getSpectatorLocation());
}
return;
}
IPlayer corePlayer = getPlayerManager().getPlayer(player);
// clear inventory
corePlayer.getPlayerInventory().clearPlayer();
// set fly mode
player.setAllowFlight(true);
player.setFlying(true);
// remove the player from the arena
players.remove(player);
spectators.add(player);
inGameSpectators.add(player);
if(shouldTeleport) {
// teleport the player and give items
player.teleport(getSpectatorLocation());
}
ghostFactory.addPlayer(player);
plugin.getServer().getPluginManager().callEvent(new SpectateEvent(player, this));
plugin.getServer().getPluginManager().callEvent(new PlayerStateChangeEvent(player, this, PlayerStateChangeEvent.PlayerState.SPECTATOR));
}
// -------------------------------------------- //
// GETTERS AND SETTERS
// -------------------------------------------- //
@Override
public Cuboid getArea() {
if (currentPhase instanceof GamePhase) {
return ((GamePhase) currentPhase).getGame().getArea();
}
return super.getArea();
}
@Override
public ArenaLocation getSpectatorLocation() {
if (currentPhase instanceof GamePhase) {
return ((GamePhase) currentPhase).getGame().getSpectatorLocation();
}
return getLobbyLocation();
}
public int getGameIndex() {
if (currentPhase instanceof GamePhase) {
Game currentGame = ((GamePhase) currentPhase).getGame();
for (int i = 0; i < playingGames.size(); i++) {
if (playingGames.get(i) == currentGame) {
return i + 1;
}
}
return -1;
}
switch (getArenaState()) {
case WAITING:
case STARTING:
return 1;
case ENDING:
return playingGames.size();
case RESTARTING:
case IN_GAME:
case OTHER:
case ERROR:
return -1;
}
return -1;
}
public int getTotalGames() {
return playingGames.size();
}
public Game getCurrentGame() {
if (currentPhase instanceof GamePhase) {
return ((GamePhase) currentPhase).getGame();
}
return null;
}
public ArenaType getArenaType() {
return arenaType;
}
public void setArenaType(ArenaType arenaType) {
this.arenaType = arenaType;
}
@Override
public int getMaxPlayers() {
return super.getMaxPlayers();
}
public Map<GameType, Game> getGames() {
return games;
}
public Game createGame(GameType gameType) {
Game game = injector.getInstance(gameType.getGameClass());
game.setArena(this);
games.put(gameType, game);
return game;
}
public PointList getStarCount() {
return starCount;
}
public PointList getGameStarCount() {
return gameStarCount;
}
public int getTotalPlayers() {
return players.size() + inGameSpectators.size();
}
public int getMaxPointsPerGame() {
return maxPointsPerGame;
}
public void setMaxPointsPerGame(int maxPointsPerGame) {
this.maxPointsPerGame = maxPointsPerGame;
}
}
| 11,582 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArcadePlayer.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/Arcade/src/main/java/me/patothebest/arcade/player/ArcadePlayer.java | package me.patothebest.arcade.player;
import com.google.inject.Inject;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.lang.Locale;
import me.patothebest.gamecore.player.CorePlayer;
import me.patothebest.gamecore.scoreboard.ScoreboardFile;
public class ArcadePlayer extends CorePlayer {
@Inject private ArcadePlayer(ScoreboardFile scoreboardFile, @Assisted Locale defaultLocale) {
super(scoreboardFile, defaultLocale);
}
}
| 475 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HungerGamesModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/HungerGamesModule.java | package me.patothebest.hungergames;
import com.google.inject.Singleton;
import com.google.inject.assistedinject.FactoryModuleBuilder;
import com.google.inject.name.Names;
import me.patothebest.gamecore.feature.features.chests.refill.ChestRefillFeature;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import me.patothebest.gamecore.kit.Kit;
import me.patothebest.gamecore.kit.NullKit;
import me.patothebest.gamecore.player.CorePlayer;
import me.patothebest.gamecore.player.PlayerFactory;
import me.patothebest.hungergames.arena.ArenaModule;
import me.patothebest.hungergames.commands.ConvertCommands;
import me.patothebest.hungergames.commands.HungerGamesCommand;
import me.patothebest.hungergames.commands.MidChestsCommand;
import me.patothebest.hungergames.commands.SetupArenaCommands;
import me.patothebest.hungergames.commands.SpawnsCommand;
import me.patothebest.hungergames.commands.SupplyDropsCommand;
import me.patothebest.hungergames.commands.TeamSetupCommands;
import me.patothebest.hungergames.config.Config;
import me.patothebest.hungergames.feature.SupplyDropFeature;
import me.patothebest.hungergames.lang.LocaleManager;
import me.patothebest.hungergames.player.HungerGamesPlayer;
import me.patothebest.hungergames.stats.StatsModule;
import me.patothebest.hungergames.placeholder.HungerGamesPlaceholderModule;
public class HungerGamesModule extends AbstractBukkitModule<HungerGames> {
public HungerGamesModule(HungerGames plugin) {
super(plugin);
}
@Override
protected void configure() {
bind(HungerGames.class).toInstance(plugin);
install(new FactoryModuleBuilder().implement(CorePlayer.class, HungerGamesPlayer.class).build(PlayerFactory.class));
install(new ArenaModule(plugin));
install(new HungerGamesPlaceholderModule(plugin));
install(new StatsModule(plugin));
bind(CoreConfig.class).to(Config.class).in(Singleton.class);
plugin.registerModule(Config.class);
bind(Kit.class).annotatedWith(Names.named("DefaultKit")).to(NullKit.class);
registerModule(HungerGamesCommand.class);
registerModule(TeamSetupCommands.Parent.class);
registerModule(ConvertCommands.Parent.class);
registerModule(SetupArenaCommands.class);
registerModule(MidChestsCommand.class);
registerModule(MidChestsCommand.Parent.class);
registerModule(SpawnsCommand.class);
registerModule(SpawnsCommand.Parent.class);
registerModule(SupplyDropsCommand.class);
registerModule(SupplyDropsCommand.Parent.class);
registerModule(LocaleManager.class);
registerDynamicModule(ChestRefillFeature.class);
registerDynamicModule(SupplyDropFeature.class);
}
}
| 2,797 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HungerGames.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/HungerGames.java | package me.patothebest.hungergames;
import com.google.inject.Binder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.PluginInfo;
@PluginInfo(
pluginName = "HungerGames",
worldPrefix = "HG_",
pluginTitle = "HG",
langPrefix = "HG",
gameTitle = "HG",
placeholderPrefix = "hg",
permissionPrefix = "hg",
sqlPrefix = "hungergames",
baseCommand = "hg",
loggerPrefix = "HG",
// TODO: Change this when possible
resourceId = "",
header = " _ _ _____ \n" +
"| | | | | __ \\ \n" +
"| |_| |_ _ _ __ __ _ ___ _ __| | \\/ __ _ _ __ ___ ___ ___ \n" +
"| _ | | | | '_ \\ / _` |/ _ \\ '__| | __ / _` | '_ ` _ \\ / _ \\/ __|\n" +
"| | | | |_| | | | | (_| | __/ | | |_\\ \\ (_| | | | | | | __/\\__ \\\n" +
"\\_| |_/\\__,_|_| |_|\\__, |\\___|_| \\____/\\__,_|_| |_| |_|\\___||___/\n" +
" __/ | \n" +
" |___/ "
)
public class HungerGames extends CorePlugin {
@Override
public void configure(Binder binder) {
binder.install(new HungerGamesModule(this));
}
} | 1,443 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HungerGamesPlaceholderModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/placeholder/HungerGamesPlaceholderModule.java | package me.patothebest.hungergames.placeholder;
import com.google.inject.multibindings.Multibinder;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.hungergames.HungerGames;
import me.patothebest.hungergames.placeholder.placeholders.all.NextEventPlaceholder;
import me.patothebest.hungergames.placeholder.placeholders.all.TypePlaceholder;
import me.patothebest.hungergames.placeholder.placeholders.all.NextEventTimePlaceholder;
public class HungerGamesPlaceholderModule extends AbstractBukkitModule<HungerGames> {
public HungerGamesPlaceholderModule(HungerGames plugin) {
super(plugin);
}
@Override
protected void configure() {
Multibinder<PlaceHolder> placeholders = Multibinder.newSetBinder(binder(), PlaceHolder.class);
// Placeholders for players only
placeholders.addBinding().to(NextEventPlaceholder.class);
placeholders.addBinding().to(NextEventTimePlaceholder.class);
placeholders.addBinding().to(TypePlaceholder.class);
}
}
| 1,097 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TypePlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/placeholder/placeholders/all/TypePlaceholder.java | package me.patothebest.hungergames.placeholder.placeholders.all;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.hungergames.arena.Arena;
import org.bukkit.entity.Player;
import javax.inject.Inject;
public class TypePlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject public TypePlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "type";
}
@Override
public String replace(Player player, String args) {
return replace(playerManager.getPlayer(player).getCurrentArena());
}
@Override
public String replace(AbstractArena arena) {
return arena == null ? "None" : ((Arena)arena).getArenaType().getName();
}
}
| 946 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
NextEventPlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/placeholder/placeholders/all/NextEventPlaceholder.java | package me.patothebest.hungergames.placeholder.placeholders.all;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.hungergames.phase.HungerGamesPhase;
import org.bukkit.entity.Player;
import javax.inject.Inject;
public class NextEventPlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject public NextEventPlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "next_event";
}
@Override
public String replace(Player player, String args) {
return replace(playerManager.getPlayer(player).getCurrentArena());
}
@Override
public String replace(AbstractArena arena) {
return arena == null || arena.getPhase().getNextPhase() == null || !(arena.getPhase().getNextPhase() instanceof HungerGamesPhase) ? "None" : ((HungerGamesPhase) arena.getPhase().getNextPhase()).getPhaseType().getConfigName();
}
}
| 1,126 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
NextEventTimePlaceholder.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/placeholder/placeholders/all/NextEventTimePlaceholder.java | package me.patothebest.hungergames.placeholder.placeholders.all;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.feature.features.other.LimitedTimePhaseFeature;
import me.patothebest.gamecore.placeholder.PlaceHolder;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.Utils;
import org.bukkit.entity.Player;
import javax.inject.Inject;
public class NextEventTimePlaceholder implements PlaceHolder {
private final PlayerManager playerManager;
@Inject public NextEventTimePlaceholder(PlayerManager playerManager) {
this.playerManager = playerManager;
}
@Override
public String getPlaceholderName() {
return "next_event_countdown";
}
@Override
public String replace(Player player, String args) {
return replace(playerManager.getPlayer(player).getCurrentArena());
}
@Override
public String replace(AbstractArena arena) {
return arena == null || arena.getFeature(LimitedTimePhaseFeature.class) == null ? "None" : Utils.secondsToString(Math.max(0, arena.getFeature(LimitedTimePhaseFeature.class).getRemainingTime()));
}
}
| 1,177 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SupplyDropFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/feature/SupplyDropFeature.java | package me.patothebest.hungergames.feature;
import com.google.inject.Inject;
import fr.mrmicky.fastparticle.FastParticle;
import fr.mrmicky.fastparticle.ParticleType;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.feature.AbstractRunnableFeature;
import me.patothebest.gamecore.feature.features.chests.refill.ChestFile;
import me.patothebest.gamecore.feature.features.chests.refill.ChestType;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.modules.Module;
import me.patothebest.gamecore.util.Sounds;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ChestLocations;
import me.patothebest.hungergames.lang.Lang;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Chest;
import org.bukkit.entity.FallingBlock;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.Action;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.util.Vector;
import java.util.List;
public class SupplyDropFeature extends AbstractRunnableFeature implements Module {
private final static double STEP = Math.PI / 20;
private final static double TWO_PI = Math.PI * 2;
private final ChestFile supplyChestFile;
private final CorePlugin plugin;
private final int minAmount;
private final int maxAmount;
private boolean hasDropped = false;
private FallingBlock fallingBlock;
private double angle = 0;
private Vector velocity = new Vector(0, -0.2, 0);
private int ticks = 0;
private boolean landed = false;
private Location chestLocation;
@Inject private SupplyDropFeature(CorePlugin plugin, CoreConfig config) {
supplyChestFile = new ChestFile(plugin, ChestLocations.SUPPLY, ChestType.NORMAL);
this.plugin = plugin;
minAmount = config.getInt("supply-drops.min-items-amount", -1);
maxAmount = config.getInt("supply-drops.max-items-amount", -1);
}
@Override
public void run() {
if (!landed && fallingBlock.isDead()) {
cancel();
return;
}
Location location = landed ? chestLocation : fallingBlock.getLocation();
double offset = landed ? 0.5 : 0;
if (!landed) {
fallingBlock.setVelocity(velocity);
}
angle %= TWO_PI;
double x = Math.cos(angle) * 1.25;
double y = location.getY() + 0.75 + (Math.cos(angle) * 0.5);
double z = Math.sin(angle) * 1.25;
FastParticle.spawnParticle(location.getWorld(), ParticleType.FLAME, x + location.getX() + offset, y, z + location.getZ() + offset, 1, 0, 0, 0, 0);
FastParticle.spawnParticle(location.getWorld(), ParticleType.FLAME, -x + location.getX() + offset, y, -z + location.getZ() + offset, 1, 0, 0, 0, 0);
if (!landed && ticks % 2 == 0) {
if (ParticleType.CAMPFIRE_SIGNAL_SMOKE.isSupported()) {
FastParticle.spawnParticle(location.getWorld(), ParticleType.CAMPFIRE_SIGNAL_SMOKE, location.getX() + 0.5, y, location.getZ() + 0.5, 1, 0, 0, 0, 1);
}
}
if (!landed && ticks++ % 5 == 0) {
Sounds.ENTITY_FIREWORK_ROCKET_LAUNCH.play(location);
}
angle += STEP;
}
@EventHandler
public void onChestOpen(PlayerInteractEvent event) {
if (event.getAction() != Action.RIGHT_CLICK_BLOCK && event.getAction() != Action.LEFT_CLICK_BLOCK) {
return;
}
if (event.getClickedBlock().getType() != me.patothebest.gamecore.itemstack.Material.CHEST.parseMaterial()) {
return;
}
if (!isEventInArena(event)) {
return;
}
if (event.getClickedBlock().getLocation().equals(chestLocation)) {
cancel();
}
}
@EventHandler
public void onSupplyDropLand(EntityChangeBlockEvent event) {
if (!isEventInArena(event)) {
return;
}
if (!(event.getEntity() instanceof FallingBlock)) {
return;
}
FallingBlock fallingBlock = (FallingBlock) event.getEntity();
if (this.fallingBlock != fallingBlock) {
return;
}
event.setCancelled(true);
event.getBlock().setType(Material.CHEST);
Location location = fallingBlock.getLocation();
Inventory blockInventory = ((Chest) event.getBlock().getState()).getBlockInventory();
supplyChestFile.fill(blockInventory, minAmount, maxAmount);
Sounds.BLOCK_ANVIL_LAND.play(location);
FastParticle.spawnParticle(location.getWorld(), ParticleType.SMOKE_LARGE, location, 3, 0, 0, 0, 0);
fallingBlock.remove();
chestLocation = event.getBlock().getLocation();
landed = true;
}
@Override
public void initializeFeature() {
if (hasDropped) {
return;
}
hasDropped = true;
List<ArenaLocation> supplyDrops = ((Arena) arena).getSupplyDrops();
ArenaLocation location = Utils.getRandomElementFromList(supplyDrops);
if (location == null) {
return;
}
arena.sendMessageToArena(player -> Lang.SUPPLY_DROP_INCOMING.replace(player, location.getX() + ", " + location.getY() + ", " + location.getZ()));
arena.playSound(Sounds.BLOCK_NOTE_BLOCK_PLING);
Location add = location.clone().add(0.5, 100, 0.5);
fallingBlock = arena.getWorld().spawnFallingBlock(add, Material.NOTE_BLOCK, (byte) 0);
fallingBlock.setDropItem(false);
runTaskTimer(plugin, 0L, 1L);
}
@Override
public void stopFeature() {
super.stopFeature();
fallingBlock = null;
hasDropped = false;
landed = false;
chestLocation = null;
}
}
| 5,960 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HungerGamesArenaProtectionFeature.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/feature/HungerGamesArenaProtectionFeature.java | package me.patothebest.hungergames.feature;
import com.google.inject.Inject;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.feature.features.protection.GameProtectionFeature;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.player.PlayerManager;
import org.bukkit.block.Block;
import org.bukkit.event.Event;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
public class HungerGamesArenaProtectionFeature extends GameProtectionFeature {
private final Set<org.bukkit.Material> breakableBlocks = new HashSet<>();
@Inject protected HungerGamesArenaProtectionFeature(CoreConfig config, PlayerManager playerManager) {
super(playerManager);
List<Material> materials = new ArrayList<>();
List<String> breakableBlocksConfig = config.getStringList("breakable-blocks");
for (String materialName : breakableBlocksConfig) {
Optional<Material> optionalMaterial = Material.matchMaterial(materialName);
if (optionalMaterial.isPresent()) {
Material material = optionalMaterial.get();
if (!materials.contains(material)) {
materials.add(material);
}
}
}
for (Material material : materials) {
if (material.isSupported()) {
org.bukkit.Material bukkitMaterial = material.parseMaterial(false);
if (bukkitMaterial != null) {
breakableBlocks.add(bukkitMaterial);
}
}
}
}
@Override
protected boolean isBlockProtected(AbstractArena arena, Block block, Event event) {
if (super.isBlockProtected(arena, block, event)) {
return true;
}
if (!(event instanceof BlockBreakEvent) && !(event instanceof BlockPlaceEvent)) {
return false;
}
return !breakableBlocks.contains(block.getType());
}
}
| 2,197 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HungerGamesPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/HungerGamesPhase.java | package me.patothebest.hungergames.phase;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.phase.Phase;
import org.bukkit.configuration.ConfigurationSection;
public interface HungerGamesPhase<T extends AbstractArena> extends Phase<T> {
PhaseType getPhaseType();
void setTimeTilNextPhase(int time);
default void parseExtraData(ConfigurationSection phasesConfigurationSection) {}
}
| 432 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
PhaseType.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/PhaseType.java | package me.patothebest.hungergames.phase;
import me.patothebest.hungergames.phase.phases.EndHGPhase;
import me.patothebest.hungergames.phase.phases.RefillPhase;
import me.patothebest.hungergames.phase.phases.SupplyDropPhase;
import me.patothebest.hungergames.phase.phases.BorderShrinkPhase;
import me.patothebest.hungergames.phase.phases.DeathmatchPhase;
public enum PhaseType {
NONE("null", null),
REFILL("Refill", RefillPhase.class),
BORDER_SHRINK("Border Shrink", BorderShrinkPhase.class),
SUPPLY_DROP("Supply Drop", SupplyDropPhase.class),
DEATHMATCH("Deathmatch", DeathmatchPhase.class),
END("End", EndHGPhase.class),
;
private final String configName;
private final Class<? extends HungerGamesPhase> phaseClass;
PhaseType(String configName, Class<? extends HungerGamesPhase> phaseClass) {
this.configName = configName;
this.phaseClass = phaseClass;
}
public static PhaseType getPhaseType(String name) {
PhaseType phaseType = null;
for (PhaseType phaseType2 : PhaseType.values()) {
if(phaseType2.getConfigName().equalsIgnoreCase(name)) {
phaseType = phaseType2;
}
}
return phaseType;
}
/**
* Gets the configName
*
* @return the configName
*/
public String getConfigName() {
return configName;
}
/**
* Gets the phase class
*
* @return the phase class
*/
public Class<? extends HungerGamesPhase> getPhaseClass() {
return phaseClass;
}
}
| 1,571 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
AbstractHungerGamesPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/AbstractHungerGamesPhase.java | package me.patothebest.hungergames.phase;
import me.patothebest.gamecore.arena.ArenaState;
import me.patothebest.gamecore.event.arena.ArenaPrePhaseChangeEvent;
import me.patothebest.gamecore.feature.features.other.LimitedTimePhaseFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.phase.AbstractPhase;
import me.patothebest.gamecore.util.Sounds;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.HungerGames;
import me.patothebest.hungergames.phase.phases.BorderShrinkPhase;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.scheduler.BukkitTask;
public abstract class AbstractHungerGamesPhase extends AbstractPhase<HungerGames, Arena> implements HungerGamesPhase<Arena>, Listener {
private int phaseTime;
private BukkitTask bukkitTask;
public AbstractHungerGamesPhase(HungerGames plugin) {
super(plugin);
}
@Override
public void start() {
((LimitedTimePhaseFeature)getFeatures().get(LimitedTimePhaseFeature.class)).setTimeUntilNextStage(phaseTime);
super.start();
if (arena.getNextPhase() instanceof BorderShrinkPhase) {
bukkitTask = Bukkit.getScheduler().runTaskLater(plugin, () -> {
arena.sendMessageToArena(CoreLang.BORDER_SHRINK_SOON_CHAT::getMessage);
arena.sendTitleToArena((player, titleBuilder) -> {
titleBuilder.withTitle(CoreLang.BORDER_SHRINK_SOON_SUBTITLE.getMessage(player))
.withFadeInTime(1)
.withStayTime(2)
.withFadeOutTime(1);
});
arena.playSound(Sounds.BLOCK_NOTE_BLOCK_PLING);
}, (phaseTime - 30) * 20);
plugin.registerListener(this);
}
}
@Override
public void stop() {
super.stop();
if (bukkitTask != null) {
bukkitTask.cancel();
bukkitTask = null;
HandlerList.unregisterAll(this);
}
}
@EventHandler
public void onPhasePreChange(ArenaPrePhaseChangeEvent event) {
if (event.getArena() != arena) {
return;
}
if (bukkitTask != null) {
bukkitTask.cancel();
bukkitTask = null;
HandlerList.unregisterAll(this);
}
}
public void setTimeTilNextPhase(int phaseTime) {
this.phaseTime = phaseTime;
}
@Override
public ArenaState getArenaState() {
return ArenaState.IN_GAME;
}
}
| 2,638 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HungerGamesGameBasePhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/HungerGamesGameBasePhase.java | package me.patothebest.hungergames.phase;
import com.google.inject.Provider;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.feature.features.chests.refill.ChestRefillFeature;
import me.patothebest.gamecore.feature.features.other.CompassRadarFeature;
import me.patothebest.gamecore.feature.features.other.DeathMessageFeature;
import me.patothebest.gamecore.feature.features.other.InformationalFeature;
import me.patothebest.gamecore.feature.features.other.LimitedTimePhaseFeature;
import me.patothebest.gamecore.feature.features.other.PetsFeature;
import me.patothebest.gamecore.feature.features.other.ThrowTNTFeature;
import me.patothebest.gamecore.feature.features.protection.GameProtectionFeature;
import me.patothebest.gamecore.feature.features.protection.NoBorderTrespassingFeature;
import me.patothebest.gamecore.feature.features.protection.NoTeamDamageFeature;
import me.patothebest.gamecore.feature.features.spectator.DeathSpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorFeature;
import me.patothebest.gamecore.feature.features.spectator.SpectatorProtectionFeature;
import me.patothebest.gamecore.guis.UserGUIFactory;
import me.patothebest.gamecore.nms.NMS;
import me.patothebest.gamecore.phase.phases.GamePhase;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.sign.SignManager;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import me.patothebest.hungergames.feature.HungerGamesArenaProtectionFeature;
import javax.inject.Inject;
public class HungerGamesGameBasePhase extends GamePhase<CorePlugin, Arena> implements HungerGamesPhase<Arena> {
private int phaseTime;
@Inject private HungerGamesGameBasePhase(CorePlugin plugin, Provider<NMS> nmsProvider, PlayerManager playerManager, SignManager signManager, UserGUIFactory userGUIFactory) {
super(plugin, nmsProvider, signManager, playerManager, userGUIFactory);
}
@Override
public void configure() {
registerFeature(PetsFeature.class);
registerFeature(DeathMessageFeature.class);
registerFeature(NoBorderTrespassingFeature.class);
registerFeature(ChestRefillFeature.class);
registerFeature(DeathSpectatorFeature.class);
registerFeature(SpectatorProtectionFeature.class);
registerFeature(SpectatorFeature.class);
registerFeature(GameProtectionFeature.class);
registerFeature(LimitedTimePhaseFeature.class);
registerFeature(CompassRadarFeature.class);
registerFeature(InformationalFeature.class);
registerFeature(HungerGamesArenaProtectionFeature.class);
registerFeature(ThrowTNTFeature.class);
if(arena.getArenaType() == ArenaType.TEAM) {
registerFeature(NoTeamDamageFeature.class);
}
}
@Override
public void start() {
((LimitedTimePhaseFeature)getFeatures().get(LimitedTimePhaseFeature.class)).setTimeUntilNextStage(phaseTime);
super.start();
}
@Override
public PhaseType getPhaseType() {
return PhaseType.NONE;
}
/**
* Sets the phsae time
*/
@Override
public void setTimeTilNextPhase(int phsaeTime) {
this.phaseTime = phsaeTime;
}
} | 3,297 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
DeathmatchPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/phases/DeathmatchPhase.java | package me.patothebest.hungergames.phase.phases;
import com.google.inject.Inject;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.feature.features.protection.DeathmatchFeature;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.hungergames.HungerGames;
import me.patothebest.hungergames.phase.AbstractHungerGamesPhase;
import me.patothebest.hungergames.phase.PhaseType;
import org.bukkit.Location;
import org.bukkit.WorldBorder;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class DeathmatchPhase extends AbstractHungerGamesPhase {
@Inject private DeathmatchPhase(HungerGames plugin) {
super(plugin);
}
@Override
public void configure() {
setPreviousPhaseFeatures(true);
registerFeature(DeathmatchFeature.class);
}
@Override
public void start() {
List<ArenaLocation> spawnLocations;
if (arena.getTeams().size() > 1) {
spawnLocations = new ArrayList<>();
for (AbstractGameTeam value : arena.getTeams().values()) {
spawnLocations.add(value.getSpawn());
}
} else {
spawnLocations = arena.getSpawns();
}
Location centerLocation = arena.getCenterLocation();
if (arena.getTeams().size() > 1) {
for (AbstractGameTeam value : arena.getTeams().values()) {
for (Player player : value.getPlayers()) {
player.teleport(value.getSpawn().clone().add(0.5, 1, 0.5));
}
}
} else {
int spawnIndex = 0;
for (Player player : arena.getPlayers()) {
player.teleport(spawnLocations.get(spawnIndex++).clone().add(0.5, 1, 0.5));
}
}
ArenaLocation singleSpawn;
if (arena.getTeams().size() > 1) {
singleSpawn = arena.getTeams().values().iterator().next().getSpawn();
} else {
singleSpawn = arena.getSpawns().get(0);
}
double distance = centerLocation.distance(singleSpawn) + 3;
WorldBorder worldBorder = arena.getWorld().getWorldBorder();
worldBorder.setCenter(centerLocation);
worldBorder.setSize(distance*2);
worldBorder.setDamageAmount(2);
super.start();
}
@Override
public PhaseType getPhaseType() {
return PhaseType.DEATHMATCH;
}
} | 2,460 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SupplyDropPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/phases/SupplyDropPhase.java | package me.patothebest.hungergames.phase.phases;
import com.google.inject.Inject;
import me.patothebest.hungergames.HungerGames;
import me.patothebest.hungergames.feature.SupplyDropFeature;
import me.patothebest.hungergames.phase.AbstractHungerGamesPhase;
import me.patothebest.hungergames.phase.PhaseType;
public class SupplyDropPhase extends AbstractHungerGamesPhase {
@Inject private SupplyDropPhase(HungerGames plugin) {
super(plugin);
}
@Override
public void configure() {
setPreviousPhaseFeatures(true);
registerFeature(SupplyDropFeature.class);
}
@Override
public PhaseType getPhaseType() {
return PhaseType.SUPPLY_DROP;
}
} | 700 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
EndHGPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/phases/EndHGPhase.java | package me.patothebest.hungergames.phase.phases;
import com.google.inject.Inject;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.phase.phases.EndPhase;
import me.patothebest.hungergames.phase.HungerGamesPhase;
import me.patothebest.hungergames.phase.PhaseType;
public class EndHGPhase extends EndPhase implements HungerGamesPhase<AbstractArena> {
@Inject private EndHGPhase(CorePlugin plugin) {
super(plugin);
}
@Override
public PhaseType getPhaseType() {
return PhaseType.END;
}
@Override
public void setTimeTilNextPhase(int phsaeTime) {
}
}
| 675 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
RefillPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/phases/RefillPhase.java | package me.patothebest.hungergames.phase.phases;
import com.google.inject.Inject;
import me.patothebest.gamecore.feature.features.chests.refill.ChestRefillFeature;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.phase.phases.CagePhase;
import me.patothebest.gamecore.util.Sounds;
import me.patothebest.hungergames.phase.AbstractHungerGamesPhase;
import me.patothebest.hungergames.HungerGames;
import me.patothebest.hungergames.phase.PhaseType;
public class RefillPhase extends AbstractHungerGamesPhase {
@Inject private RefillPhase(HungerGames plugin) {
super(plugin);
}
@Override
public void configure() {
setPreviousPhaseFeatures(true);
}
@Override
public void start() {
arena.getFeature(ChestRefillFeature.class).refill();
if (!(arena.getPreviousPhase(this) instanceof CagePhase)) {
arena.playSound(Sounds.BLOCK_CHEST_OPEN);
arena.sendTitleToArena((player, titleBuilder) ->
titleBuilder.withFadeInTime(1)
.withStayTime(2)
.withFadeOutTime(1)
.withTitle(CoreLang.CHESTS_REFILLED.getMessage(player)));
}
super.start();
}
@Override
public PhaseType getPhaseType() {
return PhaseType.REFILL;
}
} | 1,333 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
BorderShrinkPhase.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/phase/phases/BorderShrinkPhase.java | package me.patothebest.hungergames.phase.phases;
import com.google.inject.Inject;
import me.patothebest.gamecore.feature.features.other.WorldBorderFeature;
import me.patothebest.hungergames.phase.AbstractHungerGamesPhase;
import me.patothebest.hungergames.phase.PhaseType;
import me.patothebest.hungergames.HungerGames;
import org.bukkit.configuration.ConfigurationSection;
public class BorderShrinkPhase extends AbstractHungerGamesPhase {
private int startSize;
private int endSize;
private int shrinkTime;
@Inject private BorderShrinkPhase(HungerGames plugin) {
super(plugin);
}
@Override
public void configure() {
setPreviousPhaseFeatures(true);
}
@Override
public void parseExtraData(ConfigurationSection phasesConfigurationSection) {
startSize = phasesConfigurationSection.getInt("start-size");
endSize = phasesConfigurationSection.getInt("end-size");
shrinkTime = phasesConfigurationSection.getInt("shrink-time");
}
@Override
public void start() {
WorldBorderFeature worldBorderFeature = registerFeature(WorldBorderFeature.class);
worldBorderFeature.setStartSize(startSize);
worldBorderFeature.setEndSize(endSize);
worldBorderFeature.setTimeToShrink(shrinkTime);
worldBorderFeature.setShrink(true);
super.start();
}
@Override
public PhaseType getPhaseType() {
return PhaseType.BORDER_SHRINK;
}
} | 1,473 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Config.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/config/Config.java | package me.patothebest.hungergames.config;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.gamecore.file.CoreConfig;
import me.patothebest.gamecore.modules.ActivableModule;
import me.patothebest.hungergames.HungerGames;
@Singleton
public class Config extends CoreConfig implements ActivableModule {
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
@Inject private Config(HungerGames plugin) {
super(plugin, "config");
this.header = "SkyWars Configuration";
load();
}
// -------------------------------------------- //
// ON ENABLE
// -------------------------------------------- //
@Override
public void onEnable() {
readConfig();
}
// -------------------------------------------- //
// CACHE
// -------------------------------------------- //
@Override
public void readConfig() {
super.readConfig();
}
} | 1,033 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
HungerGamesCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/commands/HungerGamesCommand.java | package me.patothebest.hungergames.commands;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.BaseCommand;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.commands.DebugCommand;
import me.patothebest.gamecore.commands.admin.AdminCommand;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.commands.user.ArenaUserCommands;
import me.patothebest.gamecore.commands.user.LocaleCommand;
import me.patothebest.gamecore.modules.RegisteredCommandModule;
import me.patothebest.hungergames.lang.Lang;
import me.patothebest.hungergames.HungerGames;
import org.bukkit.command.CommandSender;
@Singleton
public class HungerGamesCommand implements RegisteredCommandModule, BaseCommand {
private final HungerGames plugin;
@Inject private HungerGamesCommand(HungerGames plugin) {
this.plugin = plugin;
}
@Command(
aliases = {"hungergames", "hg"},
langDescription = @LangDescription(
element = "COMMAND_DESC",
langClass = Lang.class
)
)
@NestedCommand(
defaultToBody = true,
value = {
ArenaUserCommands.class,
LocaleCommand.class,
SetupCommand.class,
DebugCommand.class,
AdminCommand.class,
JoinArenaOverrideCommand.class
}
)
public void hungerGames(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(plugin.getCommandManager().getCommandManager(), args).showAdminInFooter(true).display(sender);
}
}
| 2,018 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
JoinArenaOverrideCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/commands/JoinArenaOverrideCommand.java | package me.patothebest.hungergames.commands;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaGroup;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandOverride;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.event.EventRegistry;
import me.patothebest.gamecore.event.player.RandomArenaJoinEvent;
import me.patothebest.gamecore.guis.UserGUIFactory;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.player.PlayerManager;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
public class JoinArenaOverrideCommand {
private final EventRegistry eventRegistry;
private final PlayerManager playerManager;
private final ArenaManager arenaManager;
private final UserGUIFactory userGUIFactory;
private final static Comparator<AbstractArena> COMPARATOR = Comparator.comparingInt(arena2 -> -arena2.getPlayers().size());
@Inject private JoinArenaOverrideCommand(EventRegistry eventRegistry, PlayerManager playerManager, ArenaManager arenaManager, UserGUIFactory userGUIFactory) {
this.eventRegistry = eventRegistry;
this.playerManager = playerManager;
this.arenaManager = arenaManager;
this.userGUIFactory = userGUIFactory;
}
@Command(
aliases = {"join", "j"},
usage = "[arena|solo|team] [-r(andom)]",
flags = "r",
max = 1,
langDescription = @LangDescription(
langClass = CoreLang.class,
element = "JOIN_ARENA"
)
)
@CommandOverride
public List<String> joinCommand(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
return CommandUtils.complete(args.getString(0, ""), Utils.toList(arenaManager.getArenas().values()));
}
ArenaGroup arenaGroup = null;
if (args.isInBounds(0)) {
arenaGroup = arenaManager.getGroup(args.getString(0));
}
if (args.hasFlag('r')) {
Arena currentArena = (Arena) playerManager.getPlayer(player.getName()).getCurrentArena();
List<AbstractArena> joinableArenas;
if (currentArena != null) {
arenaGroup = currentArena.getArenaGroup();
}
if (arenaGroup != null) {
ArenaGroup finalArenaGroup = arenaGroup;
joinableArenas = arenaManager.getJoinableArenas(player, arena -> arena.getArenaGroup() == finalArenaGroup && !arena.isFull());
} else {
joinableArenas = arenaManager.getJoinableArenas(player, arena -> !arena.isFull());
}
CommandUtils.validateTrue(!joinableArenas.isEmpty(), CoreLang.NO_ARENAS);
RandomArenaJoinEvent arenaJoinEvent = eventRegistry.callEvent(new RandomArenaJoinEvent(player, joinableArenas.get(0)));
CommandUtils.validateNotNull(arenaJoinEvent.getArena(), CoreLang.NO_ARENAS);
if (currentArena == arenaJoinEvent.getArena()) {
return null;
}
if (currentArena != null) {
currentArena.removePlayer(player);
}
arenaJoinEvent.getArena().addPlayer(player);
return null;
}
// check args
if (!args.isInBounds(0)) {
userGUIFactory.createJoinArenaUI(player);
return null;
}
if (arenaGroup != null) {
ArenaGroup finalArenaGroup1 = arenaGroup;
userGUIFactory.createJoinArenaUI(player, abstractArena -> ((Arena)abstractArena).getArenaType() == finalArenaGroup1);
return null;
}
// requirements
if (playerManager.getPlayer(player.getName()).getCurrentArena() != null) {
player.sendMessage(CoreLang.ALREADY_IN_ARENA.getMessage(player));
return null;
}
Arena arena = (Arena) arenaManager.getArena(args.getString(0));
if (arena == null) {
if (args.getString(0).equalsIgnoreCase("random-solo") || args.getString(0).equalsIgnoreCase("random-team")) {
ArenaGroup arenaType = (args.getString(0).equalsIgnoreCase("random-solo")) ? ArenaType.SOLO : ArenaType.TEAM;
Optional<AbstractArena> min = arenaManager.getArenas()
.values()
.stream()
.filter(o -> ((Arena)o).getArenaType() == arenaType && o.canJoinArena() && o.isEnabled())
.min(COMPARATOR);
if (min.isPresent()) {
arena = (Arena) min.get();
} else {
player.sendMessage(CoreLang.NO_ARENAS.getMessage(player));
return null;
}
} else {
player.sendMessage(CoreLang.ARENA_DOES_NOT_EXIST.getMessage(player));
return null;
}
}
if (!arena.isEnabled()) {
player.sendMessage(CoreLang.ARENA_IS_NOT_PLAYABLE.getMessage(player));
return null;
}
if (arena.getPhase().canJoin()) {
if (arena.isFull()) {
player.sendMessage(CoreLang.ARENA_IS_FULL.getMessage(player));
return null;
}
arena.addPlayer(player);
} else if (arena.canJoinArena()) {
player.sendMessage(CoreLang.ARENA_HAS_STARTED.getMessage(player));
} else {
player.sendMessage(CoreLang.ARENA_IS_RESTARTING.getMessage(player));
}
return null;
}
} | 6,232 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SupplyDropsCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/commands/SupplyDropsCommand.java | package me.patothebest.hungergames.commands;
import me.patothebest.gamecore.actionbar.ActionBar;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.chat.Pagination;
import me.patothebest.gamecore.command.ChatColor;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.modules.RegisteredCommandModule;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.lang.Lang;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerInteractEvent;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Singleton
public class SupplyDropsCommand implements ListenerModule {
private final Map<Player, Arena> playerArenaMap = new HashMap<>();
private final ArenaManager arenaManager;
@Inject
private SupplyDropsCommand(ArenaManager arenaManager) {
this.arenaManager = arenaManager;
}
@ChildOf(SetupCommand.class)
public static class Parent implements RegisteredCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Parent(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@Command(
aliases = {"supplydrops", "drops"},
langDescription = @LangDescription(
element = "SUPPLY_DROP_COMMAND",
langClass = Lang.class
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(value = SupplyDropsCommand.class)
public void supplyDrops(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
@EventHandler
public void listen(PlayerInteractEvent event) {
if (!playerArenaMap.containsKey(event.getPlayer())) {
return;
}
if (event.getClickedBlock() == null || event.getClickedBlock().getType() == Material.AIR.parseMaterial()) {
return;
}
Arena arena = playerArenaMap.remove(event.getPlayer());
ArenaLocation supplyDropLocation = new ArenaLocation(arena, event.getClickedBlock().getLocation());
if (!arena.getSupplyDrops().contains(supplyDropLocation)) {
arena.getSupplyDrops().add(supplyDropLocation);
ActionBar.sendActionBar(event.getPlayer(), Lang.SUPPLY_DROP_ADDED.getMessage(event.getPlayer()));
} else {
int i = arena.getSupplyDrops().indexOf(supplyDropLocation);
arena.getSupplyDrops().remove(supplyDropLocation);
ActionBar.sendActionBar(event.getPlayer(), Lang.SUPPLY_DROP_REMOVED.getMessage(event.getPlayer()));
}
event.setCancelled(true);
}
@Command(
aliases = {"add"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "SUPPLY_DROP_ADD",
langClass = Lang.class
)
)
public List<String> addSupplyDrop(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
playerArenaMap.put(player, arena);
Lang.SUPPLY_DROP_CLICK_TO_ADD.replaceAndSend(player);
return null;
}
@Command(
aliases = {"remove", "delete"},
usage = "<arena> <id>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "SUPPLY_DROP_REMOVE",
langClass = Lang.class
)
)
public List<String> removeSupplyDrop(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
int index = args.getInteger(1);
CommandUtils.validateTrue(index <= arena.getSupplyDrops().size() && index > 0, CoreLang.OUT_OF_BOUNDS);
arena.getSupplyDrops().remove(index-1);
Lang.SUPPLY_DROP_REMOVED.replaceAndSend(player, index);
return null;
}
@Command(
aliases = {"list", "ls"},
usage = "<arena> [page]",
min = 1,
max = 2,
langDescription = @LangDescription(
element = "SUPPLY_DROP_LIST",
langClass = Lang.class
)
)
public List<String> listSupplyDrops(CommandContext args, CommandSender sender) throws CommandException {
CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
int page = args.getInteger(1, 1);
new Pagination<ArenaLocation>() {
@Override
protected String title() {
return "Supply Drops";
}
@Override
protected String entry(ArenaLocation entry, int index, CommandSender commandSender) {
return ChatColor.GRAY + "* " + ChatColor.GOLD.toString() + (index+1) + ". " + ChatColor.BLUE + "Drop "
+ ChatColor.YELLOW + " Location: " + Utils.locationToCoords(entry, sender);
}
}.display(sender, arena.getSupplyDrops(), page);
return null;
}
@Command(
aliases = {"clear", "cl"},
usage = "<arena>",
min = 1,
langDescription = @LangDescription(
element = "SUPPLY_DROP_CLEAR",
langClass = Lang.class
)
)
public List<String> clearSupplydrops(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
arena.getSupplyDrops().clear();
Lang.SUPPLY_DROP_CLEARED.sendMessage(player);
return null;
}
}
| 8,061 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SpawnsCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/commands/SpawnsCommand.java | package me.patothebest.hungergames.commands;
import me.patothebest.gamecore.actionbar.ActionBar;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.chat.Pagination;
import me.patothebest.gamecore.command.ChatColor;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.modules.RegisteredCommandModule;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import me.patothebest.hungergames.lang.Lang;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerInteractEvent;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Singleton
public class SpawnsCommand implements ListenerModule {
private final Map<Player, Arena> playerArenaMap = new HashMap<>();
private final ArenaManager arenaManager;
@Inject
private SpawnsCommand(ArenaManager arenaManager) {
this.arenaManager = arenaManager;
}
@ChildOf(SetupCommand.class)
public static class Parent implements RegisteredCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Parent(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@Command(
aliases = {"spawns"},
langDescription = @LangDescription(
element = "SPAWNS_DESC",
langClass = Lang.class
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(value = SpawnsCommand.class)
public void midChest(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
@EventHandler
public void listen(PlayerInteractEvent event) {
if (!playerArenaMap.containsKey(event.getPlayer())) {
return;
}
if (event.getClickedBlock() == null || event.getClickedBlock().getType() == Material.AIR.parseMaterial()) {
return;
}
Arena arena = playerArenaMap.get(event.getPlayer());
ArenaLocation spawnLocation = new ArenaLocation(arena, event.getClickedBlock().getLocation());
if (!arena.getSpawns().contains(spawnLocation)) {
arena.getSpawns().add(spawnLocation);
ActionBar.sendActionBar(event.getPlayer(), Lang.SPAWN_ADDED.replace(event.getPlayer(), arena.getSpawns().size()-1));
event.setCancelled(true);
} else {
int i = arena.getSpawns().indexOf(spawnLocation);
arena.getSpawns().remove(spawnLocation);
ActionBar.sendActionBar(event.getPlayer(), Lang.SPAWN_REMOVED.replace(event.getPlayer(), i));
event.setCancelled(true);
}
}
@Command(
aliases = {"toggle"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "ADD_SPAWNS_DESC",
langClass = Lang.class
)
)
public List<String> toggle(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
if (args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.SOLO, Lang.ARENA_MUST_BE_SOLO);
if (playerArenaMap.containsKey(player)) {
playerArenaMap.remove(player);
Lang.ADD_STOP_SPAWNS.sendMessage(player);
} else {
playerArenaMap.put(player, arena);
Lang.ADD_SPAWNS.sendMessage(player);
}
return null;
}
@Command(
aliases = {"add", "addspawn"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "ADD_SPAWN",
langClass = Lang.class
)
)
public List<String> addSpawn(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.SOLO, Lang.ARENA_MUST_BE_SOLO);
arena.getSpawns().add(new ArenaLocation(arena, player.getLocation()));
player.sendMessage(Lang.SPAWN_ADDED.replace(player, arena.getSpawns().size()));
return null;
}
@Command(
aliases = {"remove", "delete"},
usage = "<arena> <id>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "REMOVE_SPAWN",
langClass = Lang.class
)
)
public List<String> removeSpawn(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.SOLO, Lang.ARENA_MUST_BE_SOLO);
int index = args.getInteger(1);
CommandUtils.validateTrue(index <= arena.getSpawns().size() && index > 0, CoreLang.OUT_OF_BOUNDS);
arena.getSpawns().remove(index-1);
Lang.SPAWN_REMOVED.replaceAndSend(player, index);
return null;
}
@Command(
aliases = {"list", "ls"},
usage = "<arena> [page]",
min = 1,
max = 2,
langDescription = @LangDescription(
element = "LIST_SPAWN",
langClass = Lang.class
)
)
public List<String> listSpawns(CommandContext args, CommandSender sender) throws CommandException {
CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.SOLO, Lang.ARENA_MUST_BE_SOLO);
int page = args.getInteger(1, 1);
new Pagination<ArenaLocation>() {
@Override
protected String title() {
return "Spawns";
}
@Override
protected String entry(ArenaLocation entry, int index, CommandSender commandSender) {
return ChatColor.GRAY + "* " + ChatColor.GOLD.toString() + (index+1) + ". " + ChatColor.BLUE + "Spawn "
+ ChatColor.YELLOW + " Location: " + Utils.locationToCoords(entry, sender);
}
}.display(sender, arena.getSpawns(), page);
return null;
}
@Command(
aliases = {"clear", "cl"},
usage = "<arena>",
min = 1,
langDescription = @LangDescription(
element = "CLEAR_SPAWNS",
langClass = Lang.class
)
)
public List<String> clearSpawns(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.SOLO, Lang.ARENA_MUST_BE_SOLO);
arena.getSpawns().clear();
Lang.CLEARED_SPAWNS.sendMessage(player);
return null;
}
@Command(
aliases = {"spawnheight", "height", "setspawnheight", "setheight"},
usage = "<arena> <height>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "SPAWN_HEIGHT",
langClass = Lang.class
)
)
public List<String> spawnHeight(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
arena.setSpawnHeight(args.getInteger(1));
Lang.SET_SPAWN_HEIGHT.sendMessage(player);
return null;
}
}
| 10,568 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ConvertCommands.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/commands/ConvertCommands.java | package me.patothebest.hungergames.commands;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.gamecore.world.ArenaWorld;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import me.patothebest.hungergames.arena.GameTeam;
import org.bukkit.DyeColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import java.io.File;
import java.util.List;
public class ConvertCommands {
private final ArenaManager arenaManager;
@Inject private ConvertCommands(ArenaManager arenaManager) {
this.arenaManager = arenaManager;
}
@ChildOf(SetupCommand.class)
public static class Parent implements ParentCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Parent(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@Command(
aliases = "convert",
desc = "Command for converting",
langDescription = @LangDescription(
langClass = CoreLang.class,
element = ""
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(
value = ConvertCommands.class,
defaultToBody = true
)
public void convert(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
@Command(
aliases = {"toteam"},
usage = "<arena>",
min = 1,
max = 1,
desc = "convert an arena to team",
langDescription = @LangDescription(
langClass = CoreLang.class,
element = ""
)
)
public List<String> convertArena(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
if (args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getEnabledArena(args, 0, arenaManager);
Utils.unZip(new File(ArenaWorld.WORLD_DIRECTORY, arena.getName() + ".zip").getPath(), new File(PluginConfig.WORLD_PREFIX + arena.getName() + "-Team" + File.separatorChar).getPath());
new File(PluginConfig.WORLD_PREFIX + arena.getName() + "-Team" + File.separatorChar + "uid.dat").delete();
Arena newArena = (Arena) arenaManager.createArena(arena.getName() + "-Team");
newArena.setArenaGroup(ArenaType.TEAM);
newArena.setArea(arena.getArea().clone().setArena(newArena));
newArena.setLobbyLocation(new ArenaLocation(newArena, arena.getLobbyLocation()));
newArena.setMaxPlayers(arena.getMaxPlayers()*2);
newArena.setMinPlayers(arena.getMinPlayers());
newArena.setPermissionGroup(arena.getPermissionGroup());
newArena.setSpectatorLocation(new ArenaLocation(newArena, arena.getSpectatorLocation()));
newArena.save();
newArena.initializePhase();
int i = 0;
int i2 = 1;
boolean appendTeam = arena.getSpawns().size() > DyeColor.values().length;
for (ArenaLocation arenaLocation : arena.getSpawns()) {
if(i == DyeColor.values().length) {
i = 0;
i2++;
}
DyeColor color = DyeColor.values()[i];
GameTeam team = newArena.createTeam(Utils.capitalizeFirstLetter(color.name()) + (appendTeam ? "#" + i2 : ""), color);
team.setSpawn(new ArenaLocation(newArena, arenaLocation));
i++;
}
newArena.enableArena();
return null;
}
}
| 4,894 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeamSetupCommands.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/commands/TeamSetupCommands.java | package me.patothebest.hungergames.commands;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import me.patothebest.hungergames.lang.Lang;
import org.bukkit.DyeColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import java.util.List;
public class TeamSetupCommands {
private final ArenaManager arenaManager;
@Inject private TeamSetupCommands(ArenaManager arenaManager) {
this.arenaManager = arenaManager;
}
@ChildOf(SetupCommand.class)
public static class Parent implements ParentCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Parent(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@Command(
aliases = "teams",
langDescription = @LangDescription(
element = "TEAMS_COMMAND_DESCRIPTION",
langClass = CoreLang.class
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(
value = TeamSetupCommands.class,
defaultToBody = true
)
public void teams(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
@Command(
aliases = {"create", "add", "new"},
usage = "<arena> <team name> <team color>",
min = 3,
max = 3,
langDescription = @LangDescription(
element = "NEW_TEAM",
langClass = CoreLang.class
)
)
public List<String> addGameTeam(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
switch(args.getSuggestionContext().getIndex()) {
case 0:
return CommandUtils.complete(args.getString(0), arenaManager);
case 2:
return CommandUtils.complete(args.getString(2), DyeColor.values());
default:
return null;
}
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.TEAM, Lang.ARENA_MUST_BE_TEAM);
DyeColor dyeColor = Utils.getEnumValueFromString(DyeColor.class, args.getString(2));
CommandUtils.validateNotNull(dyeColor, CoreLang.TEAM_COLOR_NOT_FOUND);
CommandUtils.validateTrue(!arena.containsTeam(args.getString(0)), CoreLang.TEAM_COLOR_ALREADY_EXIST);
// create and add the game team
arena.createTeam(args.getString(1), dyeColor);
player.sendMessage(CoreLang.TEAM_CREATED.getMessage(player));
arena.save();
return null;
}
@Command(
aliases = {"setspawn", "setteamspawn"},
usage = "<arena> <team name>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "NEW_TEAM_SPAWN",
langClass = CoreLang.class
)
)
public List<String> setTeamSpawn(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
switch(args.getSuggestionContext().getIndex()) {
case 0:
return CommandUtils.complete(args.getString(0), arenaManager);
case 1:
return CommandUtils.completeNameable(args.getString(1), CommandUtils.getDisabledArena(args, 0, arenaManager).getTeams().values());
default:
return null;
}
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
CommandUtils.validateTrue(arena.getArenaType() == ArenaType.TEAM, Lang.ARENA_MUST_BE_TEAM);
AbstractGameTeam gameTeam = CommandUtils.getTeam(arena, args, 1);
gameTeam.setSpawn(player.getLocation());
player.sendMessage(CoreLang.TEAM_SPAWN_SET.getMessage(player));
arena.save();
return null;
}
}
| 5,333 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
MidChestsCommand.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/commands/MidChestsCommand.java | package me.patothebest.hungergames.commands;
import me.patothebest.gamecore.actionbar.ActionBar;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.chat.CommandPagination;
import me.patothebest.gamecore.chat.Pagination;
import me.patothebest.gamecore.command.ChatColor;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.CommandPermissions;
import me.patothebest.gamecore.command.CommandsManager;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.command.NestedCommand;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ListenerModule;
import me.patothebest.gamecore.modules.RegisteredCommandModule;
import me.patothebest.gamecore.permission.Permission;
import me.patothebest.gamecore.scheduler.PluginScheduler;
import me.patothebest.gamecore.selection.Selection;
import me.patothebest.gamecore.selection.SelectionManager;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.gamecore.vector.Cuboid;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.lang.Lang;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerInteractEvent;
import javax.inject.Inject;
import javax.inject.Provider;
import javax.inject.Singleton;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Singleton
public class MidChestsCommand implements ListenerModule {
private final Map<Player, Arena> playerArenaMap = new HashMap<>();
private final ArenaManager arenaManager;
private final PluginScheduler pluginScheduler;
private final Provider<SelectionManager> selectionManagerProvider;
@Inject
private MidChestsCommand(ArenaManager arenaManager, PluginScheduler pluginScheduler, Provider<SelectionManager> selectionManagerProvider) {
this.arenaManager = arenaManager;
this.pluginScheduler = pluginScheduler;
this.selectionManagerProvider = selectionManagerProvider;
}
@ChildOf(SetupCommand.class)
public static class Parent implements RegisteredCommandModule {
private final CommandsManager<CommandSender> commandsManager;
@Inject
private Parent(CommandsManager<CommandSender> commandsManager) {
this.commandsManager = commandsManager;
}
@Command(
aliases = {"middlechest", "midchest"},
langDescription = @LangDescription(
element = "MIDCHEST_DESC",
langClass = Lang.class
)
)
@CommandPermissions(permission = Permission.SETUP)
@NestedCommand(value = MidChestsCommand.class)
public void midChest(CommandContext args, CommandSender sender) throws CommandException {
new CommandPagination(commandsManager, args).display(sender);
}
}
@EventHandler
public void listen(PlayerInteractEvent event) {
if (!playerArenaMap.containsKey(event.getPlayer())) {
return;
}
if (event.getClickedBlock() == null || event.getClickedBlock().getType() == Material.AIR.parseMaterial()) {
return;
}
if (event.getClickedBlock().getType() != Material.CHEST.parseMaterial() || event.getClickedBlock().getType() != Material.TRAPPED_CHEST.parseMaterial()) {
return;
}
Arena arena = playerArenaMap.get(event.getPlayer());
ArenaLocation arenaLocation = new ArenaLocation(arena, event.getClickedBlock().getLocation());
if (!arena.getMidChestLocations().contains(arenaLocation)) {
arena.getMidChestLocations().add(arenaLocation);
ActionBar.sendActionBar(event.getPlayer(), Lang.MID_CHEST_ADDED);
event.setCancelled(true);
} else {
arena.getMidChestLocations().remove(arenaLocation);
ActionBar.sendActionBar(event.getPlayer(), Lang.MID_CHEST_REMOVED);
event.setCancelled(true);
}
}
@Command(
aliases = {"toggle"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "MID_CHEST",
langClass = Lang.class
)
)
public List<String> toggle(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
if (args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
if (playerArenaMap.containsKey(player)) {
playerArenaMap.remove(player);
Lang.ADD_STOP_MID_CHEST.sendMessage(player);
} else {
playerArenaMap.put(player, arena);
Lang.ADD_MID_CHEST.sendMessage(player);
}
return null;
}
@Command(
aliases = {"scan"},
usage = "<arena>",
min = 1,
max = 1,
langDescription = @LangDescription(
element = "SCAN_CHESTS",
langClass = Lang.class
)
)
public List<String> scanArea(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if (args.getSuggestionContext() != null) {
if (args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getDisabledArena(args, 0, arenaManager);
Selection selection = selectionManagerProvider.get().getSelection(player);
CommandUtils.validateTrue(selection != null && selection.arePointsSet(), CoreLang.SELECT_AN_AREA);
Cuboid cuboid = selection.toCubiod("temp", arena);
int blocksToScan = (cuboid.getUpperSW().getBlockX() - cuboid.getLowerNE().getBlockX()) * (cuboid.getUpperSW().getBlockZ() - cuboid.getLowerNE().getBlockZ()) * (cuboid.getUpperSW().getBlockY() - cuboid.getLowerNE().getBlockY());
int blocksScanned = 0;
int chestsFound = 0;
double interval = blocksToScan / 100.0;
long lastSent = 0;
Lang.SCANNING_AREA.sendMessage(player);
for (int x = cuboid.getLowerNE().getBlockX(); x < cuboid.getUpperSW().getBlockX(); x++) {
for (int z = cuboid.getLowerNE().getBlockZ(); z < cuboid.getUpperSW().getBlockZ(); z++) {
for (int y = cuboid.getLowerNE().getBlockY(); y < cuboid.getUpperSW().getBlockY(); y++) {
if (arena.getWorld().getBlockAt(x, y, z).getType() == Material.CHEST.parseMaterial() || arena.getWorld().getBlockAt(x, y, z).getType() == Material.TRAPPED_CHEST.parseMaterial()) {
ArenaLocation arenaLocation = new ArenaLocation(arena, arena.getWorld(), x, y, z);
arena.getMidChestLocations().add(arenaLocation);
chestsFound++;
}
blocksScanned++;
if (blocksScanned % interval < 1) {
double progress = (double) blocksScanned / blocksToScan;
if(System.currentTimeMillis() - 50 >= lastSent) {
Utils.displayProgress(Lang.SCANNING_AREA.getMessage(player), progress, Math.ceil(progress * 100.0) + "%", player);
lastSent = System.currentTimeMillis();
}
}
}
}
}
Utils.displayProgress(Lang.SCANNING_AREA.getMessage(player), 1, 100.0 + "%", player);
Lang.SCANNED_AREA.replaceAndSend(player, chestsFound);
return null;
}
@Command(
aliases = {"list", "ls"},
usage = "<arena> [page]",
min = 1,
max = 2,
langDescription = @LangDescription(
element = "LIST_MID_CHEST",
langClass = Lang.class
)
)
public List<String> listMidChests(CommandContext args, CommandSender sender) throws CommandException {
CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
int page = args.getInteger(1, 1);
new Pagination<ArenaLocation>() {
@Override
protected String title() {
return "Mid-Chests";
}
@Override
protected String entry(ArenaLocation entry, int index, CommandSender commandSender) {
return ChatColor.GRAY + "* " + ChatColor.GOLD.toString() + (index+1) + ". " + ChatColor.BLUE + "Mid-Chest "
+ ChatColor.YELLOW + " Location: " + Utils.locationToCoords(entry, sender);
}
}.display(sender, arena.getMidChestLocations(), page);
return null;
}
@Command(
aliases = {"clear", "cl"},
usage = "<arena>",
min = 1,
langDescription = @LangDescription(
element = "CLEAR_MID_CHESTS",
langClass = Lang.class
)
)
public List<String> clearSpawns(CommandContext args, CommandSender sender) throws CommandException {
Player player = CommandUtils.getPlayer(sender);
if(args.getSuggestionContext() != null) {
if(args.getSuggestionContext().getIndex() == 0) {
return CommandUtils.complete(args.getString(0), arenaManager);
}
return null;
}
Arena arena = CommandUtils.getArena(args, 0, arenaManager);
arena.getMidChestLocations().clear();
Lang.CLEARED_MID_CHEST.sendMessage(player);
return null;
}
}
| 10,708 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SetupArenaCommands.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/commands/SetupArenaCommands.java | package me.patothebest.hungergames.commands;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.arena.ArenaGroup;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.command.ChildOf;
import me.patothebest.gamecore.command.Command;
import me.patothebest.gamecore.command.CommandContext;
import me.patothebest.gamecore.command.CommandException;
import me.patothebest.gamecore.command.LangDescription;
import me.patothebest.gamecore.commands.setup.SetupCommand;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.modules.ParentCommandModule;
import me.patothebest.gamecore.util.CommandUtils;
import me.patothebest.hungergames.arena.Arena;
import org.bukkit.Location;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import java.io.File;
@ChildOf(SetupCommand.class)
public class SetupArenaCommands implements ParentCommandModule {
private final ArenaManager arenaManager;
@Inject private SetupArenaCommands(ArenaManager arenaManager) {
this.arenaManager = arenaManager;
}
@Command(
aliases = {"createarena", "newarena"},
usage = "<arena> <mode>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "NEW_ARENA",
langClass = CoreLang.class
)
)
public void createArena(CommandContext args, CommandSender sender) throws CommandException {
String arenaName = args.getString(0);
ArenaGroup group = arenaManager.getGroup(args.getString(1));
// requirements
CommandUtils.validateTrue(arenaManager.getArena(arenaName) == null, CoreLang.ARENA_ALREADY_EXIST);
// create the arena
Arena arena = (Arena) arenaManager.createArena(arenaName);
arena.setArenaGroup(group);
arena.initializePhase();
CoreLang.ARENA_CREATED.sendMessage(sender);
if(sender instanceof Player) {
Player player = CommandUtils.getPlayer(sender);
player.teleport(new Location(arena.getWorld(), 0, 100, 0));
}
}
@Command(
aliases = {"import", "importarena"},
usage = "<arena> <mode>",
min = 2,
max = 2,
langDescription = @LangDescription(
element = "IMPORT_ARENA",
langClass = CoreLang.class
)
)
public void importArena(CommandContext args, CommandSender sender) throws CommandException {
String arenaName = args.getString(0);
ArenaGroup group = arenaManager.getGroup(args.getString(1).toUpperCase());
// requirements
CommandUtils.validateNotNull(group, CoreLang.ARENA_GROUP_NOT_FOUND);
CommandUtils.validateTrue(arenaManager.getArena(arenaName) == null, CoreLang.ARENA_ALREADY_EXIST);
File worldFolder = new File(arenaName + File.separatorChar);
CommandUtils.validateTrue(worldFolder.exists(), CoreLang.FOLDER_DOESNT_EXIST);
CommandUtils.validateTrue(worldFolder.isDirectory(), CoreLang.ARENA_IS_FILE);
CommandUtils.validateTrue(worldFolder.renameTo(new File(PluginConfig.WORLD_PREFIX + arenaName + File.separatorChar)), CoreLang.SOMETHING_WENT_WRONG_IMPORTING);
// requirements
CommandUtils.validateTrue(arenaManager.getArena(arenaName) == null, CoreLang.ARENA_ALREADY_EXIST);
// create the arena
Arena arena = (Arena) arenaManager.createArena(arenaName);
arena.setArenaGroup(group);
arena.initializePhase();
CoreLang.ARENA_IMPORTED.sendMessage(sender);
if(sender instanceof Player) {
Player player = CommandUtils.getPlayer(sender);
player.teleport(new Location(arena.getWorld(), 0, 100, 0));
}
}
} | 3,872 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
StatsModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/StatsModule.java | package me.patothebest.hungergames.stats;
import com.google.inject.multibindings.Multibinder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import me.patothebest.gamecore.stats.Statistic;
import me.patothebest.hungergames.stats.statistics.solo.SoloDeathStatistic;
import me.patothebest.hungergames.stats.statistics.solo.SoloKillStatistic;
import me.patothebest.hungergames.stats.statistics.solo.SoloLosesStatistic;
import me.patothebest.hungergames.stats.statistics.solo.SoloWinsStatistic;
import me.patothebest.hungergames.stats.statistics.team.TeamDeathStatistic;
import me.patothebest.hungergames.stats.statistics.team.TeamKillStatistic;
import me.patothebest.hungergames.stats.statistics.team.TeamWinsStatistic;
import me.patothebest.hungergames.stats.statistics.team.TeamLosesStatistic;
public class StatsModule extends AbstractBukkitModule<CorePlugin> {
public StatsModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
Multibinder<Statistic> statisticMultibinder = Multibinder.newSetBinder(binder(), Statistic.class);
// Solo
statisticMultibinder.addBinding().to(SoloDeathStatistic.class);
statisticMultibinder.addBinding().to(SoloKillStatistic.class);
statisticMultibinder.addBinding().to(SoloLosesStatistic.class);
statisticMultibinder.addBinding().to(SoloWinsStatistic.class);
// Team
statisticMultibinder.addBinding().to(TeamDeathStatistic.class);
statisticMultibinder.addBinding().to(TeamKillStatistic.class);
statisticMultibinder.addBinding().to(TeamLosesStatistic.class);
statisticMultibinder.addBinding().to(TeamWinsStatistic.class);
}
}
| 1,764 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeamWinsStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/statistics/team/TeamWinsStatistic.java | package me.patothebest.hungergames.stats.statistics.team;
import me.patothebest.gamecore.event.arena.GameEndEvent;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.stats.AbstractStatistic;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.event.EventHandler;
public class TeamWinsStatistic extends AbstractStatistic {
@EventHandler
public void onGameEnd(GameEndEvent event) {
if (((Arena) event.getArena()).getArenaType() != ArenaType.TEAM) {
return;
}
event.getWinners().forEach(winner -> {
IPlayer player = playerManager.getPlayer(winner);
if (player == null) {
return;
}
updateStat(player, 1);
});
}
@Override
public String getStatName() {
return "twins";
}
}
| 904 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeamKillStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/statistics/team/TeamKillStatistic.java | package me.patothebest.hungergames.stats.statistics.team;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.stats.AbstractStatistic;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
public class TeamKillStatistic extends AbstractStatistic {
@EventHandler(priority = EventPriority.LOWEST)
public void onDeath(CombatDeathEvent event) {
if (event.getKillerPlayer() != null && getPlayer(event.getKillerPlayer()) != null) {
if (!getPlayer(event.getKillerPlayer()).isInArena()) {
return;
}
if(((Arena)getPlayer(event.getKillerPlayer()).getCurrentArena()).getArenaType() != ArenaType.TEAM) {
return;
}
updateStat(event.getKillerPlayer(), 1);
}
}
@Override
public String getStatName() {
return "tkills";
}
}
| 1,009 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeamDeathStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/statistics/team/TeamDeathStatistic.java | package me.patothebest.hungergames.stats.statistics.team;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.stats.AbstractStatistic;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
public class TeamDeathStatistic extends AbstractStatistic {
@EventHandler(priority = EventPriority.LOWEST)
public void onDeath(CombatDeathEvent event) {
Player player = event.getPlayer();
if(!getPlayer(player).isInArena()) {
return;
}
if(((Arena)getPlayer(player).getCurrentArena()).getArenaType() != ArenaType.TEAM) {
return;
}
updateStat(player, 1);
}
@Override
public String getStatName() {
return "tdeaths";
}
}
| 905 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
TeamLosesStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/statistics/team/TeamLosesStatistic.java | package me.patothebest.hungergames.stats.statistics.team;
import me.patothebest.gamecore.event.arena.GameEndEvent;
import me.patothebest.gamecore.event.player.PlayerLooseEvent;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.stats.AbstractStatistic;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.event.EventHandler;
public class TeamLosesStatistic extends AbstractStatistic {
@EventHandler
public void onGameEnd(GameEndEvent event) {
if(((Arena)event.getArena()).getArenaType() != ArenaType.TEAM) {
return;
}
event.getLosers().forEach(loser -> {
IPlayer player = playerManager.getPlayer(loser);
if(player == null) {
return;
}
updateStat(player, 1);
});
}
@EventHandler
public void onLoose(PlayerLooseEvent event){
if(((Arena)event.getArena()).getArenaType() != ArenaType.TEAM) {
return;
}
updateStat(event.getPlayer(), 1);
}
@Override
public String getStatName() {
return "tloses";
}
}
| 1,183 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SoloKillStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/statistics/solo/SoloKillStatistic.java | package me.patothebest.hungergames.stats.statistics.solo;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.stats.AbstractStatistic;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
public class SoloKillStatistic extends AbstractStatistic {
@EventHandler(priority = EventPriority.LOWEST)
public void onDeath(CombatDeathEvent event) {
if (event.getKillerPlayer() != null && getPlayer(event.getKillerPlayer()) != null) {
if (!getPlayer(event.getKillerPlayer()).isInArena()) {
return;
}
if(((Arena)getPlayer(event.getKillerPlayer()).getCurrentArena()).getArenaType() != ArenaType.SOLO) {
return;
}
updateStat(event.getKillerPlayer(), 1);
}
}
@Override
public String getStatName() {
return "skills";
}
}
| 1,009 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SoloWinsStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/statistics/solo/SoloWinsStatistic.java | package me.patothebest.hungergames.stats.statistics.solo;
import me.patothebest.gamecore.event.arena.GameEndEvent;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.stats.AbstractStatistic;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.event.EventHandler;
public class SoloWinsStatistic extends AbstractStatistic {
@EventHandler
public void onGameEnd(GameEndEvent event) {
if (((Arena) event.getArena()).getArenaType() != ArenaType.SOLO) {
return;
}
event.getWinners().forEach(winner -> {
IPlayer player = playerManager.getPlayer(winner);
if (player == null) {
return;
}
updateStat(player, 1);
});
}
@Override
public String getStatName() {
return "swins";
}
}
| 904 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SoloDeathStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/statistics/solo/SoloDeathStatistic.java | package me.patothebest.hungergames.stats.statistics.solo;
import me.patothebest.gamecore.combat.CombatDeathEvent;
import me.patothebest.gamecore.stats.AbstractStatistic;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
public class SoloDeathStatistic extends AbstractStatistic {
@EventHandler(priority = EventPriority.LOWEST)
public void onDeath(CombatDeathEvent event) {
Player player = event.getPlayer();
if(!getPlayer(player).isInArena()) {
return;
}
if(((Arena)getPlayer(player).getCurrentArena()).getArenaType() != ArenaType.SOLO) {
return;
}
updateStat(player, 1);
}
@Override
public String getStatName() {
return "sdeaths";
}
}
| 905 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
SoloLosesStatistic.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/stats/statistics/solo/SoloLosesStatistic.java | package me.patothebest.hungergames.stats.statistics.solo;
import me.patothebest.gamecore.event.arena.GameEndEvent;
import me.patothebest.gamecore.event.player.PlayerLooseEvent;
import me.patothebest.gamecore.player.IPlayer;
import me.patothebest.gamecore.stats.AbstractStatistic;
import me.patothebest.hungergames.arena.Arena;
import me.patothebest.hungergames.arena.ArenaType;
import org.bukkit.event.EventHandler;
public class SoloLosesStatistic extends AbstractStatistic {
@EventHandler
public void onGameEnd(GameEndEvent event) {
if(((Arena)event.getArena()).getArenaType() != ArenaType.SOLO) {
return;
}
event.getLosers().forEach(loser -> {
IPlayer player = playerManager.getPlayer(loser);
if(player == null) {
return;
}
updateStat(player, 1);
});
}
@EventHandler
public void onLoose(PlayerLooseEvent event){
if(((Arena)event.getArena()).getArenaType() != ArenaType.SOLO) {
return;
}
updateStat(event.getPlayer(), 1);
}
@Override
public String getStatName() {
return "sloses";
}
}
| 1,183 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
LocaleManager.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/lang/LocaleManager.java | package me.patothebest.hungergames.lang;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import me.patothebest.gamecore.lang.CoreLocaleManager;
import me.patothebest.gamecore.modules.Module;
import me.patothebest.hungergames.HungerGames;
@Singleton
public class LocaleManager extends CoreLocaleManager implements Module {
@Inject private LocaleManager(HungerGames plugin) {
super(plugin, Lang.values());
}
} | 447 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Lang.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/lang/Lang.java | package me.patothebest.hungergames.lang;
import me.patothebest.gamecore.PluginConfig;
import me.patothebest.gamecore.lang.CommentType;
import me.patothebest.gamecore.lang.CoreComments;
import me.patothebest.gamecore.lang.CoreLang;
import me.patothebest.gamecore.lang.CoreLocaleManager;
import me.patothebest.gamecore.lang.LangComment;
import me.patothebest.gamecore.lang.Locale;
import me.patothebest.gamecore.lang.interfaces.IComment;
import me.patothebest.gamecore.lang.interfaces.ILang;
import org.bukkit.ChatColor;
import java.util.HashMap;
import java.util.Map;
public enum Lang implements ILang {
// -----------------------------------
// General Messages
// -----------------------------------
HEADER(CommentType.HEADER, "Hunger Games Messages"),
GENERAL(CommentType.SUBHEADER_NOT_SPACED, "General Messages"),
COMMAND_DESC("Command for general hungergames commands"),
// -------------------------------------------- //
// Setup messages
// -------------------------------------------- //
SETUP(CommentType.HEADER, "Setup messages"),
SETUP_COMMAND_DESCRIPTIONS(CommentType.SUBHEADER_NOT_SPACED, "Command descriptions"),
ADD_SPAWN("Adds a spawn to a solo arena"),
REMOVE_SPAWN("Removes a spawn from a solo arena"),
LIST_SPAWN("List all the spawns from a solo arena"),
CLEAR_SPAWNS("Clears all the spawns from a solo arena"),
ADD_SPAWNS_DESC("Adds multiple to a solo arena by right clicking"),
LIST_MID_CHEST("List all the mid chests from an arena"),
CLEAR_MID_CHESTS("Clears all the mid chests from an arena"),
MID_CHEST("Adds mid chests to the arena"),
SCAN_CHESTS("Scans the selected area for mid chests"),
SPAWN_HEIGHT("Sets the spawn height for the arena"),
SETUP_SUCCESSFUL_MESSAGES(CommentType.SUBHEADER_SPACED, "Successful messages"),
SPAWNS_DESC("Command for spawns"),
MIDCHEST_DESC("Command for mid chests"),
ADD_MID_CHEST(true, "&aClick all the chests in mid to add them to the list. Type this command again to stop adding chests."),
ADD_STOP_MID_CHEST(true, "&aStopped adding mid chests."),
MID_CHEST_ADDED(true, "&aMid-chest added"),
MID_CHEST_REMOVED(true, "&aMid-chest removed"),
SCANNING_AREA("Scanning area..."),
SCANNED_AREA(true, "Scan complete! Found %chests% chests.", "chests"),
ADD_SPAWNS(true, "&aClick all the blocks where you want a player to spawn. Type this command again to stop adding spawns."),
CLEARED_SPAWNS(true, "&cCleared all spawns"),
CLEARED_MID_CHEST(true, "&cCleared all mid chests"),
ADD_STOP_SPAWNS(true, "&aStopped adding spawns"),
SPAWN_ADDED(true, "&aSpawn %id% added", "id"),
SPAWN_REMOVED(true, "&7Spawn %id% removed", "id"),
SET_SPAWN_HEIGHT(true, "&aSpawn height has been set!"),
SETUP_ERRORS(CommentType.SUBHEADER_SPACED, "Error messages"),
ARENA_MUST_BE_SOLO(true, "&cArena must be solo arena"),
ARENA_MUST_BE_TEAM(true, "&cArena must be team arena"),
SUPPLY_DROPS(CommentType.SUBHEADER_SPACED, "Supply drops"),
SUPPLY_DROP_COMMAND("Command for supply drops"),
SUPPLY_DROP_ADD("Adds a supply drop location to the map"),
SUPPLY_DROP_REMOVE("Removes a supply drop location from the map"),
SUPPLY_DROP_LIST("List all the supply drops that are present in the map"),
SUPPLY_DROP_CLEAR("Clears all supply drops"),
SUPPLY_DROP_CLEARED("&cCleared all supply drops"),
SUPPLY_DROP_CLICK_TO_ADD("Right-click a block to add as a supply drop location"),
SUPPLY_DROP_ADDED("&aSupply drop added!"),
SUPPLY_DROP_REMOVED("&cSupply drop removed."),
SUPPLY_DROP_INCOMING("&6⌧ &a&lSupply drop incoming at (%location%)", "location"),
;
private String defaultMessage;
private Map<Locale, String> message;
private Map<Locale, String> rawMessage;
private boolean prefix;
private IComment comment;
private String[] arguments;
Lang(CoreComments CoreComments) {
this.comment = CoreComments;
}
Lang(CommentType commentType, String title) {
this.comment = new LangComment(commentType, title);
}
Lang(String defaultMessage, String... arguments) {
this(false, defaultMessage, arguments);
}
Lang(boolean prefix, String defaultMessage, String... arguments) {
this.defaultMessage = defaultMessage;
this.prefix = prefix;
this.message = new HashMap<>();
this.rawMessage = new HashMap<>();
this.arguments = arguments;
setMessage(CoreLocaleManager.getLocale("en"), defaultMessage);
}
@Override
public String getMessage(Locale locale) {
return (prefix ? CoreLang.PREFIX.getMessage(locale) : "") + message.get(locale);
}
@Override
public String getRawMessage(Locale locale) {
return rawMessage.get(locale);
}
@Override
public void setMessage(Locale locale, String message) {
this.message.put(locale, ChatColor.translateAlternateColorCodes('&', message).replace("%newline%", "\n").replace("%plugin_prefix%", PluginConfig.LANG_PREFIX).replace("%game_title%", PluginConfig.GAME_TITLE));
this.rawMessage.put(locale, message);
}
public void transferMessage(Lang lang) {
message = lang.message;
rawMessage = lang.rawMessage;
}
@Override
public String getDefaultMessage() {
return defaultMessage;
}
@Override
public boolean isComment() {
return comment != null;
}
@Override
public IComment getComment() {
return comment;
}
@Override
public String[] getArguments() {
return arguments;
}
} | 5,624 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaType.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/arena/ArenaType.java | package me.patothebest.hungergames.arena;
import me.patothebest.gamecore.arena.ArenaGroup;
public class ArenaType {
public static final ArenaGroup SOLO = new ArenaGroup("SOLO");
public static final ArenaGroup TEAM = new ArenaGroup("TEAM");
}
| 254 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
GameTeam.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/arena/GameTeam.java | package me.patothebest.hungergames.arena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import org.bukkit.DyeColor;
import java.util.Map;
public class GameTeam extends AbstractGameTeam {
public GameTeam(Arena arena, String name, DyeColor color) {
super(arena, name, color);
}
public GameTeam(Arena arena, Map<String, Object> data) {
super(arena, data);
}
@Override
public Map<String, Object> serialize() {
return super.serialize();
}
@Override
public String toString() {
return "GameTeam{" +
"arena=" + arena.getName() +
", players=" + players +
", name='" + name + '\'' +
", color=" + color +
", teamChatPrefix=" + teamChatPrefix +
", spawn=" + spawn +
'}';
}
}
| 863 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ArenaModule.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/arena/ArenaModule.java | package me.patothebest.hungergames.arena;
import com.google.common.collect.ImmutableSet;
import com.google.inject.TypeLiteral;
import com.google.inject.assistedinject.FactoryModuleBuilder;
import com.google.inject.multibindings.OptionalBinder;
import me.patothebest.gamecore.CorePlugin;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.ArenaFactory;
import me.patothebest.gamecore.arena.ArenaGroup;
import me.patothebest.gamecore.arena.ArenaManager;
import me.patothebest.gamecore.feature.features.chests.refill.ChestLocation;
import me.patothebest.gamecore.injector.AbstractBukkitModule;
import java.util.Set;
public class ArenaModule extends AbstractBukkitModule<CorePlugin> {
public ArenaModule(CorePlugin plugin) {
super(plugin);
}
@Override
protected void configure() {
install(new FactoryModuleBuilder().implement(AbstractArena.class, Arena.class).build(ArenaFactory.class));
registerModule(ArenaManager.class);
// Bind arena groups
OptionalBinder.newOptionalBinder(binder(), new TypeLiteral<Set<ArenaGroup>>() {})
.setBinding().toInstance(ImmutableSet.of(ArenaType.SOLO, ArenaType.TEAM));
bind(new TypeLiteral<Set<ChestLocation>>() {})
.toInstance(ImmutableSet.of(ChestLocations.REST, ChestLocations.MID));
}
}
| 1,365 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
ChestLocations.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/arena/ChestLocations.java | package me.patothebest.hungergames.arena;
import me.patothebest.gamecore.feature.features.chests.refill.ChestLocation;
public class ChestLocations {
public static ChestLocation REST = new ChestLocation("rest");
public static ChestLocation MID = new ChestLocation("mid");
public static ChestLocation SUPPLY = new ChestLocation("supply");
}
| 355 | Java | .java | PatoTheBest/MiniGames | 13 | 2 | 1 | 2020-08-07T03:43:56Z | 2022-01-23T23:52:46Z |
Arena.java | /FileExtraction/Java_unseen/PatoTheBest_MiniGames/Games/HungerGames/src/main/java/me/patothebest/hungergames/arena/Arena.java | package me.patothebest.hungergames.arena;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Provider;
import com.google.inject.assistedinject.Assisted;
import me.patothebest.gamecore.arena.AbstractArena;
import me.patothebest.gamecore.arena.AbstractGameTeam;
import me.patothebest.gamecore.arena.ArenaGroup;
import me.patothebest.gamecore.arena.types.CentrableArena;
import me.patothebest.gamecore.arena.types.ChestArena;
import me.patothebest.gamecore.arena.types.SpawneableArena;
import me.patothebest.gamecore.event.arena.GameEndEvent;
import me.patothebest.gamecore.feature.features.chests.refill.ChestLocation;
import me.patothebest.gamecore.feature.features.gameoptions.GameOptionsFeature;
import me.patothebest.gamecore.feature.features.gameoptions.individual.ProjectileTrailSelectorGameOption;
import me.patothebest.gamecore.feature.features.gameoptions.individual.WalkTrailSelectorGameOption;
import me.patothebest.gamecore.feature.features.gameoptions.time.TimeSelectorGameOption;
import me.patothebest.gamecore.feature.features.gameoptions.weather.WeatherSelectorGameOption;
import me.patothebest.gamecore.feature.features.protection.GracePeriodFeature;
import me.patothebest.gamecore.itemstack.Material;
import me.patothebest.gamecore.phase.phases.CelebrationPhase;
import me.patothebest.gamecore.phase.phases.EndPhase;
import me.patothebest.gamecore.phase.phases.LobbyPhase;
import me.patothebest.gamecore.phase.phases.TeamAssignPhase;
import me.patothebest.gamecore.phase.phases.WaitingPhase;
import me.patothebest.gamecore.util.PlayerList;
import me.patothebest.gamecore.util.Utils;
import me.patothebest.gamecore.vector.ArenaLocation;
import me.patothebest.hungergames.phase.HungerGamesGameBasePhase;
import me.patothebest.hungergames.phase.HungerGamesPhase;
import me.patothebest.hungergames.phase.PhaseType;
import org.apache.commons.lang.Validate;
import org.bukkit.Chunk;
import org.bukkit.DyeColor;
import org.bukkit.Location;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class Arena extends AbstractArena implements ChestArena, CentrableArena, SpawneableArena {
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
private final List<ArenaLocation> supplyDrops = new ArrayList<>();
private final List<ArenaLocation> spawns = new ArrayList<>();
private final List<ArenaLocation> chestLocations = new ArrayList<>();
private final List<ArenaLocation> midChestLocations = new ArrayList<>();
private Location centerLocation;
private int spawnHeight;
// -------------------------------------------- //
// CONSTRUCTOR
// -------------------------------------------- //
@Inject private Arena(@Assisted("name") String name, @Assisted("worldName") String worldName, Provider<Injector> injector) {
super(name, worldName, injector.get());
}
@SuppressWarnings("unchecked")
@Override
protected void parseData(Map<String, Object> map) {
super.parseData(map);
if(map.containsKey("spawn-height")) {
this.spawnHeight = (int) map.get("spawn-height");
} else {
this.spawnHeight = 15;
}
if(map.containsKey("chests")) {
List<Map<String, Object>> chestList = (List<Map<String, Object>>) map.get("chests");
chestList.forEach(stringObjectMap -> {
chestLocations.add(ArenaLocation.deserialize(stringObjectMap, this));
});
}
if(map.containsKey("mid-chests")) {
List<Map<String, Object>> chestList = (List<Map<String, Object>>) map.get("mid-chests");
chestList.forEach(stringObjectMap -> {
midChestLocations.add(ArenaLocation.deserialize(stringObjectMap, this));
});
}
if(map.containsKey("supply-drops")) {
List<Map<String, Object>> supplyDropList = (List<Map<String, Object>>) map.get("supply-drops");
supplyDropList.forEach(stringObjectMap -> {
supplyDrops.add(ArenaLocation.deserialize(stringObjectMap, this));
});
}
if(arenaGroup == ArenaType.SOLO) {
if(map.containsKey("spawns")) {
List<Map<String, Object>> spawnList = (List<Map<String, Object>>) map.get("spawns");
spawnList.forEach(stringObjectMap -> {
spawns.add(ArenaLocation.deserialize(stringObjectMap, this));
});
}
needsLobbyLocation = false;
}
}
@Override
public void initializePhase() {
if(arenaGroup == null) {
return;
}
if(arenaGroup == ArenaType.TEAM) {
LobbyPhase lobbyPhase = addPhase(LobbyPhase.class);
lobbyPhase.setTeamItemSlot(3);
GameOptionsFeature gameOptionsFeature = lobbyPhase.registerFeature(GameOptionsFeature.class);
gameOptionsFeature.registerGameOption(lobbyPhase, TimeSelectorGameOption.class, 10);
gameOptionsFeature.registerGameOption(lobbyPhase, WeatherSelectorGameOption.class, 12);
gameOptionsFeature.registerGameOption(lobbyPhase, WalkTrailSelectorGameOption.class, 14);
gameOptionsFeature.registerGameOption(lobbyPhase, ProjectileTrailSelectorGameOption.class, 16);
gameOptionsFeature.setSlot(5);
addPhase(TeamAssignPhase.class);
}
WaitingPhase waitingPhase = addPhase(WaitingPhase.class);
GameOptionsFeature gameOptionsFeature = (GameOptionsFeature) waitingPhase.registerFeature(GameOptionsFeature.class);
gameOptionsFeature.registerGameOption(waitingPhase, TimeSelectorGameOption.class, 10);
gameOptionsFeature.registerGameOption(waitingPhase, WeatherSelectorGameOption.class, 12);
gameOptionsFeature.registerGameOption(waitingPhase, WalkTrailSelectorGameOption.class, 14);
gameOptionsFeature.registerGameOption(waitingPhase, ProjectileTrailSelectorGameOption.class, 16);
if(arenaGroup == ArenaType.TEAM) {
waitingPhase.setAutoStart(true);
} else {
waitingPhase.setCanJoin(true);
addPhase(TeamAssignPhase.class);
}
HungerGamesGameBasePhase hungerGamesGameBasePhase = addPhase(HungerGamesGameBasePhase.class);
if (config.getBoolean("grace-period.enabled")) {
GracePeriodFeature gracePeriodFeature = hungerGamesGameBasePhase.registerFeature(GracePeriodFeature.class);
int gracePeriodTime = config.getInt("grace-period.time");
gracePeriodFeature.setGraceTime(gracePeriodTime);
}
ConfigurationSection phases = config.getConfigurationSection(getArenaType().getName().toLowerCase() + "-phases");
for (String phaseString : phases.getKeys(false)) {
ConfigurationSection phasesConfigurationSection = phases.getConfigurationSection(phaseString);
PhaseType phaseType = PhaseType.getPhaseType(phasesConfigurationSection.getString("type"));
if(phaseType == null) {
Utils.printError("Unknown phase type " + phasesConfigurationSection.getString("type") + " in " + phasesConfigurationSection.getCurrentPath());
continue;
}
HungerGamesPhase phase = addPhase(phaseType.getPhaseClass());
phase.parseExtraData(phasesConfigurationSection);
((HungerGamesPhase)getPreviousPhase(phase)).setTimeTilNextPhase(phasesConfigurationSection.getInt("time"));
}
addPhase(CelebrationPhase.class);
addPhase(EndPhase.class);
if(arenaGroup == ArenaType.SOLO) {
createTeam("Players", DyeColor.YELLOW).setTeamChatPrefix(false);
needsLobbyLocation = false;
}
}
@Override
public void checkWin() {
if(arenaGroup == ArenaType.SOLO) {
if(getPlayers().size() == 1) {
// call the ArenaEndEvent with the winners and losers
plugin.callEvent(new GameEndEvent(this, getPlayers(), new PlayerList()));
setPhase(CelebrationPhase.class);
}
} else {
int teamsAlive = 0;
for (AbstractGameTeam gameTeam : teams.values()) {
if(gameTeam.getPlayers().size() > 0) {
teamsAlive++;
}
}
if(teamsAlive <= 1) {
// call the ArenaEndEvent with the winners and losers
plugin.callEvent(new GameEndEvent(this, getPlayers(), new PlayerList()));
setPhase(CelebrationPhase.class);
}
}
}
@Override
public List<ArenaLocation> getArenaChests(ChestLocation chestLocation) {
if (chestLocation == ChestLocations.REST) {
return chestLocations;
} else if (chestLocation == ChestLocations.MID) {
return midChestLocations;
}
throw new IllegalArgumentException("Unknown chest location " + chestLocation + "!");
}
// -------------------------------------------- //
// SAVING
// -------------------------------------------- //
@Override
public boolean canArenaBeEnabled(CommandSender commandSender) {
return super.canArenaBeEnabled(commandSender);
}
@Override
public Map<String, Object> serialize() {
Map<String, Object> dataMap = super.serialize();
if(arenaGroup == ArenaType.SOLO) {
dataMap.put("spawns", serializeSpawns());
}
dataMap.put("chests", serializeChests());
dataMap.put("supply-drops", serializeSupplyDropss());
dataMap.put("mid-chests", serializeMidChests());
dataMap.put("spawn-height", spawnHeight);
return dataMap;
}
private List<Map<String, Object>> serializeSpawns() {
List<Map<String, Object>> serializedSpawns = new ArrayList<>();
spawns.forEach(spawn -> serializedSpawns.add(spawn.serialize()));
return serializedSpawns;
}
private List<Map<String, Object>> serializeSupplyDropss() {
List<Map<String, Object>> serializedSupplyDrops = new ArrayList<>();
supplyDrops.forEach(supplyDrop -> serializedSupplyDrops.add(supplyDrop.serialize()));
return serializedSupplyDrops;
}
private List<Map<String, Object>> serializeChests() {
List<Map<String, Object>> serializedChests = new ArrayList<>();
chestLocations.forEach(chestLocation -> serializedChests.add(chestLocation.serialize()));
return serializedChests;
}
private List<Map<String, Object>> serializeMidChests() {
List<Map<String, Object>> serializedChests = new ArrayList<>();
midChestLocations.forEach(chestLocation -> serializedChests.add(chestLocation.serialize()));
return serializedChests;
}
@Override
protected List<Map<String, Object>> serializeTeams() {
return arenaGroup == ArenaType.SOLO ? null : super.serializeTeams();
}
// -------------------------------------------- //
// TEAMS
// -------------------------------------------- //
@Override
public GameTeam createTeam(String name, DyeColor color) {
Validate.isTrue(!teams.containsKey(name), "Team already exists!");
GameTeam gameTeam = new GameTeam(this, name, color);
addTeam(gameTeam);
return gameTeam;
}
@Override
public GameTeam createTeam(Map<String, Object> data) {
return new GameTeam(this, data);
}
@Override
public int getMinimumRequiredPlayers() {
return 2;
}
@Override
public void enableArena() {
chestLocations.clear();
for (Chunk chunk : area.getChunks()) {
chunk.load();
int cx = chunk.getX() << 4;
int cz = chunk.getZ() << 4;
for (int x = cx; x < cx + 16; x++) {
for (int z = cz; z < cz + 16; z++) {
for (int y = 0; y < 256; y++) {
if (getWorld().getBlockAt(x, y, z).getType() == Material.CHEST.parseMaterial() || getWorld().getBlockAt(x, y, z).getType() == Material.TRAPPED_CHEST.parseMaterial()) {
Location location = getWorld().getBlockAt(x, y, z).getLocation();
if(!midChestLocations.contains(new ArenaLocation(this, location))) {
chestLocations.add(new ArenaLocation(this, location));
}
}
}
}
}
}
super.enableArena();
}
// -------------------------------------------- //
// GETTERS AND SETTERS
// -------------------------------------------- //
@Override
public Location getCenterLocation() {
if(centerLocation == null) {
if(arenaGroup == ArenaType.SOLO) {
centerLocation = Utils.getCenterLocation(spawns);
} else {
List<ArenaLocation> locations = new ArrayList<>();
for (AbstractGameTeam gameTeam : teams.values()) {
locations.add(gameTeam.getSpawn());
}
centerLocation = Utils.getCenterLocation(locations);
}
}
return centerLocation;
}
public ArenaGroup getArenaType() {
return arenaGroup;
}
public List<ArenaLocation> getSupplyDrops() {
return supplyDrops;
}
@Override
public List<ArenaLocation> getSpawns() {
return spawns;
}
public List<ArenaLocation> getMidChestLocations() {
return midChestLocations;
}
@Override
public int getSpawnHeight() {
return spawnHeight;
}
public void setSpawnHeight(int spawnHeight) {
this.spawnHeight = spawnHeight;
}
@Override
public int getMaxPlayers() {
return arenaGroup == ArenaType.SOLO ? spawns.size() : super.getMaxPlayers();
}
}
| 14,159 | 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.