SPIGOT-2013 Added Comparator/Hopper material, enhanced Diode

4 files changed, 500 insertions, 33 deletions

diff --git a/src/main/java/org/bukkit/Material.java b/src/main/java/org/bukkit/Material.java
index 6de16317..914d9e89 100644
--- a/src/main/java/org/bukkit/Material.java
+++ b/src/main/java/org/bukkit/Material.java
@@ -13,6 +13,7 @@ import org.bukkit.material.Chest;
 import org.bukkit.material.Coal;
 import org.bukkit.material.CocoaPlant;
 import org.bukkit.material.Command;
+import org.bukkit.material.Comparator;
 import org.bukkit.material.Crops;
 import org.bukkit.material.DetectorRail;
 import org.bukkit.material.Diode;
@@ -23,6 +24,7 @@ import org.bukkit.material.EnderChest;
 import org.bukkit.material.FlowerPot;
 import org.bukkit.material.Furnace;
 import org.bukkit.material.Gate;
+import org.bukkit.material.Hopper;
 import org.bukkit.material.Ladder;
 import org.bukkit.material.Leaves;
 import org.bukkit.material.Lever;
@@ -216,12 +218,12 @@ public enum Material {
     TRAPPED_CHEST(146, Chest.class),
     GOLD_PLATE(147),
     IRON_PLATE(148),
-    REDSTONE_COMPARATOR_OFF(149),
-    REDSTONE_COMPARATOR_ON(150),
+    REDSTONE_COMPARATOR_OFF(149, Comparator.class),
+    REDSTONE_COMPARATOR_ON(150, Comparator.class),
     DAYLIGHT_DETECTOR(151),
     REDSTONE_BLOCK(152),
     QUARTZ_ORE(153),
-    HOPPER(154),
+    HOPPER(154, Hopper.class),
     QUARTZ_BLOCK(155),
     QUARTZ_STAIRS(156, Stairs.class),
     ACTIVATOR_RAIL(157, PoweredRail.class),
diff --git a/src/main/java/org/bukkit/material/Comparator.java b/src/main/java/org/bukkit/material/Comparator.java
new file mode 100644
index 00000000..b5602ee6
--- /dev/null
+++ b/src/main/java/org/bukkit/material/Comparator.java
@@ -0,0 +1,200 @@
+package org.bukkit.material;
+
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+
+/**
+ * Represents a comparator in the on or off state, in normal or subtraction mode and facing in a specific direction.
+ *
+ * @see Material#REDSTONE_COMPARATOR_OFF
+ * @see Material#REDSTONE_COMPARATOR_ON
+ */
+public class Comparator extends MaterialData implements Directional, Redstone {
+    protected static final BlockFace DEFAULT_DIRECTION = BlockFace.NORTH;
+    protected static final boolean DEFAULT_SUBTRACTION_MODE = false;
+    protected static final boolean DEFAULT_STATE = false;
+
+    /**
+     * Constructs a comparator switched off, with the default mode (normal) and facing the default direction (north).
+     */
+    public Comparator() {
+        this(DEFAULT_DIRECTION, DEFAULT_SUBTRACTION_MODE, false);
+    }
+
+    /**
+     * Constructs a comparator switched off, with the default mode (normal) and facing the specified direction.
+     *
+     * @param facingDirection the direction the comparator is facing
+     *
+     * @see BlockFace
+     */
+    public Comparator(BlockFace facingDirection) {
+        this(facingDirection, DEFAULT_SUBTRACTION_MODE, DEFAULT_STATE);
+    }
+
+    /**
+     * Constructs a comparator switched off, with the specified mode and facing the specified direction.
+     *
+     * @param facingDirection the direction the comparator is facing
+     * @param isSubtraction True if the comparator is in subtraction mode, false for normal comparator operation
+     *
+     * @see BlockFace
+     */
+    public Comparator(BlockFace facingDirection, boolean isSubtraction) {
+    	this(facingDirection, isSubtraction, DEFAULT_STATE);
+    }
+
+    /**
+     * Constructs a comparator switched on or off, with the specified mode and facing the specified direction.
+     *
+     * @param facingDirection the direction the comparator is facing
+     * @param isSubtraction True if the comparator is in subtraction mode, false for normal comparator operation
+     * @param state True if the comparator is in the on state
+     *
+     * @see BlockFace
+     */
+    public Comparator(BlockFace facingDirection, boolean isSubtraction, boolean state) {
+        super(state ? Material.REDSTONE_COMPARATOR_ON : Material.REDSTONE_COMPARATOR_OFF);
+        setFacingDirection(facingDirection);
+        setSubtractionMode(isSubtraction);
+    }
+
+    /**
+     * @param type the raw type id
+     * @deprecated Magic value
+     */
+    @Deprecated
+    public Comparator(int type) {
+        super(type);
+    }
+
+    public Comparator(Material type) {
+        super(type);
+    }
+
+    /**
+     * @param type the raw type id
+     * @param data the raw data value
+     * @deprecated Magic value
+     */
+    @Deprecated
+    public Comparator(int type, byte data) {
+        super(type, data);
+    }
+
+    /**
+     * @param type the type
+     * @param data the raw data value
+     * @deprecated Magic value
+     */
+    @Deprecated
+    public Comparator(Material type, byte data) {
+        super(type, data);
+    }
+
+    /**
+     * Sets whether the comparator is in subtraction mode.
+     *
+     * @param isSubtraction True if the comparator is in subtraction mode, false for normal comparator operation
+     */
+    public void setSubtractionMode(boolean isSubtraction) {
+        setData((byte)(getData() & 0xB | (isSubtraction ? 0x4 : 0x0)));
+    }
+
+    /**
+     * Checks whether the comparator is in subtraction mode
+     *
+     * @return True if the comparator is in subtraction mode, false if normal comparator operation
+     */
+    public boolean isSubtractionMode() {
+        return (getData() & 0x4) != 0;
+    }
+
+    /**
+     * Sets the direction this comparator is facing
+     *
+     * @param face The direction to set this comparator to
+     *
+     * @see BlockFace
+     */
+    @Override
+    public void setFacingDirection(BlockFace face) {
+        int data = getData() & 0xC;
+
+        switch (face) {
+        case EAST:
+            data |= 0x1;
+            break;
+
+        case SOUTH:
+            data |= 0x2;
+            break;
+
+        case WEST:
+            data |= 0x3;
+            break;
+
+        case NORTH:
+        default:
+            data |= 0x0;
+        }
+
+        setData((byte)data);
+    }
+
+    /**
+     * Gets the direction this comparator is facing
+     *
+     * @return The direction this comparator is facing
+     *
+     * @see BlockFace
+     */
+    @Override
+    public BlockFace getFacing() {
+        byte data = (byte) (getData() & 0x3);
+
+        switch (data) {
+        case 0x0:
+        default:
+            return BlockFace.NORTH;
+
+        case 0x1:
+            return BlockFace.EAST;
+
+        case 0x2:
+            return BlockFace.SOUTH;
+
+        case 0x3:
+            return BlockFace.WEST;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " facing " + getFacing() + " in " + (isSubtractionMode() ? "subtraction" : "comparator") + " mode";
+    }
+
+    @Override
+    public Comparator clone() {
+        return (Comparator) super.clone();
+    }
+
+    /**
+     * Checks if the comparator is powered
+     *
+     * @return true if the comparator is powered
+     */
+    @Override
+    public boolean isPowered() {
+        return getItemType() == Material.REDSTONE_COMPARATOR_ON;
+    }
+
+    /**
+     * Checks if the comparator is being powered
+     *
+     * @return true if the comparator is being powered
+     */
+    public boolean isBeingPowered() {
+        return (getData() & 0x8) != 0;
+    }
+}
diff --git a/src/main/java/org/bukkit/material/Diode.java b/src/main/java/org/bukkit/material/Diode.java
index fbfacc06..84014c4f 100644
--- a/src/main/java/org/bukkit/material/Diode.java
+++ b/src/main/java/org/bukkit/material/Diode.java
@@ -3,9 +3,71 @@ package org.bukkit.material;
 import org.bukkit.Material;
 import org.bukkit.block.BlockFace;
 
-public class Diode extends MaterialData implements Directional {
+/**
+ * Represents a diode/repeater in the on or off state, with a delay and facing
+ * in a specific direction.
+ *
+ * @see Material#DIODE_BLOCK_OFF
+ * @see Material#DIODE_BLOCK_ON
+ */
+public class Diode extends MaterialData implements Directional, Redstone {
+
+    protected static final BlockFace DEFAULT_DIRECTION = BlockFace.NORTH;
+    protected static final int DEFAULT_DELAY = 1;
+    protected static final boolean DEFAULT_STATE = false;
+
+    /**
+     * Constructs a diode switched on, with a delay of 1 and facing the default
+     * direction (north).
+     *
+     * By default this constructor creates a diode that is switched on for
+     * backwards compatibility with past implementations.
+     */
     public Diode() {
-        super(Material.DIODE_BLOCK_ON);
+        this(DEFAULT_DIRECTION, DEFAULT_DELAY, true);
+    }
+
+    /**
+     * Constructs a diode switched off, with a delay of 1 and facing the
+     * specified direction.
+     *
+     * @param facingDirection the direction the diode is facing
+     *
+     * @see BlockFace
+     */
+    public Diode(BlockFace facingDirection) {
+        this(facingDirection, DEFAULT_DELAY, DEFAULT_STATE);
+    }
+
+    /**
+     * Constructs a diode switched off, with the specified delay and facing the
+     * specified direction.
+     *
+     * @param facingDirection the direction the diode is facing
+     * @param delay The number of ticks (1-4) before the diode turns on after
+     * being powered
+     *
+     * @see BlockFace
+     */
+    public Diode(BlockFace facingDirection, int delay) {
+        this(facingDirection, delay, DEFAULT_STATE);
+    }
+
+    /**
+     * Constructs a diode switched on or off, with the specified delay and
+     * facing the specified direction.
+     *
+     * @param facingDirection the direction the diode is facing
+     * @param delay The number of ticks (1-4) before the diode turns on after
+     * being powered
+     * @param state True if the diode is in the on state
+     *
+     * @see BlockFace
+     */
+    public Diode(BlockFace facingDirection, int delay, boolean state) {
+        super(state ? Material.DIODE_BLOCK_ON : Material.DIODE_BLOCK_OFF);
+        setFacingDirection(facingDirection);
+        setDelay(delay);
     }
 
     /**
@@ -42,10 +104,9 @@ public class Diode extends MaterialData implements Directional {
     }
 
     /**
-     * Sets the delay of the repeater
+     * Sets the delay of the repeater.
      *
-     * @param delay
-     *            The new delay (1-4)
+     * @param delay The new delay (1-4)
      */
     public void setDelay(int delay) {
         if (delay > 4) {
@@ -60,7 +121,7 @@ public class Diode extends MaterialData implements Directional {
     }
 
     /**
-     * Gets the delay of the repeater in ticks
+     * Gets the delay of the repeater in ticks.
      *
      * @return The delay (1-4)
      */
@@ -68,48 +129,61 @@ public class Diode extends MaterialData implements Directional {
         return (getData() >> 2) + 1;
     }
 
+    /**
+     * Sets the direction this diode is facing.
+     *
+     * @param face The direction to set this diode to
+     *
+     * @see BlockFace
+     */
+    @Override
     public void setFacingDirection(BlockFace face) {
         int delay = getDelay();
         byte data;
 
         switch (face) {
-        case EAST:
-            data = 0x1;
-            break;
-
-        case SOUTH:
-            data = 0x2;
-            break;
-
-        case WEST:
-            data = 0x3;
-            break;
-
-        case NORTH:
-        default:
-            data = 0x0;
+            case EAST:
+                data = 0x1;
+                break;
+            case SOUTH:
+                data = 0x2;
+                break;
+            case WEST:
+                data = 0x3;
+                break;
+            case NORTH:
+            default:
+                data = 0x0;
         }
 
         setData(data);
         setDelay(delay);
     }
 
+    /**
+     * Gets the direction this diode is facing
+     *
+     * @return The direction this diode is facing
+     *
+     * @see BlockFace
+     */
+    @Override
     public BlockFace getFacing() {
         byte data = (byte) (getData() & 0x3);
 
         switch (data) {
-        case 0x0:
-        default:
-            return BlockFace.NORTH;
+            case 0x0:
+            default:
+                return BlockFace.NORTH;
 
-        case 0x1:
-            return BlockFace.EAST;
+            case 0x1:
+                return BlockFace.EAST;
 
-        case 0x2:
-            return BlockFace.SOUTH;
+            case 0x2:
+                return BlockFace.SOUTH;
 
-        case 0x3:
-            return BlockFace.WEST;
+            case 0x3:
+                return BlockFace.WEST;
         }
     }
 
@@ -122,4 +196,14 @@ public class Diode extends MaterialData implements Directional {
     public Diode clone() {
         return (Diode) super.clone();
     }
+
+    /**
+     * Checks if the diode is powered.
+     *
+     * @return true if the diode is powered
+     */
+    @Override
+    public boolean isPowered() {
+        return getItemType() == Material.DIODE_BLOCK_ON;
+    }
 }
diff --git a/src/main/java/org/bukkit/material/Hopper.java b/src/main/java/org/bukkit/material/Hopper.java
new file mode 100644
index 00000000..d1516f25
--- /dev/null
+++ b/src/main/java/org/bukkit/material/Hopper.java
@@ -0,0 +1,181 @@
+package org.bukkit.material;
+
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+
+/**
+ * Represents a hopper in an active or deactivated state and facing in a
+ * specific direction.
+ *
+ * @see Material#HOPPER
+ */
+public class Hopper extends MaterialData implements Directional, Redstone {
+
+    protected static final BlockFace DEFAULT_DIRECTION = BlockFace.DOWN;
+    protected static final boolean DEFAULT_ACTIVE = true;
+
+    /**
+     * Constructs a hopper facing the default direction (down) and initially
+     * active.
+     */
+    public Hopper() {
+        this(DEFAULT_DIRECTION, DEFAULT_ACTIVE);
+    }
+
+    /**
+     * Constructs a hopper facing the specified direction and initially active.
+     *
+     * @param facingDirection the direction the hopper is facing
+     *
+     * @see BlockFace
+     */
+    public Hopper(BlockFace facingDirection) {
+        this(facingDirection, DEFAULT_ACTIVE);
+    }
+
+    /**
+     * Constructs a hopper facing the specified direction and either active or
+     * not.
+     *
+     * @param facingDirection the direction the hopper is facing
+     * @param isActive True if the hopper is initially active, false if
+     * deactivated
+     *
+     * @see BlockFace
+     */
+    public Hopper(BlockFace facingDirection, boolean isActive) {
+        super(Material.HOPPER);
+        setFacingDirection(facingDirection);
+        setActive(isActive);
+    }
+
+    /**
+     * @param type the raw type id
+     * @deprecated Magic value
+     */
+    @Deprecated
+    public Hopper(int type) {
+        super(type);
+    }
+
+    public Hopper(Material type) {
+        super(type);
+    }
+
+    /**
+     * @param type the raw type id
+     * @param data the raw data value
+     * @deprecated Magic value
+     */
+    @Deprecated
+    public Hopper(int type, byte data) {
+        super(type, data);
+    }
+
+    /**
+     * @param type the type
+     * @param data the raw data value
+     * @deprecated Magic value
+     */
+    @Deprecated
+    public Hopper(Material type, byte data) {
+        super(type, data);
+    }
+
+    /**
+     * Sets whether the hopper is active or not.
+     *
+     * @param isActive True if the hopper is active, false if deactivated as if
+     * powered by redstone
+     */
+    public void setActive(boolean isActive) {
+        setData((byte) (getData() & 0x7 | (isActive ? 0x0 : 0x8)));
+    }
+
+    /**
+     * Checks whether the hopper is active or not.
+     *
+     * @return True if the hopper is active, false if deactivated
+     */
+    public boolean isActive() {
+        return (getData() & 0x8) == 0;
+    }
+
+    /**
+     * Sets the direction this hopper is facing
+     *
+     * @param face The direction to set this hopper to
+     *
+     * @see BlockFace
+     */
+    @Override
+    public void setFacingDirection(BlockFace face) {
+        int data = getData() & 0x8;
+
+        switch (face) {
+            case DOWN:
+                data |= 0x0;
+                break;
+            case NORTH:
+                data |= 0x2;
+                break;
+            case SOUTH:
+                data |= 0x3;
+                break;
+            case WEST:
+                data |= 0x4;
+                break;
+            case EAST:
+                data |= 0x5;
+                break;
+        }
+
+        setData((byte) data);
+    }
+
+    /**
+     * Gets the direction this hopper is facing
+     *
+     * @return The direction this hopper is facing
+     *
+     * @see BlockFace
+     */
+    @Override
+    public BlockFace getFacing() {
+        byte data = (byte) (getData() & 0x7);
+
+        switch (data) {
+            default:
+            case 0x0:
+                return BlockFace.DOWN;
+            case 0x2:
+                return BlockFace.NORTH;
+            case 0x3:
+                return BlockFace.SOUTH;
+            case 0x4:
+                return BlockFace.WEST;
+            case 0x5:
+                return BlockFace.EAST;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " facing " + getFacing();
+    }
+
+    @Override
+    public Hopper clone() {
+        return (Hopper) super.clone();
+    }
+
+    /**
+     * Checks if the hopper is powered.
+     *
+     * @return true if the hopper is powered
+     */
+    @Override
+    public boolean isPowered() {
+        return (getData() & 0x8) != 0;
+    }
+}