GH-1192 Extend /back functionality to per-death and per-teleport

eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migration_0030_Move_back_to_dedicated_section.java

@@ -0,0 +1,17 @@
+package com.eternalcode.core.configuration.migrations;
+
+import static eu.okaeri.configs.migrate.ConfigMigrationDsl.move;
+
+import eu.okaeri.configs.migrate.builtin.NamedMigration;
+
+public class Migration_0030_Move_back_to_dedicated_section extends NamedMigration {
+    Migration_0030_Move_back_to_dedicated_section() {
+        super(
+            "Improve homes config",
+            move("teleport.teleportedToLastLocation", "back.teleportedToLastTeleportLocation"),
+            move("teleport.teleportedSpecifiedPlayerLastLocation", "back.teleportedTargetPlayerToLastTeleportLocation"),
+            move("teleport.lastLocationNoExist", "back.lastLocationNotFound")
+        );
+    }
+}
+

eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migrations.java

@@ -18,6 +18,7 @@ public class Migrations {
         new Migration_0013_Move_enchant_messages_to_dedicated_section(),
         new Migration_0014_Move_butcher_messages_to_dedicated_section(),
         new Migration_0015_Move_ignore_messages_to_dedicated_section(),
+        new Migration_0030_Move_back_to_dedicated_section(),
         new Migration_0031_Move_death_messages_to_dedicated_section(),
         new Migration_0032_Move_join_quit_messages_to_dedicated_section(),
         };

eternalcore-core/src/main/java/com/eternalcode/core/feature/back/BackCommand.java

