Engine: Added ShakeScreen() special action

Also implemented F12 to return to the title screen and added a move frequency variable to events that decides how often they move.

11 files changed, 256 insertions, 8 deletions

@@ -5,6 +5,7 @@
 package com.fourisland.fourpuzzle;
 
 import com.fourisland.fourpuzzle.database.Database;
+import com.fourisland.fourpuzzle.database.Transitions;
 import com.fourisland.fourpuzzle.database.Vocabulary;
 import com.fourisland.fourpuzzle.gamestate.TitleScreenGameState;
 import com.fourisland.fourpuzzle.util.Interval;
@@ -104,6 +105,14 @@ public class PuzzleApplication extends Application {
                     {
                         debugSpeed = true;
                     }
+                } else if (e.getKeyCode() == KeyEvent.VK_F12)
+                {
+                    try {
+                        /* If the user presses F12, return to the title screen */
+                        Display.transition(Database.getTransition(Transitions.Generic), new TitleScreenGameState(), false);
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                    }
                 } else {
                     // If anything else is pressed, let the GameState handle it
                     KeyboardInput.getKey().keyInput(e);
@@ -25,6 +25,7 @@ import com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove.MoveEventTh
 import com.fourisland.fourpuzzle.gamestate.mapview.viewpoint.AutomaticViewpoint;
 import com.fourisland.fourpuzzle.gamestate.mapview.viewpoint.Viewpoint;
 import com.fourisland.fourpuzzle.gamestate.menu.MenuGameState;
+import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.event.KeyEvent;
 import java.awt.image.BufferedImage;
@@ -260,6 +261,11 @@ public class MapViewGameState implements GameState {
         int x = currentViewpoint.getX();
         int y = currentViewpoint.getY();
         
+        /* Fill the background with black so specialized viewpoints that go off
+         * the screen such as ShakingViewpoint render properly */
+        g.setColor(Color.BLACK);
+        g.fillRect(0, 0, Game.WIDTH, Game.HEIGHT);
+        
         // Render the lower layer of the map
         g.drawImage(currentMap.renderLower(), 0, 0, Game.WIDTH, Game.HEIGHT, x, y, x+Game.WIDTH, y+Game.HEIGHT, null);
 
@@ -218,4 +218,15 @@ public abstract class AbstractEvent implements Event {
     {
         return moveSpeed;
     }
+    
+    private MoveFrequency freq;
+    public void setFrequency(MoveFrequency freq)
+    {
+        this.freq = freq;
+    }
+    
+    public MoveFrequency getFrequency()
+    {
+        return freq;
+    }
 }
@@ -51,4 +51,7 @@ public interface Event {
     
     public void setMoveSpeed(MoveSpeed moveSpeed);
     public MoveSpeed getMoveSpeed();
+    
+    public void setFrequency(MoveFrequency freq);
+    public MoveFrequency getFrequency();
 }
@@ -25,6 +25,7 @@ public class HeroEvent extends AbstractEvent implements Event {
     {
         setLocation(new Point());
         setMoveSpeed(MoveSpeed.Faster);
+        setFrequency(MoveFrequency.EIGHT);
     }
     
     public String getLabel()
@@ -12,6 +12,7 @@ import com.fourisland.fourpuzzle.Direction;
 import com.fourisland.fourpuzzle.gamestate.mapview.event.graphic.BlankEventGraphic;
 import com.fourisland.fourpuzzle.gamestate.mapview.event.graphic.MoveableEventGraphic;
 import com.fourisland.fourpuzzle.gamestate.mapview.event.precondition.Precondition;
+import com.fourisland.fourpuzzle.util.PauseTimer;
 
 /**
  *
@@ -97,15 +98,21 @@ public class LayerEvent extends AbstractEvent implements Event {
         }
     }
     
+    PauseTimer pt = new PauseTimer(0);
     public void startMoving()
     {
-        Direction toMove = getPossibleEvent().getMovement().nextMovement(new ImmutableEvent(this));
-        
-        if (toMove != null)
+        if (pt.isElapsed())
         {
-            if (getPossibleEvent().getGraphic() instanceof MoveableEventGraphic)
+            pt.setTimer(getFrequency().getFrequency()-1);
+            
+            Direction toMove = getPossibleEvent().getMovement().nextMovement(new ImmutableEvent(this));
+        
+            if (toMove != null)
             {
-                startMoving(toMove);
+                if (getPossibleEvent().getGraphic() instanceof MoveableEventGraphic)
+                {
+                    startMoving(toMove);
+                }
             }
         }
     }
@@ -169,4 +176,16 @@ public class LayerEvent extends AbstractEvent implements Event {
         return getPossibleEvent().getMoveSpeed();
     }
     
+    @Override
+    public void setFrequency(MoveFrequency freq)
+    {
+        getPossibleEvent().setFrequency(freq);
+    }
+    
+    @Override
+    public MoveFrequency getFrequency()
+    {
+        return getPossibleEvent().getFrequency();
+    }
+    
 }
\ No newline at end of file
@@ -0,0 +1,34 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+/**
+ *
+ * @author hatkirby
+ */
+public enum MoveFrequency {
+    
+    EIGHT(1),
+    SEVEN(2),
+    SIX(3),
+    FIVE(4),
+    FOUR(5),
+    THREE(6),
+    TWO(7),
+    ONE(8);
+    
+    private int freq;
+    private MoveFrequency(int freq)
+    {
+        this.freq = freq;
+    }
+    
+    public int getFrequency()
+    {
+        return freq;
+    }
+
+}
@@ -25,6 +25,7 @@ public class PossibleEvent {
     private AnimationType animation;
     private MovementType movement;
     private MoveSpeed moveSpeed;
+    private MoveFrequency freq;
     private EventCallTime calltime;
     private EventCall callback;
     
@@ -44,6 +45,7 @@ public class PossibleEvent {
         private AnimationType animation = AnimationType.CommonWithoutStepping;
         private MovementType movement = new StayStillMovementType();
         private MoveSpeed moveSpeed = MoveSpeed.Normal;
+        private MoveFrequency freq = MoveFrequency.EIGHT;
         private EventCallTime calltime = EventCallTime.PushKey;
         private EventCall callback = EventCall.getEmptyEventCall();
         
@@ -77,6 +79,12 @@ public class PossibleEvent {
             return this;
         }
         
+        public Builder freq(MoveFrequency freq)
+        {
+            this.freq = freq;
+            return this;
+        }
+        
         public Builder calltime(EventCallTime calltime)
         {
             this.calltime = calltime;
@@ -102,6 +110,7 @@ public class PossibleEvent {
         animation = builder.animation;
         movement = builder.movement;
         moveSpeed = builder.moveSpeed;
+        freq = builder.freq;
         calltime = builder.calltime;
         callback = builder.callback;
     }
@@ -114,6 +123,7 @@ public class PossibleEvent {
                 .animation(animation)
                 .movement(movement)
                 .speed(moveSpeed)
+                .freq(freq)
                 .calltime(calltime)
                 .callback(callback)
                 .build();
@@ -154,6 +164,16 @@ public class PossibleEvent {
     {
         return moveSpeed;
     }
+    
+    void setFrequency(MoveFrequency freq)
+    {
+        this.freq = freq;
+    }
+    
+    public MoveFrequency getFrequency()
+    {
+        return freq;
+    }
 
     private boolean moving = false;
     void setMoving(boolean moving)
@@ -16,6 +16,8 @@ import com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove.MoveEventTh
 import com.fourisland.fourpuzzle.gamestate.mapview.viewpoint.AutomaticViewpoint;
 import com.fourisland.fourpuzzle.gamestate.mapview.viewpoint.FixedViewpoint;
 import com.fourisland.fourpuzzle.gamestate.mapview.viewpoint.MovingViewpoint;
+import com.fourisland.fourpuzzle.gamestate.mapview.viewpoint.ShakingViewpoint;
+import com.fourisland.fourpuzzle.gamestate.mapview.viewpoint.ShakingViewpoint.ShakeSpeed;
 import com.fourisland.fourpuzzle.gamestate.mapview.viewpoint.Viewpoint;
 import com.fourisland.fourpuzzle.transition.InTransition;
 import com.fourisland.fourpuzzle.transition.OutTransition;
@@ -366,4 +368,52 @@ public class SpecialEvent {
         throw new InterruptedException();
     }
     
+    /**
+     * Shake the screen like an earthquake
+     * 
+     * @param speed How fast the screen should shake
+     * @param length The amount of time (in milliseconds) the shaking should
+     * last
+     * @param block If true, the game will wait for the shaking to complete
+     * before executing any more commands
+     * @throws java.lang.InterruptedException
+     */
+    public void ShakeScreen(ShakeSpeed speed, int length, final boolean block) throws InterruptedException
+    {
+        Viewpoint viewpoint = mapView.getViewpoint();
+        final CountDownLatch blocker;
+        
+        if (block)
+        {
+            blocker = new CountDownLatch(1);
+        } else {
+            blocker = null;
+        }
+            
+        mapView.setViewpoint(new ShakingViewpoint(viewpoint.getX(), viewpoint.getY(), speed, length, new Runnable() {
+            public void run()
+            {
+                if (block)
+                {
+                    blocker.countDown();
+                } else {
+                    ResetViewpoint();
+                }
+            }
+        }));
+        
+        if (block)
+        {
+            try
+            {
+                blocker.await();
+            } catch (InterruptedException ex)
+            {
+                throw ex;
+            } finally {
+                ResetViewpoint();
+            }
+        }
+    }
+    
 }
@@ -0,0 +1,95 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.viewpoint;
+
+import com.fourisland.fourpuzzle.util.Interval;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class ShakingViewpoint implements Viewpoint {
+    
+    int sx;
+    int length;
+    int x;
+    int y;
+    ShakeSpeed speed;
+    Interval in;
+    Runnable callback;
+    boolean back = false;
+    long start;
+    public ShakingViewpoint(int x, int y, ShakeSpeed speed, int length, Runnable callback)
+    {
+        this.sx = x;
+        this.length = length;
+        this.x = x;
+        this.y = y;
+        this.in = Interval.createMillisInterval(1000 / speed.getSpeed());
+        this.speed = speed;
+        this.callback = callback;
+        this.start = System.currentTimeMillis();
+    }
+    
+    private void refresh()
+    {
+        if (back)
+        {
+            x -= speed.getSpeed();
+            
+            if (x < sx - 16)
+            {
+                back = false;
+            }
+        } else {
+            x += speed.getSpeed();
+            
+            if (x > sx + 16)
+            {
+                back = true;
+            }
+        }
+        
+        if (start + length <= System.currentTimeMillis())
+        {
+            callback.run();
+        }
+    }
+
+    public int getX()
+    {
+        if (in.isElapsed())
+        {
+            refresh();
+        }
+        
+        return x;
+    }
+
+    public int getY()
+    {
+        return y;
+    }
+    
+    public static enum ShakeSpeed
+    {
+        Slow(16),
+        Medium(24),
+        Fast(32);
+        
+        private int speed;
+        private ShakeSpeed(int speed)
+        {
+            this.speed = speed;
+        }
+        
+        public int getSpeed()
+        {
+            return speed;
+        }
+    }
+
+}
@@ -22,12 +22,12 @@ public class Interval {
     
     public static Interval createTickInterval(float ticks)
     {
-        return createMillisInterval((int) (Game.FPS * ticks));
+        return createMillisInterval(Game.FPS * ticks);
     }
     
-    public static Interval createMillisInterval(int millis)
+    public static Interval createMillisInterval(float millis)
     {
-        return new Interval(millis*1000000);
+        return new Interval((int) (millis*1000000));
     }
     
     private long last = System.nanoTime();