Determine desired facing based on 2 facings

- For #63
Fundynamic · Oct 21, 2015 · c48fd6a · c48fd6a
1 parent 480390e
commit c48fd6a
Show file tree

Hide file tree

Showing 2 changed files with 39 additions and 11 deletions.
diff --git a/src/main/java/com/fundynamic/d2tm/game/entities/units/UnitFacings.java b/src/main/java/com/fundynamic/d2tm/game/entities/units/UnitFacings.java
@@ -96,4 +96,13 @@ public static int getCounterClockwiseSteps(int currentId, int desiredId) {
         return counterClockwise;
     }
 
+    // TODO: this looks very similar to the Projectile determine facing logic, move to somewhere else!?
+    public static UnitFacings getFacing(Vector2D from, Vector2D to) {
+        double angle = from.angleTo(to);
+        int facings = 8; // 8 facings in total for a unit
+        float chop = 360F / facings;
+        angle += (chop / 2);
+        int facing = (int) (angle / chop) % facings;
+        return byId(facing);
+    }
 }
diff --git a/src/test/java/com/fundynamic/d2tm/game/entities/units/UnitFacingsTest.java b/src/test/java/com/fundynamic/d2tm/game/entities/units/UnitFacingsTest.java
@@ -4,71 +4,72 @@
 import org.junit.Test;
 
 import static com.fundynamic.d2tm.game.entities.units.UnitFacings.*;
+import static com.fundynamic.d2tm.math.Vector2D.create;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.*;
 
 
 public class UnitFacingsTest {
 
-    Vector2D unitAbsoluteMapCoordinates = Vector2D.create(32, 32);
+    Vector2D unitAbsoluteMapCoordinates = create(32, 32);
 
     //////////////////////////////////
     // Determine facing from A to B
 
     @Test
     public void determinesFacingRightDown() {
-        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(Vector2D.create(1, 1));
+        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(create(1, 1));
         assertEquals(RIGHT_DOWN, determine(unitAbsoluteMapCoordinates, coordinatesToFaceTo));
     }
 
     @Test
     public void determinesFacingLeftDown() {
-        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(Vector2D.create(-1, 1));
+        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(create(-1, 1));
         assertEquals(UnitFacings.LEFT_DOWN, determine(unitAbsoluteMapCoordinates, coordinatesToFaceTo));
     }
 
     @Test
     public void determinesFacingRightUp() {
-        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(Vector2D.create(1, -1));
+        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(create(1, -1));
         assertEquals(RIGHT_UP, determine(unitAbsoluteMapCoordinates, coordinatesToFaceTo));
     }
 
     @Test
     public void determinesFacingLeftUp() {
-        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(Vector2D.create(-1, -1));
+        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(create(-1, -1));
         assertEquals(LEFT_UP, determine(unitAbsoluteMapCoordinates, coordinatesToFaceTo));
     }
 
     @Test
     public void determinesFacingUp() {
-        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(Vector2D.create(0, -1));
+        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(create(0, -1));
         assertEquals(UP, determine(unitAbsoluteMapCoordinates, coordinatesToFaceTo));
     }
 
     @Test
     public void determinesFacingDown() {
-        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(Vector2D.create(0, 1));
+        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(create(0, 1));
         assertEquals(UnitFacings.DOWN, determine(unitAbsoluteMapCoordinates, coordinatesToFaceTo));
     }
 
     @Test
     public void determinesFacingLeft() {
-        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(Vector2D.create(-1, 0));
+        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(create(-1, 0));
         assertEquals(LEFT, determine(unitAbsoluteMapCoordinates, coordinatesToFaceTo));
     }
 
     @Test
     public void determinesFacingRight() {
-        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(Vector2D.create(1, 0));
+        Vector2D coordinatesToFaceTo = unitAbsoluteMapCoordinates.add(create(1, 0));
         assertEquals(RIGHT, determine(unitAbsoluteMapCoordinates, coordinatesToFaceTo));
     }
 
 
     ////////////////////////////////////////////////
-    // Facing logic
+    // Facing logic - turning
 
     @Test
-    public void determineNextFacing() {
+    public void determineNextFacingFromCurrentToDesired() {
         assertThat(nextFacing(UP, RIGHT), is(RIGHT_UP));
         assertThat(nextFacing(UP, RIGHT_DOWN), is(RIGHT_UP));
         assertThat(nextFacing(UP, LEFT), is(LEFT_UP));
@@ -80,4 +81,22 @@ public void determineNextFacing() {
 
         assertThat(nextFacing(UP, LEFT), is(LEFT_UP));
     }
+
+    ////////////////////////////////////////////////
+    // Facing logic - determine desired facing based on 2 vectors
+
+    @Test
+    public void determineDesiredFacingBasedOnVectors() {
+        Vector2D center = create(32, 32);
+        assertThat(getFacing(center, create(64, 64)), is(RIGHT_DOWN));
+        assertThat(getFacing(center, create(64, 32)), is(RIGHT));
+        assertThat(getFacing(center, create(64, 0)), is(RIGHT_UP));
+
+        assertThat(getFacing(center, create(32, 64)), is(DOWN));
+        assertThat(getFacing(center, create(32, 0)), is(UP));
+
+        assertThat(getFacing(center, create(0, 64)), is(LEFT_DOWN));
+        assertThat(getFacing(center, create(0, 32)), is(LEFT));
+        assertThat(getFacing(center, create(0, 0)), is(LEFT_UP));
+    }
 }