Migrates the entire package nomenclature to be more direct and straightforward. (#17)

Signed-off-by: Paul Reilly <pawereus@gmail.com>

Fossil/src/main/java/fns/fossil/bouncypads/PadHolder.java

@@ -0,0 +1,157 @@
+package fns.fossil.bouncypads;
+
+import fns.fossil.Fossil;
+import fns.patchwork.base.Patchwork;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Stream;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Tag;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Holds all the active pads for each player, and also manages player pad interaction.
+ */
+public class PadHolder implements Listener
+{
+    /**
+     * A map of all the currently active pads, stored by {@link Player} {@link UUID}.
+     */
+    private final Map<UUID, BouncyPad> pads = new HashMap<>();
+
+    /**
+     * Creates a new pad holder.
+     */
+    public PadHolder()
+    {
+        Bukkit.getPluginManager()
+              .registerEvents(this, Patchwork
+                      .getInstance()
+                      .getRegistrations()
+                      .getModuleRegistry()
+                      .getProvider(Fossil.class)
+                      .getModule());
+    }
+
+    /**
+     * Adds a pad for the given player. If the player already has a pad stored in the map, it will be overwritten with
+     * the new pad.
+     *
+     * @param player The player to add the pad for.
+     * @param pad    The pad to add.
+     */
+    public void addPad(final Player player, final BouncyPad pad)
+    {
+        this.pads.put(player.getUniqueId(), pad);
+    }
+
+    /**
+     * Removes the pad for the given player, if the player has one.
+     *
+     * @param player The player to remove the pad for.
+     */
+    public void removePad(final Player player)
+    {
+        this.pads.remove(player.getUniqueId());
+    }
+
+    /**
+     * Gets the pad for the given player, if the player has one. If the player has no active pad, this will return
+     * null.
+     *
+     * @param player The player to get the pad for.
+     * @return The pad for the given player.
+     */
+    @Nullable
+    public BouncyPad getPad(final Player player)
+    {
+        return this.pads.get(player.getUniqueId());
+    }
+
+    /**
+     * Checks if there is a pad active for the given player.
+     *
+     * @param player The player to check.
+     * @return True if the player has a pad, false otherwise.
+     */
+    public boolean hasPad(final Player player)
+    {
+        return this.pads.containsKey(player.getUniqueId());
+    }
+
+    /**
+     * Gets a map of all the currently active pads, stored by {@link Player} {@link UUID}.
+     *
+     * @return A map of all the currently active pads.
+     */
+    public Map<UUID, BouncyPad> getPads()
+    {
+        return this.pads;
+    }
+
+    /**
+     * Handles player pad interaction. This will check the relative block for each acceptible direction, and pass the
+     * resulting block face (if any) to the bounce pad. See
+     * {@link BouncyPad#bouncePad(Player, org.bukkit.block.BlockFace)} for how the resulting block face is processed.
+     *
+     * @param event The event which gets called when a player moves.
+     */
+    @EventHandler
+    public void onPlayerMove(final PlayerMoveEvent event)
+    {
+        final Player player = event.getPlayer();
+        if (!this.hasPad(player))
+        {
+            return;
+        }
+
+        final BouncyPad pad = this.getPad(player);
+        final Location location = player.getLocation();
+
+        final Block xNeg1 = getRelative(location, -1, 0, 0);
+        final Block xPos1 = getRelative(location, 1, 0, 0);
+        final Block zNeg1 = getRelative(location, 0, 0, -1);
+        final Block zPos1 = getRelative(location, 0, 0, 1);
+        final Block yNeg1 = getRelative(location, 0, -1, 0);
+
+        Stream.of(xNeg1, xPos1, zNeg1, zPos1, yNeg1)
+              .filter(this::isWool)
+              .map(block -> block.getFace(location.getBlock()))
+              .findFirst()
+              .ifPresent(face -> pad.bouncePad(player, face));
+    }
+
+    /**
+     * Gets the relative block at the given location.
+     *
+     * @param location The location to get the relative block from.
+     * @param x        The x mod.
+     * @param y        The y mod.
+     * @param z        The z mod.
+     * @return The relative block.
+     */
+    private Block getRelative(final Location location, final int x, final int y, final int z)
+    {
+        return location.getBlock()
+                       .getRelative(x, y, z);
+    }
+
+    /**
+     * Checks if the given block is wool.
+     *
+     * @param block The block to check.
+     * @return True if the block is wool, false otherwise.
+     * @see Tag#WOOL
+     */
+    private boolean isWool(final Block block)
+    {
+        return Tag.WOOL.isTagged(block.getType());
+    }
+}