From a45849799dcbbf92426f0bf6387e3158d0d99e3f Mon Sep 17 00:00:00 2001 From: Ben Woo <30431861+benwoo1110@users.noreply.github.com> Date: Tue, 12 Sep 2023 12:45:09 +0800 Subject: [PATCH 1/2] Implement player world actions and some refactor --- .../core/listeners/MVPlayerListener.java | 64 ++----- .../core/worldnew/WorldManager.java | 27 +-- .../core/worldnew/config/WorldConfig.java | 17 +- .../worldnew/config/WorldConfigNodes.java | 44 ++++- .../worldnew/config/WorldsConfigManager.java | 17 +- .../worldnew/helpers/PlayerWorldActions.java | 162 ++++++++++++++++++ 6 files changed, 245 insertions(+), 86 deletions(-) create mode 100644 src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldActions.java diff --git a/src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java b/src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java index 88e1074d..1aecfe93 100644 --- a/src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java +++ b/src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java @@ -15,7 +15,6 @@ import com.dumptruckman.minecraft.util.Logging; import io.vavr.control.Option; import jakarta.inject.Inject; import jakarta.inject.Provider; -import org.bukkit.GameMode; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.Server; @@ -32,7 +31,6 @@ import org.bukkit.event.player.PlayerTeleportEvent; import org.bukkit.plugin.Plugin; import org.jetbrains.annotations.NotNull; import org.jvnet.hk2.annotations.Service; - import org.mvplugins.multiverse.core.MultiverseCore; import org.mvplugins.multiverse.core.api.SafeTTeleporter; import org.mvplugins.multiverse.core.commandtools.MVCommandManager; @@ -49,6 +47,7 @@ import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; import org.mvplugins.multiverse.core.worldnew.WorldManager; import org.mvplugins.multiverse.core.worldnew.entrycheck.EntryFeeResult; import org.mvplugins.multiverse.core.worldnew.entrycheck.WorldEntryCheckerProvider; +import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; /** * Multiverse's Listener for players. @@ -66,6 +65,7 @@ public class MVPlayerListener implements InjectableListener { private final Provider commandManagerProvider; private final CorePermissionsChecker permissionsChecker; private final DestinationsProvider destinationsProvider; + private final PlayerWorldActions playerWorldActions; private final Map playerWorld = new ConcurrentHashMap(); @@ -81,7 +81,8 @@ public class MVPlayerListener implements InjectableListener { WorldEntryCheckerProvider worldEntryCheckerProvider, Provider commandManagerProvider, CorePermissionsChecker permissionsChecker, - DestinationsProvider destinationsProvider) { + DestinationsProvider destinationsProvider, + PlayerWorldActions playerWorldActions) { this.plugin = plugin; this.config = config; this.worldManagerProvider = worldManagerProvider; @@ -93,6 +94,7 @@ public class MVPlayerListener implements InjectableListener { this.commandManagerProvider = commandManagerProvider; this.permissionsChecker = permissionsChecker; this.destinationsProvider = destinationsProvider; + this.playerWorldActions = playerWorldActions; } private WorldManager getWorldManager() { @@ -359,57 +361,21 @@ public class MVPlayerListener implements InjectableListener { }, 1L); } - // FOLLOWING 2 Methods and Private class handle Per Player GameModes. - private void handleGameModeAndFlight(Player player, World world) { - - LoadedMultiverseWorld mvWorld = getWorldManager().getLoadedWorld(world.getName()).getOrNull(); - if (mvWorld != null) { - this.handleGameModeAndFlight(player, mvWorld); - } else { - Logging.finer("Not handling gamemode and flight for world '" + world.getName() - + "' not managed by Multiverse."); - } - } - /** * Handles the gamemode for the specified {@link Player}. + * * @param player The {@link Player}. - * @param world The world the player is in. + * @param world The {@link World} the player is supposed to be in. */ - public void handleGameModeAndFlight(final Player player, final LoadedMultiverseWorld world) { + private void handleGameModeAndFlight(final Player player, World world) { // We perform this task one tick later to MAKE SURE that the player actually reaches the // destination world, otherwise we'd be changing the player mode if they havent moved anywhere. - this.server.getScheduler().scheduleSyncDelayedTask(this.plugin, - new Runnable() { - @Override - public void run() { - if (!permissionsChecker.hasGameModeBypassPermission(player, world)) { - // Check that the player is in the new world and they haven't been teleported elsewhere or the event cancelled. - if (player.getWorld() == world.getBukkitWorld().getOrNull()) { - Logging.fine("Handling gamemode for player: %s, Changing to %s", player.getName(), world.getGameMode().toString()); - Logging.finest("From World: %s", player.getWorld()); - Logging.finest("To World: %s", world); - player.setGameMode(world.getGameMode()); - // Check if their flight mode should change - // TODO: need a override permission for this - if (player.getAllowFlight() && !world.getAllowFlight() && player.getGameMode() != GameMode.CREATIVE) { - player.setAllowFlight(false); - if (player.isFlying()) { - player.setFlying(false); - } - } else if (world.getAllowFlight()) { - if (player.getGameMode() == GameMode.CREATIVE) { - player.setAllowFlight(true); - } - } - } else { - Logging.fine("The gamemode/allowfly was NOT changed for player '%s' because he is now in world '%s' instead of world '%s'", - player.getName(), player.getWorld().getName(), world.getName()); - } - } else { - Logging.fine("Player: " + player.getName() + " is IMMUNE to gamemode changes!"); - } - } - }, 1L); + this.server.getScheduler().scheduleSyncDelayedTask(this.plugin, () -> { + if (!player.isOnline() || !player.getWorld().equals(world)) { + return; + } + playerWorldActions.handleFlightEnforcement(player); + playerWorldActions.handleGameModeEnforcement(player); + }, 1L); } } diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/WorldManager.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/WorldManager.java index 2ec269c2..8766d4b5 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/WorldManager.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/WorldManager.java @@ -37,6 +37,7 @@ import org.mvplugins.multiverse.core.worldnew.generators.GeneratorProvider; import org.mvplugins.multiverse.core.worldnew.helpers.DataStore.GameRulesStore; import org.mvplugins.multiverse.core.worldnew.helpers.DataTransfer; import org.mvplugins.multiverse.core.worldnew.helpers.FilesManipulator; +import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; import org.mvplugins.multiverse.core.worldnew.options.CloneWorldOptions; import org.mvplugins.multiverse.core.worldnew.options.CreateWorldOptions; import org.mvplugins.multiverse.core.worldnew.options.ImportWorldOptions; @@ -71,6 +72,7 @@ public class WorldManager { private final WorldsConfigManager worldsConfigManager; private final WorldNameChecker worldNameChecker; private final GeneratorProvider generatorProvider; + private final PlayerWorldActions playerWorldActions; private final FilesManipulator filesManipulator; private final BlockSafety blockSafety; private final SafeTTeleporter safetyTeleporter; @@ -81,6 +83,7 @@ public class WorldManager { @NotNull WorldsConfigManager worldsConfigManager, @NotNull WorldNameChecker worldNameChecker, @NotNull GeneratorProvider generatorProvider, + @NotNull PlayerWorldActions playerWorldActions, @NotNull FilesManipulator filesManipulator, @NotNull BlockSafety blockSafety, @NotNull SafeTTeleporter safetyTeleporter, @@ -93,6 +96,7 @@ public class WorldManager { this.worldsConfigManager = worldsConfigManager; this.worldNameChecker = worldNameChecker; this.generatorProvider = generatorProvider; + this.playerWorldActions = playerWorldActions; this.filesManipulator = filesManipulator; this.blockSafety = blockSafety; this.safetyTeleporter = safetyTeleporter; @@ -374,7 +378,7 @@ public class WorldManager { } if (options.removePlayers()) { - removePlayersFromWorld(world); + playerWorldActions.removeFromWorld(world); } return unloadBukkitWorld(world.getBukkitWorld().getOrNull(), options.saveBukkitWorld()).fold( @@ -392,16 +396,6 @@ public class WorldManager { })); } - private void removePlayersFromWorld(@NotNull LoadedMultiverseWorld world) { - world.getPlayers().peek(players -> players.forEach(player -> { - Location spawnLocation = Bukkit.getWorlds().get(0).getSpawnLocation(); - if (player.isOnline()) { - Logging.fine("Teleporting player '%s' to world spawn: %s", player.getName(), spawnLocation); - safetyTeleporter.safelyTeleport(null, player, spawnLocation, true); - } - })); - } - /** * Removes an existing multiverse world. It will be deleted from the worlds config and will no longer be an * unloaded world. World files will not be deleted. @@ -623,20 +617,11 @@ public class WorldManager { // different seed. newWorld.setSpawnLocation(spawnLocation); } - teleportPlayersToWorld(playersInWorld, newWorld); + playerWorldActions.teleportPlayersToWorld(playersInWorld, newWorld); saveWorldsConfig(); }); } - private void teleportPlayersToWorld(@NotNull List players, @NotNull LoadedMultiverseWorld world) { - players.forEach(player -> { - Location spawnLocation = world.getSpawnLocation(); - if (player.isOnline()) { - safetyTeleporter.safelyTeleport(null, player, spawnLocation, true); - } - }); - } - private Attempt worldActionResult(@NotNull T value) { return Attempt.success(value); } diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfig.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfig.java index 332ffbe6..c51360f9 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfig.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfig.java @@ -24,19 +24,26 @@ import org.mvplugins.multiverse.core.configuration.migration.NullStringMigratorA import org.mvplugins.multiverse.core.configuration.migration.VersionMigrator; import org.mvplugins.multiverse.core.world.configuration.AllowedPortalType; import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; +import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; /** * Represents a world configuration. */ public final class WorldConfig { + private final PlayerWorldActions playerWorldActions; private final String worldName; private final WorldConfigNodes configNodes; private final ConfigurationSectionHandle configHandle; - WorldConfig(@NotNull String worldName, @NotNull final ConfigurationSection configSection) { + WorldConfig( + @NotNull PlayerWorldActions playerWorldActions, + @NotNull String worldName, + @NotNull ConfigurationSection configSection) { + this.playerWorldActions = playerWorldActions; + this.worldName = worldName; - this.configNodes = new WorldConfigNodes(); + this.configNodes = new WorldConfigNodes(playerWorldActions); this.configHandle = ConfigurationSectionHandle.builder(configSection) .logger(Logging.getLogger()) .nodes(configNodes.getNodes()) @@ -364,14 +371,14 @@ public final class WorldConfig { } public void setMVWorld(@NotNull LoadedMultiverseWorld world) { - configNodes.world = world; + configNodes.setWorld(world); } public boolean hasMVWorld() { - return configNodes.world != null; + return configNodes.getWorld() != null; } public void deferenceMVWorld() { - configNodes.world = null; + configNodes.setWorld(null); } } diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfigNodes.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfigNodes.java index e4538fa2..72ee1853 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfigNodes.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfigNodes.java @@ -8,23 +8,35 @@ import org.bukkit.GameMode; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.World; +import org.jetbrains.annotations.NotNull; import org.mvplugins.multiverse.core.configuration.node.ConfigNode; import org.mvplugins.multiverse.core.configuration.node.Node; import org.mvplugins.multiverse.core.configuration.node.NodeGroup; import org.mvplugins.multiverse.core.world.configuration.AllowedPortalType; import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; +import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; /** * Represents nodes in a world configuration. */ public class WorldConfigNodes { - static final double CONFIG_VERSION = 1.0; + private static final double CONFIG_VERSION = 1.0; private final NodeGroup nodes = new NodeGroup(); - LoadedMultiverseWorld world = null; + private PlayerWorldActions playerWorldActions; + private LoadedMultiverseWorld world = null; - WorldConfigNodes() { + WorldConfigNodes(@NotNull PlayerWorldActions playerWorldActions) { + this.playerWorldActions = playerWorldActions; + } + + LoadedMultiverseWorld getWorld() { + return world; + } + + void setWorld(LoadedMultiverseWorld world) { + this.world = world; } public NodeGroup getNodes() { @@ -36,6 +48,11 @@ public class WorldConfigNodes { return node; } + // BEGIN CHECKSTYLE-SUPPRESSION: Javadoc + // BEGIN CHECKSTYLE-SUPPRESSION: MemberName + // BEGIN CHECKSTYLE-SUPPRESSION: Abbreviation + // BEGIN CHECKSTYLE-SUPPRESSION: VisibilityModifier + final ConfigNode ADJUST_SPAWN = node(ConfigNode.builder("adjust-spawn", Boolean.class) .defaultValue(false) .build()); @@ -46,6 +63,10 @@ public class WorldConfigNodes { final ConfigNode ALLOW_FLIGHT = node(ConfigNode.builder("allow-flight", Boolean.class) .defaultValue(false) + .onSetValue((oldValue, newValue) -> { + if (world == null) return; + playerWorldActions.handleAllFlightEnforcement(world); + }) .build()); final ConfigNode ALLOW_WEATHER = node(ConfigNode.builder("allow-weather", Boolean.class) @@ -87,7 +108,8 @@ public class WorldConfigNodes { .build()); final ConfigNode ENTRY_FEE_CURRENCY = node(ConfigNode.builder("entry-fee.currency", Material.class) - .defaultValue(Material.AIR) // TODO: Convert from material ID + // TODO: Convert from material ID + .defaultValue(Material.AIR) .name("entryfee-currency") .build()); @@ -99,11 +121,15 @@ public class WorldConfigNodes { final ConfigNode GAMEMODE = node(ConfigNode.builder("gamemode", GameMode.class) .defaultValue(GameMode.SURVIVAL) - // TODO: Set all gamemodes of players in world to this gamemode + .onSetValue((oldValue, newValue) -> { + if (world == null) return; + playerWorldActions.handleAllGameModeEnforcement(world); + }) .build()); final ConfigNode GENERATOR = node(ConfigNode.builder("generator", String.class) - .defaultValue("@error") // this should be set on world creation + // this should be set on world creation, if @error is shown in config, something went wrong + .defaultValue("@error") .name(null) .build()); @@ -126,7 +152,6 @@ public class WorldConfigNodes { final ConfigNode PLAYER_LIMIT = node(ConfigNode.builder("player-limit", Integer.class) .defaultValue(-1) - .name("player-limit") .build()); final ConfigNode PORTAL_FORM = node(ConfigNode @@ -227,4 +252,9 @@ public class WorldConfigNodes { .defaultValue(CONFIG_VERSION) .name(null) .build()); + + // END CHECKSTYLE-SUPPRESSION: Javadoc + // END CHECKSTYLE-SUPPRESSION: MemberName + // END CHECKSTYLE-SUPPRESSION: Abbreviation + // END CHECKSTYLE-SUPPRESSION: VisibilityModifier } diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldsConfigManager.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldsConfigManager.java index 22fdb299..dabcda90 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldsConfigManager.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldsConfigManager.java @@ -21,22 +21,28 @@ import org.jetbrains.annotations.NotNull; import org.jvnet.hk2.annotations.Service; import org.mvplugins.multiverse.core.MultiverseCore; +import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; /** * Manages the worlds.yml file. */ @Service public final class WorldsConfigManager { - private static final String CONFIG_FILENAME = "worlds2.yml"; // TODO: Rename to worlds.yml + // TODO: Rename to worlds.yml + private static final String CONFIG_FILENAME = "worlds2.yml"; private final Map worldConfigMap; private final File worldConfigFile; private YamlConfiguration worldsConfig; + private final PlayerWorldActions playerWorldActions; + @Inject - WorldsConfigManager(@NotNull MultiverseCore core) { + WorldsConfigManager(@NotNull MultiverseCore core, @NotNull PlayerWorldActions playerWorldActions) { worldConfigMap = new HashMap<>(); worldConfigFile = core.getDataFolder().toPath().resolve(CONFIG_FILENAME).toFile(); + + this.playerWorldActions = playerWorldActions; } /** @@ -119,7 +125,10 @@ public final class WorldsConfigManager { getWorldConfig(worldName) .peek(config -> config.load(getWorldConfigSection(worldName))) .onEmpty(() -> { - WorldConfig newWorldConfig = new WorldConfig(worldName, getWorldConfigSection(worldName)); + WorldConfig newWorldConfig = new WorldConfig( + playerWorldActions, + worldName, + getWorldConfigSection(worldName)); worldConfigMap.put(worldName, newWorldConfig); newWorldsAdded.add(newWorldConfig); }); @@ -174,7 +183,7 @@ public final class WorldsConfigManager { if (worldConfigMap.containsKey(worldName)) { throw new IllegalArgumentException("WorldConfig for world " + worldName + " already exists."); } - WorldConfig worldConfig = new WorldConfig(worldName, getWorldConfigSection(worldName)); + WorldConfig worldConfig = new WorldConfig(playerWorldActions, worldName, getWorldConfigSection(worldName)); worldConfigMap.put(worldName, worldConfig); return worldConfig; } diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldActions.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldActions.java new file mode 100644 index 00000000..920394ad --- /dev/null +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldActions.java @@ -0,0 +1,162 @@ +package org.mvplugins.multiverse.core.worldnew.helpers; + +import java.util.List; + +import com.dumptruckman.minecraft.util.Logging; +import jakarta.inject.Inject; +import jakarta.inject.Provider; +import org.bukkit.Bukkit; +import org.bukkit.GameMode; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; +import org.jvnet.hk2.annotations.Service; + +import org.mvplugins.multiverse.core.api.SafeTTeleporter; +import org.mvplugins.multiverse.core.permissions.CorePermissionsChecker; +import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; +import org.mvplugins.multiverse.core.worldnew.WorldManager; + +/** + * Handles all player actions that need to be done when a change in world related activity occurs. + */ +@Service +public class PlayerWorldActions { + + private final CorePermissionsChecker permissionsChecker; + private final SafeTTeleporter safetyTeleporter; + private final Provider worldManagerProvider; + + @Inject + PlayerWorldActions( + @NotNull CorePermissionsChecker permissionsChecker, + @NotNull SafeTTeleporter safetyTeleporter, + @NotNull Provider worldManagerProvider) { + this.permissionsChecker = permissionsChecker; + this.safetyTeleporter = safetyTeleporter; + this.worldManagerProvider = worldManagerProvider; + } + + /** + * Removes all players from the given world. + * + * @param world The world to remove all players from. + */ + public void removeFromWorld(@NotNull LoadedMultiverseWorld world) { + // TODO: Better handling of fallback world + World toWorld = Bukkit.getWorlds().get(0); + transferFromWorldTo(world, toWorld); + } + + /** + * Transfers all players from the given world to another world's spawn location. + * + * @param from The world to transfer players from. + * @param to The location to transfer players to. + */ + public void transferFromWorldTo(@NotNull LoadedMultiverseWorld from, @NotNull LoadedMultiverseWorld to) { + transferAllFromWorldToLocation(from, to.getSpawnLocation()); + } + + /** + * Transfers all players from the given world to another world's spawn location. + * + * @param from The world to transfer players from. + * @param to The world to transfer players to. + */ + public void transferFromWorldTo(@NotNull LoadedMultiverseWorld from, @NotNull World to) { + transferAllFromWorldToLocation(from, to.getSpawnLocation()); + } + + /** + * Transfers all players from the given world to the given location. + * + * @param world The world to transfer players from. + * @param location The location to transfer players to. + */ + public void transferAllFromWorldToLocation(@NotNull LoadedMultiverseWorld world, @NotNull Location location) { + world.getPlayers().peek(players -> players.forEach(player -> { + if (player.isOnline()) { + Logging.fine("Teleporting player '%s' to world spawn: %s", player.getName(), location); + safetyTeleporter.safelyTeleport(null, player, location, true); + } + })); + } + + /** + * Teleports all players to the given world's spawn location. + * + * @param players The players to teleport. + * @param world The world to teleport players to. + */ + public void teleportPlayersToWorld(@NotNull List players, @NotNull LoadedMultiverseWorld world) { + players.forEach(player -> { + Location spawnLocation = world.getSpawnLocation(); + if (player.isOnline()) { + safetyTeleporter.safelyTeleport(null, player, spawnLocation, true); + } + }); + } + + /** + * Teleports all players to the given location. + * + * @param world The world to teleport players to. + */ + public void handleAllGameModeEnforcement(@NotNull LoadedMultiverseWorld world) { + world.getPlayers().peek(players -> players.forEach(this::handleGameModeEnforcement)); + } + + /** + * Handles game mode enforcement for the given player in the world they are currently in. + * + * @param player The player to enforce game mode for. + */ + public void handleGameModeEnforcement(@NotNull Player player) { + worldManagerProvider.get().getLoadedWorld(player.getWorld()).peek(world -> { + if (permissionsChecker.hasGameModeBypassPermission(player, world)) { + Logging.finer("Player is immune to gamemode enforcement: %s", player.getName()); + return; + } + Logging.finer("Handling gamemode for player in world '%s': %s, Changing to %s", + world.getName(), player.getName(), world.getGameMode()); + player.setGameMode(world.getGameMode()); + }).onEmpty(() -> { + Logging.fine("Player %s is not in a Multiverse world, gamemode enforcement will not apply", + player.getName()); + }); + } + + /** + * Handles flight enforcement for all players in the given world. + * + * @param world The world to enforce flight in. + */ + public void handleAllFlightEnforcement(@NotNull LoadedMultiverseWorld world) { + world.getPlayers().peek(players -> players.forEach(this::handleFlightEnforcement)); + } + + /** + * Handles flight enforcement for the given player in the world they are currently in. + * + * @param player The player to enforce flight for. + */ + public void handleFlightEnforcement(@NotNull Player player) { + worldManagerProvider.get().getLoadedWorld(player.getWorld()).peek(world -> { + if (player.getAllowFlight() && !world.getAllowFlight() && player.getGameMode() != GameMode.CREATIVE) { + player.setAllowFlight(false); + if (player.isFlying()) { + player.setFlying(false); + } + } else if (world.getAllowFlight()) { + if (player.getGameMode() == GameMode.CREATIVE) { + player.setAllowFlight(true); + } + } + }).onEmpty(() -> { + Logging.fine("Player %s is not in a Multiverse world, flight enforcement will not apply", + player.getName()); + }); + } +} From f9bd7f136dea52540b2d5184d1750667ed03e5ab Mon Sep 17 00:00:00 2001 From: Ben Woo <30431861+benwoo1110@users.noreply.github.com> Date: Tue, 12 Sep 2023 13:13:54 +0800 Subject: [PATCH 2/2] Split PlayerWorldAction to PlayerWorldTeleporter and EnforcementHandler --- .../core/listeners/MVPlayerListener.java | 16 ++-- .../core/worldnew/WorldManager.java | 6 +- .../core/worldnew/config/WorldConfig.java | 11 +-- .../worldnew/config/WorldConfigNodes.java | 12 +-- .../worldnew/config/WorldsConfigManager.java | 14 +-- ...ldActions.java => EnforcementHandler.java} | 79 +--------------- .../helpers/PlayerWorldTeleporter.java | 89 +++++++++++++++++++ 7 files changed, 118 insertions(+), 109 deletions(-) rename src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/{PlayerWorldActions.java => EnforcementHandler.java} (52%) create mode 100644 src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldTeleporter.java diff --git a/src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java b/src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java index 1aecfe93..6d0ac3e1 100644 --- a/src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java +++ b/src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java @@ -47,7 +47,8 @@ import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; import org.mvplugins.multiverse.core.worldnew.WorldManager; import org.mvplugins.multiverse.core.worldnew.entrycheck.EntryFeeResult; import org.mvplugins.multiverse.core.worldnew.entrycheck.WorldEntryCheckerProvider; -import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; +import org.mvplugins.multiverse.core.worldnew.helpers.EnforcementHandler; +import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldTeleporter; /** * Multiverse's Listener for players. @@ -63,9 +64,8 @@ public class MVPlayerListener implements InjectableListener { private final MVEconomist economist; private final WorldEntryCheckerProvider worldEntryCheckerProvider; private final Provider commandManagerProvider; - private final CorePermissionsChecker permissionsChecker; private final DestinationsProvider destinationsProvider; - private final PlayerWorldActions playerWorldActions; + private final EnforcementHandler enforcementHandler; private final Map playerWorld = new ConcurrentHashMap(); @@ -80,9 +80,8 @@ public class MVPlayerListener implements InjectableListener { MVEconomist economist, WorldEntryCheckerProvider worldEntryCheckerProvider, Provider commandManagerProvider, - CorePermissionsChecker permissionsChecker, DestinationsProvider destinationsProvider, - PlayerWorldActions playerWorldActions) { + EnforcementHandler enforcementHandler) { this.plugin = plugin; this.config = config; this.worldManagerProvider = worldManagerProvider; @@ -92,9 +91,8 @@ public class MVPlayerListener implements InjectableListener { this.economist = economist; this.worldEntryCheckerProvider = worldEntryCheckerProvider; this.commandManagerProvider = commandManagerProvider; - this.permissionsChecker = permissionsChecker; this.destinationsProvider = destinationsProvider; - this.playerWorldActions = playerWorldActions; + this.enforcementHandler = enforcementHandler; } private WorldManager getWorldManager() { @@ -374,8 +372,8 @@ public class MVPlayerListener implements InjectableListener { if (!player.isOnline() || !player.getWorld().equals(world)) { return; } - playerWorldActions.handleFlightEnforcement(player); - playerWorldActions.handleGameModeEnforcement(player); + enforcementHandler.handleFlightEnforcement(player); + enforcementHandler.handleGameModeEnforcement(player); }, 1L); } } diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/WorldManager.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/WorldManager.java index 8766d4b5..3855f0b7 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/WorldManager.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/WorldManager.java @@ -37,7 +37,7 @@ import org.mvplugins.multiverse.core.worldnew.generators.GeneratorProvider; import org.mvplugins.multiverse.core.worldnew.helpers.DataStore.GameRulesStore; import org.mvplugins.multiverse.core.worldnew.helpers.DataTransfer; import org.mvplugins.multiverse.core.worldnew.helpers.FilesManipulator; -import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; +import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldTeleporter; import org.mvplugins.multiverse.core.worldnew.options.CloneWorldOptions; import org.mvplugins.multiverse.core.worldnew.options.CreateWorldOptions; import org.mvplugins.multiverse.core.worldnew.options.ImportWorldOptions; @@ -72,7 +72,7 @@ public class WorldManager { private final WorldsConfigManager worldsConfigManager; private final WorldNameChecker worldNameChecker; private final GeneratorProvider generatorProvider; - private final PlayerWorldActions playerWorldActions; + private final PlayerWorldTeleporter playerWorldActions; private final FilesManipulator filesManipulator; private final BlockSafety blockSafety; private final SafeTTeleporter safetyTeleporter; @@ -83,7 +83,7 @@ public class WorldManager { @NotNull WorldsConfigManager worldsConfigManager, @NotNull WorldNameChecker worldNameChecker, @NotNull GeneratorProvider generatorProvider, - @NotNull PlayerWorldActions playerWorldActions, + @NotNull PlayerWorldTeleporter playerWorldActions, @NotNull FilesManipulator filesManipulator, @NotNull BlockSafety blockSafety, @NotNull SafeTTeleporter safetyTeleporter, diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfig.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfig.java index c51360f9..f5a2f417 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfig.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfig.java @@ -24,26 +24,23 @@ import org.mvplugins.multiverse.core.configuration.migration.NullStringMigratorA import org.mvplugins.multiverse.core.configuration.migration.VersionMigrator; import org.mvplugins.multiverse.core.world.configuration.AllowedPortalType; import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; -import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; +import org.mvplugins.multiverse.core.worldnew.helpers.EnforcementHandler; /** * Represents a world configuration. */ public final class WorldConfig { - private final PlayerWorldActions playerWorldActions; private final String worldName; private final WorldConfigNodes configNodes; private final ConfigurationSectionHandle configHandle; WorldConfig( - @NotNull PlayerWorldActions playerWorldActions, @NotNull String worldName, - @NotNull ConfigurationSection configSection) { - this.playerWorldActions = playerWorldActions; - + @NotNull ConfigurationSection configSection, + @NotNull EnforcementHandler enforcementHandler) { this.worldName = worldName; - this.configNodes = new WorldConfigNodes(playerWorldActions); + this.configNodes = new WorldConfigNodes(enforcementHandler); this.configHandle = ConfigurationSectionHandle.builder(configSection) .logger(Logging.getLogger()) .nodes(configNodes.getNodes()) diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfigNodes.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfigNodes.java index 72ee1853..cdb0bd2f 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfigNodes.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldConfigNodes.java @@ -15,7 +15,7 @@ import org.mvplugins.multiverse.core.configuration.node.Node; import org.mvplugins.multiverse.core.configuration.node.NodeGroup; import org.mvplugins.multiverse.core.world.configuration.AllowedPortalType; import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; -import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; +import org.mvplugins.multiverse.core.worldnew.helpers.EnforcementHandler; /** * Represents nodes in a world configuration. @@ -24,11 +24,11 @@ public class WorldConfigNodes { private static final double CONFIG_VERSION = 1.0; private final NodeGroup nodes = new NodeGroup(); - private PlayerWorldActions playerWorldActions; + private EnforcementHandler enforcementHandler; private LoadedMultiverseWorld world = null; - WorldConfigNodes(@NotNull PlayerWorldActions playerWorldActions) { - this.playerWorldActions = playerWorldActions; + WorldConfigNodes(@NotNull EnforcementHandler enforcementHandler) { + this.enforcementHandler = enforcementHandler; } LoadedMultiverseWorld getWorld() { @@ -65,7 +65,7 @@ public class WorldConfigNodes { .defaultValue(false) .onSetValue((oldValue, newValue) -> { if (world == null) return; - playerWorldActions.handleAllFlightEnforcement(world); + enforcementHandler.handleAllFlightEnforcement(world); }) .build()); @@ -123,7 +123,7 @@ public class WorldConfigNodes { .defaultValue(GameMode.SURVIVAL) .onSetValue((oldValue, newValue) -> { if (world == null) return; - playerWorldActions.handleAllGameModeEnforcement(world); + enforcementHandler.handleAllGameModeEnforcement(world); }) .build()); diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldsConfigManager.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldsConfigManager.java index dabcda90..b51d38a2 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldsConfigManager.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/config/WorldsConfigManager.java @@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull; import org.jvnet.hk2.annotations.Service; import org.mvplugins.multiverse.core.MultiverseCore; -import org.mvplugins.multiverse.core.worldnew.helpers.PlayerWorldActions; +import org.mvplugins.multiverse.core.worldnew.helpers.EnforcementHandler; /** * Manages the worlds.yml file. @@ -35,14 +35,14 @@ public final class WorldsConfigManager { private final File worldConfigFile; private YamlConfiguration worldsConfig; - private final PlayerWorldActions playerWorldActions; + private final EnforcementHandler enforcementHandler; @Inject - WorldsConfigManager(@NotNull MultiverseCore core, @NotNull PlayerWorldActions playerWorldActions) { + WorldsConfigManager(@NotNull MultiverseCore core, @NotNull EnforcementHandler enforcementHandler) { worldConfigMap = new HashMap<>(); worldConfigFile = core.getDataFolder().toPath().resolve(CONFIG_FILENAME).toFile(); - this.playerWorldActions = playerWorldActions; + this.enforcementHandler = enforcementHandler; } /** @@ -126,9 +126,9 @@ public final class WorldsConfigManager { .peek(config -> config.load(getWorldConfigSection(worldName))) .onEmpty(() -> { WorldConfig newWorldConfig = new WorldConfig( - playerWorldActions, worldName, - getWorldConfigSection(worldName)); + getWorldConfigSection(worldName), + enforcementHandler); worldConfigMap.put(worldName, newWorldConfig); newWorldsAdded.add(newWorldConfig); }); @@ -183,7 +183,7 @@ public final class WorldsConfigManager { if (worldConfigMap.containsKey(worldName)) { throw new IllegalArgumentException("WorldConfig for world " + worldName + " already exists."); } - WorldConfig worldConfig = new WorldConfig(playerWorldActions, worldName, getWorldConfigSection(worldName)); + WorldConfig worldConfig = new WorldConfig(worldName, getWorldConfigSection(worldName), enforcementHandler); worldConfigMap.put(worldName, worldConfig); return worldConfig; } diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldActions.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/EnforcementHandler.java similarity index 52% rename from src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldActions.java rename to src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/EnforcementHandler.java index 920394ad..246b7a23 100644 --- a/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldActions.java +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/EnforcementHandler.java @@ -1,104 +1,29 @@ package org.mvplugins.multiverse.core.worldnew.helpers; -import java.util.List; - import com.dumptruckman.minecraft.util.Logging; import jakarta.inject.Inject; import jakarta.inject.Provider; -import org.bukkit.Bukkit; import org.bukkit.GameMode; -import org.bukkit.Location; -import org.bukkit.World; import org.bukkit.entity.Player; import org.jetbrains.annotations.NotNull; import org.jvnet.hk2.annotations.Service; -import org.mvplugins.multiverse.core.api.SafeTTeleporter; import org.mvplugins.multiverse.core.permissions.CorePermissionsChecker; import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; import org.mvplugins.multiverse.core.worldnew.WorldManager; -/** - * Handles all player actions that need to be done when a change in world related activity occurs. - */ @Service -public class PlayerWorldActions { +public class EnforcementHandler { private final CorePermissionsChecker permissionsChecker; - private final SafeTTeleporter safetyTeleporter; private final Provider worldManagerProvider; @Inject - PlayerWorldActions( - @NotNull CorePermissionsChecker permissionsChecker, - @NotNull SafeTTeleporter safetyTeleporter, - @NotNull Provider worldManagerProvider) { + EnforcementHandler(CorePermissionsChecker permissionsChecker, Provider worldManagerProvider) { this.permissionsChecker = permissionsChecker; - this.safetyTeleporter = safetyTeleporter; this.worldManagerProvider = worldManagerProvider; } - /** - * Removes all players from the given world. - * - * @param world The world to remove all players from. - */ - public void removeFromWorld(@NotNull LoadedMultiverseWorld world) { - // TODO: Better handling of fallback world - World toWorld = Bukkit.getWorlds().get(0); - transferFromWorldTo(world, toWorld); - } - - /** - * Transfers all players from the given world to another world's spawn location. - * - * @param from The world to transfer players from. - * @param to The location to transfer players to. - */ - public void transferFromWorldTo(@NotNull LoadedMultiverseWorld from, @NotNull LoadedMultiverseWorld to) { - transferAllFromWorldToLocation(from, to.getSpawnLocation()); - } - - /** - * Transfers all players from the given world to another world's spawn location. - * - * @param from The world to transfer players from. - * @param to The world to transfer players to. - */ - public void transferFromWorldTo(@NotNull LoadedMultiverseWorld from, @NotNull World to) { - transferAllFromWorldToLocation(from, to.getSpawnLocation()); - } - - /** - * Transfers all players from the given world to the given location. - * - * @param world The world to transfer players from. - * @param location The location to transfer players to. - */ - public void transferAllFromWorldToLocation(@NotNull LoadedMultiverseWorld world, @NotNull Location location) { - world.getPlayers().peek(players -> players.forEach(player -> { - if (player.isOnline()) { - Logging.fine("Teleporting player '%s' to world spawn: %s", player.getName(), location); - safetyTeleporter.safelyTeleport(null, player, location, true); - } - })); - } - - /** - * Teleports all players to the given world's spawn location. - * - * @param players The players to teleport. - * @param world The world to teleport players to. - */ - public void teleportPlayersToWorld(@NotNull List players, @NotNull LoadedMultiverseWorld world) { - players.forEach(player -> { - Location spawnLocation = world.getSpawnLocation(); - if (player.isOnline()) { - safetyTeleporter.safelyTeleport(null, player, spawnLocation, true); - } - }); - } - /** * Teleports all players to the given location. * diff --git a/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldTeleporter.java b/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldTeleporter.java new file mode 100644 index 00000000..facecadd --- /dev/null +++ b/src/main/java/org/mvplugins/multiverse/core/worldnew/helpers/PlayerWorldTeleporter.java @@ -0,0 +1,89 @@ +package org.mvplugins.multiverse.core.worldnew.helpers; + +import java.util.List; + +import com.dumptruckman.minecraft.util.Logging; +import jakarta.inject.Inject; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; +import org.jvnet.hk2.annotations.Service; + +import org.mvplugins.multiverse.core.api.SafeTTeleporter; +import org.mvplugins.multiverse.core.worldnew.LoadedMultiverseWorld; + +/** + * Handles all player actions that need to be done when a change in world related activity occurs. + */ +@Service +public class PlayerWorldTeleporter { + private final SafeTTeleporter safetyTeleporter; + + @Inject + PlayerWorldTeleporter(@NotNull SafeTTeleporter safetyTeleporter) { + this.safetyTeleporter = safetyTeleporter; + } + + /** + * Removes all players from the given world. + * + * @param world The world to remove all players from. + */ + public void removeFromWorld(@NotNull LoadedMultiverseWorld world) { + // TODO: Better handling of fallback world + World toWorld = Bukkit.getWorlds().get(0); + transferFromWorldTo(world, toWorld); + } + + /** + * Transfers all players from the given world to another world's spawn location. + * + * @param from The world to transfer players from. + * @param to The location to transfer players to. + */ + public void transferFromWorldTo(@NotNull LoadedMultiverseWorld from, @NotNull LoadedMultiverseWorld to) { + transferAllFromWorldToLocation(from, to.getSpawnLocation()); + } + + /** + * Transfers all players from the given world to another world's spawn location. + * + * @param from The world to transfer players from. + * @param to The world to transfer players to. + */ + public void transferFromWorldTo(@NotNull LoadedMultiverseWorld from, @NotNull World to) { + transferAllFromWorldToLocation(from, to.getSpawnLocation()); + } + + /** + * Transfers all players from the given world to the given location. + * + * @param world The world to transfer players from. + * @param location The location to transfer players to. + */ + public void transferAllFromWorldToLocation(@NotNull LoadedMultiverseWorld world, @NotNull Location location) { + world.getPlayers().peek(players -> players.forEach(player -> { + if (player.isOnline()) { + Logging.fine("Teleporting player '%s' to world spawn: %s", player.getName(), location); + safetyTeleporter.safelyTeleport(null, player, location, true); + } + })); + } + + /** + * Teleports all players to the given world's spawn location. + * + * @param players The players to teleport. + * @param world The world to teleport players to. + */ + public void teleportPlayersToWorld(@NotNull List players, @NotNull LoadedMultiverseWorld world) { + players.forEach(player -> { + Location spawnLocation = world.getSpawnLocation(); + if (player.isOnline()) { + safetyTeleporter.safelyTeleport(null, player, spawnLocation, true); + } + }); + } +}