@@ -0,0 +1,108 @@
+package com.eternalcode.core.feature.back;
+
+import com.eternalcode.annotations.scan.command.DescriptionDocs;
+import com.eternalcode.commons.bukkit.position.Position;
+import com.eternalcode.commons.bukkit.position.PositionAdapter;
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.notice.NoticeService;
+import com.eternalcode.core.viewer.Viewer;
+import dev.rollczi.litecommands.annotations.argument.Arg;
+import dev.rollczi.litecommands.annotations.command.Command;
+import dev.rollczi.litecommands.annotations.context.Sender;
+import dev.rollczi.litecommands.annotations.execute.Execute;
+import dev.rollczi.litecommands.annotations.execute.ExecuteDefault;
+import dev.rollczi.litecommands.annotations.permission.Permission;
+import java.util.Optional;
+import org.bukkit.entity.Player;
+
+@Command(name = "back")
+public class BackCommand {
+
+    private final BackService backService;
+    private final NoticeService noticeService;
+
+    @Inject
+    public BackCommand(BackService backService, NoticeService noticeService) {
+        this.backService = backService;
+        this.noticeService = noticeService;
+    }
+
+    @ExecuteDefault
+    @Execute(name = "teleport")
+    @Permission("eternalcore.back.teleport")
+    @DescriptionDocs(description = "Teleport to your last teleport location")
+    public void executeBackTeleport(@Sender Player player) {
+        if (this.teleportBack(player)) {
+            this.noticeService.player(player.getUniqueId(), translation -> translation.back().teleportedToLastTeleportLocation());
+            return;
+        }
+        this.noticeService.player(player.getUniqueId(), translation -> translation.back().lastLocationNotFound());
+    }
+
+    @Execute(name = "death")
+    @Permission("eternalcore.back.death")
+    @DescriptionDocs(description = "Teleport to your last death location")
+    public void executeBackDeath(@Sender Player player) {
+        if (this.teleportBackDeath(player)) {
+            this.noticeService.player(player.getUniqueId(), translation -> translation.back().teleportedToLastDeathLocation());
+            return;
+        }
+        this.noticeService.player(player.getUniqueId(), translation -> translation.back().lastLocationNotFound());
+    }
+
+    @Execute(name = "teleport")
+    @Permission("eternalcore.back.teleport.other")
+    @DescriptionDocs(description = "Teleport specified player to their last teleport location", arguments = "<player>")
+    public void executeBackTeleportOther(@Sender Viewer viewer, @Arg Player target) {
+        if (this.teleportBack(target)) {
+            this.noticeService.player(target.getUniqueId(), translation -> translation.back().teleportedToLastTeleportLocationByAdmin());
+
+            this.noticeService.create()
+                .viewer(viewer)
+                .notice(translation -> translation.back().teleportedTargetPlayerToLastTeleportLocation())
+                .placeholder("{PLAYER}", target.getName())
+                .send();
+            return;
+        }
+        this.noticeService.player(viewer.getUniqueId(), translation -> translation.back().lastLocationNotFound());
+    }
+
+    @Execute(name = "death")
+    @Permission("eternalcore.back.death.other")
+    @DescriptionDocs(description = "Teleport specified player to their last death location", arguments = "<player>")
+    public void executeBackDeathOther(@Sender Viewer viewer, @Arg Player target) {
+        if (this.teleportBackDeath(target)) {
+            this.noticeService.player(target.getUniqueId(), translation -> translation.back().teleportedToLastDeathLocationByAdmin());
+
+            this.noticeService.create()
+                .viewer(viewer)
+                .notice(translation -> translation.back().teleportedTargetPlayerToLastDeathLocation())
+                .placeholder("{PLAYER}", target.getName())
+                .send();
+            return;
+        }
+        this.noticeService.player(viewer.getUniqueId(), translation -> translation.back().lastLocationNotFound());
+    }
+
+    private boolean teleportBack(Player target) {
+        Optional<Position> teleportLocation = this.backService.getTeleportLocation(target.getUniqueId());
+
+        if (teleportLocation.isPresent()) {
+            this.backService.teleportBack(target, PositionAdapter.convert(teleportLocation.get()));
+
+            return true;
+        }
+        return false;
+    }
+
+    private boolean teleportBackDeath(Player target) {
+        Optional<Position> deathLocation = this.backService.getDeathLocation(target.getUniqueId());
+
+        if (deathLocation.isPresent()) {
+            this.backService.teleportBack(target, PositionAdapter.convert(deathLocation.get()));
+
+            return true;
+        }
+        return false;
+    }
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/back/BackController.java

@@ -0,0 +1,36 @@
+package com.eternalcode.core.feature.back;
+
+import com.eternalcode.commons.bukkit.position.PositionAdapter;
+import com.eternalcode.core.injector.annotations.Inject;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+
+public class BackController implements Listener {
+
+    private final BackService backService;
+
+    @Inject
+    public BackController(BackService backService) {
+        this.backService = backService;
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onPlayerDeath(PlayerDeathEvent event) {
+        Player entity = event.getEntity();
+
+        this.backService.markDeathLocation(entity.getUniqueId(), PositionAdapter.convert(entity.getLocation()));
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onPlayerTeleport(PlayerTeleportEvent event) {
+        if (event.getCause() == PlayerTeleportEvent.TeleportCause.PLUGIN) {
+            return;
+        }
+
+        this.backService.markTeleportLocation(event.getPlayer().getUniqueId(), PositionAdapter.convert(event.getFrom()));
+    }
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/back/BackService.java

@@ -0,0 +1,76 @@
+package com.eternalcode.core.feature.back;
+
+import com.eternalcode.commons.bukkit.position.Position;
+import com.eternalcode.commons.bukkit.position.PositionAdapter;
+import com.eternalcode.core.feature.teleport.TeleportService;
+import com.eternalcode.core.feature.teleport.TeleportTaskService;
+import com.eternalcode.core.feature.teleportrequest.TeleportRequestSettings;
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.injector.annotations.component.Service;
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+@Service
+public class BackService {
+
+    private static final String BYPASS_PERMISSION = "eternalcore.teleport.bypass";
+
+    private final TeleportService teleportService;
+    private final TeleportTaskService teleportTaskService;
+    private final TeleportRequestSettings settings;
+
+    private final Cache<UUID, Position> deathLocations;
+    private final Cache<UUID, Position> teleportLocations;
+
+    @Inject
+    public BackService(
+        TeleportService teleportService,
+        TeleportTaskService teleportTaskService,
+        TeleportRequestSettings settings
+    ) {
+        this.teleportService = teleportService;
+        this.teleportTaskService = teleportTaskService;
+        this.settings = settings;
+
+        this.deathLocations = Caffeine.newBuilder()
+            .expireAfterWrite(2, TimeUnit.HOURS)
+            .build();
+        this.teleportLocations = Caffeine.newBuilder()
+            .expireAfterWrite(2, TimeUnit.HOURS)
+            .build();
+    }
+
+    public Optional<Position> getDeathLocation(UUID playerId) {
+        return Optional.ofNullable(deathLocations.getIfPresent(playerId));
+    }
+
+    public Optional<Position> getTeleportLocation(UUID playerId) {
+        return Optional.ofNullable(teleportLocations.getIfPresent(playerId));
+    }
+
+    public void markDeathLocation(UUID player, Position position) {
+        this.deathLocations.put(player, position);
+    }
+
+    public void markTeleportLocation(UUID player, Position position) {
+        this.teleportLocations.put(player, position);
+    }
+
+    public void teleportBack(Player player, Location location) {
+        if (player.hasPermission(BYPASS_PERMISSION)) {
+            teleportService.teleport(player, location);
+            return;
+        }
+        teleportTaskService.createTeleport(
+            player.getUniqueId(),
+            PositionAdapter.convert(player.getLocation()),
+            PositionAdapter.convert(location),
+            settings.tpaTimer()
+        );
+    }
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/back/messages/BackMessages.java

@@ -0,0 +1,19 @@
+package com.eternalcode.core.feature.back.messages;
+
+import com.eternalcode.multification.notice.Notice;
+
+public interface BackMessages {
+
+    Notice lastLocationNotFound();
+
+    // Teleport do ostatniej lokalizacji teleportacji
+    Notice teleportedToLastTeleportLocation();
+    Notice teleportedTargetPlayerToLastTeleportLocation();
+    Notice teleportedToLastTeleportLocationByAdmin();
+
+    // Teleport do ostatniej lokalizacji śmierci
+    Notice teleportedToLastDeathLocation();
+    Notice teleportedTargetPlayerToLastDeathLocation();
+    Notice teleportedToLastDeathLocationByAdmin();
+
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/back/messages/ENBackMessages.java

@@ -0,0 +1,28 @@
+package com.eternalcode.core.feature.back.messages;
+
+import com.eternalcode.multification.notice.Notice;
+import eu.okaeri.configs.OkaeriConfig;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+
+@Getter
+@Accessors(fluent = true)
+public class ENBackMessages extends OkaeriConfig implements BackMessages {
+
+    public Notice lastLocationNotFound = Notice.chat(
+        "<red>► <white>You don't have any last location to teleport to!");
+
+    public Notice teleportedToLastTeleportLocation = Notice.chat(
+        "<green>► <white>You have been teleported to your last location!");
+    public Notice teleportedTargetPlayerToLastTeleportLocation = Notice.chat(
+        "<green>► <white>Player <green>{PLAYER} <white>has been teleported to their last location!");
+    public Notice teleportedToLastTeleportLocationByAdmin = Notice.chat(
+        "<green>► <white>You have been teleported to your last location by an administrator!");
+
+    public Notice teleportedToLastDeathLocation = Notice.chat(
+        "<green>► <white>You have been teleported to your last death location!");
+    public Notice teleportedTargetPlayerToLastDeathLocation = Notice.chat(
+        "<green>► <white>Player <green>{PLAYER} <white>has been teleported to their last death location!");
+    public Notice teleportedToLastDeathLocationByAdmin = Notice.chat(
+        "<green>► <white>You have been teleported to your last death location by an administrator!");
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/back/messages/PLBackMessages.java

@@ -0,0 +1,29 @@
+package com.eternalcode.core.feature.back.messages;
+
+import com.eternalcode.multification.notice.Notice;
+import eu.okaeri.configs.OkaeriConfig;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+
+@Getter
+@Accessors(fluent = true)
+public class PLBackMessages extends OkaeriConfig implements BackMessages {
+
+    public Notice lastLocationNotFound = Notice.chat(
+        "<red>► <white>Nie masz żadnej ostatniej lokalizacji, do której można się teleportować!");
+
+    public Notice teleportedToLastTeleportLocation = Notice.chat(
+        "<green>► <white>Zostałeś przeteleportowany do ostatniej lokalizacji!");
+    public Notice teleportedTargetPlayerToLastTeleportLocation = Notice.chat(
+        "<green>► <white>Gracz <green>{PLAYER} <white>został przeteleportowany do swojej ostatniej lokalizacji!");
+    public Notice teleportedToLastTeleportLocationByAdmin = Notice.chat(
+        "<green>► <white>Zostałeś przeteleportowany do ostatniej lokalizacji przez administratora!");
+
+    public Notice teleportedToLastDeathLocation = Notice.chat(
+        "<green>► <white>Zostałeś przeteleportowany do ostatniej lokalizacji śmierci!");
+    public Notice teleportedTargetPlayerToLastDeathLocation = Notice.chat(
+        "<green>► <white>Gracz <green>{PLAYER} <white>został przeteleportowany do swojej ostatniej lokalizacji śmierci!");
+    public Notice teleportedToLastDeathLocationByAdmin = Notice.chat(
+        "<green>► <white>Zostałeś przeteleportowany do ostatniej lokalizacji śmierci przez administratora!");
+
+}