Implementation Updates

Datura/src/main/java/me/totalfreedom/datura/punishment/Cager.java

@@ -0,0 +1,166 @@
+package me.totalfreedom.datura.punishment;
+
+import me.totalfreedom.base.CommonsBase;
+import me.totalfreedom.service.Service;
+import me.totalfreedom.utils.Shaper;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import java.util.*;
+import java.util.function.DoubleUnaryOperator;
+
+public class Cager extends Service
+{
+    private final Set<UUID> cagedPlayers;
+    private final Map<UUID, Location> cageLocations;
+
+    public Cager()
+    {
+        super("cage_service");
+        this.cagedPlayers = new HashSet<>();
+        this.cageLocations = new HashMap<>();
+        Bukkit.getPluginManager().registerEvents(new CageListener(), CommonsBase.getInstance());
+    }
+
+    /**
+     * This method will cage the player using {@link #createCage(Location, Material)}.
+     * <p>This will also add the returned location to the {@link #cageLocations} map.
+     *
+     * @param uuid The UUID of the player to cage.
+     */
+    public void cagePlayer(UUID uuid)
+    {
+        Player player = Bukkit.getPlayer(uuid);
+        if (player == null) return;
+
+        cagedPlayers.add(uuid);
+        cageLocations.put(uuid, createCage(player.getLocation(), Material.GLASS));
+    }
+
+    public void cagePlayer(UUID uuid, Material material)
+    {
+        Player player = Bukkit.getPlayer(uuid);
+        if (player == null) return;
+
+        cagedPlayers.add(uuid);
+        cageLocations.put(uuid, createCage(player.getLocation(), material));
+    }
+
+    /**
+     * This method will uncage the player by removing them from the {@link #cagedPlayers} set.
+     *
+     * @param uuid The UUID of the player to uncage.
+     */
+    public void uncagePlayer(UUID uuid)
+    {
+        cagedPlayers.remove(uuid);
+        Location location = cageLocations.get(uuid);
+
+        createCage(location, Material.AIR); // Remove the cage (set all blocks to air).
+
+        cageLocations.remove(uuid);
+    }
+
+    /**
+     * This method will check to make sure each caged player remains within their cage.
+     * We use
+     * <p>
+     * <code>{@link Location#distanceSquared(Location)} * {@link Math#pow(double, double)}</code>
+     * <p>
+     * to check if the player is outside the cage.
+     */
+    @Override
+    public void tick()
+    {
+        for (UUID uuid : cagedPlayers)
+        {
+            Player player = Bukkit.getPlayer(uuid);
+            if (player == null) continue;
+
+            Location cageLocation = getCageLocation(player);
+
+            final boolean inside;
+            if (!player.getWorld().equals(cageLocation.getWorld()))
+            {
+                inside = false;
+            } else
+            {
+                inside = player.getLocation().distanceSquared(cageLocation) > (Math.pow(2.5, 2.0));
+            }
+
+            if (!inside)
+            {
+                player.teleport(cageLocation);
+            }
+        }
+    }
+
+    /**
+     * This method returns whether the player is caged.
+     * <p>This method requires the player to be online to execute properly.</p>
+     *
+     * @param player The player to check.
+     * @return Whether the player is caged.
+     */
+    public Location getCageLocation(Player player)
+    {
+        return cageLocations.get(player.getUniqueId());
+    }
+
+    /**
+     * This method generates a cube centered around the passed location,
+     * made of the provided material. This method returns the passed location object.
+     * We use the {@link Shaper} class to generate the cube, which allows us to define
+     * custom shapes using {@link DoubleUnaryOperator}s.
+     *
+     * @param location   The location to center the cube around.
+     * @param material The material to use for the cube.
+     * @return The center location of the cube (the passed location).
+     * @see Shaper
+     * @see DoubleUnaryOperator
+     */
+    public Location createCage(Location location, Material material)
+    {
+        Shaper shaper = new Shaper(location.getWorld(), 0.0, 4.0);
+        List<Location> cubed = new LinkedList<>();
+        cubed.addAll(shaper.generate(5, t -> t, t -> 4.0, t -> t));
+        cubed.addAll(shaper.generate(5, t -> t, t -> 0.0, t -> t));
+        cubed.addAll(shaper.generate(5, t -> 0.0, t -> t, t -> t));
+        cubed.addAll(shaper.generate(5, t -> 4.0, t -> t, t -> t));
+        cubed.addAll(shaper.generate(5, t -> t, t -> t, t -> 0.0));
+        cubed.addAll(shaper.generate(5, t -> t, t -> t, t -> 4.0));
+
+        for (Location l : cubed)
+        {
+            location.getWorld().getBlockAt(l).setType(material);
+        }
+
+        return location.clone(); // Return the passed location as that is the center of the cube.
+    }
+
+    private final class CageListener implements Listener
+    {
+        @EventHandler
+        public void blockBreakEvent(BlockBreakEvent event)
+        {
+            if (cagedPlayers.contains(event.getPlayer().getUniqueId()))
+            {
+                event.setCancelled(true);
+            }
+        }
+
+        @EventHandler
+        public void playerLeaveEvent(PlayerQuitEvent event) {
+            if (cagedPlayers.contains(event.getPlayer().getUniqueId()))
+            {
+                uncagePlayer(event.getPlayer().getUniqueId());
+            }
+        }
+    }
+}

