Face -> Side

its easier to code for, and will be quicker performance wise

Author: modmuss50

src/main/java/team/reborn/energy/EnergyFace.java

@@ -5,7 +5,7 @@ public class EnergyHandler {
 	private final EnergyStorage holder;
 
 	private boolean simulate = false;
-	private EnergyFace face = EnergyFace.UNKNOWN;
+	private EnergySide side = EnergySide.UNKNOWN;
 
 	//Not to be called by a mod, use Energy.of
 	EnergyHandler(EnergyStorage holder) {
@@ -22,17 +22,17 @@ public EnergyHandler simulate() {
 	 * @return the amount of energy actually extracted
 	 */
 	public double extract(double amount) {
-		double stored = holder.getStored(face);
-		double energyExtracted = Math.min(Math.min(stored, amount), holder.getMaxOutput(face));
+		double stored = holder.getStored(side);
+		double energyExtracted = Math.min(Math.min(stored, amount), holder.getMaxOutput(side));
 		if (energyExtracted > 0 && !simulate) {
 			holder.setStored(stored - energyExtracted);
 		}
 		return energyExtracted;
 	}
 
 	public double insert(double amount) {
-		double stored = holder.getStored(face);
-		double energyInserted = Math.min(Math.min(holder.getMaxStoredPower() - stored, amount), holder.getMaxInput(face));
+		double stored = holder.getStored(side);
+		double energyInserted = Math.min(Math.min(holder.getMaxStoredPower() - stored, amount), holder.getMaxInput(side));
 		if (!simulate) {
 			holder.setStored(stored + energyInserted);
 		}
@@ -53,23 +53,23 @@ public void set(double amount){
 
 	//Returns the max amount of energy that can be inputted
 	public double getMaxInput() {
-		return Math.min(holder.getMaxInput(face), holder.getMaxStoredPower() - holder.getStored(face));
+		return Math.min(holder.getMaxInput(side), holder.getMaxStoredPower() - holder.getStored(side));
 	}
 
 	public double getMaxOutput() {
-		return Math.min(holder.getMaxOutput(face), holder.getStored(face));
+		return Math.min(holder.getMaxOutput(side), holder.getStored(side));
 	}
 
 	public double getEnergy() {
-		return holder.getStored(face);
+		return holder.getStored(side);
 	}
 
 	public EnergyMovement into(EnergyHandler target) {
 		return new EnergyMovement(this, target);
 	}
 
-	public EnergyHandler face(EnergyFace face) {
-		this.face = face;
+	public EnergyHandler side(EnergySide side) {
+		this.side = side;
 		return this;
 	}
 }

src/main/java/team/reborn/energy/EnergyHandler.java

@@ -12,11 +12,11 @@ public interface EnergyHolder {
 	 */
 	EnergyTier getTier();
 
-	default double getMaxInput(EnergyFace face) {
+	default double getMaxInput(EnergySide side) {
 		return getTier().getMaxInput();
 	}
 
-	default double getMaxOutput(EnergyFace face) {
+	default double getMaxOutput(EnergySide side) {
 		return getTier().getMaxOutput();
 	}
 

src/main/java/team/reborn/energy/EnergyHolder.java

@@ -0,0 +1,20 @@
+package team.reborn.energy;
+
+public enum  EnergySide {
+	DOWN,
+	UP,
+	NORTH,
+	SOUTH,
+	WEST,
+	EAST,
+	UNKNOWN;
+
+	private static final EnergySide[] VALUES = values();
+
+	public static EnergySide fromMinecraft(Enum<?> e){
+		if(e == null){
+			return UNKNOWN;
+		}
+		return VALUES[e.ordinal()];
+	}
+}

src/main/java/team/reborn/energy/EnergySide.java

@@ -5,7 +5,7 @@ public interface EnergyStorage extends EnergyHolder {
 	/**
 	 * Returns the currently stored energy
 	 */
-	double getStored(EnergyFace face);
+	double getStored(EnergySide face);
 
 	/**
 	 * Sets the stored energy to the provided amount
@@ -14,6 +14,4 @@ public interface EnergyStorage extends EnergyHolder {
 	 */
 	void setStored(double amount);
 
-
-
 }

src/main/java/team/reborn/energy/EnergyStorage.java

@@ -221,7 +221,7 @@ class DummyClass {}
 		Energy.registerHolder(DummyClass.class, dummyClass -> new EnergyStorage() {
 
 			@Override
-			public double getStored(EnergyFace face) {
+			public double getStored(EnergySide side) {
 				return 100;
 			}
 
@@ -254,44 +254,44 @@ public void testNoHolder(){
 	@Test
 	public void testSidedness() {
 		//Source can only be accessed from the top
-		TestingHolder source = new TestingHolder.Facing(500, 1000, EnergyTier.HIGH, EnergyFace.TOP);
+		TestingHolder source = new TestingHolder.Facing(500, 1000, EnergyTier.HIGH, EnergySide.UP);
 		//target can only be accessed form the bottom
-		TestingHolder target = new TestingHolder.Facing(0, 1000, EnergyTier.HIGH, EnergyFace.BOTTOM);
+		TestingHolder target = new TestingHolder.Facing(0, 1000, EnergyTier.HIGH, EnergySide.DOWN);
 
 		//No side provided, due to the impl of the Holder, this should return 0
 		assertEquals(0, Energy.of(source).getEnergy(), 0);
 		//Same test as before, just from the top
-		assertEquals(500, Energy.of(source).face(EnergyFace.TOP).getEnergy(), 0);
+		assertEquals(500, Energy.of(source).side(EnergySide.UP).getEnergy(), 0);
 
 		//Try an extract 100 energy out of the unknown side, should fail
 		assertEquals(0, Energy.of(source).extract(100), 0);
 		//Ensure it failed by checking we still have 500 energy
-		assertEquals(500, Energy.of(source).face(EnergyFace.TOP).getEnergy(), 0);
+		assertEquals(500, Energy.of(source).side(EnergySide.UP).getEnergy(), 0);
 
 		//Remove 100 energy from the allowed top side
-		assertEquals(100, Energy.of(source).face(EnergyFace.TOP).extract(100), 0);
+		assertEquals(100, Energy.of(source).side(EnergySide.UP).extract(100), 0);
 		//Test there is now only 400 energy in the the source
-		assertEquals(400, Energy.of(source).face(EnergyFace.TOP).getEnergy(), 0);
+		assertEquals(400, Energy.of(source).side(EnergySide.UP).getEnergy(), 0);
 
 
 		double moved = Energy.of(source)
-			.face(EnergyFace.TOP)
+			.side(EnergySide.UP)
 			.into(Energy.of(target)) //This should fail because no side is set on the target holder
 			.move(100);
 
 		assertEquals(0, moved, 0);
 
-		assertEquals(0, Energy.of(target).face(EnergyFace.TOP).getEnergy(), 0);
-		assertEquals(400, Energy.of(source).face(EnergyFace.TOP).getEnergy(), 0);
+		assertEquals(0, Energy.of(target).side(EnergySide.UP).getEnergy(), 0);
+		assertEquals(400, Energy.of(source).side(EnergySide.UP).getEnergy(), 0);
 
 		moved = Energy.of(source)
-			.face(EnergyFace.TOP)
-			.into(Energy.of(target).face(EnergyFace.BOTTOM)) //This should now work as the target can only be accessed from the bottom
+			.side(EnergySide.UP)
+			.into(Energy.of(target).side(EnergySide.DOWN)) //This should now work as the target can only be accessed from the bottom
 			.move(100);
 
 		assertEquals(100, moved, 0);
-		assertEquals(300, Energy.of(source).face(EnergyFace.TOP).getEnergy(), 0);
-		assertEquals(100, Energy.of(target).face(EnergyFace.BOTTOM).getEnergy(), 0);
+		assertEquals(300, Energy.of(source).side(EnergySide.UP).getEnergy(), 0);
+		assertEquals(100, Energy.of(target).side(EnergySide.DOWN).getEnergy(), 0);
 	}
 
 
@@ -311,7 +311,7 @@ public void minecraftTests() {
 			final EnergyHolder energyHolder = (EnergyHolder) ((ItemStack) is).getItem();
 			return new EnergyStorage() {
 				@Override
-				public double getStored(EnergyFace face) {
+				public double getStored(EnergySide side) {
 					return 100; //TODO read from NBT here.
 				}
 
@@ -336,5 +336,8 @@ public EnergyTier getTier() {
 
 		assertEquals(100, Energy.of(itemStack).getEnergy(), 0);
 
+		assertEquals(EnergySide.DOWN, EnergySide.fromMinecraft(EnergySide.DOWN));
+		assertEquals(EnergySide.UNKNOWN, EnergySide.fromMinecraft(null));
+
 	}
 }

src/test/java/team/reborn/energy/test/PowerTests.java

@@ -1,6 +1,6 @@
 package team.reborn.energy.test;
 
-import team.reborn.energy.EnergyFace;
+import team.reborn.energy.EnergySide;
 import team.reborn.energy.EnergyStorage;
 import team.reborn.energy.EnergyTier;
 
@@ -23,7 +23,7 @@ public TestingHolder(double stored, double max, EnergyTier tier) {
 	}
 
 	@Override
-	public double getStored(EnergyFace face) {
+	public double getStored(EnergySide side) {
 		return stored;
 	}
 
@@ -43,34 +43,34 @@ public EnergyTier getTier() {
 	}
 
 
-	//Only allows power access on the face provided
+	//Only allows power access on the side provided
 	public static class Facing extends TestingHolder {
 
-		private final EnergyFace face;
+		private final EnergySide side;
 
-		public Facing(double stored, double max, EnergyFace face) {
+		public Facing(double stored, double max, EnergySide side) {
 			super(stored, max);
-			this.face = face;
+			this.side = side;
 		}
 
-		public Facing(double stored, double max, EnergyTier tier, EnergyFace face) {
+		public Facing(double stored, double max, EnergyTier tier, EnergySide side) {
 			super(stored, max, tier);
-			this.face = face;
+			this.side = side;
 		}
 
 		@Override
-		public double getStored(EnergyFace face) {
-			return this.face == face ? super.getStored(face) : 0;
+		public double getStored(EnergySide side) {
+			return this.side == side ? super.getStored(side) : 0;
 		}
 
 		@Override
-		public double getMaxInput(EnergyFace face) {
-			return this.face == face ? super.getMaxInput(face) : 0;
+		public double getMaxInput(EnergySide side) {
+			return this.side == side ? super.getMaxInput(side) : 0;
 		}
 
 		@Override
-		public double getMaxOutput(EnergyFace face) {
-			return this.face == face ? super.getMaxOutput(face) : 0;
+		public double getMaxOutput(EnergySide side) {
+			return this.side == side ? super.getMaxOutput(side) : 0;
 		}
 	}