From 7192fa361ceda2aaad6506025ac601be2b2cec3a Mon Sep 17 00:00:00 2001 From: Andrew <65760867+VolanDeMor1@users.noreply.github.com> Date: Sat, 19 Jun 2021 11:42:11 +0300 Subject: [PATCH 1/7] Add files via upload --- pom.xml | 170 +++++++------- src/main/java/fun/asgard/Handler.java | 12 +- src/main/java/fun/asgard/TAGA.java | 17 +- .../api/events/gameevents/GameEvent.java | 70 ++++++ .../api/events/gameevents/GameStartEvent.java | 49 ++++ .../api/events/gameevents/GameStopEvent.java | 102 ++++++++ .../GamePlayerConnectEvent.java | 29 +++ .../GamePlayerDeathEvent.java | 30 +++ .../GamePlayerDisconnectEvent.java | 28 +++ .../gameplayerevents/GamePlayerEvent.java | 70 ++++++ .../GamePlayerJoinedTeamEvent.java | 13 ++ .../GamePlayerLeftTeamEvent.java | 13 ++ .../GameTeamDisconnectEvent.java | 19 ++ .../events/gameteamevents/GameTeamEvent.java | 52 +++++ .../fun/asgard/api/objects/game/BaseGame.java | 56 +++++ .../fun/asgard/api/objects/game/Game.java | 22 ++ .../asgard/api/objects/game/GamePlayer.java | 23 ++ .../fun/asgard/api/objects/game/GameTeam.java | 29 +++ .../fun/asgard/api/objects/game/TeamGame.java | 9 + .../api/objects/managers/GamesManager.java | 27 +++ .../api/objects/managers/PlayersManager.java | 55 +++++ .../api/objects/managers/TaskManager.java | 19 ++ .../fun/asgard/api/objects/task/Task.java | 11 + .../asgard/api/objects/task/TaskRunnable.java | 7 + src/main/java/fun/asgard/internal/Utils.java | 14 +- .../managers/gamemanager/AGameManager.java | 70 ++++++ .../managers/gamemanager/EGameManager.java | 12 + .../playersmanager/APlayersManager.java | 218 ++++++++++++++++++ .../playersmanager/EPlayersManager.java | 18 ++ .../managers/taskmanager/ATaskManager.java | 75 ++++++ .../managers/taskmanager/ETaskManager.java | 12 + .../asgard/internal/objects/game/AGame.java | 142 ++++++++++++ .../asgard/internal/objects/game/EGame.java | 19 ++ .../objects/gameplayer/AGamePlayer.java | 76 ++++++ .../objects/gameplayer/EGamePlayer.java | 20 ++ .../internal/objects/gameteam/AGameTeam.java | 76 ++++++ .../internal/objects/gameteam/EGameTeam.java | 18 ++ .../asgard/internal/objects/task/ATask.java | 32 +++ .../asgard/internal/objects/task/ETask.java | 11 + .../internal/objects/teamgame/ATeamGame.java | 143 ++++++++++++ .../internal/objects/teamgame/ETeamGame.java | 20 ++ src/test/java/SamplePlugin.java | 18 +- 42 files changed, 1813 insertions(+), 113 deletions(-) create mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java create mode 100644 src/main/java/fun/asgard/api/objects/game/BaseGame.java create mode 100644 src/main/java/fun/asgard/api/objects/game/Game.java create mode 100644 src/main/java/fun/asgard/api/objects/game/GamePlayer.java create mode 100644 src/main/java/fun/asgard/api/objects/game/GameTeam.java create mode 100644 src/main/java/fun/asgard/api/objects/game/TeamGame.java create mode 100644 src/main/java/fun/asgard/api/objects/managers/GamesManager.java create mode 100644 src/main/java/fun/asgard/api/objects/managers/PlayersManager.java create mode 100644 src/main/java/fun/asgard/api/objects/managers/TaskManager.java create mode 100644 src/main/java/fun/asgard/api/objects/task/Task.java create mode 100644 src/main/java/fun/asgard/api/objects/task/TaskRunnable.java create mode 100644 src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java create mode 100644 src/main/java/fun/asgard/internal/objects/game/AGame.java create mode 100644 src/main/java/fun/asgard/internal/objects/game/EGame.java create mode 100644 src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java create mode 100644 src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java create mode 100644 src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java create mode 100644 src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java create mode 100644 src/main/java/fun/asgard/internal/objects/task/ATask.java create mode 100644 src/main/java/fun/asgard/internal/objects/task/ETask.java create mode 100644 src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java create mode 100644 src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java diff --git a/pom.xml b/pom.xml index 97821f4..1e6c00d 100644 --- a/pom.xml +++ b/pom.xml @@ -1,82 +1,88 @@ - - - 4.0.0 - - fun.asgard - TAGA - v1.2.0 - jar - - TAGA - - - 11 - UTF-8 - - - - - github - GitHub TheAsgard Apache Maven Packages - https://maven.pkg.github.com/TheAsgard/TAGA - - - - - - - org.apache.maven.plugins - maven-compiler-plugin - 3.8.1 - - ${java.version} - ${java.version} - - - - org.apache.maven.plugins - maven-shade-plugin - 3.2.4 - - - package - - shade - - - false - - - - - - - - src/main/resources - true - - - - - - - papermc-repo - https://papermc.io/repo/repository/maven-public/ - - - sonatype - https://oss.sonatype.org/content/groups/public/ - - - - - - com.destroystokyo.paper - paper-api - 1.16.5-R0.1-SNAPSHOT - provided - - - + + + 4.0.0 + + fun.asgard + TAGA + v1.2.0 + jar + + TAGA + + + 11 + UTF-8 + + + + + + maven-assembly-plugin + + + + fun.asgard.TAGA + + + + jar-with-dependencies + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.2.4 + + + package + + shade + + + true + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.1 + + 15 + 15 + + + + + + src/main/resources + true + + + + + + + papermc-repo + https://papermc.io/repo/repository/maven-public/ + + + sonatype + https://oss.sonatype.org/content/groups/public/ + + + + + + com.destroystokyo.paper + paper-api + 1.16.5-R0.1-SNAPSHOT + provided + + + + diff --git a/src/main/java/fun/asgard/Handler.java b/src/main/java/fun/asgard/Handler.java index 8ea6b05..b8f1f46 100644 --- a/src/main/java/fun/asgard/Handler.java +++ b/src/main/java/fun/asgard/Handler.java @@ -1,7 +1,7 @@ package fun.asgard; -import fun.asgard.api.events.GamePlayerDeathEvent; -import fun.asgard.api.objects.GamePlayer; +import fun.asgard.api.events.gameplayerevents.GamePlayerDeathEvent; +import fun.asgard.api.objects.game.GamePlayer; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; @@ -23,8 +23,8 @@ protected Handler(TAGA taga, Plugin client) { public void onPlayerKick(PlayerKickEvent event) { this.pl.getGameManager().getGames().forEach((name, game) -> { if (game.isLeaveOnKick() - && game.getPlayers().containsKey(event.getPlayer())) { - game.disconnectPlayer(game.getPlayers().get(event.getPlayer())); + && game.getPlayersManager().getPlayers().containsKey(event.getPlayer())) { + game.getPlayersManager().disconnectPlayer(game.getPlayersManager().getPlayers().get(event.getPlayer())); } }); } @@ -32,8 +32,8 @@ public void onPlayerKick(PlayerKickEvent event) { @EventHandler public void onPlayerDeath(PlayerDeathEvent event) { this.pl.getGameManager().getGames().forEach((name, game) -> { - if (game.getPlayers().containsKey(event.getEntity())) { - GamePlayer gp = game.getPlayers().get(event.getEntity()); + if (game.getPlayersManager().getPlayers().containsKey(event.getEntity())) { + GamePlayer gp = game.getPlayersManager().getPlayers().get(event.getEntity()); gp.setDied(true); this.client.getServer().getPluginManager() .callEvent(new GamePlayerDeathEvent(game, gp)); diff --git a/src/main/java/fun/asgard/TAGA.java b/src/main/java/fun/asgard/TAGA.java index 2f1e7c7..ac05eed 100644 --- a/src/main/java/fun/asgard/TAGA.java +++ b/src/main/java/fun/asgard/TAGA.java @@ -1,17 +1,18 @@ package fun.asgard; -import fun.asgard.internal.managers.GameManager; -import fun.asgard.internal.managers.TaskManager; - +import fun.asgard.api.objects.managers.GamesManager; +import fun.asgard.api.objects.managers.TaskManager; +import fun.asgard.internal.managers.gamemanager.EGameManager; +import fun.asgard.internal.managers.taskmanager.ETaskManager; import org.bukkit.event.Listener; import org.bukkit.plugin.Plugin; public final class TAGA implements Listener { - private final GameManager gm; + private final GamesManager gm; private final TaskManager tm; - private static final String VERSION = "v1.2.0"; + private static final String VERSION = "v1.3.0"; public TAGA (Plugin client) { if (client == null) @@ -19,12 +20,12 @@ public TAGA (Plugin client) { client.getServer().getLogger().info("[TAGA] Starting TAGA-" + getVersion() + " on " + client.getServer().getVersion()); - this.gm = new GameManager(this, client); - this.tm = new TaskManager(this, client); + this.gm = new EGameManager(this, client); + this.tm = new ETaskManager(this, client); client.getServer().getPluginManager().registerEvents(new Handler(this, client), client); } - public GameManager getGameManager() { + public GamesManager getGameManager() { return gm; } diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java new file mode 100644 index 0000000..a3f128a --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java @@ -0,0 +1,70 @@ +package fun.asgard.api.events.gameevents; + +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +import java.util.HashSet; + +public class GameEvent extends Event { + + private static HandlerList handlers = null; + + private final TeamGame teamGame; + private final Game game; + private final HashSet winners = new HashSet<>(); + private final HashSet losers = new HashSet<>(); + private final HashSet players = new HashSet<>(); + + /** + * + * @param game Game + */ + protected GameEvent(Game game, HashSet winners, HashSet losers, HashSet players) { + handlers = new HandlerList(); + this.game = game; + this.teamGame = null; + } + + /** + * + * @param teamGame Game + */ + protected GameEvent(TeamGame teamGame, HashSet winners, HashSet losers, HashSet players) { + handlers = new HandlerList(); + this.teamGame = teamGame; + this.game = null; + } + + public HashSet getLosers() { + return losers; + } + + public HashSet getPlayers() { + return players; + } + + public HashSet getWinners() { + return winners; + } + + public TeamGame getTeamGame() { + return teamGame; + } + + public Game getGame() { + return game; + } + + public @NotNull HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java new file mode 100644 index 0000000..1e07dc6 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java @@ -0,0 +1,49 @@ +package fun.asgard.api.events.gameevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; + +import java.util.Arrays; +import java.util.HashSet; + +public class GameStartEvent extends GameEvent { + + /** + * + * @param game Game + * @param players Game players + */ + public GameStartEvent(Game game, GamePlayer[] players) { + super(game, null, null, new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + */ + public GameStartEvent(Game game, HashSet players) { + super(game, null, null, players); + } + + /** + * + * @param game Game + * @param players Game players + */ + public GameStartEvent(TeamGame game, GamePlayer[] players) { + super(game, null, null, new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + */ + public GameStartEvent(TeamGame game, HashSet players) { + super(game, null, null, players); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java new file mode 100644 index 0000000..f013487 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java @@ -0,0 +1,102 @@ +package fun.asgard.api.events.gameevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; + +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; + +public class GameStopEvent extends GameEvent { + + /** + * + * @param game Game + * @param players Game players + */ + public GameStopEvent(Game game, GamePlayer[] players) { + super(game, null, null, new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winner Winner of the game + * @param loser Loser of the game + */ + public GameStopEvent(Game game, GamePlayer[] players, GamePlayer winner, GamePlayer loser) { + super(game, new HashSet<>(Collections.singletonList(winner)), new HashSet<>(Collections.singletonList(loser)), + new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winners Winners of the game + * @param losers Losers of the game + */ + public GameStopEvent(Game game, GamePlayer[] players, GamePlayer[] winners, GamePlayer[] losers) { + super(game, new HashSet<>(Arrays.asList(winners)), new HashSet<>(Arrays.asList(losers)), + new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winners Winners of the game + * @param losers Losers of the game + */ + public GameStopEvent(Game game, HashSet players, HashSet winners, HashSet losers) { + super(game, winners, losers, players); + } + + /** + * + * @param game Game + * @param players Game players + */ + public GameStopEvent(TeamGame game, GamePlayer[] players) { + super(game, null, null, new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winner Winner of the game + * @param loser Loser of the game + */ + public GameStopEvent(TeamGame game, GamePlayer[] players, GamePlayer winner, GamePlayer loser) { + super(game, new HashSet<>(Collections.singletonList(winner)), new HashSet<>(Collections.singletonList(loser)), + new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winners Winners of the game + * @param losers Losers of the game + */ + public GameStopEvent(TeamGame game, GamePlayer[] players, GamePlayer[] winners, GamePlayer[] losers) { + super(game, new HashSet<>(Arrays.asList(winners)), new HashSet<>(Arrays.asList(losers)), + new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winners Winners of the game + * @param losers Losers of the game + */ + public GameStopEvent(TeamGame game, HashSet players, HashSet winners, HashSet losers) { + super(game, winners, losers, players); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java new file mode 100644 index 0000000..aa590c4 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java @@ -0,0 +1,29 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerConnectEvent extends GamePlayerEvent { + + /** + * + * @param game Game + * @param player Game player + */ + public GamePlayerConnectEvent(Game game, Player player, GamePlayer gamePlayer) { + super(game, player, gamePlayer); + } + + /** + * + * @param teamGame Team game + * @param player Game player + */ + public GamePlayerConnectEvent(TeamGame teamGame, Player player, GamePlayer gamePlayer) { + super(teamGame, player, gamePlayer); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java new file mode 100644 index 0000000..78184eb --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java @@ -0,0 +1,30 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerDeathEvent extends GamePlayerEvent { + + /** + * + * @param game Game + * @param player Game player + */ + public GamePlayerDeathEvent(Game game, GamePlayer player) { + super(game, null, player); + } + + + /** + * + * @param teamGame Team game + * @param player Game player + */ + public GamePlayerDeathEvent(TeamGame teamGame, Player player) { + super(teamGame, player, null); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java new file mode 100644 index 0000000..2131956 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java @@ -0,0 +1,28 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerDisconnectEvent extends GamePlayerEvent { + + /** + * + * @param game Game + * @param player Game player + */ + public GamePlayerDisconnectEvent(Game game, Player player) { + super(game, player, null); + } + + /** + * + * @param game Game + * @param player Game player + */ + public GamePlayerDisconnectEvent(TeamGame game, Player player) { + super(game, player, null); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java new file mode 100644 index 0000000..4b1bd7c --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java @@ -0,0 +1,70 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +public class GamePlayerEvent extends Event { + + private static HandlerList handlers = null; + + private final Player player; + private final GamePlayer gp; + private final TeamGame teamGame; + private final Game game; + + /** + * + * @param game Game + * @param player Game player + */ + protected GamePlayerEvent(Game game, Player player, GamePlayer gp) { + handlers = new HandlerList(); + this.gp = gp; + this.player = player; + this.game = game; + this.teamGame = null; + } + + /** + * + * @param teamGame Game + * @param player Game player + */ + protected GamePlayerEvent(TeamGame teamGame, Player player, GamePlayer gp) { + handlers = new HandlerList(); + this.gp = gp; + this.player = player; + this.teamGame = teamGame; + this.game = null; + } + + public GamePlayer getGamePlayer() { + return gp; + } + + public Player getPlayer() { + return player; + } + + public TeamGame getTeamGame() { + return teamGame; + } + + public Game getGame() { + return game; + } + + public @NotNull HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java new file mode 100644 index 0000000..0d16960 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java @@ -0,0 +1,13 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerJoinedTeamEvent extends GamePlayerEvent { + + public GamePlayerJoinedTeamEvent(TeamGame teamGame, Player player, GamePlayer gp) { + super(teamGame, player, gp); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java new file mode 100644 index 0000000..5820e67 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java @@ -0,0 +1,13 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerLeftTeamEvent extends GamePlayerEvent { + + public GamePlayerLeftTeamEvent(TeamGame teamGame, Player player, GamePlayer gp) { + super(teamGame, player, gp); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java new file mode 100644 index 0000000..9031c18 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java @@ -0,0 +1,19 @@ +package fun.asgard.api.events.gameteamevents; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +import java.util.Set; + +public class GameTeamDisconnectEvent extends GameTeamEvent { + + /** + * + * @param game Game + * @param players Game players + */ + public GameTeamDisconnectEvent(TeamGame game, Set players) { + super(game, players, null); + } + +} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java new file mode 100644 index 0000000..54287c4 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java @@ -0,0 +1,52 @@ +package fun.asgard.api.events.gameteamevents; + +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +import java.util.Set; + +public class GameTeamEvent extends Event { + + private static HandlerList handlers = null; + + private final Set players; + private final TeamGame game; + private final GameTeam team; + + /** + * + * @param game Team game + * @param players Game players + */ + protected GameTeamEvent(TeamGame game, Set players, GameTeam team) { + handlers = new HandlerList(); + this.players = players; + this.game = game; + this.team = team; + } + + public Set getPlayers() { + return players; + } + + public TeamGame getTeamGame() { + return game; + } + + public GameTeam getTeam() { + return team; + } + + public @NotNull HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} diff --git a/src/main/java/fun/asgard/api/objects/game/BaseGame.java b/src/main/java/fun/asgard/api/objects/game/BaseGame.java new file mode 100644 index 0000000..f8b6b77 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/BaseGame.java @@ -0,0 +1,56 @@ +package fun.asgard.api.objects.game; + +import org.bukkit.World; + +import java.util.HashSet; + +public interface BaseGame { + + /** + * After calling the method, GameStartEvent will be triggered + */ + void start(); + + /** + * After calling the method, GameEndEvent will be triggered + */ + void stop(boolean saveWorld); + + /** + * After calling the method, GameEndEvent will be triggered + */ + void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld); + + /** + * After calling the method, GameEndEvent will be triggered + */ + void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld); + + /** + * After calling the method, GameEndEvent will be triggered + */ + void stop(HashSet winners, HashSet losers, boolean saveWorld); + + /** + * After calling the method, no event will be triggered + */ + void shutdown(boolean saveWorld); + + + long getWhenStarted(); + + long getTime(); + + String getGameName(); + + World getWorld(); + + void setTime(long time); + + void setLeaveOnKick(boolean kickOnLeave); + + boolean isLeaveOnKick(); + + boolean isTeamGame(); + +} diff --git a/src/main/java/fun/asgard/api/objects/game/Game.java b/src/main/java/fun/asgard/api/objects/game/Game.java new file mode 100644 index 0000000..b0a34e0 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/Game.java @@ -0,0 +1,22 @@ +package fun.asgard.api.objects.game; + +import fun.asgard.api.objects.managers.PlayersManager; +import java.util.HashSet; + +public interface Game extends BaseGame { + + void start(); + + void stop(boolean saveWorld); + + void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld); + + void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld); + + void stop(HashSet winners, HashSet losers, boolean saveWorld); + + void shutdown(boolean saveWorld); + + PlayersManager getPlayersManager(); + +} diff --git a/src/main/java/fun/asgard/api/objects/game/GamePlayer.java b/src/main/java/fun/asgard/api/objects/game/GamePlayer.java new file mode 100644 index 0000000..3327c07 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/GamePlayer.java @@ -0,0 +1,23 @@ +package fun.asgard.api.objects.game; + +import org.bukkit.entity.Player; + +public interface GamePlayer { + + Player getPlayer(); + + BaseGame getGame(); + + int getScore(); + + GameTeam getTeam(); + + boolean isDied(); + + void setScore(int score); + + void setDied(boolean isDied); + + void setTeam(GameTeam team); + +} diff --git a/src/main/java/fun/asgard/api/objects/game/GameTeam.java b/src/main/java/fun/asgard/api/objects/game/GameTeam.java new file mode 100644 index 0000000..8b63ecc --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/GameTeam.java @@ -0,0 +1,29 @@ +package fun.asgard.api.objects.game; + +import org.bukkit.Color; + +import java.util.HashSet; + +public interface GameTeam { + + HashSet getPlayers(); + + BaseGame getTeamGame(); + + int getScore(); + + boolean isLost(); + + Color getColor(); + + String getName(); + + void setScore(int score); + + void setLost(boolean isLost); + + void setColor(Color color); + + void setName(String name); + +} diff --git a/src/main/java/fun/asgard/api/objects/game/TeamGame.java b/src/main/java/fun/asgard/api/objects/game/TeamGame.java new file mode 100644 index 0000000..2877de9 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/TeamGame.java @@ -0,0 +1,9 @@ +package fun.asgard.api.objects.game; + +import fun.asgard.api.objects.managers.PlayersManager; + +public interface TeamGame extends BaseGame { + + PlayersManager getPlayersManager(); + +} diff --git a/src/main/java/fun/asgard/api/objects/managers/GamesManager.java b/src/main/java/fun/asgard/api/objects/managers/GamesManager.java new file mode 100644 index 0000000..0c3da8e --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/managers/GamesManager.java @@ -0,0 +1,27 @@ +package fun.asgard.api.objects.managers; + +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.World; + +import java.util.HashMap; + +public interface GamesManager { + + Game createGame(World world, String gameName, long timer); + + Game createGame(World world, String gameName); + + TeamGame createTeamGame(World world, String gameName, long timer); + + TeamGame createTeamGame(World world, String gameName); + + Game getGame(String gameName); + + TeamGame getTeamGame(String gameName); + + HashMap getGames(); + + HashMap getTeamGames(); + +} diff --git a/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java b/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java new file mode 100644 index 0000000..a042fd6 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java @@ -0,0 +1,55 @@ +package fun.asgard.api.objects.managers; + +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.Color; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +import java.util.HashMap; + +public interface PlayersManager { + + Game getGame(); + + TeamGame getTeamGame(); + + HashMap getTeams(); + + HashMap getPlayers(); + + GameTeam getTeam(String name); + + void connectPlayer(Player player); + + void connectPlayer(Player player, Location location); + + void connectPlayer(Player player, double x, double y, double z); + + void disconnectPlayer(GamePlayer player); + + void disconnectPlayer(GamePlayer player, Location location); + + void disconnectPlayer(GamePlayer player, double x, double y, double z); + + GameTeam createTeam(String name, Color color); + + void connectPlayer(Player player, GameTeam team); + + void connectPlayer(Player player, GameTeam team, Location location); + + void connectPlayer(Player player, GameTeam team, double x, double y, double z); + + void disconnectTeam(GameTeam team); + + void disconnectTeam(GameTeam team, Location location); + + void disconnectTeam(GameTeam team, double x, double y, double z); + + void sendMessage(String message); + + void sendTeamMessage(String message, GameTeam team); + +} diff --git a/src/main/java/fun/asgard/api/objects/managers/TaskManager.java b/src/main/java/fun/asgard/api/objects/managers/TaskManager.java new file mode 100644 index 0000000..9012ce2 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/managers/TaskManager.java @@ -0,0 +1,19 @@ +package fun.asgard.api.objects.managers; + +import fun.asgard.api.objects.task.Task; +import fun.asgard.api.objects.task.TaskRunnable; +import org.jetbrains.annotations.NotNull; + +import java.util.HashMap; + +public interface TaskManager { + + void createTask(@NotNull TaskRunnable task, long delay, long period); + + void createTask(@NotNull TaskRunnable task, String taskName, long delay, long period); + + Task getTask(String taskName); + + HashMap getTasks(); + +} diff --git a/src/main/java/fun/asgard/api/objects/task/Task.java b/src/main/java/fun/asgard/api/objects/task/Task.java new file mode 100644 index 0000000..d1548d4 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/task/Task.java @@ -0,0 +1,11 @@ +package fun.asgard.api.objects.task; + +public interface Task { + + void cancel(); + + String getName(); + + void setName(String name); + +} diff --git a/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java b/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java new file mode 100644 index 0000000..e8793d8 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java @@ -0,0 +1,7 @@ +package fun.asgard.api.objects.task; + +public interface TaskRunnable { + + void execute(Task task); + +} diff --git a/src/main/java/fun/asgard/internal/Utils.java b/src/main/java/fun/asgard/internal/Utils.java index 6f7b0f4..274c863 100644 --- a/src/main/java/fun/asgard/internal/Utils.java +++ b/src/main/java/fun/asgard/internal/Utils.java @@ -1,18 +1,16 @@ package fun.asgard.internal; -import fun.asgard.api.objects.GamePlayer; - -import org.bukkit.entity.Player; - import java.util.HashMap; import java.util.HashSet; public class Utils { - public static HashSet getValuesFromHashMap(HashMap map) { - HashSet res = new HashSet<>(); - map.forEach((k, a) -> res.add(a)); - return res; + public static HashSet valueSet(HashMap map) { + return new HashSet<>(map.values()); + } + + public static double getRandom(double min, double max){ + return (Math.random() * ((max - min) + 1)) + min; } } diff --git a/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java b/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java new file mode 100644 index 0000000..7a38c13 --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java @@ -0,0 +1,70 @@ +package fun.asgard.internal.managers.gamemanager; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.TeamGame; +import fun.asgard.api.objects.managers.GamesManager; +import fun.asgard.internal.objects.game.EGame; + +import fun.asgard.internal.objects.teamgame.ETeamGame; +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +import java.util.HashMap; + +public abstract class AGameManager implements GamesManager { + + private final HashMap games = new HashMap<>(); + private final HashMap teamGames = new HashMap<>(); + private final TAGA taga; + private final Plugin client; + + protected AGameManager(TAGA taga, Plugin client) { + this.taga = taga; + this.client = client; + } + + @Override + public Game createGame(World world, String gameName, long timer) { + EGame game = new EGame(this.taga, this.client, world, gameName, timer); + this.games.put(gameName, game); + return game; + } + + @Override + public Game createGame(World world, String gameName) { + return this.createGame(world, gameName, -1); + } + + @Override + public TeamGame createTeamGame(World world, String gameName, long timer) { + TeamGame game = new ETeamGame(this.taga, this.client, world, gameName, timer); + this.teamGames.put(gameName, game); + return game; + } + + @Override + public TeamGame createTeamGame(World world, String gameName) { + return this.createTeamGame(world, gameName, -1); + } + + @Override + public Game getGame(String gameName) { + return this.getGames().get(gameName); + } + + @Override + public TeamGame getTeamGame(String gameName) { + return this.getTeamGames().get(gameName); + } + + @Override + public HashMap getGames() { + return this.games; + } + + @Override + public HashMap getTeamGames() { + return this.teamGames; + } +} diff --git a/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java b/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java new file mode 100644 index 0000000..bf306b6 --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java @@ -0,0 +1,12 @@ +package fun.asgard.internal.managers.gamemanager; + +import fun.asgard.TAGA; +import org.bukkit.plugin.Plugin; + +public class EGameManager extends AGameManager { + + public EGameManager(TAGA taga, Plugin client) { + super(taga, client); + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java b/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java new file mode 100644 index 0000000..49a688d --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java @@ -0,0 +1,218 @@ +package fun.asgard.internal.managers.playersmanager; + +import fun.asgard.TAGA; +import fun.asgard.api.events.gameplayerevents.GamePlayerConnectEvent; +import fun.asgard.api.events.gameplayerevents.GamePlayerDisconnectEvent; +import fun.asgard.api.events.gameplayerevents.GamePlayerJoinedTeamEvent; +import fun.asgard.api.events.gameteamevents.GameTeamDisconnectEvent; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import fun.asgard.api.objects.managers.PlayersManager; +import fun.asgard.internal.objects.gameplayer.EGamePlayer; +import org.bukkit.Color; +import org.bukkit.Location; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + +import java.util.HashMap; +import java.util.stream.Collectors; + +public abstract class APlayersManager implements PlayersManager { + + private final TAGA taga; + private final Plugin client; + private final Game game; + private final TeamGame teamGame; + private final HashMap teams; + + private final HashMap players = new HashMap<>(); + + protected APlayersManager(TAGA taga, Plugin client, Game game) { + this.client = client; + this.taga = taga; + this.game = game; + this.teamGame = null; + this.teams = null; + } + + protected APlayersManager(TAGA taga, Plugin client, TeamGame teamGame) { + this.client = client; + this.taga = taga; + this.game = null; + this.teamGame = teamGame; + this.teams = new HashMap<>(); + } + + @Override + public void connectPlayer(Player player) { + this.checkIfValidGame(); + GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); + this.players.put(player, gp); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, Location location) { + this.checkIfValidGame(); + GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); + this.players.put(player, gp); + player.teleport(location); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, double x, double y, double z) { + this.checkIfValidGame(); + GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); + this.players.put(player, gp); + player.teleport(new Location(getGame().getWorld(), x, y, z)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, GameTeam team) { + this.checkIfValidGame(true); + GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); + this.players.put(player, gp); + this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, GameTeam team, Location location) { + this.checkIfValidGame(true); + GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); + this.players.put(player, gp); + player.teleport(location); + this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, GameTeam team, double x, double y, double z) { + this.checkIfValidGame(true); + GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); + this.players.put(player, gp); + player.teleport(new Location(getTeamGame().getWorld(), x, y, z)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); + } + + @Override + public void disconnectPlayer(GamePlayer player) { + this.checkIfValidGame(); + this.players.remove(player.getPlayer()); + this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); + } + + @Override + public void disconnectPlayer(GamePlayer player, Location location) { + this.checkIfValidGame(); + this.players.remove(player.getPlayer()); + player.getPlayer().teleport(location); + this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); + } + + @Override + public void disconnectPlayer(GamePlayer player, double x, double y, double z) { + this.checkIfValidGame(); + this.players.remove(player.getPlayer()); + player.getPlayer().teleport(new Location(getGame().getWorld(), x, y, z)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); + } + + @Override + public void disconnectTeam(GameTeam team) { + this.checkIfValidGame(true); + team.getPlayers().forEach(pl -> this.players.remove(pl.getPlayer())); + this.teams.remove(team.getName()); + this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), + team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); + } + + @Override + public void disconnectTeam(GameTeam team, Location location) { + this.checkIfValidGame(true); + team.getPlayers().forEach(pl -> { + this.players.remove(pl.getPlayer()); + pl.getPlayer().teleport(location); + }); + this.teams.remove(team.getName()); + this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), + team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); + } + + @Override + public void disconnectTeam(GameTeam team, double x, double y, double z) { + this.checkIfValidGame(true); + team.getPlayers().forEach(pl -> { + this.players.remove(pl.getPlayer()); + pl.getPlayer().teleport(new Location(getGame().getWorld(), x, y, z)); + }); + this.teams.remove(team.getName()); + this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), + team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); + } + + @Override + public GameTeam createTeam(String name, Color color) { + this.checkIfValidGame(true); + return null; + } + + @Override + public void sendMessage(String message) { + this.getPlayers().forEach((player, gamePlayer) -> player.sendMessage(message)); + } + + @Override + public void sendTeamMessage(String message, GameTeam team) { + team.getPlayers().forEach(gamePlayer -> gamePlayer.getPlayer().sendMessage(message)); + } + + @Override + public Game getGame() { + return game; + } + + @Override + public TeamGame getTeamGame() { + return teamGame; + } + + @Override + public HashMap getPlayers() { + return players; + } + + @Override + public HashMap getTeams() { + return teams; + } + + @Override + public GameTeam getTeam(String name) { + return this.getTeams().get(name); + } + + public boolean isTeamGame() { + return this.getTeamGame() != null; + } + + private boolean checkIfValidGame() { + return this.checkIfValidGame(false); + } + + private boolean checkIfValidGame(boolean ifTeamInteraction) { + if (ifTeamInteraction && getTeamGame() == null) { + throw new IllegalCallerException("It is impossible to call the method, the game is not a team game!"); + } else if (!ifTeamInteraction && getGame() == null) { + throw new IllegalCallerException("It is impossible to call the method, the game is team!"); + } else { + return true; + } + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java b/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java new file mode 100644 index 0000000..57fcf39 --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java @@ -0,0 +1,18 @@ +package fun.asgard.internal.managers.playersmanager; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.plugin.Plugin; + +public class EPlayersManager extends APlayersManager { + + public EPlayersManager(TAGA taga, Plugin client, Game game) { + super(taga, client, game); + } + + public EPlayersManager(TAGA taga, Plugin client, TeamGame teamGame) { + super(taga, client, teamGame); + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java b/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java new file mode 100644 index 0000000..4ed709d --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java @@ -0,0 +1,75 @@ +package fun.asgard.internal.managers.taskmanager; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.managers.TaskManager; +import fun.asgard.api.objects.task.Task; +import fun.asgard.api.objects.task.TaskRunnable; +import fun.asgard.internal.Utils; +import fun.asgard.internal.objects.task.ETask; + +import org.bukkit.plugin.Plugin; + +import org.jetbrains.annotations.NotNull; + +import java.util.HashMap; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public abstract class ATaskManager implements TaskManager { + + private final TAGA taga; + private final Plugin client; + private final HashMap tasks = new HashMap<>(); + + protected ATaskManager(TAGA taga, Plugin client) { + this.taga = taga; + this.client = client; + } + + @Override + public void createTask(@NotNull TaskRunnable task, long delay, long period){ + if (delay < 0) + throw new IllegalArgumentException("Negative delay."); + if (period <= 0) + throw new IllegalArgumentException("Non-positive period."); + + ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); + String id = "Task-" + this.getRandomId(); + Task gt = new ETask(service, id); + service.scheduleWithFixedDelay(() -> task.execute(gt), delay, period, TimeUnit.MILLISECONDS); + + this.tasks.put(id, gt); + } + + @Override + public void createTask(@NotNull TaskRunnable task, String taskName, long delay, long period){ + if (delay < 0) + throw new IllegalArgumentException("Negative delay."); + if (period <= 0) + throw new IllegalArgumentException("Non-positive period."); + + ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); + Task gt = new ETask(service, taskName); + service.scheduleWithFixedDelay(() -> task.execute(gt), delay, period, TimeUnit.MILLISECONDS); + + this.tasks.put(taskName, gt); + } + + @Override + public Task getTask(String taskName) { + return this.getTasks().get(taskName); + } + + @Override + public HashMap getTasks() { + return tasks; + } + + private String getRandomId() { + String str = String.valueOf(Utils.getRandom(this.getTasks().size(), 1000)); + if (this.getTask(str) != null) return getRandomId(); + else return str; + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java b/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java new file mode 100644 index 0000000..f883d05 --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java @@ -0,0 +1,12 @@ +package fun.asgard.internal.managers.taskmanager; + +import fun.asgard.TAGA; +import org.bukkit.plugin.Plugin; + +public class ETaskManager extends ATaskManager { + + public ETaskManager(TAGA taga, Plugin client) { + super(taga, client); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/game/AGame.java b/src/main/java/fun/asgard/internal/objects/game/AGame.java new file mode 100644 index 0000000..6b75d81 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/game/AGame.java @@ -0,0 +1,142 @@ +package fun.asgard.internal.objects.game; + +import fun.asgard.TAGA; +import fun.asgard.api.events.gameevents.GameStartEvent; +import fun.asgard.api.events.gameevents.GameStopEvent; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.managers.PlayersManager; +import fun.asgard.internal.Utils; +import fun.asgard.internal.managers.playersmanager.EPlayersManager; +import org.bukkit.Bukkit; +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +import java.util.HashSet; + +public abstract class AGame implements Game { + + private final World world; + private final String gameName; + private final TAGA taga; + private final Plugin client; + private final PlayersManager playersManager; + + private long started; + private long time; + private boolean leaveOnKick = false; + + /** + * @param client The one who uses the api + * @param world World of the game + * @param gameName Name of the game + * @param time Game time + */ + protected AGame(TAGA taga, Plugin client, World world, String gameName, long time) { + this.taga = taga; + this.client = client; + this.gameName = gameName; + this.world = world; + this.time = time; + this.playersManager = new EPlayersManager(taga, client, this); + } + + @Override + public long getWhenStarted() { + return started; + } + + @Override + public long getTime() { + return time; + } + + @Override + public String getGameName() { + return gameName; + } + + @Override + public World getWorld() { + return world; + } + + @Override + public void setTime(long time) { + this.time = time; + } + + @Override + public void setLeaveOnKick(boolean kickOnLeave) { + this.leaveOnKick = kickOnLeave; + } + + @Override + public boolean isLeaveOnKick() { + return leaveOnKick; + } + + @Override + public void start() { + if (this.world.getLoadedChunks().length <= 0 + || !this.client.getServer().getWorlds().contains(this.world)) { + this.client.getServer().getWorlds().add(this.world); + } + + this.started = System.currentTimeMillis(); + Bukkit.getPluginManager().callEvent(new GameStartEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()))); + + } + + @Override + public void stop(boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray())); + this.shutdown(saveWorld); + } + + @Override + public void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winner, loser)); + this.shutdown(saveWorld); + } + + @Override + public void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winners, losers)); + this.shutdown(saveWorld); + } + + + @Override + public void stop(HashSet winners, HashSet losers, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()), winners, losers)); + this.shutdown(saveWorld); + } + + @Override + public void shutdown(boolean saveWorld) { + this.time = 0; + this.getPlayersManager().getPlayers().forEach((pl, gp) -> this.getPlayersManager().disconnectPlayer(gp)); + Bukkit.unloadWorld(this.world, saveWorld); + } + + @Override + public PlayersManager getPlayersManager() { + return this.playersManager; + } + + @Override + public boolean isTeamGame() { + return false; + } + + @Override + public String toString() { + return "Game { " + + "world = " + world.getName() + + ", gameName = '" + gameName + '\'' + + ", time = " + time + + '}'; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/game/EGame.java b/src/main/java/fun/asgard/internal/objects/game/EGame.java new file mode 100644 index 0000000..ccc5008 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/game/EGame.java @@ -0,0 +1,19 @@ +package fun.asgard.internal.objects.game; + +import fun.asgard.TAGA; +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +public class EGame extends AGame { + + /** + * @param client The one who uses the api + * @param world World of the game + * @param gameName Name of the game + * @param time Game time + */ + public EGame(TAGA taga, Plugin client, World world, String gameName, long time) { + super(taga, client, world, gameName, time); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java b/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java new file mode 100644 index 0000000..602ad92 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java @@ -0,0 +1,76 @@ +package fun.asgard.internal.objects.gameplayer; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public abstract class AGamePlayer implements GamePlayer { + + private final TAGA taga; + private final Player player; + private final Game game; + private final TeamGame teamgame; + private GameTeam team = null; + private int score = 0; + private boolean isDied = false; + + protected AGamePlayer(TAGA taga, Player player, Game game) { + this.taga = taga; + this.player = player; + this.game = game; + this.teamgame = null; + } + + protected AGamePlayer(TAGA taga, Player player, TeamGame game, GameTeam team) { + this.taga = taga; + this.player = player; + this.teamgame = game; + this.game = null; + this.team = team; + } + + @Override + public Player getPlayer() { + return this.player; + } + + @Override + public Game getGame() { + return this.game; + } + + @Override + public int getScore() { + return this.score; + } + + @Override + public GameTeam getTeam() { + return this.team; + } + + @Override + public boolean isDied() { + return this.isDied; + } + + @Override + public void setScore(int score) { + this.score = score; + } + + @Override + public void setDied(boolean isDied) { + this.isDied = isDied; + } + + @Override + public void setTeam(GameTeam team) { + this.team = team; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java b/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java new file mode 100644 index 0000000..7d4142d --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java @@ -0,0 +1,20 @@ +package fun.asgard.internal.objects.gameplayer; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GameTeam; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class EGamePlayer extends AGamePlayer { + + public EGamePlayer(TAGA taga, Player player, Game game) { + super(taga, player, game); + } + + public EGamePlayer(TAGA taga, Player player, TeamGame game, GameTeam team) { + super(taga, player, game, team); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java b/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java new file mode 100644 index 0000000..d9391cb --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java @@ -0,0 +1,76 @@ +package fun.asgard.internal.objects.gameteam; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.Color; + +import java.util.HashSet; + +public abstract class AGameTeam implements GameTeam { + + private final HashSet players = new HashSet<>(); + private final TeamGame game; + + private int score; + private boolean isLost; + private Color color; + private String name; + + protected AGameTeam(TeamGame game, Color color, String name) { + this.game = game; + this.color = color; + this.name = name; + } + + @Override + public HashSet getPlayers() { + return this.players; + } + + @Override + public TeamGame getTeamGame() { + return this.game; + } + + @Override + public int getScore() { + return this.score; + } + + @Override + public boolean isLost() { + return this.isLost; + } + + @Override + public Color getColor() { + return this.color; + } + + @Override + public String getName() { + return this.name; + } + + @Override + public void setScore(int score) { + this.score = score; + } + + @Override + public void setLost(boolean isLost) { + this.isLost = isLost; + } + + @Override + public void setColor(Color color) { + this.color = color; + } + + @Override + public void setName(String name) { + this.name = name; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java b/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java new file mode 100644 index 0000000..78abf59 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java @@ -0,0 +1,18 @@ +package fun.asgard.internal.objects.gameteam; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.Color; + +public class EGameTeam extends AGameTeam { + + /** + * + * @param teamGame Team game + * @param color Color of the team + * @param name Team name + */ + public EGameTeam(TeamGame teamGame, Color color, String name) { + super(teamGame, color, name); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/task/ATask.java b/src/main/java/fun/asgard/internal/objects/task/ATask.java new file mode 100644 index 0000000..e6d6646 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/task/ATask.java @@ -0,0 +1,32 @@ +package fun.asgard.internal.objects.task; + +import fun.asgard.api.objects.task.Task; + +import java.util.concurrent.ScheduledExecutorService; + +public abstract class ATask implements Task { + + private final ScheduledExecutorService service; + private String name; + + protected ATask(ScheduledExecutorService service, String name) { + this.service = service; + this.name = name; + } + + @Override + public void cancel() { + this.service.shutdown(); + } + + @Override + public String getName() { + return this.name; + } + + @Override + public void setName(String name) { + this.name = name; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/task/ETask.java b/src/main/java/fun/asgard/internal/objects/task/ETask.java new file mode 100644 index 0000000..63bcfeb --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/task/ETask.java @@ -0,0 +1,11 @@ +package fun.asgard.internal.objects.task; + +import java.util.concurrent.ScheduledExecutorService; + +public class ETask extends ATask { + + public ETask(ScheduledExecutorService service, String name) { + super(service, name); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java b/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java new file mode 100644 index 0000000..08ef092 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java @@ -0,0 +1,143 @@ +package fun.asgard.internal.objects.teamgame; + +import fun.asgard.TAGA; +import fun.asgard.api.events.gameevents.GameStartEvent; +import fun.asgard.api.events.gameevents.GameStopEvent; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import fun.asgard.api.objects.managers.PlayersManager; +import fun.asgard.internal.Utils; +import fun.asgard.internal.managers.playersmanager.EPlayersManager; +import org.bukkit.Bukkit; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + +import java.util.HashMap; +import java.util.HashSet; + +public abstract class ATeamGame implements TeamGame { + + private final PlayersManager playersManager; + private final World world; + private final String gameName; + private final TAGA taga; + private final Plugin client; + + private long started; + private long time; + private boolean leaveOnKick = false; + + /** + * @param client The one who uses the api + * @param world World of the game + * @param gameName Name of the game + * @param time Game time + */ + protected ATeamGame(TAGA taga, Plugin client, World world, String gameName, long time) { + this.taga = taga; + this.client = client; + this.gameName = gameName; + this.world = world; + this.time = time; + this.playersManager = new EPlayersManager(taga, client, this); + } + + @Override + public void start() { + if (this.world.getLoadedChunks().length <= 0 + || !this.client.getServer().getWorlds().contains(this.world)) { + this.client.getServer().getWorlds().add(this.world); + } + + this.started = System.currentTimeMillis(); + Bukkit.getPluginManager().callEvent(new GameStartEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()))); + } + + @Override + public void stop(boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray())); + this.shutdown(saveWorld); + } + + @Override + public void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winner, loser)); + this.shutdown(saveWorld); + } + + @Override + public void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winners, losers)); + this.shutdown(saveWorld); + } + + @Override + public void stop(HashSet winners, HashSet losers, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()), winners, losers)); + this.shutdown(saveWorld); + } + + @Override + public void shutdown(boolean saveWorld) { + this.time = 0; + this.getPlayersManager().getPlayers().forEach((pl, gp) -> this.getPlayersManager().disconnectPlayer(gp)); + Bukkit.unloadWorld(this.world, saveWorld); + } + + @Override + public PlayersManager getPlayersManager() { + return this.playersManager; + } + + @Override + public long getWhenStarted() { + return this.started; + } + + @Override + public long getTime() { + return this.time; + } + + @Override + public String getGameName() { + return this.gameName; + } + + @Override + public World getWorld() { + return this.world; + } + + @Override + public void setTime(long time) { + this.time = time; + } + + @Override + public void setLeaveOnKick(boolean leaveOnKick) { + this.leaveOnKick = leaveOnKick; + } + + @Override + public boolean isLeaveOnKick() { + return this.leaveOnKick; + } + + @Override + public boolean isTeamGame() { + return true; + } + + @Override + public String toString() { + return "TeamGame { " + + "world = " + world.getName() + + ", gameName = '" + gameName + '\'' + + ", time = " + time + + '}'; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java b/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java new file mode 100644 index 0000000..90c9ccb --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java @@ -0,0 +1,20 @@ +package fun.asgard.internal.objects.teamgame; + + +import fun.asgard.TAGA; +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +public class ETeamGame extends ATeamGame { + + /** + * @param client The one who uses the api + * @param world World of the game + * @param gameName Name of the game + * @param time Game time + */ + public ETeamGame(TAGA taga, Plugin client, World world, String gameName, long time) { + super(taga, client, world, gameName, time); + } + +} diff --git a/src/test/java/SamplePlugin.java b/src/test/java/SamplePlugin.java index 3940640..affd8a6 100644 --- a/src/test/java/SamplePlugin.java +++ b/src/test/java/SamplePlugin.java @@ -1,7 +1,7 @@ import fun.asgard.TAGA; -import fun.asgard.api.events.GameStartEvent; -import fun.asgard.api.events.GameStopEvent; -import fun.asgard.api.objects.Game; +import fun.asgard.api.events.gameevents.GameStartEvent; +import fun.asgard.api.events.gameevents.GameStopEvent; +import fun.asgard.api.objects.game.Game; import org.bukkit.Bukkit; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; @@ -18,7 +18,7 @@ public void onEnable() { Game game1 = taga.getGameManager().createGame(Bukkit.getWorld("world"), "SampleGame", 5 * 1000); Game game2 = taga.getGameManager().createGame(Bukkit.getWorld("world"), "SampleGame2", 5 * 1000); - game2.setKickOnLeave(true); + game2.setLeaveOnKick(true); } @Override @@ -28,9 +28,9 @@ public void onDisable() { @EventHandler public void onPlayerJoined(PlayerJoinEvent event) { - Game game = taga.getGameManager().getGames().get("ABOBA"); - game.connectPlayer(event.getPlayer()); - if (game.getPlayers().size() >= 1) { + Game game = taga.getGameManager().getGames().get("SampleGame2"); + game.getPlayersManager().connectPlayer(event.getPlayer()); + if (game.getPlayersManager().getPlayers().size() >= 1) { game.start(); } } @@ -40,10 +40,10 @@ public void onGameStart(GameStartEvent event) { event.getPlayers().forEach(player -> { player.getPlayer().sendMessage("Game is started!"); }); - taga.getTaskManager().createGameTask(() -> + taga.getTaskManager().createTask(task -> event.getPlayers().forEach(player -> player.getPlayer().sendMessage("5 minutes of the game has passed!")), - event.getGame(), 5 * 60 * 1000, 5 * 60 * 1000); + event.getGame().getGameName(), 5 * 60 * 1000, 5 * 60 * 1000); } @EventHandler From 14f848f64815ee1a4fc5ae0cedf7c41760397409 Mon Sep 17 00:00:00 2001 From: Andrew <65760867+VolanDeMor1@users.noreply.github.com> Date: Sat, 19 Jun 2021 11:43:46 +0300 Subject: [PATCH 2/7] Update maven-publish.yml --- .github/workflows/maven-publish.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/maven-publish.yml b/.github/workflows/maven-publish.yml index bc15d30..30d5ee5 100644 --- a/.github/workflows/maven-publish.yml +++ b/.github/workflows/maven-publish.yml @@ -18,10 +18,10 @@ jobs: steps: - uses: actions/checkout@v2 - - name: Set up JDK 11 + - name: Set up JDK 16 uses: actions/setup-java@v2 with: - java-version: '11' + java-version: '16' distribution: 'adopt' server-id: github # Value of the distributionManagement/repository/id field of the pom.xml settings-path: ${{ github.workspace }} # location for the settings.xml file From e018308e66c44ca9dc4563819caa57da98b08245 Mon Sep 17 00:00:00 2001 From: Andrew <65760867+VolanDeMor1@users.noreply.github.com> Date: Sat, 19 Jun 2021 11:44:01 +0300 Subject: [PATCH 3/7] Update maven.yml --- .github/workflows/maven.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml index 61064f4..a5c3bc3 100644 --- a/.github/workflows/maven.yml +++ b/.github/workflows/maven.yml @@ -16,10 +16,10 @@ jobs: steps: - uses: actions/checkout@v2 - - name: Set up JDK 11 + - name: Set up JDK 16 uses: actions/setup-java@v2 with: - java-version: '11' + java-version: '16' distribution: 'adopt' - name: Build with Maven run: mvn -B package --file pom.xml From 8abe2ebfff1712c8fff6843b2cd9f4ef61d00568 Mon Sep 17 00:00:00 2001 From: Andrew <65760867+VolanDeMor1@users.noreply.github.com> Date: Sat, 19 Jun 2021 11:49:38 +0300 Subject: [PATCH 4/7] Update pom.xml --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 1e6c00d..7673a3b 100644 --- a/pom.xml +++ b/pom.xml @@ -12,7 +12,7 @@ TAGA - 11 + 16 UTF-8 From 3411a3040048d9150b466724e9348ddd4c8cee6b Mon Sep 17 00:00:00 2001 From: Andrew <65760867+VolanDeMor1@users.noreply.github.com> Date: Sat, 19 Jun 2021 11:53:47 +0300 Subject: [PATCH 5/7] Delete src directory --- src/main/java/fun/asgard/Handler.java | 44 ---- src/main/java/fun/asgard/TAGA.java | 40 ---- .../api/events/GamePlayerDeathEvent.java | 44 ---- .../fun/asgard/api/events/GameStartEvent.java | 57 ----- .../fun/asgard/api/events/GameStopEvent.java | 101 -------- .../asgard/api/events/PlayerConnectEvent.java | 44 ---- .../api/events/PlayerDisconnectEvent.java | 44 ---- .../api/events/gameevents/GameEvent.java | 70 ------ .../api/events/gameevents/GameStartEvent.java | 49 ---- .../api/events/gameevents/GameStopEvent.java | 102 -------- .../GamePlayerConnectEvent.java | 29 --- .../GamePlayerDeathEvent.java | 30 --- .../GamePlayerDisconnectEvent.java | 28 --- .../gameplayerevents/GamePlayerEvent.java | 70 ------ .../GamePlayerJoinedTeamEvent.java | 13 -- .../GamePlayerLeftTeamEvent.java | 13 -- .../GameTeamDisconnectEvent.java | 19 -- .../events/gameteamevents/GameTeamEvent.java | 52 ----- .../java/fun/asgard/api/objects/Game.java | 74 ------ .../fun/asgard/api/objects/GamePlayer.java | 19 -- .../java/fun/asgard/api/objects/GameTask.java | 9 - .../fun/asgard/api/objects/game/BaseGame.java | 56 ----- .../fun/asgard/api/objects/game/Game.java | 22 -- .../asgard/api/objects/game/GamePlayer.java | 23 -- .../fun/asgard/api/objects/game/GameTeam.java | 29 --- .../fun/asgard/api/objects/game/TeamGame.java | 9 - .../api/objects/managers/GamesManager.java | 27 --- .../api/objects/managers/PlayersManager.java | 55 ----- .../api/objects/managers/TaskManager.java | 19 -- .../fun/asgard/api/objects/task/Task.java | 11 - .../asgard/api/objects/task/TaskRunnable.java | 7 - src/main/java/fun/asgard/internal/Utils.java | 16 -- .../asgard/internal/managers/GameManager.java | 41 ---- .../asgard/internal/managers/TaskManager.java | 52 ----- .../managers/gamemanager/AGameManager.java | 70 ------ .../managers/gamemanager/EGameManager.java | 12 - .../playersmanager/APlayersManager.java | 218 ------------------ .../playersmanager/EPlayersManager.java | 18 -- .../managers/taskmanager/ATaskManager.java | 75 ------ .../managers/taskmanager/ETaskManager.java | 12 - .../asgard/internal/objects/Game/AGame.java | 196 ---------------- .../asgard/internal/objects/Game/EGame.java | 19 -- .../objects/GamePlayer/AGamePlayer.java | 53 ----- .../objects/GamePlayer/EGamePlayer.java | 14 -- .../internal/objects/GameTask/AGameTask.java | 29 --- .../internal/objects/GameTask/EGameTask.java | 13 -- .../asgard/internal/objects/game/AGame.java | 142 ------------ .../asgard/internal/objects/game/EGame.java | 19 -- .../objects/gameplayer/AGamePlayer.java | 76 ------ .../objects/gameplayer/EGamePlayer.java | 20 -- .../internal/objects/gameteam/AGameTeam.java | 76 ------ .../internal/objects/gameteam/EGameTeam.java | 18 -- .../asgard/internal/objects/task/ATask.java | 32 --- .../asgard/internal/objects/task/ETask.java | 11 - .../internal/objects/teamgame/ATeamGame.java | 143 ------------ .../internal/objects/teamgame/ETeamGame.java | 20 -- src/test/java/SamplePlugin.java | 56 ----- src/test/resources/plugin.yml | 5 - 58 files changed, 2665 deletions(-) delete mode 100644 src/main/java/fun/asgard/Handler.java delete mode 100644 src/main/java/fun/asgard/TAGA.java delete mode 100644 src/main/java/fun/asgard/api/events/GamePlayerDeathEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/GameStartEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/GameStopEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/PlayerConnectEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/PlayerDisconnectEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java delete mode 100644 src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java delete mode 100644 src/main/java/fun/asgard/api/objects/Game.java delete mode 100644 src/main/java/fun/asgard/api/objects/GamePlayer.java delete mode 100644 src/main/java/fun/asgard/api/objects/GameTask.java delete mode 100644 src/main/java/fun/asgard/api/objects/game/BaseGame.java delete mode 100644 src/main/java/fun/asgard/api/objects/game/Game.java delete mode 100644 src/main/java/fun/asgard/api/objects/game/GamePlayer.java delete mode 100644 src/main/java/fun/asgard/api/objects/game/GameTeam.java delete mode 100644 src/main/java/fun/asgard/api/objects/game/TeamGame.java delete mode 100644 src/main/java/fun/asgard/api/objects/managers/GamesManager.java delete mode 100644 src/main/java/fun/asgard/api/objects/managers/PlayersManager.java delete mode 100644 src/main/java/fun/asgard/api/objects/managers/TaskManager.java delete mode 100644 src/main/java/fun/asgard/api/objects/task/Task.java delete mode 100644 src/main/java/fun/asgard/api/objects/task/TaskRunnable.java delete mode 100644 src/main/java/fun/asgard/internal/Utils.java delete mode 100644 src/main/java/fun/asgard/internal/managers/GameManager.java delete mode 100644 src/main/java/fun/asgard/internal/managers/TaskManager.java delete mode 100644 src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java delete mode 100644 src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java delete mode 100644 src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java delete mode 100644 src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java delete mode 100644 src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java delete mode 100644 src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java delete mode 100644 src/main/java/fun/asgard/internal/objects/Game/AGame.java delete mode 100644 src/main/java/fun/asgard/internal/objects/Game/EGame.java delete mode 100644 src/main/java/fun/asgard/internal/objects/GamePlayer/AGamePlayer.java delete mode 100644 src/main/java/fun/asgard/internal/objects/GamePlayer/EGamePlayer.java delete mode 100644 src/main/java/fun/asgard/internal/objects/GameTask/AGameTask.java delete mode 100644 src/main/java/fun/asgard/internal/objects/GameTask/EGameTask.java delete mode 100644 src/main/java/fun/asgard/internal/objects/game/AGame.java delete mode 100644 src/main/java/fun/asgard/internal/objects/game/EGame.java delete mode 100644 src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java delete mode 100644 src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java delete mode 100644 src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java delete mode 100644 src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java delete mode 100644 src/main/java/fun/asgard/internal/objects/task/ATask.java delete mode 100644 src/main/java/fun/asgard/internal/objects/task/ETask.java delete mode 100644 src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java delete mode 100644 src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java delete mode 100644 src/test/java/SamplePlugin.java delete mode 100644 src/test/resources/plugin.yml diff --git a/src/main/java/fun/asgard/Handler.java b/src/main/java/fun/asgard/Handler.java deleted file mode 100644 index b8f1f46..0000000 --- a/src/main/java/fun/asgard/Handler.java +++ /dev/null @@ -1,44 +0,0 @@ -package fun.asgard; - -import fun.asgard.api.events.gameplayerevents.GamePlayerDeathEvent; -import fun.asgard.api.objects.game.GamePlayer; - -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.entity.PlayerDeathEvent; -import org.bukkit.event.player.PlayerKickEvent; -import org.bukkit.plugin.Plugin; - -public class Handler implements Listener { - - private final TAGA pl; - private final Plugin client; - - protected Handler(TAGA taga, Plugin client) { - this.pl = taga; - this.client = client; - } - - @EventHandler - public void onPlayerKick(PlayerKickEvent event) { - this.pl.getGameManager().getGames().forEach((name, game) -> { - if (game.isLeaveOnKick() - && game.getPlayersManager().getPlayers().containsKey(event.getPlayer())) { - game.getPlayersManager().disconnectPlayer(game.getPlayersManager().getPlayers().get(event.getPlayer())); - } - }); - } - - @EventHandler - public void onPlayerDeath(PlayerDeathEvent event) { - this.pl.getGameManager().getGames().forEach((name, game) -> { - if (game.getPlayersManager().getPlayers().containsKey(event.getEntity())) { - GamePlayer gp = game.getPlayersManager().getPlayers().get(event.getEntity()); - gp.setDied(true); - this.client.getServer().getPluginManager() - .callEvent(new GamePlayerDeathEvent(game, gp)); - } - }); - } - -} diff --git a/src/main/java/fun/asgard/TAGA.java b/src/main/java/fun/asgard/TAGA.java deleted file mode 100644 index ac05eed..0000000 --- a/src/main/java/fun/asgard/TAGA.java +++ /dev/null @@ -1,40 +0,0 @@ -package fun.asgard; - -import fun.asgard.api.objects.managers.GamesManager; -import fun.asgard.api.objects.managers.TaskManager; -import fun.asgard.internal.managers.gamemanager.EGameManager; -import fun.asgard.internal.managers.taskmanager.ETaskManager; -import org.bukkit.event.Listener; -import org.bukkit.plugin.Plugin; - -public final class TAGA implements Listener { - - private final GamesManager gm; - private final TaskManager tm; - - private static final String VERSION = "v1.3.0"; - - public TAGA (Plugin client) { - if (client == null) - throw new IllegalArgumentException("Plugin must be valid"); - - client.getServer().getLogger().info("[TAGA] Starting TAGA-" + getVersion() + " on " + client.getServer().getVersion()); - - this.gm = new EGameManager(this, client); - this.tm = new ETaskManager(this, client); - client.getServer().getPluginManager().registerEvents(new Handler(this, client), client); - } - - public GamesManager getGameManager() { - return gm; - } - - public TaskManager getTaskManager() { - return tm; - } - - public static String getVersion() { - return VERSION; - } - -} diff --git a/src/main/java/fun/asgard/api/events/GamePlayerDeathEvent.java b/src/main/java/fun/asgard/api/events/GamePlayerDeathEvent.java deleted file mode 100644 index 95e2a35..0000000 --- a/src/main/java/fun/asgard/api/events/GamePlayerDeathEvent.java +++ /dev/null @@ -1,44 +0,0 @@ -package fun.asgard.api.events; - -import fun.asgard.api.objects.Game; - -import fun.asgard.api.objects.GamePlayer; -import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; - -import org.jetbrains.annotations.NotNull; - -public class GamePlayerDeathEvent extends Event { - - private static final HandlerList handlers = new HandlerList(); - - private final GamePlayer player; - private final Game game; - - /** - * - * @param game Game - * @param player Game player - */ - public GamePlayerDeathEvent(Game game, GamePlayer player) { - this.player = player; - this.game = game; - } - - public GamePlayer getPlayer() { - return player; - } - - public Game getGame() { - return game; - } - - public @NotNull HandlerList getHandlers() { - return handlers; - } - - public static HandlerList getHandlerList() { - return handlers; - } - -} diff --git a/src/main/java/fun/asgard/api/events/GameStartEvent.java b/src/main/java/fun/asgard/api/events/GameStartEvent.java deleted file mode 100644 index 8d740b7..0000000 --- a/src/main/java/fun/asgard/api/events/GameStartEvent.java +++ /dev/null @@ -1,57 +0,0 @@ -package fun.asgard.api.events; - -import fun.asgard.api.objects.Game; - -import fun.asgard.api.objects.GamePlayer; -import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; - -import org.jetbrains.annotations.NotNull; - -import java.util.Arrays; -import java.util.HashSet; - -public class GameStartEvent extends Event { - - private static final HandlerList handlers = new HandlerList(); - - private final HashSet players = new HashSet<>(); - private final Game game; - - /** - * - * @param game Game - * @param players Game players - */ - public GameStartEvent(Game game, GamePlayer[] players) { - this.players.addAll(Arrays.asList(players)); - this.game = game; - } - - /** - * - * @param game Game - * @param players Game players - */ - public GameStartEvent(Game game, HashSet players) { - this.players.addAll(players); - this.game = game; - } - - public HashSet getPlayers() { - return players; - } - - public Game getGame() { - return game; - } - - public @NotNull HandlerList getHandlers() { - return handlers; - } - - public static HandlerList getHandlerList() { - return handlers; - } - -} diff --git a/src/main/java/fun/asgard/api/events/GameStopEvent.java b/src/main/java/fun/asgard/api/events/GameStopEvent.java deleted file mode 100644 index 141dcd3..0000000 --- a/src/main/java/fun/asgard/api/events/GameStopEvent.java +++ /dev/null @@ -1,101 +0,0 @@ -package fun.asgard.api.events; - -import fun.asgard.api.objects.Game; - -import fun.asgard.api.objects.GamePlayer; -import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; - -import org.jetbrains.annotations.NotNull; - -import java.util.Arrays; -import java.util.HashSet; - -public class GameStopEvent extends Event { - - private static final HandlerList handlers = new HandlerList(); - - private final Game game; - private final HashSet winners = new HashSet<>(); - private final HashSet losers = new HashSet<>(); - private final HashSet players = new HashSet<>(); - - /** - * - * @param game Game - * @param players Game players - */ - public GameStopEvent(Game game, GamePlayer[] players) { - this.players.addAll(Arrays.asList(players)); - this.game = game; - } - - /** - * - * @param game Game - * @param players Game players - * @param winner Winner of the game - * @param loser Loser of the game - */ - public GameStopEvent(Game game, GamePlayer[] players, GamePlayer winner, GamePlayer loser) { - this.players.addAll(Arrays.asList(players)); - this.game = game; - this.winners.add(winner); - this.losers.add(loser); - } - - /** - * - * @param game Game - * @param players Game players - * @param winners Winners of the game - * @param losers Losers of the game - */ - public GameStopEvent(Game game, GamePlayer[] players, GamePlayer[] winners, GamePlayer[] losers) { - this.players.addAll(Arrays.asList(players)); - this.game = game; - - this.winners.addAll(Arrays.asList(winners)); - this.losers.addAll(Arrays.asList(losers)); - } - - /** - * - * @param game Game - * @param players Game players - * @param winners Winners of the game - * @param losers Losers of the game - */ - public GameStopEvent(Game game, HashSet players, HashSet winners, HashSet losers) { - this.players.addAll(players); - this.game = game; - - this.winners.addAll(winners); - this.losers.addAll(losers); - } - - public HashSet getLosers() { - return losers; - } - - public HashSet getWinners() { - return winners; - } - - public HashSet getPlayers() { - return players; - } - - public Game getGame() { - return game; - } - - public @NotNull HandlerList getHandlers() { - return handlers; - } - - public static HandlerList getHandlerList() { - return handlers; - } - -} diff --git a/src/main/java/fun/asgard/api/events/PlayerConnectEvent.java b/src/main/java/fun/asgard/api/events/PlayerConnectEvent.java deleted file mode 100644 index 9702030..0000000 --- a/src/main/java/fun/asgard/api/events/PlayerConnectEvent.java +++ /dev/null @@ -1,44 +0,0 @@ -package fun.asgard.api.events; - -import fun.asgard.api.objects.Game; - -import org.bukkit.entity.Player; -import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; - -import org.jetbrains.annotations.NotNull; - -public class PlayerConnectEvent extends Event { - - private static final HandlerList handlers = new HandlerList(); - - private final Player player; - private final Game game; - - /** - * - * @param game Game - * @param player Game player - */ - public PlayerConnectEvent(Game game, Player player) { - this.player = player; - this.game = game; - } - - public Player getPlayer() { - return player; - } - - public Game getGame() { - return game; - } - - public @NotNull HandlerList getHandlers() { - return handlers; - } - - public static HandlerList getHandlerList() { - return handlers; - } - -} diff --git a/src/main/java/fun/asgard/api/events/PlayerDisconnectEvent.java b/src/main/java/fun/asgard/api/events/PlayerDisconnectEvent.java deleted file mode 100644 index de4ce21..0000000 --- a/src/main/java/fun/asgard/api/events/PlayerDisconnectEvent.java +++ /dev/null @@ -1,44 +0,0 @@ -package fun.asgard.api.events; - -import fun.asgard.api.objects.Game; - -import org.bukkit.entity.Player; -import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; - -import org.jetbrains.annotations.NotNull; - -public class PlayerDisconnectEvent extends Event { - - private static final HandlerList handlers = new HandlerList(); - - private final Player player; - private final Game game; - - /** - * - * @param game Game - * @param player Game player - */ - public PlayerDisconnectEvent(Game game, Player player) { - this.player = player; - this.game = game; - } - - public Player getPlayer() { - return player; - } - - public Game getGame() { - return game; - } - - public @NotNull HandlerList getHandlers() { - return handlers; - } - - public static HandlerList getHandlerList() { - return handlers; - } - -} diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java deleted file mode 100644 index a3f128a..0000000 --- a/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java +++ /dev/null @@ -1,70 +0,0 @@ -package fun.asgard.api.events.gameevents; - -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; -import org.jetbrains.annotations.NotNull; - -import java.util.HashSet; - -public class GameEvent extends Event { - - private static HandlerList handlers = null; - - private final TeamGame teamGame; - private final Game game; - private final HashSet winners = new HashSet<>(); - private final HashSet losers = new HashSet<>(); - private final HashSet players = new HashSet<>(); - - /** - * - * @param game Game - */ - protected GameEvent(Game game, HashSet winners, HashSet losers, HashSet players) { - handlers = new HandlerList(); - this.game = game; - this.teamGame = null; - } - - /** - * - * @param teamGame Game - */ - protected GameEvent(TeamGame teamGame, HashSet winners, HashSet losers, HashSet players) { - handlers = new HandlerList(); - this.teamGame = teamGame; - this.game = null; - } - - public HashSet getLosers() { - return losers; - } - - public HashSet getPlayers() { - return players; - } - - public HashSet getWinners() { - return winners; - } - - public TeamGame getTeamGame() { - return teamGame; - } - - public Game getGame() { - return game; - } - - public @NotNull HandlerList getHandlers() { - return handlers; - } - - public static HandlerList getHandlerList() { - return handlers; - } - -} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java deleted file mode 100644 index 1e07dc6..0000000 --- a/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java +++ /dev/null @@ -1,49 +0,0 @@ -package fun.asgard.api.events.gameevents; - -import fun.asgard.api.objects.game.Game; - -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.TeamGame; - -import java.util.Arrays; -import java.util.HashSet; - -public class GameStartEvent extends GameEvent { - - /** - * - * @param game Game - * @param players Game players - */ - public GameStartEvent(Game game, GamePlayer[] players) { - super(game, null, null, new HashSet<>(Arrays.asList(players))); - } - - /** - * - * @param game Game - * @param players Game players - */ - public GameStartEvent(Game game, HashSet players) { - super(game, null, null, players); - } - - /** - * - * @param game Game - * @param players Game players - */ - public GameStartEvent(TeamGame game, GamePlayer[] players) { - super(game, null, null, new HashSet<>(Arrays.asList(players))); - } - - /** - * - * @param game Game - * @param players Game players - */ - public GameStartEvent(TeamGame game, HashSet players) { - super(game, null, null, players); - } - -} diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java deleted file mode 100644 index f013487..0000000 --- a/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java +++ /dev/null @@ -1,102 +0,0 @@ -package fun.asgard.api.events.gameevents; - -import fun.asgard.api.objects.game.Game; - -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.TeamGame; - -import java.util.Arrays; -import java.util.Collections; -import java.util.HashSet; - -public class GameStopEvent extends GameEvent { - - /** - * - * @param game Game - * @param players Game players - */ - public GameStopEvent(Game game, GamePlayer[] players) { - super(game, null, null, new HashSet<>(Arrays.asList(players))); - } - - /** - * - * @param game Game - * @param players Game players - * @param winner Winner of the game - * @param loser Loser of the game - */ - public GameStopEvent(Game game, GamePlayer[] players, GamePlayer winner, GamePlayer loser) { - super(game, new HashSet<>(Collections.singletonList(winner)), new HashSet<>(Collections.singletonList(loser)), - new HashSet<>(Arrays.asList(players))); - } - - /** - * - * @param game Game - * @param players Game players - * @param winners Winners of the game - * @param losers Losers of the game - */ - public GameStopEvent(Game game, GamePlayer[] players, GamePlayer[] winners, GamePlayer[] losers) { - super(game, new HashSet<>(Arrays.asList(winners)), new HashSet<>(Arrays.asList(losers)), - new HashSet<>(Arrays.asList(players))); - } - - /** - * - * @param game Game - * @param players Game players - * @param winners Winners of the game - * @param losers Losers of the game - */ - public GameStopEvent(Game game, HashSet players, HashSet winners, HashSet losers) { - super(game, winners, losers, players); - } - - /** - * - * @param game Game - * @param players Game players - */ - public GameStopEvent(TeamGame game, GamePlayer[] players) { - super(game, null, null, new HashSet<>(Arrays.asList(players))); - } - - /** - * - * @param game Game - * @param players Game players - * @param winner Winner of the game - * @param loser Loser of the game - */ - public GameStopEvent(TeamGame game, GamePlayer[] players, GamePlayer winner, GamePlayer loser) { - super(game, new HashSet<>(Collections.singletonList(winner)), new HashSet<>(Collections.singletonList(loser)), - new HashSet<>(Arrays.asList(players))); - } - - /** - * - * @param game Game - * @param players Game players - * @param winners Winners of the game - * @param losers Losers of the game - */ - public GameStopEvent(TeamGame game, GamePlayer[] players, GamePlayer[] winners, GamePlayer[] losers) { - super(game, new HashSet<>(Arrays.asList(winners)), new HashSet<>(Arrays.asList(losers)), - new HashSet<>(Arrays.asList(players))); - } - - /** - * - * @param game Game - * @param players Game players - * @param winners Winners of the game - * @param losers Losers of the game - */ - public GameStopEvent(TeamGame game, HashSet players, HashSet winners, HashSet losers) { - super(game, winners, losers, players); - } - -} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java deleted file mode 100644 index aa590c4..0000000 --- a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java +++ /dev/null @@ -1,29 +0,0 @@ -package fun.asgard.api.events.gameplayerevents; - -import fun.asgard.api.objects.game.Game; - -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; - -public class GamePlayerConnectEvent extends GamePlayerEvent { - - /** - * - * @param game Game - * @param player Game player - */ - public GamePlayerConnectEvent(Game game, Player player, GamePlayer gamePlayer) { - super(game, player, gamePlayer); - } - - /** - * - * @param teamGame Team game - * @param player Game player - */ - public GamePlayerConnectEvent(TeamGame teamGame, Player player, GamePlayer gamePlayer) { - super(teamGame, player, gamePlayer); - } - -} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java deleted file mode 100644 index 78184eb..0000000 --- a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java +++ /dev/null @@ -1,30 +0,0 @@ -package fun.asgard.api.events.gameplayerevents; - -import fun.asgard.api.objects.game.Game; - -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; - -public class GamePlayerDeathEvent extends GamePlayerEvent { - - /** - * - * @param game Game - * @param player Game player - */ - public GamePlayerDeathEvent(Game game, GamePlayer player) { - super(game, null, player); - } - - - /** - * - * @param teamGame Team game - * @param player Game player - */ - public GamePlayerDeathEvent(TeamGame teamGame, Player player) { - super(teamGame, player, null); - } - -} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java deleted file mode 100644 index 2131956..0000000 --- a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java +++ /dev/null @@ -1,28 +0,0 @@ -package fun.asgard.api.events.gameplayerevents; - -import fun.asgard.api.objects.game.Game; - -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; - -public class GamePlayerDisconnectEvent extends GamePlayerEvent { - - /** - * - * @param game Game - * @param player Game player - */ - public GamePlayerDisconnectEvent(Game game, Player player) { - super(game, player, null); - } - - /** - * - * @param game Game - * @param player Game player - */ - public GamePlayerDisconnectEvent(TeamGame game, Player player) { - super(game, player, null); - } - -} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java deleted file mode 100644 index 4b1bd7c..0000000 --- a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java +++ /dev/null @@ -1,70 +0,0 @@ -package fun.asgard.api.events.gameplayerevents; - -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; -import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; -import org.jetbrains.annotations.NotNull; - -public class GamePlayerEvent extends Event { - - private static HandlerList handlers = null; - - private final Player player; - private final GamePlayer gp; - private final TeamGame teamGame; - private final Game game; - - /** - * - * @param game Game - * @param player Game player - */ - protected GamePlayerEvent(Game game, Player player, GamePlayer gp) { - handlers = new HandlerList(); - this.gp = gp; - this.player = player; - this.game = game; - this.teamGame = null; - } - - /** - * - * @param teamGame Game - * @param player Game player - */ - protected GamePlayerEvent(TeamGame teamGame, Player player, GamePlayer gp) { - handlers = new HandlerList(); - this.gp = gp; - this.player = player; - this.teamGame = teamGame; - this.game = null; - } - - public GamePlayer getGamePlayer() { - return gp; - } - - public Player getPlayer() { - return player; - } - - public TeamGame getTeamGame() { - return teamGame; - } - - public Game getGame() { - return game; - } - - public @NotNull HandlerList getHandlers() { - return handlers; - } - - public static HandlerList getHandlerList() { - return handlers; - } - -} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java deleted file mode 100644 index 0d16960..0000000 --- a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java +++ /dev/null @@ -1,13 +0,0 @@ -package fun.asgard.api.events.gameplayerevents; - -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; - -public class GamePlayerJoinedTeamEvent extends GamePlayerEvent { - - public GamePlayerJoinedTeamEvent(TeamGame teamGame, Player player, GamePlayer gp) { - super(teamGame, player, gp); - } - -} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java deleted file mode 100644 index 5820e67..0000000 --- a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java +++ /dev/null @@ -1,13 +0,0 @@ -package fun.asgard.api.events.gameplayerevents; - -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; - -public class GamePlayerLeftTeamEvent extends GamePlayerEvent { - - public GamePlayerLeftTeamEvent(TeamGame teamGame, Player player, GamePlayer gp) { - super(teamGame, player, gp); - } - -} diff --git a/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java deleted file mode 100644 index 9031c18..0000000 --- a/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java +++ /dev/null @@ -1,19 +0,0 @@ -package fun.asgard.api.events.gameteamevents; - -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; - -import java.util.Set; - -public class GameTeamDisconnectEvent extends GameTeamEvent { - - /** - * - * @param game Game - * @param players Game players - */ - public GameTeamDisconnectEvent(TeamGame game, Set players) { - super(game, players, null); - } - -} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java deleted file mode 100644 index 54287c4..0000000 --- a/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java +++ /dev/null @@ -1,52 +0,0 @@ -package fun.asgard.api.events.gameteamevents; - -import fun.asgard.api.objects.game.GameTeam; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; -import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; -import org.jetbrains.annotations.NotNull; - -import java.util.Set; - -public class GameTeamEvent extends Event { - - private static HandlerList handlers = null; - - private final Set players; - private final TeamGame game; - private final GameTeam team; - - /** - * - * @param game Team game - * @param players Game players - */ - protected GameTeamEvent(TeamGame game, Set players, GameTeam team) { - handlers = new HandlerList(); - this.players = players; - this.game = game; - this.team = team; - } - - public Set getPlayers() { - return players; - } - - public TeamGame getTeamGame() { - return game; - } - - public GameTeam getTeam() { - return team; - } - - public @NotNull HandlerList getHandlers() { - return handlers; - } - - public static HandlerList getHandlerList() { - return handlers; - } - -} diff --git a/src/main/java/fun/asgard/api/objects/Game.java b/src/main/java/fun/asgard/api/objects/Game.java deleted file mode 100644 index 7267cf4..0000000 --- a/src/main/java/fun/asgard/api/objects/Game.java +++ /dev/null @@ -1,74 +0,0 @@ -package fun.asgard.api.objects; - -import org.bukkit.Location; -import org.bukkit.World; -import org.bukkit.entity.Player; - -import java.util.HashMap; -import java.util.HashSet; - -public interface Game { - - /** - * After calling the method, GameStartEvent will be triggered - */ - void start(); - - /** - * After calling the method, GameEndEvent will be triggered - */ - void stop(boolean saveWorld); - - /** - * After calling the method, GameEndEvent will be triggered - */ - void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld); - - /** - * After calling the method, GameEndEvent will be triggered - */ - void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld); - - /** - * After calling the method, GameEndEvent will be triggered - */ - void stop(HashSet winners, HashSet losers, boolean saveWorld); - - /** - * After calling the method, no event will be triggered - */ - void shutdown(boolean saveWorld); - - void connectPlayer(Player player); - - void connectPlayer(Player player, Location location); - - void connectPlayer(Player player, double x, double y, double z); - - void disconnectPlayer(GamePlayer player); - - void disconnectPlayer(GamePlayer player, Location location); - - void disconnectPlayer(GamePlayer player, double x, double y, double z); - - HashSet getTasks(); - - long getWhenStarted(); - - HashMap getPlayers(); - - long getTime(); - - String getGameName(); - - World getWorld(); - - GameTask getTask(); - - void setTime(long time); - - void setKickOnLeave(boolean kickOnLeave); - - boolean isLeaveOnKick(); - -} diff --git a/src/main/java/fun/asgard/api/objects/GamePlayer.java b/src/main/java/fun/asgard/api/objects/GamePlayer.java deleted file mode 100644 index f4d1c7a..0000000 --- a/src/main/java/fun/asgard/api/objects/GamePlayer.java +++ /dev/null @@ -1,19 +0,0 @@ -package fun.asgard.api.objects; - -import org.bukkit.entity.Player; - -public interface GamePlayer { - - Player getPlayer(); - - Game getGame(); - - int getScore(); - - boolean isDied(); - - void setScore(int score); - - void setDied(boolean isDied); - -} diff --git a/src/main/java/fun/asgard/api/objects/GameTask.java b/src/main/java/fun/asgard/api/objects/GameTask.java deleted file mode 100644 index 6998231..0000000 --- a/src/main/java/fun/asgard/api/objects/GameTask.java +++ /dev/null @@ -1,9 +0,0 @@ -package fun.asgard.api.objects; - -public interface GameTask { - - void cancel(); - - Game getGame(); - -} diff --git a/src/main/java/fun/asgard/api/objects/game/BaseGame.java b/src/main/java/fun/asgard/api/objects/game/BaseGame.java deleted file mode 100644 index f8b6b77..0000000 --- a/src/main/java/fun/asgard/api/objects/game/BaseGame.java +++ /dev/null @@ -1,56 +0,0 @@ -package fun.asgard.api.objects.game; - -import org.bukkit.World; - -import java.util.HashSet; - -public interface BaseGame { - - /** - * After calling the method, GameStartEvent will be triggered - */ - void start(); - - /** - * After calling the method, GameEndEvent will be triggered - */ - void stop(boolean saveWorld); - - /** - * After calling the method, GameEndEvent will be triggered - */ - void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld); - - /** - * After calling the method, GameEndEvent will be triggered - */ - void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld); - - /** - * After calling the method, GameEndEvent will be triggered - */ - void stop(HashSet winners, HashSet losers, boolean saveWorld); - - /** - * After calling the method, no event will be triggered - */ - void shutdown(boolean saveWorld); - - - long getWhenStarted(); - - long getTime(); - - String getGameName(); - - World getWorld(); - - void setTime(long time); - - void setLeaveOnKick(boolean kickOnLeave); - - boolean isLeaveOnKick(); - - boolean isTeamGame(); - -} diff --git a/src/main/java/fun/asgard/api/objects/game/Game.java b/src/main/java/fun/asgard/api/objects/game/Game.java deleted file mode 100644 index b0a34e0..0000000 --- a/src/main/java/fun/asgard/api/objects/game/Game.java +++ /dev/null @@ -1,22 +0,0 @@ -package fun.asgard.api.objects.game; - -import fun.asgard.api.objects.managers.PlayersManager; -import java.util.HashSet; - -public interface Game extends BaseGame { - - void start(); - - void stop(boolean saveWorld); - - void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld); - - void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld); - - void stop(HashSet winners, HashSet losers, boolean saveWorld); - - void shutdown(boolean saveWorld); - - PlayersManager getPlayersManager(); - -} diff --git a/src/main/java/fun/asgard/api/objects/game/GamePlayer.java b/src/main/java/fun/asgard/api/objects/game/GamePlayer.java deleted file mode 100644 index 3327c07..0000000 --- a/src/main/java/fun/asgard/api/objects/game/GamePlayer.java +++ /dev/null @@ -1,23 +0,0 @@ -package fun.asgard.api.objects.game; - -import org.bukkit.entity.Player; - -public interface GamePlayer { - - Player getPlayer(); - - BaseGame getGame(); - - int getScore(); - - GameTeam getTeam(); - - boolean isDied(); - - void setScore(int score); - - void setDied(boolean isDied); - - void setTeam(GameTeam team); - -} diff --git a/src/main/java/fun/asgard/api/objects/game/GameTeam.java b/src/main/java/fun/asgard/api/objects/game/GameTeam.java deleted file mode 100644 index 8b63ecc..0000000 --- a/src/main/java/fun/asgard/api/objects/game/GameTeam.java +++ /dev/null @@ -1,29 +0,0 @@ -package fun.asgard.api.objects.game; - -import org.bukkit.Color; - -import java.util.HashSet; - -public interface GameTeam { - - HashSet getPlayers(); - - BaseGame getTeamGame(); - - int getScore(); - - boolean isLost(); - - Color getColor(); - - String getName(); - - void setScore(int score); - - void setLost(boolean isLost); - - void setColor(Color color); - - void setName(String name); - -} diff --git a/src/main/java/fun/asgard/api/objects/game/TeamGame.java b/src/main/java/fun/asgard/api/objects/game/TeamGame.java deleted file mode 100644 index 2877de9..0000000 --- a/src/main/java/fun/asgard/api/objects/game/TeamGame.java +++ /dev/null @@ -1,9 +0,0 @@ -package fun.asgard.api.objects.game; - -import fun.asgard.api.objects.managers.PlayersManager; - -public interface TeamGame extends BaseGame { - - PlayersManager getPlayersManager(); - -} diff --git a/src/main/java/fun/asgard/api/objects/managers/GamesManager.java b/src/main/java/fun/asgard/api/objects/managers/GamesManager.java deleted file mode 100644 index 0c3da8e..0000000 --- a/src/main/java/fun/asgard/api/objects/managers/GamesManager.java +++ /dev/null @@ -1,27 +0,0 @@ -package fun.asgard.api.objects.managers; - -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.World; - -import java.util.HashMap; - -public interface GamesManager { - - Game createGame(World world, String gameName, long timer); - - Game createGame(World world, String gameName); - - TeamGame createTeamGame(World world, String gameName, long timer); - - TeamGame createTeamGame(World world, String gameName); - - Game getGame(String gameName); - - TeamGame getTeamGame(String gameName); - - HashMap getGames(); - - HashMap getTeamGames(); - -} diff --git a/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java b/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java deleted file mode 100644 index a042fd6..0000000 --- a/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java +++ /dev/null @@ -1,55 +0,0 @@ -package fun.asgard.api.objects.managers; - -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.GameTeam; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.Color; -import org.bukkit.Location; -import org.bukkit.entity.Player; - -import java.util.HashMap; - -public interface PlayersManager { - - Game getGame(); - - TeamGame getTeamGame(); - - HashMap getTeams(); - - HashMap getPlayers(); - - GameTeam getTeam(String name); - - void connectPlayer(Player player); - - void connectPlayer(Player player, Location location); - - void connectPlayer(Player player, double x, double y, double z); - - void disconnectPlayer(GamePlayer player); - - void disconnectPlayer(GamePlayer player, Location location); - - void disconnectPlayer(GamePlayer player, double x, double y, double z); - - GameTeam createTeam(String name, Color color); - - void connectPlayer(Player player, GameTeam team); - - void connectPlayer(Player player, GameTeam team, Location location); - - void connectPlayer(Player player, GameTeam team, double x, double y, double z); - - void disconnectTeam(GameTeam team); - - void disconnectTeam(GameTeam team, Location location); - - void disconnectTeam(GameTeam team, double x, double y, double z); - - void sendMessage(String message); - - void sendTeamMessage(String message, GameTeam team); - -} diff --git a/src/main/java/fun/asgard/api/objects/managers/TaskManager.java b/src/main/java/fun/asgard/api/objects/managers/TaskManager.java deleted file mode 100644 index 9012ce2..0000000 --- a/src/main/java/fun/asgard/api/objects/managers/TaskManager.java +++ /dev/null @@ -1,19 +0,0 @@ -package fun.asgard.api.objects.managers; - -import fun.asgard.api.objects.task.Task; -import fun.asgard.api.objects.task.TaskRunnable; -import org.jetbrains.annotations.NotNull; - -import java.util.HashMap; - -public interface TaskManager { - - void createTask(@NotNull TaskRunnable task, long delay, long period); - - void createTask(@NotNull TaskRunnable task, String taskName, long delay, long period); - - Task getTask(String taskName); - - HashMap getTasks(); - -} diff --git a/src/main/java/fun/asgard/api/objects/task/Task.java b/src/main/java/fun/asgard/api/objects/task/Task.java deleted file mode 100644 index d1548d4..0000000 --- a/src/main/java/fun/asgard/api/objects/task/Task.java +++ /dev/null @@ -1,11 +0,0 @@ -package fun.asgard.api.objects.task; - -public interface Task { - - void cancel(); - - String getName(); - - void setName(String name); - -} diff --git a/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java b/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java deleted file mode 100644 index e8793d8..0000000 --- a/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java +++ /dev/null @@ -1,7 +0,0 @@ -package fun.asgard.api.objects.task; - -public interface TaskRunnable { - - void execute(Task task); - -} diff --git a/src/main/java/fun/asgard/internal/Utils.java b/src/main/java/fun/asgard/internal/Utils.java deleted file mode 100644 index 274c863..0000000 --- a/src/main/java/fun/asgard/internal/Utils.java +++ /dev/null @@ -1,16 +0,0 @@ -package fun.asgard.internal; - -import java.util.HashMap; -import java.util.HashSet; - -public class Utils { - - public static HashSet valueSet(HashMap map) { - return new HashSet<>(map.values()); - } - - public static double getRandom(double min, double max){ - return (Math.random() * ((max - min) + 1)) + min; - } - -} diff --git a/src/main/java/fun/asgard/internal/managers/GameManager.java b/src/main/java/fun/asgard/internal/managers/GameManager.java deleted file mode 100644 index b255177..0000000 --- a/src/main/java/fun/asgard/internal/managers/GameManager.java +++ /dev/null @@ -1,41 +0,0 @@ -package fun.asgard.internal.managers; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.Game; -import fun.asgard.internal.objects.Game.EGame; - -import org.bukkit.World; -import org.bukkit.plugin.Plugin; - -import java.util.HashMap; - -public class GameManager { - - private final HashMap games = new HashMap<>(); - private final TAGA taga; - private final Plugin client; - - public GameManager(TAGA taga, Plugin client) { - this.taga = taga; - this.client = client; - } - - public Game createGame(World world, String gameName, long timer) { - EGame game = new EGame(this.taga, this.client, world, gameName, timer); - this.games.put(gameName, game); - return game; - } - - public Game createGame(World world, String gameName) { - return this.createGame(world, gameName, -1); - } - - public Game getGame(String gameName) { - return this.getGames().get(gameName); - } - - public HashMap getGames() { - return this.games; - } - -} diff --git a/src/main/java/fun/asgard/internal/managers/TaskManager.java b/src/main/java/fun/asgard/internal/managers/TaskManager.java deleted file mode 100644 index 74c985d..0000000 --- a/src/main/java/fun/asgard/internal/managers/TaskManager.java +++ /dev/null @@ -1,52 +0,0 @@ -package fun.asgard.internal.managers; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.Game; -import fun.asgard.api.objects.GameTask; -import fun.asgard.internal.objects.GameTask.EGameTask; - -import org.bukkit.plugin.Plugin; - -import org.jetbrains.annotations.NotNull; - -import java.util.HashMap; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; - -public class TaskManager { - - private final TAGA taga; - private final Plugin client; - private final HashMap tasks = new HashMap<>(); - - public TaskManager(TAGA taga, Plugin client) { - this.taga = taga; - this.client = client; - } - - public GameTask createGameTask(@NotNull Runnable task, Game game, long delay, long period){ - if (this.tasks.containsKey(game)) - throw new IllegalArgumentException("GameTask has already been created for this game"); - if (delay < 0) - throw new IllegalArgumentException("Negative delay."); - if (period <= 0) - throw new IllegalArgumentException("Non-positive period."); - - ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); - service.scheduleWithFixedDelay(task, delay, period, TimeUnit.MILLISECONDS); - - GameTask gt = new EGameTask(game, service); - this.getAllTasks().put(game, gt); - return gt; - } - - public GameTask getTask(Game game) { - return this.getAllTasks().get(game); - } - - public HashMap getAllTasks() { - return tasks; - } - -} diff --git a/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java b/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java deleted file mode 100644 index 7a38c13..0000000 --- a/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java +++ /dev/null @@ -1,70 +0,0 @@ -package fun.asgard.internal.managers.gamemanager; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.TeamGame; -import fun.asgard.api.objects.managers.GamesManager; -import fun.asgard.internal.objects.game.EGame; - -import fun.asgard.internal.objects.teamgame.ETeamGame; -import org.bukkit.World; -import org.bukkit.plugin.Plugin; - -import java.util.HashMap; - -public abstract class AGameManager implements GamesManager { - - private final HashMap games = new HashMap<>(); - private final HashMap teamGames = new HashMap<>(); - private final TAGA taga; - private final Plugin client; - - protected AGameManager(TAGA taga, Plugin client) { - this.taga = taga; - this.client = client; - } - - @Override - public Game createGame(World world, String gameName, long timer) { - EGame game = new EGame(this.taga, this.client, world, gameName, timer); - this.games.put(gameName, game); - return game; - } - - @Override - public Game createGame(World world, String gameName) { - return this.createGame(world, gameName, -1); - } - - @Override - public TeamGame createTeamGame(World world, String gameName, long timer) { - TeamGame game = new ETeamGame(this.taga, this.client, world, gameName, timer); - this.teamGames.put(gameName, game); - return game; - } - - @Override - public TeamGame createTeamGame(World world, String gameName) { - return this.createTeamGame(world, gameName, -1); - } - - @Override - public Game getGame(String gameName) { - return this.getGames().get(gameName); - } - - @Override - public TeamGame getTeamGame(String gameName) { - return this.getTeamGames().get(gameName); - } - - @Override - public HashMap getGames() { - return this.games; - } - - @Override - public HashMap getTeamGames() { - return this.teamGames; - } -} diff --git a/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java b/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java deleted file mode 100644 index bf306b6..0000000 --- a/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java +++ /dev/null @@ -1,12 +0,0 @@ -package fun.asgard.internal.managers.gamemanager; - -import fun.asgard.TAGA; -import org.bukkit.plugin.Plugin; - -public class EGameManager extends AGameManager { - - public EGameManager(TAGA taga, Plugin client) { - super(taga, client); - } - -} diff --git a/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java b/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java deleted file mode 100644 index 49a688d..0000000 --- a/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java +++ /dev/null @@ -1,218 +0,0 @@ -package fun.asgard.internal.managers.playersmanager; - -import fun.asgard.TAGA; -import fun.asgard.api.events.gameplayerevents.GamePlayerConnectEvent; -import fun.asgard.api.events.gameplayerevents.GamePlayerDisconnectEvent; -import fun.asgard.api.events.gameplayerevents.GamePlayerJoinedTeamEvent; -import fun.asgard.api.events.gameteamevents.GameTeamDisconnectEvent; -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.GameTeam; -import fun.asgard.api.objects.game.TeamGame; -import fun.asgard.api.objects.managers.PlayersManager; -import fun.asgard.internal.objects.gameplayer.EGamePlayer; -import org.bukkit.Color; -import org.bukkit.Location; -import org.bukkit.entity.Player; -import org.bukkit.plugin.Plugin; - -import java.util.HashMap; -import java.util.stream.Collectors; - -public abstract class APlayersManager implements PlayersManager { - - private final TAGA taga; - private final Plugin client; - private final Game game; - private final TeamGame teamGame; - private final HashMap teams; - - private final HashMap players = new HashMap<>(); - - protected APlayersManager(TAGA taga, Plugin client, Game game) { - this.client = client; - this.taga = taga; - this.game = game; - this.teamGame = null; - this.teams = null; - } - - protected APlayersManager(TAGA taga, Plugin client, TeamGame teamGame) { - this.client = client; - this.taga = taga; - this.game = null; - this.teamGame = teamGame; - this.teams = new HashMap<>(); - } - - @Override - public void connectPlayer(Player player) { - this.checkIfValidGame(); - GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); - this.players.put(player, gp); - this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); - } - - @Override - public void connectPlayer(Player player, Location location) { - this.checkIfValidGame(); - GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); - this.players.put(player, gp); - player.teleport(location); - this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); - } - - @Override - public void connectPlayer(Player player, double x, double y, double z) { - this.checkIfValidGame(); - GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); - this.players.put(player, gp); - player.teleport(new Location(getGame().getWorld(), x, y, z)); - this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); - } - - @Override - public void connectPlayer(Player player, GameTeam team) { - this.checkIfValidGame(true); - GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); - this.players.put(player, gp); - this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); - this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); - } - - @Override - public void connectPlayer(Player player, GameTeam team, Location location) { - this.checkIfValidGame(true); - GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); - this.players.put(player, gp); - player.teleport(location); - this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); - this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); - } - - @Override - public void connectPlayer(Player player, GameTeam team, double x, double y, double z) { - this.checkIfValidGame(true); - GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); - this.players.put(player, gp); - player.teleport(new Location(getTeamGame().getWorld(), x, y, z)); - this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); - this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); - } - - @Override - public void disconnectPlayer(GamePlayer player) { - this.checkIfValidGame(); - this.players.remove(player.getPlayer()); - this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); - } - - @Override - public void disconnectPlayer(GamePlayer player, Location location) { - this.checkIfValidGame(); - this.players.remove(player.getPlayer()); - player.getPlayer().teleport(location); - this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); - } - - @Override - public void disconnectPlayer(GamePlayer player, double x, double y, double z) { - this.checkIfValidGame(); - this.players.remove(player.getPlayer()); - player.getPlayer().teleport(new Location(getGame().getWorld(), x, y, z)); - this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); - } - - @Override - public void disconnectTeam(GameTeam team) { - this.checkIfValidGame(true); - team.getPlayers().forEach(pl -> this.players.remove(pl.getPlayer())); - this.teams.remove(team.getName()); - this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), - team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); - } - - @Override - public void disconnectTeam(GameTeam team, Location location) { - this.checkIfValidGame(true); - team.getPlayers().forEach(pl -> { - this.players.remove(pl.getPlayer()); - pl.getPlayer().teleport(location); - }); - this.teams.remove(team.getName()); - this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), - team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); - } - - @Override - public void disconnectTeam(GameTeam team, double x, double y, double z) { - this.checkIfValidGame(true); - team.getPlayers().forEach(pl -> { - this.players.remove(pl.getPlayer()); - pl.getPlayer().teleport(new Location(getGame().getWorld(), x, y, z)); - }); - this.teams.remove(team.getName()); - this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), - team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); - } - - @Override - public GameTeam createTeam(String name, Color color) { - this.checkIfValidGame(true); - return null; - } - - @Override - public void sendMessage(String message) { - this.getPlayers().forEach((player, gamePlayer) -> player.sendMessage(message)); - } - - @Override - public void sendTeamMessage(String message, GameTeam team) { - team.getPlayers().forEach(gamePlayer -> gamePlayer.getPlayer().sendMessage(message)); - } - - @Override - public Game getGame() { - return game; - } - - @Override - public TeamGame getTeamGame() { - return teamGame; - } - - @Override - public HashMap getPlayers() { - return players; - } - - @Override - public HashMap getTeams() { - return teams; - } - - @Override - public GameTeam getTeam(String name) { - return this.getTeams().get(name); - } - - public boolean isTeamGame() { - return this.getTeamGame() != null; - } - - private boolean checkIfValidGame() { - return this.checkIfValidGame(false); - } - - private boolean checkIfValidGame(boolean ifTeamInteraction) { - if (ifTeamInteraction && getTeamGame() == null) { - throw new IllegalCallerException("It is impossible to call the method, the game is not a team game!"); - } else if (!ifTeamInteraction && getGame() == null) { - throw new IllegalCallerException("It is impossible to call the method, the game is team!"); - } else { - return true; - } - } - -} diff --git a/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java b/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java deleted file mode 100644 index 57fcf39..0000000 --- a/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java +++ /dev/null @@ -1,18 +0,0 @@ -package fun.asgard.internal.managers.playersmanager; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.plugin.Plugin; - -public class EPlayersManager extends APlayersManager { - - public EPlayersManager(TAGA taga, Plugin client, Game game) { - super(taga, client, game); - } - - public EPlayersManager(TAGA taga, Plugin client, TeamGame teamGame) { - super(taga, client, teamGame); - } - -} diff --git a/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java b/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java deleted file mode 100644 index 4ed709d..0000000 --- a/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java +++ /dev/null @@ -1,75 +0,0 @@ -package fun.asgard.internal.managers.taskmanager; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.managers.TaskManager; -import fun.asgard.api.objects.task.Task; -import fun.asgard.api.objects.task.TaskRunnable; -import fun.asgard.internal.Utils; -import fun.asgard.internal.objects.task.ETask; - -import org.bukkit.plugin.Plugin; - -import org.jetbrains.annotations.NotNull; - -import java.util.HashMap; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; - -public abstract class ATaskManager implements TaskManager { - - private final TAGA taga; - private final Plugin client; - private final HashMap tasks = new HashMap<>(); - - protected ATaskManager(TAGA taga, Plugin client) { - this.taga = taga; - this.client = client; - } - - @Override - public void createTask(@NotNull TaskRunnable task, long delay, long period){ - if (delay < 0) - throw new IllegalArgumentException("Negative delay."); - if (period <= 0) - throw new IllegalArgumentException("Non-positive period."); - - ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); - String id = "Task-" + this.getRandomId(); - Task gt = new ETask(service, id); - service.scheduleWithFixedDelay(() -> task.execute(gt), delay, period, TimeUnit.MILLISECONDS); - - this.tasks.put(id, gt); - } - - @Override - public void createTask(@NotNull TaskRunnable task, String taskName, long delay, long period){ - if (delay < 0) - throw new IllegalArgumentException("Negative delay."); - if (period <= 0) - throw new IllegalArgumentException("Non-positive period."); - - ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); - Task gt = new ETask(service, taskName); - service.scheduleWithFixedDelay(() -> task.execute(gt), delay, period, TimeUnit.MILLISECONDS); - - this.tasks.put(taskName, gt); - } - - @Override - public Task getTask(String taskName) { - return this.getTasks().get(taskName); - } - - @Override - public HashMap getTasks() { - return tasks; - } - - private String getRandomId() { - String str = String.valueOf(Utils.getRandom(this.getTasks().size(), 1000)); - if (this.getTask(str) != null) return getRandomId(); - else return str; - } - -} diff --git a/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java b/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java deleted file mode 100644 index f883d05..0000000 --- a/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java +++ /dev/null @@ -1,12 +0,0 @@ -package fun.asgard.internal.managers.taskmanager; - -import fun.asgard.TAGA; -import org.bukkit.plugin.Plugin; - -public class ETaskManager extends ATaskManager { - - public ETaskManager(TAGA taga, Plugin client) { - super(taga, client); - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/Game/AGame.java b/src/main/java/fun/asgard/internal/objects/Game/AGame.java deleted file mode 100644 index 2ce5a69..0000000 --- a/src/main/java/fun/asgard/internal/objects/Game/AGame.java +++ /dev/null @@ -1,196 +0,0 @@ -package fun.asgard.internal.objects.Game; - -import fun.asgard.TAGA; -import fun.asgard.api.events.GameStartEvent; -import fun.asgard.api.events.GameStopEvent; -import fun.asgard.api.events.PlayerConnectEvent; -import fun.asgard.api.events.PlayerDisconnectEvent; -import fun.asgard.api.objects.Game; -import fun.asgard.api.objects.GamePlayer; -import fun.asgard.api.objects.GameTask; -import fun.asgard.internal.Utils; -import fun.asgard.internal.objects.GamePlayer.EGamePlayer; - -import org.bukkit.Bukkit; -import org.bukkit.Location; -import org.bukkit.World; -import org.bukkit.entity.Player; -import org.bukkit.plugin.Plugin; - -import java.util.HashMap; -import java.util.HashSet; - -public abstract class AGame implements Game { - - private final World world; - private final String gameName; - private final TAGA taga; - private final Plugin client; - - private final HashMap players = new HashMap<>(); - private final HashSet tasks = new HashSet<>(); - - private long started; - private long time; - private boolean leaveOnKick = false; - - /** - * @param client The one who uses the api - * @param world World of the game - * @param gameName Name of the game - * @param time Game time - */ - public AGame(TAGA taga, Plugin client, World world, String gameName, long time) { - this.taga = taga; - this.client = client; - this.gameName = gameName; - this.world = world; - this.time = time; - } - - @Override - public void start() { - if (this.world.getLoadedChunks().length <= 0 - || !this.client.getServer().getWorlds().contains(this.world)) { - this.client.getServer().getWorlds().add(this.world); - } - - this.started = System.currentTimeMillis(); - Bukkit.getPluginManager().callEvent(new GameStartEvent(this, Utils.getValuesFromHashMap(this.players))); - } - - @Override - public void stop(boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.getValuesFromHashMap(this.players).toArray())); - this.shutdown(saveWorld); - } - - - @Override - public void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.getValuesFromHashMap(this.players).toArray(), winner, loser)); - this.shutdown(saveWorld); - } - - @Override - public void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.getValuesFromHashMap(this.players).toArray(), winners, losers)); - this.shutdown(saveWorld); - } - - - @Override - public void stop(HashSet winners, HashSet losers, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, Utils.getValuesFromHashMap(this.players), winners, losers)); - this.shutdown(saveWorld); - } - - @Override - public void shutdown(boolean saveWorld) { - this.time = 0; - this.getTasks().forEach(GameTask::cancel); - this.players.forEach((pl, gp) -> this.disconnectPlayer(gp)); - Bukkit.unloadWorld(this.world, saveWorld); - } - - @Override - public void connectPlayer(Player player) { - this.players.put(player, new EGamePlayer(this.taga, player, this)); - this.client.getServer().getPluginManager().callEvent(new PlayerConnectEvent(this, player)); - } - - @Override - public void connectPlayer(Player player, Location location) { - this.players.put(player, new EGamePlayer(this.taga, player, this)); - player.teleport(location); - this.client.getServer().getPluginManager().callEvent(new PlayerConnectEvent(this, player)); - } - - @Override - public void connectPlayer(Player player, double x, double y, double z) { - this.players.put(player, (new EGamePlayer(this.taga, player, this))); - player.teleport(new Location(this.world, x, y, z)); - this.client.getServer().getPluginManager().callEvent(new PlayerConnectEvent(this, player)); - } - - @Override - public void disconnectPlayer(GamePlayer player) { - this.players.remove(player); - this.client.getServer().getPluginManager().callEvent(new PlayerDisconnectEvent(this, player.getPlayer())); - } - - @Override - public void disconnectPlayer(GamePlayer player, Location location) { - this.players.remove(player); - player.getPlayer().teleport(location); - this.client.getServer().getPluginManager().callEvent(new PlayerDisconnectEvent(this, player.getPlayer())); - } - - @Override - public void disconnectPlayer(GamePlayer player, double x, double y, double z) { - this.players.remove(player); - player.getPlayer().teleport(new Location(this.world, x, y, z)); - this.client.getServer().getPluginManager().callEvent(new PlayerDisconnectEvent(this, player.getPlayer())); - } - - @Override - public HashSet getTasks() { - return tasks; - } - - @Override - public long getWhenStarted() { - return started; - } - - @Override - public HashMap getPlayers() { - return players; - } - - @Override - public long getTime() { - return time; - } - - @Override - public String getGameName() { - return gameName; - } - - @Override - public World getWorld() { - return world; - } - - @Override - public GameTask getTask() { - return this.taga.getTaskManager().getTask(this); - } - - @Override - public void setTime(long time) { - this.time = time; - } - - @Override - public void setKickOnLeave(boolean kickOnLeave) { - this.leaveOnKick = kickOnLeave; - } - - @Override - public boolean isLeaveOnKick() { - return leaveOnKick; - } - - @Override - public String toString() { - return "Game { " + - "world = " + world.getName() + - ", gameName = '" + gameName + '\'' + - ", time = " + time + - ", players = " + players + - '}'; - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/Game/EGame.java b/src/main/java/fun/asgard/internal/objects/Game/EGame.java deleted file mode 100644 index a17ff9e..0000000 --- a/src/main/java/fun/asgard/internal/objects/Game/EGame.java +++ /dev/null @@ -1,19 +0,0 @@ -package fun.asgard.internal.objects.Game; - -import fun.asgard.TAGA; -import org.bukkit.World; -import org.bukkit.plugin.Plugin; - -public class EGame extends AGame { - - /** - * @param client The one who uses the api - * @param world World of the game - * @param gameName Name of the game - * @param time Game time - */ - public EGame(TAGA taga, Plugin client, World world, String gameName, long time) { - super(taga, client, world, gameName, time); - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/GamePlayer/AGamePlayer.java b/src/main/java/fun/asgard/internal/objects/GamePlayer/AGamePlayer.java deleted file mode 100644 index 28f9dd1..0000000 --- a/src/main/java/fun/asgard/internal/objects/GamePlayer/AGamePlayer.java +++ /dev/null @@ -1,53 +0,0 @@ -package fun.asgard.internal.objects.GamePlayer; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.Game; -import fun.asgard.api.objects.GamePlayer; - -import org.bukkit.entity.Player; - -public abstract class AGamePlayer implements GamePlayer { - - private final TAGA taga; - private final Player player; - private final Game game; - private int score = 0; - private boolean isDied = false; - - public AGamePlayer(TAGA taga, Player player, Game game) { - this.taga = taga; - this.player = player; - this.game = game; - } - - @Override - public Player getPlayer() { - return this.player; - } - - @Override - public Game getGame() { - return this.game; - } - - @Override - public int getScore() { - return this.score; - } - - @Override - public boolean isDied() { - return this.isDied; - } - - @Override - public void setScore(int score) { - this.score = score; - } - - @Override - public void setDied(boolean isDied) { - this.isDied = isDied; - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/GamePlayer/EGamePlayer.java b/src/main/java/fun/asgard/internal/objects/GamePlayer/EGamePlayer.java deleted file mode 100644 index c606a03..0000000 --- a/src/main/java/fun/asgard/internal/objects/GamePlayer/EGamePlayer.java +++ /dev/null @@ -1,14 +0,0 @@ -package fun.asgard.internal.objects.GamePlayer; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.Game; - -import org.bukkit.entity.Player; - -public class EGamePlayer extends AGamePlayer { - - public EGamePlayer(TAGA taga, Player player, Game game) { - super(taga, player, game); - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/GameTask/AGameTask.java b/src/main/java/fun/asgard/internal/objects/GameTask/AGameTask.java deleted file mode 100644 index 9ad5043..0000000 --- a/src/main/java/fun/asgard/internal/objects/GameTask/AGameTask.java +++ /dev/null @@ -1,29 +0,0 @@ -package fun.asgard.internal.objects.GameTask; - -import fun.asgard.api.objects.Game; -import fun.asgard.api.objects.GameTask; - -import java.util.concurrent.ScheduledExecutorService; - -public abstract class AGameTask implements GameTask { - - private final ScheduledExecutorService service; - private final Game game; - - public AGameTask(Game game, ScheduledExecutorService service) { - this.game = game; - this.service = service; - } - - @Override - public void cancel() { - this.game.getTasks().remove(this); - this.service.shutdown(); - } - - @Override - public Game getGame() { - return this.game; - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/GameTask/EGameTask.java b/src/main/java/fun/asgard/internal/objects/GameTask/EGameTask.java deleted file mode 100644 index 050ee44..0000000 --- a/src/main/java/fun/asgard/internal/objects/GameTask/EGameTask.java +++ /dev/null @@ -1,13 +0,0 @@ -package fun.asgard.internal.objects.GameTask; - -import fun.asgard.api.objects.Game; - -import java.util.concurrent.ScheduledExecutorService; - -public class EGameTask extends AGameTask { - - public EGameTask(Game game, ScheduledExecutorService service) { - super(game, service); - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/game/AGame.java b/src/main/java/fun/asgard/internal/objects/game/AGame.java deleted file mode 100644 index 6b75d81..0000000 --- a/src/main/java/fun/asgard/internal/objects/game/AGame.java +++ /dev/null @@ -1,142 +0,0 @@ -package fun.asgard.internal.objects.game; - -import fun.asgard.TAGA; -import fun.asgard.api.events.gameevents.GameStartEvent; -import fun.asgard.api.events.gameevents.GameStopEvent; -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.managers.PlayersManager; -import fun.asgard.internal.Utils; -import fun.asgard.internal.managers.playersmanager.EPlayersManager; -import org.bukkit.Bukkit; -import org.bukkit.World; -import org.bukkit.plugin.Plugin; - -import java.util.HashSet; - -public abstract class AGame implements Game { - - private final World world; - private final String gameName; - private final TAGA taga; - private final Plugin client; - private final PlayersManager playersManager; - - private long started; - private long time; - private boolean leaveOnKick = false; - - /** - * @param client The one who uses the api - * @param world World of the game - * @param gameName Name of the game - * @param time Game time - */ - protected AGame(TAGA taga, Plugin client, World world, String gameName, long time) { - this.taga = taga; - this.client = client; - this.gameName = gameName; - this.world = world; - this.time = time; - this.playersManager = new EPlayersManager(taga, client, this); - } - - @Override - public long getWhenStarted() { - return started; - } - - @Override - public long getTime() { - return time; - } - - @Override - public String getGameName() { - return gameName; - } - - @Override - public World getWorld() { - return world; - } - - @Override - public void setTime(long time) { - this.time = time; - } - - @Override - public void setLeaveOnKick(boolean kickOnLeave) { - this.leaveOnKick = kickOnLeave; - } - - @Override - public boolean isLeaveOnKick() { - return leaveOnKick; - } - - @Override - public void start() { - if (this.world.getLoadedChunks().length <= 0 - || !this.client.getServer().getWorlds().contains(this.world)) { - this.client.getServer().getWorlds().add(this.world); - } - - this.started = System.currentTimeMillis(); - Bukkit.getPluginManager().callEvent(new GameStartEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()))); - - } - - @Override - public void stop(boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray())); - this.shutdown(saveWorld); - } - - @Override - public void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winner, loser)); - this.shutdown(saveWorld); - } - - @Override - public void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winners, losers)); - this.shutdown(saveWorld); - } - - - @Override - public void stop(HashSet winners, HashSet losers, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()), winners, losers)); - this.shutdown(saveWorld); - } - - @Override - public void shutdown(boolean saveWorld) { - this.time = 0; - this.getPlayersManager().getPlayers().forEach((pl, gp) -> this.getPlayersManager().disconnectPlayer(gp)); - Bukkit.unloadWorld(this.world, saveWorld); - } - - @Override - public PlayersManager getPlayersManager() { - return this.playersManager; - } - - @Override - public boolean isTeamGame() { - return false; - } - - @Override - public String toString() { - return "Game { " + - "world = " + world.getName() + - ", gameName = '" + gameName + '\'' + - ", time = " + time + - '}'; - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/game/EGame.java b/src/main/java/fun/asgard/internal/objects/game/EGame.java deleted file mode 100644 index ccc5008..0000000 --- a/src/main/java/fun/asgard/internal/objects/game/EGame.java +++ /dev/null @@ -1,19 +0,0 @@ -package fun.asgard.internal.objects.game; - -import fun.asgard.TAGA; -import org.bukkit.World; -import org.bukkit.plugin.Plugin; - -public class EGame extends AGame { - - /** - * @param client The one who uses the api - * @param world World of the game - * @param gameName Name of the game - * @param time Game time - */ - public EGame(TAGA taga, Plugin client, World world, String gameName, long time) { - super(taga, client, world, gameName, time); - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java b/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java deleted file mode 100644 index 602ad92..0000000 --- a/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java +++ /dev/null @@ -1,76 +0,0 @@ -package fun.asgard.internal.objects.gameplayer; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.GameTeam; - -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; - -public abstract class AGamePlayer implements GamePlayer { - - private final TAGA taga; - private final Player player; - private final Game game; - private final TeamGame teamgame; - private GameTeam team = null; - private int score = 0; - private boolean isDied = false; - - protected AGamePlayer(TAGA taga, Player player, Game game) { - this.taga = taga; - this.player = player; - this.game = game; - this.teamgame = null; - } - - protected AGamePlayer(TAGA taga, Player player, TeamGame game, GameTeam team) { - this.taga = taga; - this.player = player; - this.teamgame = game; - this.game = null; - this.team = team; - } - - @Override - public Player getPlayer() { - return this.player; - } - - @Override - public Game getGame() { - return this.game; - } - - @Override - public int getScore() { - return this.score; - } - - @Override - public GameTeam getTeam() { - return this.team; - } - - @Override - public boolean isDied() { - return this.isDied; - } - - @Override - public void setScore(int score) { - this.score = score; - } - - @Override - public void setDied(boolean isDied) { - this.isDied = isDied; - } - - @Override - public void setTeam(GameTeam team) { - this.team = team; - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java b/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java deleted file mode 100644 index 7d4142d..0000000 --- a/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java +++ /dev/null @@ -1,20 +0,0 @@ -package fun.asgard.internal.objects.gameplayer; - -import fun.asgard.TAGA; -import fun.asgard.api.objects.game.Game; -import fun.asgard.api.objects.game.GameTeam; - -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.entity.Player; - -public class EGamePlayer extends AGamePlayer { - - public EGamePlayer(TAGA taga, Player player, Game game) { - super(taga, player, game); - } - - public EGamePlayer(TAGA taga, Player player, TeamGame game, GameTeam team) { - super(taga, player, game, team); - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java b/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java deleted file mode 100644 index d9391cb..0000000 --- a/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java +++ /dev/null @@ -1,76 +0,0 @@ -package fun.asgard.internal.objects.gameteam; - -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.GameTeam; -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.Color; - -import java.util.HashSet; - -public abstract class AGameTeam implements GameTeam { - - private final HashSet players = new HashSet<>(); - private final TeamGame game; - - private int score; - private boolean isLost; - private Color color; - private String name; - - protected AGameTeam(TeamGame game, Color color, String name) { - this.game = game; - this.color = color; - this.name = name; - } - - @Override - public HashSet getPlayers() { - return this.players; - } - - @Override - public TeamGame getTeamGame() { - return this.game; - } - - @Override - public int getScore() { - return this.score; - } - - @Override - public boolean isLost() { - return this.isLost; - } - - @Override - public Color getColor() { - return this.color; - } - - @Override - public String getName() { - return this.name; - } - - @Override - public void setScore(int score) { - this.score = score; - } - - @Override - public void setLost(boolean isLost) { - this.isLost = isLost; - } - - @Override - public void setColor(Color color) { - this.color = color; - } - - @Override - public void setName(String name) { - this.name = name; - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java b/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java deleted file mode 100644 index 78abf59..0000000 --- a/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java +++ /dev/null @@ -1,18 +0,0 @@ -package fun.asgard.internal.objects.gameteam; - -import fun.asgard.api.objects.game.TeamGame; -import org.bukkit.Color; - -public class EGameTeam extends AGameTeam { - - /** - * - * @param teamGame Team game - * @param color Color of the team - * @param name Team name - */ - public EGameTeam(TeamGame teamGame, Color color, String name) { - super(teamGame, color, name); - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/task/ATask.java b/src/main/java/fun/asgard/internal/objects/task/ATask.java deleted file mode 100644 index e6d6646..0000000 --- a/src/main/java/fun/asgard/internal/objects/task/ATask.java +++ /dev/null @@ -1,32 +0,0 @@ -package fun.asgard.internal.objects.task; - -import fun.asgard.api.objects.task.Task; - -import java.util.concurrent.ScheduledExecutorService; - -public abstract class ATask implements Task { - - private final ScheduledExecutorService service; - private String name; - - protected ATask(ScheduledExecutorService service, String name) { - this.service = service; - this.name = name; - } - - @Override - public void cancel() { - this.service.shutdown(); - } - - @Override - public String getName() { - return this.name; - } - - @Override - public void setName(String name) { - this.name = name; - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/task/ETask.java b/src/main/java/fun/asgard/internal/objects/task/ETask.java deleted file mode 100644 index 63bcfeb..0000000 --- a/src/main/java/fun/asgard/internal/objects/task/ETask.java +++ /dev/null @@ -1,11 +0,0 @@ -package fun.asgard.internal.objects.task; - -import java.util.concurrent.ScheduledExecutorService; - -public class ETask extends ATask { - - public ETask(ScheduledExecutorService service, String name) { - super(service, name); - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java b/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java deleted file mode 100644 index 08ef092..0000000 --- a/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java +++ /dev/null @@ -1,143 +0,0 @@ -package fun.asgard.internal.objects.teamgame; - -import fun.asgard.TAGA; -import fun.asgard.api.events.gameevents.GameStartEvent; -import fun.asgard.api.events.gameevents.GameStopEvent; -import fun.asgard.api.objects.game.GamePlayer; -import fun.asgard.api.objects.game.GameTeam; -import fun.asgard.api.objects.game.TeamGame; -import fun.asgard.api.objects.managers.PlayersManager; -import fun.asgard.internal.Utils; -import fun.asgard.internal.managers.playersmanager.EPlayersManager; -import org.bukkit.Bukkit; -import org.bukkit.World; -import org.bukkit.entity.Player; -import org.bukkit.plugin.Plugin; - -import java.util.HashMap; -import java.util.HashSet; - -public abstract class ATeamGame implements TeamGame { - - private final PlayersManager playersManager; - private final World world; - private final String gameName; - private final TAGA taga; - private final Plugin client; - - private long started; - private long time; - private boolean leaveOnKick = false; - - /** - * @param client The one who uses the api - * @param world World of the game - * @param gameName Name of the game - * @param time Game time - */ - protected ATeamGame(TAGA taga, Plugin client, World world, String gameName, long time) { - this.taga = taga; - this.client = client; - this.gameName = gameName; - this.world = world; - this.time = time; - this.playersManager = new EPlayersManager(taga, client, this); - } - - @Override - public void start() { - if (this.world.getLoadedChunks().length <= 0 - || !this.client.getServer().getWorlds().contains(this.world)) { - this.client.getServer().getWorlds().add(this.world); - } - - this.started = System.currentTimeMillis(); - Bukkit.getPluginManager().callEvent(new GameStartEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()))); - } - - @Override - public void stop(boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray())); - this.shutdown(saveWorld); - } - - @Override - public void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winner, loser)); - this.shutdown(saveWorld); - } - - @Override - public void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winners, losers)); - this.shutdown(saveWorld); - } - - @Override - public void stop(HashSet winners, HashSet losers, boolean saveWorld) { - this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()), winners, losers)); - this.shutdown(saveWorld); - } - - @Override - public void shutdown(boolean saveWorld) { - this.time = 0; - this.getPlayersManager().getPlayers().forEach((pl, gp) -> this.getPlayersManager().disconnectPlayer(gp)); - Bukkit.unloadWorld(this.world, saveWorld); - } - - @Override - public PlayersManager getPlayersManager() { - return this.playersManager; - } - - @Override - public long getWhenStarted() { - return this.started; - } - - @Override - public long getTime() { - return this.time; - } - - @Override - public String getGameName() { - return this.gameName; - } - - @Override - public World getWorld() { - return this.world; - } - - @Override - public void setTime(long time) { - this.time = time; - } - - @Override - public void setLeaveOnKick(boolean leaveOnKick) { - this.leaveOnKick = leaveOnKick; - } - - @Override - public boolean isLeaveOnKick() { - return this.leaveOnKick; - } - - @Override - public boolean isTeamGame() { - return true; - } - - @Override - public String toString() { - return "TeamGame { " + - "world = " + world.getName() + - ", gameName = '" + gameName + '\'' + - ", time = " + time + - '}'; - } - -} diff --git a/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java b/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java deleted file mode 100644 index 90c9ccb..0000000 --- a/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java +++ /dev/null @@ -1,20 +0,0 @@ -package fun.asgard.internal.objects.teamgame; - - -import fun.asgard.TAGA; -import org.bukkit.World; -import org.bukkit.plugin.Plugin; - -public class ETeamGame extends ATeamGame { - - /** - * @param client The one who uses the api - * @param world World of the game - * @param gameName Name of the game - * @param time Game time - */ - public ETeamGame(TAGA taga, Plugin client, World world, String gameName, long time) { - super(taga, client, world, gameName, time); - } - -} diff --git a/src/test/java/SamplePlugin.java b/src/test/java/SamplePlugin.java deleted file mode 100644 index affd8a6..0000000 --- a/src/test/java/SamplePlugin.java +++ /dev/null @@ -1,56 +0,0 @@ -import fun.asgard.TAGA; -import fun.asgard.api.events.gameevents.GameStartEvent; -import fun.asgard.api.events.gameevents.GameStopEvent; -import fun.asgard.api.objects.game.Game; -import org.bukkit.Bukkit; -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.player.PlayerJoinEvent; -import org.bukkit.plugin.java.JavaPlugin; - -public class SamplePlugin extends JavaPlugin implements Listener { - - public static TAGA taga; - - @Override - public void onEnable() { - taga = new TAGA(this); - - Game game1 = taga.getGameManager().createGame(Bukkit.getWorld("world"), "SampleGame", 5 * 1000); - Game game2 = taga.getGameManager().createGame(Bukkit.getWorld("world"), "SampleGame2", 5 * 1000); - game2.setLeaveOnKick(true); - } - - @Override - public void onDisable() { - taga.getGameManager().getGames().forEach((name, game) -> game.shutdown(false)); - } - - @EventHandler - public void onPlayerJoined(PlayerJoinEvent event) { - Game game = taga.getGameManager().getGames().get("SampleGame2"); - game.getPlayersManager().connectPlayer(event.getPlayer()); - if (game.getPlayersManager().getPlayers().size() >= 1) { - game.start(); - } - } - - @EventHandler - public void onGameStart(GameStartEvent event) { - event.getPlayers().forEach(player -> { - player.getPlayer().sendMessage("Game is started!"); - }); - taga.getTaskManager().createTask(task -> - event.getPlayers().forEach(player -> - player.getPlayer().sendMessage("5 minutes of the game has passed!")), - event.getGame().getGameName(), 5 * 60 * 1000, 5 * 60 * 1000); - } - - @EventHandler - public void onGameStop(GameStopEvent event) { - event.getPlayers().forEach(player -> { - player.getPlayer().sendMessage("The game is stopped"); - }); - } - -} diff --git a/src/test/resources/plugin.yml b/src/test/resources/plugin.yml deleted file mode 100644 index 2713f17..0000000 --- a/src/test/resources/plugin.yml +++ /dev/null @@ -1,5 +0,0 @@ -name: SamplePlugin -version: ${project.version} -main: SamplePlugin -api-version: 1.16 -authors: [ Volan4ik ] From 2cea4e5ccff42161e9889df112a15e2771f317b1 Mon Sep 17 00:00:00 2001 From: Andrew <65760867+VolanDeMor1@users.noreply.github.com> Date: Sat, 19 Jun 2021 11:54:41 +0300 Subject: [PATCH 6/7] Add files via upload --- src/main/java/fun/asgard/Handler.java | 44 ++++ src/main/java/fun/asgard/TAGA.java | 40 ++++ .../api/events/gameevents/GameEvent.java | 70 ++++++ .../api/events/gameevents/GameStartEvent.java | 49 ++++ .../api/events/gameevents/GameStopEvent.java | 102 ++++++++ .../GamePlayerConnectEvent.java | 29 +++ .../GamePlayerDeathEvent.java | 30 +++ .../GamePlayerDisconnectEvent.java | 28 +++ .../gameplayerevents/GamePlayerEvent.java | 70 ++++++ .../GamePlayerJoinedTeamEvent.java | 13 ++ .../GamePlayerLeftTeamEvent.java | 13 ++ .../GameTeamDisconnectEvent.java | 19 ++ .../events/gameteamevents/GameTeamEvent.java | 52 +++++ .../fun/asgard/api/objects/game/BaseGame.java | 56 +++++ .../fun/asgard/api/objects/game/Game.java | 22 ++ .../asgard/api/objects/game/GamePlayer.java | 23 ++ .../fun/asgard/api/objects/game/GameTeam.java | 29 +++ .../fun/asgard/api/objects/game/TeamGame.java | 9 + .../api/objects/managers/GamesManager.java | 27 +++ .../api/objects/managers/PlayersManager.java | 55 +++++ .../api/objects/managers/TaskManager.java | 19 ++ .../fun/asgard/api/objects/task/Task.java | 11 + .../asgard/api/objects/task/TaskRunnable.java | 7 + src/main/java/fun/asgard/internal/Utils.java | 16 ++ .../managers/gamemanager/AGameManager.java | 70 ++++++ .../managers/gamemanager/EGameManager.java | 12 + .../playersmanager/APlayersManager.java | 218 ++++++++++++++++++ .../playersmanager/EPlayersManager.java | 18 ++ .../managers/taskmanager/ATaskManager.java | 75 ++++++ .../managers/taskmanager/ETaskManager.java | 12 + .../asgard/internal/objects/game/AGame.java | 142 ++++++++++++ .../asgard/internal/objects/game/EGame.java | 19 ++ .../objects/gameplayer/AGamePlayer.java | 76 ++++++ .../objects/gameplayer/EGamePlayer.java | 20 ++ .../internal/objects/gameteam/AGameTeam.java | 76 ++++++ .../internal/objects/gameteam/EGameTeam.java | 18 ++ .../asgard/internal/objects/task/ATask.java | 32 +++ .../asgard/internal/objects/task/ETask.java | 11 + .../internal/objects/teamgame/ATeamGame.java | 143 ++++++++++++ .../internal/objects/teamgame/ETeamGame.java | 20 ++ src/test/java/SamplePlugin.java | 56 +++++ src/test/resources/plugin.yml | 5 + 42 files changed, 1856 insertions(+) create mode 100644 src/main/java/fun/asgard/Handler.java create mode 100644 src/main/java/fun/asgard/TAGA.java create mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java create mode 100644 src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java create mode 100644 src/main/java/fun/asgard/api/objects/game/BaseGame.java create mode 100644 src/main/java/fun/asgard/api/objects/game/Game.java create mode 100644 src/main/java/fun/asgard/api/objects/game/GamePlayer.java create mode 100644 src/main/java/fun/asgard/api/objects/game/GameTeam.java create mode 100644 src/main/java/fun/asgard/api/objects/game/TeamGame.java create mode 100644 src/main/java/fun/asgard/api/objects/managers/GamesManager.java create mode 100644 src/main/java/fun/asgard/api/objects/managers/PlayersManager.java create mode 100644 src/main/java/fun/asgard/api/objects/managers/TaskManager.java create mode 100644 src/main/java/fun/asgard/api/objects/task/Task.java create mode 100644 src/main/java/fun/asgard/api/objects/task/TaskRunnable.java create mode 100644 src/main/java/fun/asgard/internal/Utils.java create mode 100644 src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java create mode 100644 src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java create mode 100644 src/main/java/fun/asgard/internal/objects/game/AGame.java create mode 100644 src/main/java/fun/asgard/internal/objects/game/EGame.java create mode 100644 src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java create mode 100644 src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java create mode 100644 src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java create mode 100644 src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java create mode 100644 src/main/java/fun/asgard/internal/objects/task/ATask.java create mode 100644 src/main/java/fun/asgard/internal/objects/task/ETask.java create mode 100644 src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java create mode 100644 src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java create mode 100644 src/test/java/SamplePlugin.java create mode 100644 src/test/resources/plugin.yml diff --git a/src/main/java/fun/asgard/Handler.java b/src/main/java/fun/asgard/Handler.java new file mode 100644 index 0000000..b8f1f46 --- /dev/null +++ b/src/main/java/fun/asgard/Handler.java @@ -0,0 +1,44 @@ +package fun.asgard; + +import fun.asgard.api.events.gameplayerevents.GamePlayerDeathEvent; +import fun.asgard.api.objects.game.GamePlayer; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.PlayerDeathEvent; +import org.bukkit.event.player.PlayerKickEvent; +import org.bukkit.plugin.Plugin; + +public class Handler implements Listener { + + private final TAGA pl; + private final Plugin client; + + protected Handler(TAGA taga, Plugin client) { + this.pl = taga; + this.client = client; + } + + @EventHandler + public void onPlayerKick(PlayerKickEvent event) { + this.pl.getGameManager().getGames().forEach((name, game) -> { + if (game.isLeaveOnKick() + && game.getPlayersManager().getPlayers().containsKey(event.getPlayer())) { + game.getPlayersManager().disconnectPlayer(game.getPlayersManager().getPlayers().get(event.getPlayer())); + } + }); + } + + @EventHandler + public void onPlayerDeath(PlayerDeathEvent event) { + this.pl.getGameManager().getGames().forEach((name, game) -> { + if (game.getPlayersManager().getPlayers().containsKey(event.getEntity())) { + GamePlayer gp = game.getPlayersManager().getPlayers().get(event.getEntity()); + gp.setDied(true); + this.client.getServer().getPluginManager() + .callEvent(new GamePlayerDeathEvent(game, gp)); + } + }); + } + +} diff --git a/src/main/java/fun/asgard/TAGA.java b/src/main/java/fun/asgard/TAGA.java new file mode 100644 index 0000000..ac05eed --- /dev/null +++ b/src/main/java/fun/asgard/TAGA.java @@ -0,0 +1,40 @@ +package fun.asgard; + +import fun.asgard.api.objects.managers.GamesManager; +import fun.asgard.api.objects.managers.TaskManager; +import fun.asgard.internal.managers.gamemanager.EGameManager; +import fun.asgard.internal.managers.taskmanager.ETaskManager; +import org.bukkit.event.Listener; +import org.bukkit.plugin.Plugin; + +public final class TAGA implements Listener { + + private final GamesManager gm; + private final TaskManager tm; + + private static final String VERSION = "v1.3.0"; + + public TAGA (Plugin client) { + if (client == null) + throw new IllegalArgumentException("Plugin must be valid"); + + client.getServer().getLogger().info("[TAGA] Starting TAGA-" + getVersion() + " on " + client.getServer().getVersion()); + + this.gm = new EGameManager(this, client); + this.tm = new ETaskManager(this, client); + client.getServer().getPluginManager().registerEvents(new Handler(this, client), client); + } + + public GamesManager getGameManager() { + return gm; + } + + public TaskManager getTaskManager() { + return tm; + } + + public static String getVersion() { + return VERSION; + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java new file mode 100644 index 0000000..a3f128a --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameevents/GameEvent.java @@ -0,0 +1,70 @@ +package fun.asgard.api.events.gameevents; + +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +import java.util.HashSet; + +public class GameEvent extends Event { + + private static HandlerList handlers = null; + + private final TeamGame teamGame; + private final Game game; + private final HashSet winners = new HashSet<>(); + private final HashSet losers = new HashSet<>(); + private final HashSet players = new HashSet<>(); + + /** + * + * @param game Game + */ + protected GameEvent(Game game, HashSet winners, HashSet losers, HashSet players) { + handlers = new HandlerList(); + this.game = game; + this.teamGame = null; + } + + /** + * + * @param teamGame Game + */ + protected GameEvent(TeamGame teamGame, HashSet winners, HashSet losers, HashSet players) { + handlers = new HandlerList(); + this.teamGame = teamGame; + this.game = null; + } + + public HashSet getLosers() { + return losers; + } + + public HashSet getPlayers() { + return players; + } + + public HashSet getWinners() { + return winners; + } + + public TeamGame getTeamGame() { + return teamGame; + } + + public Game getGame() { + return game; + } + + public @NotNull HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java new file mode 100644 index 0000000..1e07dc6 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameevents/GameStartEvent.java @@ -0,0 +1,49 @@ +package fun.asgard.api.events.gameevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; + +import java.util.Arrays; +import java.util.HashSet; + +public class GameStartEvent extends GameEvent { + + /** + * + * @param game Game + * @param players Game players + */ + public GameStartEvent(Game game, GamePlayer[] players) { + super(game, null, null, new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + */ + public GameStartEvent(Game game, HashSet players) { + super(game, null, null, players); + } + + /** + * + * @param game Game + * @param players Game players + */ + public GameStartEvent(TeamGame game, GamePlayer[] players) { + super(game, null, null, new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + */ + public GameStartEvent(TeamGame game, HashSet players) { + super(game, null, null, players); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java b/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java new file mode 100644 index 0000000..f013487 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameevents/GameStopEvent.java @@ -0,0 +1,102 @@ +package fun.asgard.api.events.gameevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; + +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; + +public class GameStopEvent extends GameEvent { + + /** + * + * @param game Game + * @param players Game players + */ + public GameStopEvent(Game game, GamePlayer[] players) { + super(game, null, null, new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winner Winner of the game + * @param loser Loser of the game + */ + public GameStopEvent(Game game, GamePlayer[] players, GamePlayer winner, GamePlayer loser) { + super(game, new HashSet<>(Collections.singletonList(winner)), new HashSet<>(Collections.singletonList(loser)), + new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winners Winners of the game + * @param losers Losers of the game + */ + public GameStopEvent(Game game, GamePlayer[] players, GamePlayer[] winners, GamePlayer[] losers) { + super(game, new HashSet<>(Arrays.asList(winners)), new HashSet<>(Arrays.asList(losers)), + new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winners Winners of the game + * @param losers Losers of the game + */ + public GameStopEvent(Game game, HashSet players, HashSet winners, HashSet losers) { + super(game, winners, losers, players); + } + + /** + * + * @param game Game + * @param players Game players + */ + public GameStopEvent(TeamGame game, GamePlayer[] players) { + super(game, null, null, new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winner Winner of the game + * @param loser Loser of the game + */ + public GameStopEvent(TeamGame game, GamePlayer[] players, GamePlayer winner, GamePlayer loser) { + super(game, new HashSet<>(Collections.singletonList(winner)), new HashSet<>(Collections.singletonList(loser)), + new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winners Winners of the game + * @param losers Losers of the game + */ + public GameStopEvent(TeamGame game, GamePlayer[] players, GamePlayer[] winners, GamePlayer[] losers) { + super(game, new HashSet<>(Arrays.asList(winners)), new HashSet<>(Arrays.asList(losers)), + new HashSet<>(Arrays.asList(players))); + } + + /** + * + * @param game Game + * @param players Game players + * @param winners Winners of the game + * @param losers Losers of the game + */ + public GameStopEvent(TeamGame game, HashSet players, HashSet winners, HashSet losers) { + super(game, winners, losers, players); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java new file mode 100644 index 0000000..aa590c4 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerConnectEvent.java @@ -0,0 +1,29 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerConnectEvent extends GamePlayerEvent { + + /** + * + * @param game Game + * @param player Game player + */ + public GamePlayerConnectEvent(Game game, Player player, GamePlayer gamePlayer) { + super(game, player, gamePlayer); + } + + /** + * + * @param teamGame Team game + * @param player Game player + */ + public GamePlayerConnectEvent(TeamGame teamGame, Player player, GamePlayer gamePlayer) { + super(teamGame, player, gamePlayer); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java new file mode 100644 index 0000000..78184eb --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDeathEvent.java @@ -0,0 +1,30 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerDeathEvent extends GamePlayerEvent { + + /** + * + * @param game Game + * @param player Game player + */ + public GamePlayerDeathEvent(Game game, GamePlayer player) { + super(game, null, player); + } + + + /** + * + * @param teamGame Team game + * @param player Game player + */ + public GamePlayerDeathEvent(TeamGame teamGame, Player player) { + super(teamGame, player, null); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java new file mode 100644 index 0000000..2131956 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerDisconnectEvent.java @@ -0,0 +1,28 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.Game; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerDisconnectEvent extends GamePlayerEvent { + + /** + * + * @param game Game + * @param player Game player + */ + public GamePlayerDisconnectEvent(Game game, Player player) { + super(game, player, null); + } + + /** + * + * @param game Game + * @param player Game player + */ + public GamePlayerDisconnectEvent(TeamGame game, Player player) { + super(game, player, null); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java new file mode 100644 index 0000000..4b1bd7c --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerEvent.java @@ -0,0 +1,70 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +public class GamePlayerEvent extends Event { + + private static HandlerList handlers = null; + + private final Player player; + private final GamePlayer gp; + private final TeamGame teamGame; + private final Game game; + + /** + * + * @param game Game + * @param player Game player + */ + protected GamePlayerEvent(Game game, Player player, GamePlayer gp) { + handlers = new HandlerList(); + this.gp = gp; + this.player = player; + this.game = game; + this.teamGame = null; + } + + /** + * + * @param teamGame Game + * @param player Game player + */ + protected GamePlayerEvent(TeamGame teamGame, Player player, GamePlayer gp) { + handlers = new HandlerList(); + this.gp = gp; + this.player = player; + this.teamGame = teamGame; + this.game = null; + } + + public GamePlayer getGamePlayer() { + return gp; + } + + public Player getPlayer() { + return player; + } + + public TeamGame getTeamGame() { + return teamGame; + } + + public Game getGame() { + return game; + } + + public @NotNull HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java new file mode 100644 index 0000000..0d16960 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerJoinedTeamEvent.java @@ -0,0 +1,13 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerJoinedTeamEvent extends GamePlayerEvent { + + public GamePlayerJoinedTeamEvent(TeamGame teamGame, Player player, GamePlayer gp) { + super(teamGame, player, gp); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java new file mode 100644 index 0000000..5820e67 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameplayerevents/GamePlayerLeftTeamEvent.java @@ -0,0 +1,13 @@ +package fun.asgard.api.events.gameplayerevents; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class GamePlayerLeftTeamEvent extends GamePlayerEvent { + + public GamePlayerLeftTeamEvent(TeamGame teamGame, Player player, GamePlayer gp) { + super(teamGame, player, gp); + } + +} diff --git a/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java new file mode 100644 index 0000000..9031c18 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamDisconnectEvent.java @@ -0,0 +1,19 @@ +package fun.asgard.api.events.gameteamevents; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +import java.util.Set; + +public class GameTeamDisconnectEvent extends GameTeamEvent { + + /** + * + * @param game Game + * @param players Game players + */ + public GameTeamDisconnectEvent(TeamGame game, Set players) { + super(game, players, null); + } + +} \ No newline at end of file diff --git a/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java new file mode 100644 index 0000000..54287c4 --- /dev/null +++ b/src/main/java/fun/asgard/api/events/gameteamevents/GameTeamEvent.java @@ -0,0 +1,52 @@ +package fun.asgard.api.events.gameteamevents; + +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +import java.util.Set; + +public class GameTeamEvent extends Event { + + private static HandlerList handlers = null; + + private final Set players; + private final TeamGame game; + private final GameTeam team; + + /** + * + * @param game Team game + * @param players Game players + */ + protected GameTeamEvent(TeamGame game, Set players, GameTeam team) { + handlers = new HandlerList(); + this.players = players; + this.game = game; + this.team = team; + } + + public Set getPlayers() { + return players; + } + + public TeamGame getTeamGame() { + return game; + } + + public GameTeam getTeam() { + return team; + } + + public @NotNull HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} diff --git a/src/main/java/fun/asgard/api/objects/game/BaseGame.java b/src/main/java/fun/asgard/api/objects/game/BaseGame.java new file mode 100644 index 0000000..f8b6b77 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/BaseGame.java @@ -0,0 +1,56 @@ +package fun.asgard.api.objects.game; + +import org.bukkit.World; + +import java.util.HashSet; + +public interface BaseGame { + + /** + * After calling the method, GameStartEvent will be triggered + */ + void start(); + + /** + * After calling the method, GameEndEvent will be triggered + */ + void stop(boolean saveWorld); + + /** + * After calling the method, GameEndEvent will be triggered + */ + void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld); + + /** + * After calling the method, GameEndEvent will be triggered + */ + void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld); + + /** + * After calling the method, GameEndEvent will be triggered + */ + void stop(HashSet winners, HashSet losers, boolean saveWorld); + + /** + * After calling the method, no event will be triggered + */ + void shutdown(boolean saveWorld); + + + long getWhenStarted(); + + long getTime(); + + String getGameName(); + + World getWorld(); + + void setTime(long time); + + void setLeaveOnKick(boolean kickOnLeave); + + boolean isLeaveOnKick(); + + boolean isTeamGame(); + +} diff --git a/src/main/java/fun/asgard/api/objects/game/Game.java b/src/main/java/fun/asgard/api/objects/game/Game.java new file mode 100644 index 0000000..b0a34e0 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/Game.java @@ -0,0 +1,22 @@ +package fun.asgard.api.objects.game; + +import fun.asgard.api.objects.managers.PlayersManager; +import java.util.HashSet; + +public interface Game extends BaseGame { + + void start(); + + void stop(boolean saveWorld); + + void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld); + + void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld); + + void stop(HashSet winners, HashSet losers, boolean saveWorld); + + void shutdown(boolean saveWorld); + + PlayersManager getPlayersManager(); + +} diff --git a/src/main/java/fun/asgard/api/objects/game/GamePlayer.java b/src/main/java/fun/asgard/api/objects/game/GamePlayer.java new file mode 100644 index 0000000..3327c07 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/GamePlayer.java @@ -0,0 +1,23 @@ +package fun.asgard.api.objects.game; + +import org.bukkit.entity.Player; + +public interface GamePlayer { + + Player getPlayer(); + + BaseGame getGame(); + + int getScore(); + + GameTeam getTeam(); + + boolean isDied(); + + void setScore(int score); + + void setDied(boolean isDied); + + void setTeam(GameTeam team); + +} diff --git a/src/main/java/fun/asgard/api/objects/game/GameTeam.java b/src/main/java/fun/asgard/api/objects/game/GameTeam.java new file mode 100644 index 0000000..8b63ecc --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/GameTeam.java @@ -0,0 +1,29 @@ +package fun.asgard.api.objects.game; + +import org.bukkit.Color; + +import java.util.HashSet; + +public interface GameTeam { + + HashSet getPlayers(); + + BaseGame getTeamGame(); + + int getScore(); + + boolean isLost(); + + Color getColor(); + + String getName(); + + void setScore(int score); + + void setLost(boolean isLost); + + void setColor(Color color); + + void setName(String name); + +} diff --git a/src/main/java/fun/asgard/api/objects/game/TeamGame.java b/src/main/java/fun/asgard/api/objects/game/TeamGame.java new file mode 100644 index 0000000..2877de9 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/game/TeamGame.java @@ -0,0 +1,9 @@ +package fun.asgard.api.objects.game; + +import fun.asgard.api.objects.managers.PlayersManager; + +public interface TeamGame extends BaseGame { + + PlayersManager getPlayersManager(); + +} diff --git a/src/main/java/fun/asgard/api/objects/managers/GamesManager.java b/src/main/java/fun/asgard/api/objects/managers/GamesManager.java new file mode 100644 index 0000000..0c3da8e --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/managers/GamesManager.java @@ -0,0 +1,27 @@ +package fun.asgard.api.objects.managers; + +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.World; + +import java.util.HashMap; + +public interface GamesManager { + + Game createGame(World world, String gameName, long timer); + + Game createGame(World world, String gameName); + + TeamGame createTeamGame(World world, String gameName, long timer); + + TeamGame createTeamGame(World world, String gameName); + + Game getGame(String gameName); + + TeamGame getTeamGame(String gameName); + + HashMap getGames(); + + HashMap getTeamGames(); + +} diff --git a/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java b/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java new file mode 100644 index 0000000..a042fd6 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/managers/PlayersManager.java @@ -0,0 +1,55 @@ +package fun.asgard.api.objects.managers; + +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.Color; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +import java.util.HashMap; + +public interface PlayersManager { + + Game getGame(); + + TeamGame getTeamGame(); + + HashMap getTeams(); + + HashMap getPlayers(); + + GameTeam getTeam(String name); + + void connectPlayer(Player player); + + void connectPlayer(Player player, Location location); + + void connectPlayer(Player player, double x, double y, double z); + + void disconnectPlayer(GamePlayer player); + + void disconnectPlayer(GamePlayer player, Location location); + + void disconnectPlayer(GamePlayer player, double x, double y, double z); + + GameTeam createTeam(String name, Color color); + + void connectPlayer(Player player, GameTeam team); + + void connectPlayer(Player player, GameTeam team, Location location); + + void connectPlayer(Player player, GameTeam team, double x, double y, double z); + + void disconnectTeam(GameTeam team); + + void disconnectTeam(GameTeam team, Location location); + + void disconnectTeam(GameTeam team, double x, double y, double z); + + void sendMessage(String message); + + void sendTeamMessage(String message, GameTeam team); + +} diff --git a/src/main/java/fun/asgard/api/objects/managers/TaskManager.java b/src/main/java/fun/asgard/api/objects/managers/TaskManager.java new file mode 100644 index 0000000..9012ce2 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/managers/TaskManager.java @@ -0,0 +1,19 @@ +package fun.asgard.api.objects.managers; + +import fun.asgard.api.objects.task.Task; +import fun.asgard.api.objects.task.TaskRunnable; +import org.jetbrains.annotations.NotNull; + +import java.util.HashMap; + +public interface TaskManager { + + void createTask(@NotNull TaskRunnable task, long delay, long period); + + void createTask(@NotNull TaskRunnable task, String taskName, long delay, long period); + + Task getTask(String taskName); + + HashMap getTasks(); + +} diff --git a/src/main/java/fun/asgard/api/objects/task/Task.java b/src/main/java/fun/asgard/api/objects/task/Task.java new file mode 100644 index 0000000..d1548d4 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/task/Task.java @@ -0,0 +1,11 @@ +package fun.asgard.api.objects.task; + +public interface Task { + + void cancel(); + + String getName(); + + void setName(String name); + +} diff --git a/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java b/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java new file mode 100644 index 0000000..e8793d8 --- /dev/null +++ b/src/main/java/fun/asgard/api/objects/task/TaskRunnable.java @@ -0,0 +1,7 @@ +package fun.asgard.api.objects.task; + +public interface TaskRunnable { + + void execute(Task task); + +} diff --git a/src/main/java/fun/asgard/internal/Utils.java b/src/main/java/fun/asgard/internal/Utils.java new file mode 100644 index 0000000..274c863 --- /dev/null +++ b/src/main/java/fun/asgard/internal/Utils.java @@ -0,0 +1,16 @@ +package fun.asgard.internal; + +import java.util.HashMap; +import java.util.HashSet; + +public class Utils { + + public static HashSet valueSet(HashMap map) { + return new HashSet<>(map.values()); + } + + public static double getRandom(double min, double max){ + return (Math.random() * ((max - min) + 1)) + min; + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java b/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java new file mode 100644 index 0000000..7a38c13 --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/gamemanager/AGameManager.java @@ -0,0 +1,70 @@ +package fun.asgard.internal.managers.gamemanager; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.TeamGame; +import fun.asgard.api.objects.managers.GamesManager; +import fun.asgard.internal.objects.game.EGame; + +import fun.asgard.internal.objects.teamgame.ETeamGame; +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +import java.util.HashMap; + +public abstract class AGameManager implements GamesManager { + + private final HashMap games = new HashMap<>(); + private final HashMap teamGames = new HashMap<>(); + private final TAGA taga; + private final Plugin client; + + protected AGameManager(TAGA taga, Plugin client) { + this.taga = taga; + this.client = client; + } + + @Override + public Game createGame(World world, String gameName, long timer) { + EGame game = new EGame(this.taga, this.client, world, gameName, timer); + this.games.put(gameName, game); + return game; + } + + @Override + public Game createGame(World world, String gameName) { + return this.createGame(world, gameName, -1); + } + + @Override + public TeamGame createTeamGame(World world, String gameName, long timer) { + TeamGame game = new ETeamGame(this.taga, this.client, world, gameName, timer); + this.teamGames.put(gameName, game); + return game; + } + + @Override + public TeamGame createTeamGame(World world, String gameName) { + return this.createTeamGame(world, gameName, -1); + } + + @Override + public Game getGame(String gameName) { + return this.getGames().get(gameName); + } + + @Override + public TeamGame getTeamGame(String gameName) { + return this.getTeamGames().get(gameName); + } + + @Override + public HashMap getGames() { + return this.games; + } + + @Override + public HashMap getTeamGames() { + return this.teamGames; + } +} diff --git a/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java b/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java new file mode 100644 index 0000000..bf306b6 --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/gamemanager/EGameManager.java @@ -0,0 +1,12 @@ +package fun.asgard.internal.managers.gamemanager; + +import fun.asgard.TAGA; +import org.bukkit.plugin.Plugin; + +public class EGameManager extends AGameManager { + + public EGameManager(TAGA taga, Plugin client) { + super(taga, client); + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java b/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java new file mode 100644 index 0000000..49a688d --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/playersmanager/APlayersManager.java @@ -0,0 +1,218 @@ +package fun.asgard.internal.managers.playersmanager; + +import fun.asgard.TAGA; +import fun.asgard.api.events.gameplayerevents.GamePlayerConnectEvent; +import fun.asgard.api.events.gameplayerevents.GamePlayerDisconnectEvent; +import fun.asgard.api.events.gameplayerevents.GamePlayerJoinedTeamEvent; +import fun.asgard.api.events.gameteamevents.GameTeamDisconnectEvent; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import fun.asgard.api.objects.managers.PlayersManager; +import fun.asgard.internal.objects.gameplayer.EGamePlayer; +import org.bukkit.Color; +import org.bukkit.Location; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + +import java.util.HashMap; +import java.util.stream.Collectors; + +public abstract class APlayersManager implements PlayersManager { + + private final TAGA taga; + private final Plugin client; + private final Game game; + private final TeamGame teamGame; + private final HashMap teams; + + private final HashMap players = new HashMap<>(); + + protected APlayersManager(TAGA taga, Plugin client, Game game) { + this.client = client; + this.taga = taga; + this.game = game; + this.teamGame = null; + this.teams = null; + } + + protected APlayersManager(TAGA taga, Plugin client, TeamGame teamGame) { + this.client = client; + this.taga = taga; + this.game = null; + this.teamGame = teamGame; + this.teams = new HashMap<>(); + } + + @Override + public void connectPlayer(Player player) { + this.checkIfValidGame(); + GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); + this.players.put(player, gp); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, Location location) { + this.checkIfValidGame(); + GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); + this.players.put(player, gp); + player.teleport(location); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, double x, double y, double z) { + this.checkIfValidGame(); + GamePlayer gp = new EGamePlayer(this.taga, player, getGame()); + this.players.put(player, gp); + player.teleport(new Location(getGame().getWorld(), x, y, z)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, GameTeam team) { + this.checkIfValidGame(true); + GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); + this.players.put(player, gp); + this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, GameTeam team, Location location) { + this.checkIfValidGame(true); + GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); + this.players.put(player, gp); + player.teleport(location); + this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); + } + + @Override + public void connectPlayer(Player player, GameTeam team, double x, double y, double z) { + this.checkIfValidGame(true); + GamePlayer gp = new EGamePlayer(this.taga, player, getTeamGame(), team); + this.players.put(player, gp); + player.teleport(new Location(getTeamGame().getWorld(), x, y, z)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerJoinedTeamEvent(getTeamGame(), player, gp)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerConnectEvent(getTeamGame(), player, gp)); + } + + @Override + public void disconnectPlayer(GamePlayer player) { + this.checkIfValidGame(); + this.players.remove(player.getPlayer()); + this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); + } + + @Override + public void disconnectPlayer(GamePlayer player, Location location) { + this.checkIfValidGame(); + this.players.remove(player.getPlayer()); + player.getPlayer().teleport(location); + this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); + } + + @Override + public void disconnectPlayer(GamePlayer player, double x, double y, double z) { + this.checkIfValidGame(); + this.players.remove(player.getPlayer()); + player.getPlayer().teleport(new Location(getGame().getWorld(), x, y, z)); + this.client.getServer().getPluginManager().callEvent(new GamePlayerDisconnectEvent(getGame(), player.getPlayer())); + } + + @Override + public void disconnectTeam(GameTeam team) { + this.checkIfValidGame(true); + team.getPlayers().forEach(pl -> this.players.remove(pl.getPlayer())); + this.teams.remove(team.getName()); + this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), + team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); + } + + @Override + public void disconnectTeam(GameTeam team, Location location) { + this.checkIfValidGame(true); + team.getPlayers().forEach(pl -> { + this.players.remove(pl.getPlayer()); + pl.getPlayer().teleport(location); + }); + this.teams.remove(team.getName()); + this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), + team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); + } + + @Override + public void disconnectTeam(GameTeam team, double x, double y, double z) { + this.checkIfValidGame(true); + team.getPlayers().forEach(pl -> { + this.players.remove(pl.getPlayer()); + pl.getPlayer().teleport(new Location(getGame().getWorld(), x, y, z)); + }); + this.teams.remove(team.getName()); + this.client.getServer().getPluginManager().callEvent(new GameTeamDisconnectEvent(getTeamGame(), + team.getPlayers().stream().map(GamePlayer::getPlayer).collect(Collectors.toSet()))); + } + + @Override + public GameTeam createTeam(String name, Color color) { + this.checkIfValidGame(true); + return null; + } + + @Override + public void sendMessage(String message) { + this.getPlayers().forEach((player, gamePlayer) -> player.sendMessage(message)); + } + + @Override + public void sendTeamMessage(String message, GameTeam team) { + team.getPlayers().forEach(gamePlayer -> gamePlayer.getPlayer().sendMessage(message)); + } + + @Override + public Game getGame() { + return game; + } + + @Override + public TeamGame getTeamGame() { + return teamGame; + } + + @Override + public HashMap getPlayers() { + return players; + } + + @Override + public HashMap getTeams() { + return teams; + } + + @Override + public GameTeam getTeam(String name) { + return this.getTeams().get(name); + } + + public boolean isTeamGame() { + return this.getTeamGame() != null; + } + + private boolean checkIfValidGame() { + return this.checkIfValidGame(false); + } + + private boolean checkIfValidGame(boolean ifTeamInteraction) { + if (ifTeamInteraction && getTeamGame() == null) { + throw new IllegalCallerException("It is impossible to call the method, the game is not a team game!"); + } else if (!ifTeamInteraction && getGame() == null) { + throw new IllegalCallerException("It is impossible to call the method, the game is team!"); + } else { + return true; + } + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java b/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java new file mode 100644 index 0000000..57fcf39 --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/playersmanager/EPlayersManager.java @@ -0,0 +1,18 @@ +package fun.asgard.internal.managers.playersmanager; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.plugin.Plugin; + +public class EPlayersManager extends APlayersManager { + + public EPlayersManager(TAGA taga, Plugin client, Game game) { + super(taga, client, game); + } + + public EPlayersManager(TAGA taga, Plugin client, TeamGame teamGame) { + super(taga, client, teamGame); + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java b/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java new file mode 100644 index 0000000..4ed709d --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/taskmanager/ATaskManager.java @@ -0,0 +1,75 @@ +package fun.asgard.internal.managers.taskmanager; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.managers.TaskManager; +import fun.asgard.api.objects.task.Task; +import fun.asgard.api.objects.task.TaskRunnable; +import fun.asgard.internal.Utils; +import fun.asgard.internal.objects.task.ETask; + +import org.bukkit.plugin.Plugin; + +import org.jetbrains.annotations.NotNull; + +import java.util.HashMap; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public abstract class ATaskManager implements TaskManager { + + private final TAGA taga; + private final Plugin client; + private final HashMap tasks = new HashMap<>(); + + protected ATaskManager(TAGA taga, Plugin client) { + this.taga = taga; + this.client = client; + } + + @Override + public void createTask(@NotNull TaskRunnable task, long delay, long period){ + if (delay < 0) + throw new IllegalArgumentException("Negative delay."); + if (period <= 0) + throw new IllegalArgumentException("Non-positive period."); + + ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); + String id = "Task-" + this.getRandomId(); + Task gt = new ETask(service, id); + service.scheduleWithFixedDelay(() -> task.execute(gt), delay, period, TimeUnit.MILLISECONDS); + + this.tasks.put(id, gt); + } + + @Override + public void createTask(@NotNull TaskRunnable task, String taskName, long delay, long period){ + if (delay < 0) + throw new IllegalArgumentException("Negative delay."); + if (period <= 0) + throw new IllegalArgumentException("Non-positive period."); + + ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); + Task gt = new ETask(service, taskName); + service.scheduleWithFixedDelay(() -> task.execute(gt), delay, period, TimeUnit.MILLISECONDS); + + this.tasks.put(taskName, gt); + } + + @Override + public Task getTask(String taskName) { + return this.getTasks().get(taskName); + } + + @Override + public HashMap getTasks() { + return tasks; + } + + private String getRandomId() { + String str = String.valueOf(Utils.getRandom(this.getTasks().size(), 1000)); + if (this.getTask(str) != null) return getRandomId(); + else return str; + } + +} diff --git a/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java b/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java new file mode 100644 index 0000000..f883d05 --- /dev/null +++ b/src/main/java/fun/asgard/internal/managers/taskmanager/ETaskManager.java @@ -0,0 +1,12 @@ +package fun.asgard.internal.managers.taskmanager; + +import fun.asgard.TAGA; +import org.bukkit.plugin.Plugin; + +public class ETaskManager extends ATaskManager { + + public ETaskManager(TAGA taga, Plugin client) { + super(taga, client); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/game/AGame.java b/src/main/java/fun/asgard/internal/objects/game/AGame.java new file mode 100644 index 0000000..6b75d81 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/game/AGame.java @@ -0,0 +1,142 @@ +package fun.asgard.internal.objects.game; + +import fun.asgard.TAGA; +import fun.asgard.api.events.gameevents.GameStartEvent; +import fun.asgard.api.events.gameevents.GameStopEvent; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.managers.PlayersManager; +import fun.asgard.internal.Utils; +import fun.asgard.internal.managers.playersmanager.EPlayersManager; +import org.bukkit.Bukkit; +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +import java.util.HashSet; + +public abstract class AGame implements Game { + + private final World world; + private final String gameName; + private final TAGA taga; + private final Plugin client; + private final PlayersManager playersManager; + + private long started; + private long time; + private boolean leaveOnKick = false; + + /** + * @param client The one who uses the api + * @param world World of the game + * @param gameName Name of the game + * @param time Game time + */ + protected AGame(TAGA taga, Plugin client, World world, String gameName, long time) { + this.taga = taga; + this.client = client; + this.gameName = gameName; + this.world = world; + this.time = time; + this.playersManager = new EPlayersManager(taga, client, this); + } + + @Override + public long getWhenStarted() { + return started; + } + + @Override + public long getTime() { + return time; + } + + @Override + public String getGameName() { + return gameName; + } + + @Override + public World getWorld() { + return world; + } + + @Override + public void setTime(long time) { + this.time = time; + } + + @Override + public void setLeaveOnKick(boolean kickOnLeave) { + this.leaveOnKick = kickOnLeave; + } + + @Override + public boolean isLeaveOnKick() { + return leaveOnKick; + } + + @Override + public void start() { + if (this.world.getLoadedChunks().length <= 0 + || !this.client.getServer().getWorlds().contains(this.world)) { + this.client.getServer().getWorlds().add(this.world); + } + + this.started = System.currentTimeMillis(); + Bukkit.getPluginManager().callEvent(new GameStartEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()))); + + } + + @Override + public void stop(boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray())); + this.shutdown(saveWorld); + } + + @Override + public void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winner, loser)); + this.shutdown(saveWorld); + } + + @Override + public void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winners, losers)); + this.shutdown(saveWorld); + } + + + @Override + public void stop(HashSet winners, HashSet losers, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()), winners, losers)); + this.shutdown(saveWorld); + } + + @Override + public void shutdown(boolean saveWorld) { + this.time = 0; + this.getPlayersManager().getPlayers().forEach((pl, gp) -> this.getPlayersManager().disconnectPlayer(gp)); + Bukkit.unloadWorld(this.world, saveWorld); + } + + @Override + public PlayersManager getPlayersManager() { + return this.playersManager; + } + + @Override + public boolean isTeamGame() { + return false; + } + + @Override + public String toString() { + return "Game { " + + "world = " + world.getName() + + ", gameName = '" + gameName + '\'' + + ", time = " + time + + '}'; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/game/EGame.java b/src/main/java/fun/asgard/internal/objects/game/EGame.java new file mode 100644 index 0000000..ccc5008 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/game/EGame.java @@ -0,0 +1,19 @@ +package fun.asgard.internal.objects.game; + +import fun.asgard.TAGA; +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +public class EGame extends AGame { + + /** + * @param client The one who uses the api + * @param world World of the game + * @param gameName Name of the game + * @param time Game time + */ + public EGame(TAGA taga, Plugin client, World world, String gameName, long time) { + super(taga, client, world, gameName, time); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java b/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java new file mode 100644 index 0000000..602ad92 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/gameplayer/AGamePlayer.java @@ -0,0 +1,76 @@ +package fun.asgard.internal.objects.gameplayer; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public abstract class AGamePlayer implements GamePlayer { + + private final TAGA taga; + private final Player player; + private final Game game; + private final TeamGame teamgame; + private GameTeam team = null; + private int score = 0; + private boolean isDied = false; + + protected AGamePlayer(TAGA taga, Player player, Game game) { + this.taga = taga; + this.player = player; + this.game = game; + this.teamgame = null; + } + + protected AGamePlayer(TAGA taga, Player player, TeamGame game, GameTeam team) { + this.taga = taga; + this.player = player; + this.teamgame = game; + this.game = null; + this.team = team; + } + + @Override + public Player getPlayer() { + return this.player; + } + + @Override + public Game getGame() { + return this.game; + } + + @Override + public int getScore() { + return this.score; + } + + @Override + public GameTeam getTeam() { + return this.team; + } + + @Override + public boolean isDied() { + return this.isDied; + } + + @Override + public void setScore(int score) { + this.score = score; + } + + @Override + public void setDied(boolean isDied) { + this.isDied = isDied; + } + + @Override + public void setTeam(GameTeam team) { + this.team = team; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java b/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java new file mode 100644 index 0000000..7d4142d --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/gameplayer/EGamePlayer.java @@ -0,0 +1,20 @@ +package fun.asgard.internal.objects.gameplayer; + +import fun.asgard.TAGA; +import fun.asgard.api.objects.game.Game; +import fun.asgard.api.objects.game.GameTeam; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.entity.Player; + +public class EGamePlayer extends AGamePlayer { + + public EGamePlayer(TAGA taga, Player player, Game game) { + super(taga, player, game); + } + + public EGamePlayer(TAGA taga, Player player, TeamGame game, GameTeam team) { + super(taga, player, game, team); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java b/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java new file mode 100644 index 0000000..d9391cb --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/gameteam/AGameTeam.java @@ -0,0 +1,76 @@ +package fun.asgard.internal.objects.gameteam; + +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.Color; + +import java.util.HashSet; + +public abstract class AGameTeam implements GameTeam { + + private final HashSet players = new HashSet<>(); + private final TeamGame game; + + private int score; + private boolean isLost; + private Color color; + private String name; + + protected AGameTeam(TeamGame game, Color color, String name) { + this.game = game; + this.color = color; + this.name = name; + } + + @Override + public HashSet getPlayers() { + return this.players; + } + + @Override + public TeamGame getTeamGame() { + return this.game; + } + + @Override + public int getScore() { + return this.score; + } + + @Override + public boolean isLost() { + return this.isLost; + } + + @Override + public Color getColor() { + return this.color; + } + + @Override + public String getName() { + return this.name; + } + + @Override + public void setScore(int score) { + this.score = score; + } + + @Override + public void setLost(boolean isLost) { + this.isLost = isLost; + } + + @Override + public void setColor(Color color) { + this.color = color; + } + + @Override + public void setName(String name) { + this.name = name; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java b/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java new file mode 100644 index 0000000..78abf59 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/gameteam/EGameTeam.java @@ -0,0 +1,18 @@ +package fun.asgard.internal.objects.gameteam; + +import fun.asgard.api.objects.game.TeamGame; +import org.bukkit.Color; + +public class EGameTeam extends AGameTeam { + + /** + * + * @param teamGame Team game + * @param color Color of the team + * @param name Team name + */ + public EGameTeam(TeamGame teamGame, Color color, String name) { + super(teamGame, color, name); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/task/ATask.java b/src/main/java/fun/asgard/internal/objects/task/ATask.java new file mode 100644 index 0000000..e6d6646 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/task/ATask.java @@ -0,0 +1,32 @@ +package fun.asgard.internal.objects.task; + +import fun.asgard.api.objects.task.Task; + +import java.util.concurrent.ScheduledExecutorService; + +public abstract class ATask implements Task { + + private final ScheduledExecutorService service; + private String name; + + protected ATask(ScheduledExecutorService service, String name) { + this.service = service; + this.name = name; + } + + @Override + public void cancel() { + this.service.shutdown(); + } + + @Override + public String getName() { + return this.name; + } + + @Override + public void setName(String name) { + this.name = name; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/task/ETask.java b/src/main/java/fun/asgard/internal/objects/task/ETask.java new file mode 100644 index 0000000..63bcfeb --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/task/ETask.java @@ -0,0 +1,11 @@ +package fun.asgard.internal.objects.task; + +import java.util.concurrent.ScheduledExecutorService; + +public class ETask extends ATask { + + public ETask(ScheduledExecutorService service, String name) { + super(service, name); + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java b/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java new file mode 100644 index 0000000..08ef092 --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/teamgame/ATeamGame.java @@ -0,0 +1,143 @@ +package fun.asgard.internal.objects.teamgame; + +import fun.asgard.TAGA; +import fun.asgard.api.events.gameevents.GameStartEvent; +import fun.asgard.api.events.gameevents.GameStopEvent; +import fun.asgard.api.objects.game.GamePlayer; +import fun.asgard.api.objects.game.GameTeam; +import fun.asgard.api.objects.game.TeamGame; +import fun.asgard.api.objects.managers.PlayersManager; +import fun.asgard.internal.Utils; +import fun.asgard.internal.managers.playersmanager.EPlayersManager; +import org.bukkit.Bukkit; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + +import java.util.HashMap; +import java.util.HashSet; + +public abstract class ATeamGame implements TeamGame { + + private final PlayersManager playersManager; + private final World world; + private final String gameName; + private final TAGA taga; + private final Plugin client; + + private long started; + private long time; + private boolean leaveOnKick = false; + + /** + * @param client The one who uses the api + * @param world World of the game + * @param gameName Name of the game + * @param time Game time + */ + protected ATeamGame(TAGA taga, Plugin client, World world, String gameName, long time) { + this.taga = taga; + this.client = client; + this.gameName = gameName; + this.world = world; + this.time = time; + this.playersManager = new EPlayersManager(taga, client, this); + } + + @Override + public void start() { + if (this.world.getLoadedChunks().length <= 0 + || !this.client.getServer().getWorlds().contains(this.world)) { + this.client.getServer().getWorlds().add(this.world); + } + + this.started = System.currentTimeMillis(); + Bukkit.getPluginManager().callEvent(new GameStartEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()))); + } + + @Override + public void stop(boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray())); + this.shutdown(saveWorld); + } + + @Override + public void stop(GamePlayer winner, GamePlayer loser, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winner, loser)); + this.shutdown(saveWorld); + } + + @Override + public void stop(GamePlayer[] winners, GamePlayer[] losers, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, (GamePlayer[]) Utils.valueSet(this.getPlayersManager().getPlayers()).toArray(), winners, losers)); + this.shutdown(saveWorld); + } + + @Override + public void stop(HashSet winners, HashSet losers, boolean saveWorld) { + this.client.getServer().getPluginManager().callEvent(new GameStopEvent(this, Utils.valueSet(this.getPlayersManager().getPlayers()), winners, losers)); + this.shutdown(saveWorld); + } + + @Override + public void shutdown(boolean saveWorld) { + this.time = 0; + this.getPlayersManager().getPlayers().forEach((pl, gp) -> this.getPlayersManager().disconnectPlayer(gp)); + Bukkit.unloadWorld(this.world, saveWorld); + } + + @Override + public PlayersManager getPlayersManager() { + return this.playersManager; + } + + @Override + public long getWhenStarted() { + return this.started; + } + + @Override + public long getTime() { + return this.time; + } + + @Override + public String getGameName() { + return this.gameName; + } + + @Override + public World getWorld() { + return this.world; + } + + @Override + public void setTime(long time) { + this.time = time; + } + + @Override + public void setLeaveOnKick(boolean leaveOnKick) { + this.leaveOnKick = leaveOnKick; + } + + @Override + public boolean isLeaveOnKick() { + return this.leaveOnKick; + } + + @Override + public boolean isTeamGame() { + return true; + } + + @Override + public String toString() { + return "TeamGame { " + + "world = " + world.getName() + + ", gameName = '" + gameName + '\'' + + ", time = " + time + + '}'; + } + +} diff --git a/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java b/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java new file mode 100644 index 0000000..90c9ccb --- /dev/null +++ b/src/main/java/fun/asgard/internal/objects/teamgame/ETeamGame.java @@ -0,0 +1,20 @@ +package fun.asgard.internal.objects.teamgame; + + +import fun.asgard.TAGA; +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +public class ETeamGame extends ATeamGame { + + /** + * @param client The one who uses the api + * @param world World of the game + * @param gameName Name of the game + * @param time Game time + */ + public ETeamGame(TAGA taga, Plugin client, World world, String gameName, long time) { + super(taga, client, world, gameName, time); + } + +} diff --git a/src/test/java/SamplePlugin.java b/src/test/java/SamplePlugin.java new file mode 100644 index 0000000..affd8a6 --- /dev/null +++ b/src/test/java/SamplePlugin.java @@ -0,0 +1,56 @@ +import fun.asgard.TAGA; +import fun.asgard.api.events.gameevents.GameStartEvent; +import fun.asgard.api.events.gameevents.GameStopEvent; +import fun.asgard.api.objects.game.Game; +import org.bukkit.Bukkit; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.plugin.java.JavaPlugin; + +public class SamplePlugin extends JavaPlugin implements Listener { + + public static TAGA taga; + + @Override + public void onEnable() { + taga = new TAGA(this); + + Game game1 = taga.getGameManager().createGame(Bukkit.getWorld("world"), "SampleGame", 5 * 1000); + Game game2 = taga.getGameManager().createGame(Bukkit.getWorld("world"), "SampleGame2", 5 * 1000); + game2.setLeaveOnKick(true); + } + + @Override + public void onDisable() { + taga.getGameManager().getGames().forEach((name, game) -> game.shutdown(false)); + } + + @EventHandler + public void onPlayerJoined(PlayerJoinEvent event) { + Game game = taga.getGameManager().getGames().get("SampleGame2"); + game.getPlayersManager().connectPlayer(event.getPlayer()); + if (game.getPlayersManager().getPlayers().size() >= 1) { + game.start(); + } + } + + @EventHandler + public void onGameStart(GameStartEvent event) { + event.getPlayers().forEach(player -> { + player.getPlayer().sendMessage("Game is started!"); + }); + taga.getTaskManager().createTask(task -> + event.getPlayers().forEach(player -> + player.getPlayer().sendMessage("5 minutes of the game has passed!")), + event.getGame().getGameName(), 5 * 60 * 1000, 5 * 60 * 1000); + } + + @EventHandler + public void onGameStop(GameStopEvent event) { + event.getPlayers().forEach(player -> { + player.getPlayer().sendMessage("The game is stopped"); + }); + } + +} diff --git a/src/test/resources/plugin.yml b/src/test/resources/plugin.yml new file mode 100644 index 0000000..2713f17 --- /dev/null +++ b/src/test/resources/plugin.yml @@ -0,0 +1,5 @@ +name: SamplePlugin +version: ${project.version} +main: SamplePlugin +api-version: 1.16 +authors: [ Volan4ik ] From 4db61b1bd6f935488cdd1fb53e6db1a938d3c7a4 Mon Sep 17 00:00:00 2001 From: Andrew <65760867+VolanDeMor1@users.noreply.github.com> Date: Sat, 19 Jun 2021 13:26:08 +0300 Subject: [PATCH 7/7] Update README.md --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 91e032f..856df95 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ Made by [The Asgard](https://asgrad.fun/) with love 💙 [discord]: https://img.shields.io/badge/Our-discord-blue?style=for-the-badge&logo=discord -[version]: https://img.shields.io/badge/Version-v1.2.0-success?style=for-the-badge&logo=wiki +[version]: https://img.shields.io/badge/Version-UNSTABLE-success?style=for-the-badge&logo=wiki [download]: #how-to-use [wiki]: https://img.shields.io/badge/-Our%20wiki-yellow?style=for-the-badge&logo=wiki @@ -18,7 +18,7 @@ Made by [The Asgard](https://asgrad.fun/) with love 💙 [docs]: https://img.shields.io/badge/Our%20documentation-v1.2.0-important?style=for-the-badge&logo=wiki [docs-url]: https://github.com/TheAsgard/TAGA/wiki/Documentation -[minecraft]: https://img.shields.io/badge/Minecraft-1.16.5-red?style=for-the-badge&logo=mojang-studios +[minecraft]: https://img.shields.io/badge/Minecraft-1.16.5+-red?style=for-the-badge&logo=mojang-studios [minecraft-url]: https://www.minecraft.net/ [![version][]][download] @@ -43,7 +43,7 @@ Works with [PaperMC][papermc-url], [SpigotMC][spigotmc-url], [MohistMC][mohist-u fun.asgard TAGA - v1.2.0 + UNSTABLE ``` @@ -58,7 +58,7 @@ repositories { ``` ```gradle dependencies { - implementation 'fun.asgard:TAGA:v1.2.0' + implementation 'fun.asgard:TAGA:UNSTABLE' } ```