Datura/src/main/java/me/totalfreedom/datura/punishment/Halter.java

@@ -0,0 +1,33 @@
+package me.totalfreedom.datura.punishment;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class Halter implements Listener
+{
+    private final Set<UUID> haltedPlayers;
+
+    public Halter()
+    {
+        this.haltedPlayers = new HashSet<>();
+    }
+
+    public void halt(final UUID uuid)
+    {
+        this.haltedPlayers.add(uuid);
+    }
+
+    @EventHandler
+    public void playerMove(PlayerMoveEvent event)
+    {
+        if (haltedPlayers.contains(event.getPlayer().getUniqueId()))
+        {
+            event.setCancelled(true);
+        }
+    }
+}

Datura/src/main/java/me/totalfreedom/datura/punishment/Locker.java

@@ -0,0 +1,77 @@
+package me.totalfreedom.datura.punishment;
+
+import me.totalfreedom.base.CommonsBase;
+import me.totalfreedom.service.Service;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.util.Vector;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.SplittableRandom;
+import java.util.UUID;
+
+public class Locker extends Service
+{
+    private final Set<UUID> lockedPlayers = new HashSet<>();
+
+    public Locker()
+    {
+        super("locker-service");
+    }
+
+    public void lock(UUID uuid)
+    {
+        lockedPlayers.add(uuid);
+    }
+
+    @Override
+    public void tick()
+    {
+        lockedPlayers.removeIf(uuid -> !CommonsBase.getInstance().getServer().getOfflinePlayer(uuid).isOnline());
+
+        for (UUID uuid : lockedPlayers)
+        {
+            Player player = Bukkit.getPlayer(uuid);
+            if (player == null) continue;
+
+            lockingMethod(player);
+        }
+    }
+
+    private void lockingMethod(@NotNull Player player)
+    {
+        double x = player.getLocation().getX();
+        double z = player.getLocation().getZ();
+
+        if ((x / z % 0.001) < 1)
+        {
+            player.setVelocity(new Vector(x % 12, 0, z % 12));
+        }
+
+        player.setWalkSpeed(0.0f);
+        player.setFlySpeed(0.0f);
+        player.setAllowFlight(false);
+        player.setFlying(false);
+        player.setInvulnerable(true);
+        player.setCollidable(false);
+        player.setGliding(false);
+        player.setGlowing(true);
+        player.setSilent(true);
+        player.setCanPickupItems(false);
+        player.setInvisible(true);
+
+        player.openInventory(Bukkit.createInventory(null, 54));
+        player.closeInventory(InventoryCloseEvent.Reason.UNKNOWN);
+        player.teleport(player.getLocation().clone());
+
+        final SplittableRandom random = new SplittableRandom();
+        player.getEyeLocation().add(new Vector(
+                random.nextDouble(-1.0, 1.0),
+                random.nextDouble(-1.0, 1.0),
+                random.nextDouble(-1.0, 1.0)
+        ));
+    }
+}