5 files changed, 92 insertions, 41 deletions

@@ -13,5 +13,22 @@ public enum Direction {
     North,
     East,
     South,
-    West
+    West;
+    
+    /**
+     * Returns the direction opposite from the current one
+     * @return A Direction representing the opposite 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;
+    }
 }
@@ -134,7 +134,7 @@ public class MapViewGameState implements GameState {
                             {
                                 if (Functions.isFacing(hero, ev))
                                 {
-                                    ev.setDirection(Functions.oppositeDirection(hero.getDirection()));
+                                    ev.setDirection(hero.getDirection().oppositeDirection());
                                     ev.getCallback().activate(ev.getCalltime());
                                 }
                             } else {
@@ -10,10 +10,54 @@ package com.fourisland.fourpuzzle.gamestate.mapview.event;
  * @author hatkirby
  */
 public enum AnimationType {
-    CommonWithoutStepping,
-    CommonWithStepping,
-    WithoutStepping,
-    FixedGraphic,
-    TurnLeft,
-    TurnRight
+    /**
+     * The default AnimationType, it allows the Event to turn and to animate
+     * while it walks, but it only animates while it moves.
+     */
+    CommonWithoutStepping(true, true, false),
+    /**
+     * An AnimationType which allows the Event to turn and to animate. It will
+     * animate at all times, even while stationary.
+     */
+    CommonWithStepping(true, true, true),
+    /**
+     * An AnimationType that allows the Event to turn, but not to animate.
+     */
+    WithoutStepping(true, false, false),
+    /**
+     * An AnimationType that does not allow the Event to turn or animate.
+     */
+    FixedGraphic(false, false, false);
+    
+    private boolean canTurn;
+    private boolean canStep;
+    private boolean alwaysStepping;
+    private AnimationType(boolean canTurn, boolean canStep, boolean alwaysStepping)
+    {
+        this.canTurn = canTurn;
+        this.canStep = canStep;
+
+        if (!canStep)
+        {
+            this.alwaysStepping = false;
+        } else {
+            this.alwaysStepping = alwaysStepping;
+        }
+    }
+    
+    public boolean canTurn()
+    {
+        return canTurn;
+    }
+    
+    public boolean canStep()
+    {
+        return canStep;
+    }
+    
+    public boolean isAlwaysStepping()
+    {
+        return alwaysStepping;
+    }
+
 }
@@ -13,7 +13,6 @@ import com.fourisland.fourpuzzle.gamestate.mapview.event.graphic.BlankEventGraph
 import com.fourisland.fourpuzzle.gamestate.mapview.event.graphic.EventGraphic;
 import com.fourisland.fourpuzzle.gamestate.mapview.event.movement.MovementType;
 import com.fourisland.fourpuzzle.gamestate.mapview.event.movement.StayStillMovementType;
-import com.fourisland.fourpuzzle.util.Functions;
 import java.awt.image.BufferedImage;
 
 /**
@@ -52,7 +51,24 @@ public class PossibleEvent {
         return graphic.getImage();
     }
 
+    private boolean aSLC = false;
     public EventGraphic getGraphic() {
+        if (animation.isAlwaysStepping())
+        {
+            if (aSLC)
+            {
+                aSLC = false;
+                
+                if (animationStep == 0)
+                {
+                    setAnimationStep(2);
+                } else {
+                    setAnimationStep(animationStep-1);
+                }
+            } else {
+                aSLC = true;
+            }
+        }
         return graphic;
     }
 
@@ -90,7 +106,7 @@ public class PossibleEvent {
 
     public void setDirection(Direction direction)
     {
-        if (Functions.canTurn(this))
+        if (animation.canTurn())
         {
             this.direction = direction;
             graphic.setDirection(direction);
@@ -102,8 +118,11 @@ public class PossibleEvent {
     }
 
     public void setAnimationStep(int animationStep) {
-        this.animationStep = animationStep;
-        graphic.setAnimationStep(animationStep);
+        if (animation.canStep())
+        {
+            this.animationStep = animationStep;
+            graphic.setAnimationStep(animationStep);
+        }
     }
     
     public void addPrecondition(Precondition precondition)
@@ -7,28 +7,12 @@ package com.fourisland.fourpuzzle.util;
 
 import com.fourisland.fourpuzzle.Direction;
 import com.fourisland.fourpuzzle.gamestate.mapview.event.Event;
-import com.fourisland.fourpuzzle.gamestate.mapview.event.PossibleEvent;
 
 /**
  *
  * @author hatkirby
  */
 public class Functions {
-
-    public static boolean canTurn(PossibleEvent ev)
-    {
-        switch (ev.getAnimation())
-        {
-            case CommonWithoutStepping: return true;
-            case CommonWithStepping: return true;
-            case WithoutStepping: return true;
-            case FixedGraphic: return false;
-            case TurnLeft: return false;
-            case TurnRight: return false;
-        }
-        
-        return false;
-    }
     
     public static boolean isFacing(Event ev1, Event ev2)
     {
@@ -78,18 +62,5 @@ public class Functions {
         
         return false;
     }
-    
-    public static Direction oppositeDirection(Direction dir)
-    {
-        switch (dir)
-        {
-            case North: return Direction.South;
-            case West: return Direction.East;
-            case South: return Direction.North;
-            case East: return Direction.West;
-        }
-        
-        return null;
-    }
 
 }