Added tick-processing to AnimationType

AnimationType is designed to assert some control over a PossibleEvent's Direction and AnimationStep. Previously, it could only allow or disallow the changing of one or both of those fields. Now, certain AnimationTypes (specifically CommonWithStepping, TurnLeft and TurnRight) can modify those fields as well every tick.

2 files changed, 29 insertions, 33 deletions

@@ -5,6 +5,8 @@
 
 package com.fourisland.fourpuzzle.gamestate.mapview.event;
 
+import com.fourisland.fourpuzzle.util.Interval;
+
 /**
  *
  * @author hatkirby
@@ -14,35 +16,44 @@ public enum AnimationType {
      * 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),
+    CommonWithoutStepping(true, true),
     /**
      * An AnimationType which allows the Event to turn and to animate. It will
      * animate at all times, even while stationary.
      */
-    CommonWithStepping(true, true, true),
+    CommonWithStepping(true, true)
+    {
+        Interval in = Interval.createTickInterval(2);
+        
+        @Override
+        public void tick(PossibleEvent pe)
+        {
+            if (in.isElapsed())
+            {
+                if (pe.getAnimationStep() == 0)
+                {
+                    pe.setAnimationStep(2);
+                } else {
+                    pe.setAnimationStep(pe.getAnimationStep()-1);
+                }
+            }
+        }
+    },
     /**
      * An AnimationType that allows the Event to turn, but not to animate.
      */
-    WithoutStepping(true, false, false),
+    WithoutStepping(true, false),
     /**
      * An AnimationType that does not allow the Event to turn or animate.
      */
-    FixedGraphic(false, false, false);
+    FixedGraphic(false, false);
     
     private boolean canTurn;
     private boolean canStep;
-    private boolean alwaysStepping;
-    private AnimationType(boolean canTurn, boolean canStep, boolean alwaysStepping)
+    private AnimationType(boolean canTurn, boolean canStep)
     {
         this.canTurn = canTurn;
         this.canStep = canStep;
-
-        if (!canStep)
-        {
-            this.alwaysStepping = false;
-        } else {
-            this.alwaysStepping = alwaysStepping;
-        }
     }
     
     public boolean canTurn()
@@ -55,9 +66,9 @@ public enum AnimationType {
         return canStep;
     }
     
-    public boolean isAlwaysStepping()
+    public void tick(PossibleEvent pe)
     {
-        return alwaysStepping;
+        // Do nothing
     }
 
-}
+}
\ No newline at end of file
@@ -97,25 +97,10 @@ public class PossibleEvent {
         callback = builder.callback;
     }
 
-    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;
-            }
-        }
+        animation.tick(this);
+        
         return graphic;
     }