6 files changed, 133 insertions, 26 deletions

@@ -10,30 +10,90 @@ package com.fourisland.fourpuzzle;
  * @author hatkirby
  */
 public enum Direction {
-    North,
-    East,
-    South,
-    West;
+    North
+    {
+        public Direction opposite()
+        {
+            return Direction.South;
+        }
+        
+        public Direction left()
+        {
+            return Direction.West;
+        }
+        
+        public Direction right()
+        {
+            return Direction.East;
+        }
+    },
+    East
+    {
+        public Direction opposite()
+        {
+            return Direction.West;
+        }
+        
+        public Direction left()
+        {
+            return Direction.North;
+        }
+        
+        public Direction right()
+        {
+            return Direction.South;
+        }
+    },
+    South
+    {
+        public Direction opposite()
+        {
+            return Direction.North;
+        }
+        
+        public Direction left()
+        {
+            return Direction.East;
+        }
+        
+        public Direction right()
+        {
+            return Direction.West;
+        }
+    },
+    West
+    {
+        public Direction opposite()
+        {
+            return Direction.East;
+        }
+        
+        public Direction left()
+        {
+            return Direction.South;
+        }
+        
+        public Direction right()
+        {
+            return Direction.North;
+        }
+    };
     
     /**
-     * TODO Find a way to serve the inverse of a Direction without using a
-     * switch, which is apparently bad practice
+     * Returns the direction opposite from the current one
+     * @return A Direction representing the wanted direction
      */
+    public abstract Direction opposite();
     
     /**
-     * Returns the direction opposite from the current one
-     * @return A Direction representing the opposite direction
+     * Returns the direction counterclockwise from the current one
+     * @return A Direction representing the wanted direction
      */
-    public Direction oppositeDirection()
-    {
-        switch (this)
-        {
-            case North: return Direction.South;
-            case West: return Direction.East;
-            case South: return Direction.North;
-            case East: return Direction.West;
-        }
-        
-        return null;
-    }
+    public abstract Direction left();
+    
+    /**
+     * Returns the direction clockwise from the current one
+     * @return A Direction representing the wanted direction
+     */
+    public abstract Direction right();
 }
@@ -134,7 +134,7 @@ public class MapViewGameState implements GameState {
                             {
                                 if (Functions.isFacing(hero, ev))
                                 {
-                                    ev.setDirection(hero.getDirection().oppositeDirection());
+                                    ev.setDirection(hero.getDirection().opposite());
                                     ev.getCallback().activate(ev.getCalltime());
                                 }
                             } else {
@@ -78,7 +78,7 @@ public abstract class AbstractEvent implements Event {
             } else if (moveTimer == 0)
             {
                 setAnimationStep(1);
-                moving = false;
+                setMoving(false);
                 
                 if (getDirection() == Direction.North)
                 {
@@ -46,10 +46,44 @@ public enum AnimationType {
     /**
      * An AnimationType that does not allow the Event to turn or animate.
      */
-    FixedGraphic(false, false);
+    FixedGraphic(false, false),
+    /**
+     * An AnimationType that is identical to CommonWithoutStepping except that
+     * it causes the Event in question to continually rotate counterclockwise.
+     */
+    TurnLeft(true, true)
+    {
+        Interval in = Interval.createTickInterval(2);
+        
+        @Override
+        public void tick(PossibleEvent pe)
+        {
+            if (in.isElapsed())
+            {
+                pe.setDirection(pe.getDirection().left());
+            }
+        }
+    },
+    /**
+     * An AnimationType that is identical to CommonWithoutStepping except that
+     * it causes the Event in question to continually rotate clockwise.
+     */
+    TurnRight(true, true)
+    {
+        Interval in = Interval.createTickInterval(2);
+        
+        @Override
+        public void tick(PossibleEvent pe)
+        {
+            if (in.isElapsed())
+            {
+                pe.setDirection(pe.getDirection().right());
+            }
+        }
+    };
     
-    private boolean canTurn;
-    private boolean canStep;
+    private final boolean canTurn;
+    private final boolean canStep;
     private AnimationType(boolean canTurn, boolean canStep)
     {
         this.canTurn = canTurn;
@@ -132,4 +132,11 @@ public class LayerEvent extends AbstractEvent implements Event {
         return getPossibleEvent().getAnimationStep();
     }
     
+    @Override
+    public void setMoving(boolean moving)
+    {
+        super.setMoving(moving);
+        getPossibleEvent().setMoving(moving);
+    }
+    
 }
\ No newline at end of file
@@ -119,6 +119,12 @@ public class PossibleEvent {
         return movement;
     }
 
+    private boolean moving = false;
+    void setMoving(boolean moving)
+    {
+        this.moving = moving;
+    }
+    
     Direction getDirection()
     {
         return direction;
@@ -126,7 +132,7 @@ public class PossibleEvent {
 
     void setDirection(Direction direction)
     {
-        if (animation.canTurn())
+        if (animation.canTurn() && !moving)
         {
             this.direction = direction;
             graphic.setDirection(direction);