14 files changed, 299 insertions, 154 deletions

@@ -5,12 +5,18 @@
 
 package com.fourisland.fourpuzzle;
 
+import com.fourisland.fourpuzzle.transition.InTransition;
+import com.fourisland.fourpuzzle.transition.MultidirectionalTransition;
+import com.fourisland.fourpuzzle.transition.OutTransition;
 import com.fourisland.fourpuzzle.transition.Transition;
-import com.fourisland.fourpuzzle.transition.TransitionCallbackThread;
+import com.fourisland.fourpuzzle.transition.TransitionDirection;
+import com.fourisland.fourpuzzle.transition.TransitionUnsupportedException;
 import java.awt.Graphics2D;
 import java.awt.Image;
 import java.awt.Toolkit;
+import java.awt.image.BufferedImage;
 import java.awt.image.VolatileImage;
+import java.util.concurrent.CountDownLatch;
 import javax.swing.JDialog;
 
 /**
@@ -23,37 +29,34 @@ public class Display {
 
     public static void render(JDialog gameFrame)
     {
-        if (enabled)
-        {
-            VolatileImage vImg = gameFrame.createVolatileImage(Game.WIDTH, Game.HEIGHT);
-            render(gameFrame, vImg);
+        VolatileImage vImg = gameFrame.createVolatileImage(Game.WIDTH, Game.HEIGHT);
+        render(gameFrame, vImg);
 
-            Image img = null;
-            do
+        Image img = null;
+        do
+        {
+            int returnCode = vImg.validate(gameFrame.getGraphicsConfiguration());
+            if (returnCode == VolatileImage.IMAGE_RESTORED)
             {
-                int returnCode = vImg.validate(gameFrame.getGraphicsConfiguration());
-                if (returnCode == VolatileImage.IMAGE_RESTORED)
-                {
-                    render(gameFrame, vImg);
-                } else if (returnCode == VolatileImage.IMAGE_INCOMPATIBLE)
-                {
-                    vImg = gameFrame.createVolatileImage(Game.WIDTH, Game.HEIGHT);
-                    render(gameFrame, vImg);
-                }
+                render(gameFrame, vImg);
+            } else if (returnCode == VolatileImage.IMAGE_INCOMPATIBLE)
+            {
+                vImg = gameFrame.createVolatileImage(Game.WIDTH, Game.HEIGHT);
+                render(gameFrame, vImg);
+            }
 
-                img = vImg;
-            } while (vImg.contentsLost());
+            img = vImg;
+        } while (vImg.contentsLost());
 
-            gameFrame.getContentPane().getGraphics().drawImage(img, 0, 0, gameFrame.getContentPane().getWidth(), gameFrame.getContentPane().getHeight(), gameFrame);
-            img.flush();
-            Toolkit.getDefaultToolkit().sync();
+        gameFrame.getContentPane().getGraphics().drawImage(img, 0, 0, gameFrame.getContentPane().getWidth(), gameFrame.getContentPane().getHeight(), gameFrame);
+        img.flush();
+        Toolkit.getDefaultToolkit().sync();
 
-            if (tileAnimationFrame == 15)
-            {
-                tileAnimationFrame = 0;
-            } else {
-                tileAnimationFrame++;
-            }
+        if (tileAnimationFrame == 15)
+        {
+            tileAnimationFrame = 0;
+        } else {
+            tileAnimationFrame++;
         }
     }
 
@@ -68,38 +71,78 @@ public class Display {
         
         if (transition != null)
         {
-            transition.render(g);
+            if (transition.render(g))
+            {
+                if (startedTransition)
+                {
+                    midTransition = new BufferedImage(Game.WIDTH, Game.HEIGHT, BufferedImage.TYPE_INT_ARGB);
+                    midTransition.getGraphics().drawImage(vImg, 0, 0, null);
+                } else {
+                    midTransition = null;
+                }
+                
+                transitionWait.countDown();
+            }
         }
         
         Game.getGameState().render(g);
         g.dispose();
     }
     
-    public static void transition(Transition transition, Runnable callback)
-    {
-        setTransition(transition);
-        
-        new Thread(new TransitionCallbackThread(callback)).start();
-    }
-    
+    private static boolean startedTransition = false;
     private static Transition transition;
-    public static Transition getTransition()
-    {
-        return transition;
-    }
-    public static void setTransition(Transition transition)
+    private static CountDownLatch transitionWait;
+    private static boolean transitionRunning = false;
+    private static BufferedImage midTransition = null;
+    public static void transition(Transition transition) throws InterruptedException
     {
+        if (transition instanceof MultidirectionalTransition)
+        {
+            MultidirectionalTransition temp = (MultidirectionalTransition) transition;
+            
+            if (startedTransition && (temp.getDirection() != TransitionDirection.In))
+            {
+                throw new TransitionUnsupportedException(transition.getClass().getName(), TransitionDirection.In);
+            } else if (!startedTransition && (temp.getDirection() != TransitionDirection.Out))
+            {
+                throw new TransitionUnsupportedException(transition.getClass().getName(), TransitionDirection.Out);
+            }
+            
+            if (temp.getDirection() == TransitionDirection.In)
+            {
+                temp.setPreTransition(midTransition);
+            }
+        } else {
+            if (startedTransition && !(transition instanceof InTransition))
+            {
+                throw new TransitionUnsupportedException(transition.getClass().getName(), TransitionDirection.In);
+            } else if (!startedTransition && !(transition instanceof OutTransition))
+            {
+                throw new TransitionUnsupportedException(transition.getClass().getName(), TransitionDirection.Out);
+            }
+            
+            if (transition instanceof InTransition)
+            {
+                ((InTransition) transition).setPreTransition(midTransition);
+            }
+        }
+        
         Display.transition = transition;
+        startedTransition = !startedTransition;
+        transitionRunning = true;
+        
+        transitionWait = new CountDownLatch(1);
+        transitionWait.await();
+        
+        if (!startedTransition)
+        {
+            transitionRunning = false;
+        }
     }
     
-    private static boolean enabled = true;
-    public static boolean isEnabled()
-    {
-        return enabled;
-    }
-    public static void setEnabled(boolean aEnabled)
+    public static boolean isTransitionRunning()
     {
-        enabled = aEnabled;
+        return transitionRunning;
     }
     
 }
@@ -117,12 +117,16 @@ public class PuzzleApplication extends Application {
                         
                         if ((iTickCount > iTickTrigger) && (!gameSleep))
                         {
-                            if (Game.getKey() != null)
+                            if (!Display.isTransitionRunning())
                             {
-                                Game.getGameState().processInput();
+                                if (Game.getKey() != null)
+                                {
+                                    Game.getGameState().processInput();
+                                }
+
+                                Game.getGameState().doGameCycle();
                             }
                             
-                            Game.getGameState().doGameCycle();
                             Display.render(gameFrame);
                             
                             if (!debugSpeed)
@@ -10,11 +10,10 @@ import com.fourisland.fourpuzzle.Display;
 import com.fourisland.fourpuzzle.Game;
 import com.fourisland.fourpuzzle.SaveFile;
 import com.fourisland.fourpuzzle.transition.SquareTransition;
+import com.fourisland.fourpuzzle.transition.TransitionDirection;
 import com.fourisland.fourpuzzle.util.ObjectLoader;
 import java.awt.Graphics2D;
 import java.awt.event.KeyEvent;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 /**
  *
@@ -37,16 +36,18 @@ public class GameOverGameState implements GameState {
         if ((Game.getKey().getKeyCode() == KeyEvent.VK_ENTER) || (Game.getKey().getKeyCode() == KeyEvent.VK_SPACE))
         {
             Game.setSaveFile(new SaveFile());
-            //Display.transition(SquareTransition.class, this, new TitleScreenGameState());
-            Display.transition(new SquareTransition(true), new Runnable() {
+            
+            new Thread(new Runnable() {
                 public void run() {
                     try {
-                        Game.setGameState(new TitleScreenGameState());
-                    } catch (Exception ex) {
-                        Logger.getLogger(GameOverGameState.class.getName()).log(Level.SEVERE, null, ex);
+                        Display.transition(new SquareTransition(TransitionDirection.Out));
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
                     }
+                    
+                    Game.setGameState(new TitleScreenGameState());
                 }
-            });
+            }).start();
         }
     }
 
@@ -7,6 +7,8 @@ package com.fourisland.fourpuzzle.gamestate;
 
 import com.fourisland.fourpuzzle.*;
 import com.fourisland.fourpuzzle.gamestate.mapview.MapViewGameState;
+import com.fourisland.fourpuzzle.transition.SquareTransition;
+import com.fourisland.fourpuzzle.transition.TransitionDirection;
 import com.fourisland.fourpuzzle.util.ObjectLoader;
 import java.awt.Graphics2D;
 import java.awt.event.KeyEvent;
@@ -32,10 +34,24 @@ public class TitleScreenGameState implements GameState {
         if (Game.getKey().getKeyCode() == KeyEvent.VK_ENTER)
         {
             Game.setSaveFile(new SaveFile());
-            Game.setGameState(new MapViewGameState("TestMap", 1, 2));
-            //Game.setGameState(new SquareTransition(this, new MapViewGameState("TestMap", 0, 0)));
-            //Game.setGameState(new TransitionGameState(this, this));
-            //Game.setGameState(new GameOverGameState());
+            
+            new Thread(new Runnable() {
+                public void run() {
+                    try {
+                        Display.transition(new SquareTransition(TransitionDirection.Out));
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                    }
+                    
+                    Game.setGameState(new MapViewGameState("TestMap", 1, 2));
+                    
+                    try {
+                        Display.transition(new SquareTransition(TransitionDirection.In));
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }).start();
         }
     }
 
@@ -13,6 +13,8 @@ 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.Viewpoint;
+import com.fourisland.fourpuzzle.transition.InTransition;
+import com.fourisland.fourpuzzle.transition.OutTransition;
 import java.util.concurrent.CountDownLatch;
 
 /**
@@ -149,9 +151,33 @@ public class SpecialEvent {
         throw new UnsupportedOperationException("Not yet implemented");
     }
     
+    private boolean startedTransition = false;
+    
+    /**
+     * Displays a transition from the current map to emptiness
+     * 
+     * If this method is executed before Teleport(), Teleport() will not use
+     * the database-default out transition and instead immeditatly jump to the
+     * new map. It will also not use the database-default in transition which
+     * requires you to also execute EndTransition().
+     * 
+     * @param trans The transition to use
+     * @throws InterruptedException 
+     */
+    public void StartTransition(OutTransition trans) throws InterruptedException
+    {
+        startedTransition = true;
+        
+        Display.transition(trans);
+    }
+    
     /**
      * Moves the player to a different map
      * 
+     * If StartTransition() is executed prior to this method, then this will
+     * not preform the database-default transitions, which requires that
+     * EndTransition() is executed after this method.
+     * 
      * @param map The name of the map to move to
      * @param x The X position on the map to move to
      * @param y The Y position on the map to move to
@@ -162,6 +188,24 @@ public class SpecialEvent {
     }
     
     /**
+     * Displays a transition from the emptiness to the new map
+     * 
+     * This method is only required if you called StartTransition() before
+     * Teleport(), in which case it will display the transition. Otherwise,
+     * this action will do nothing.
+     * 
+     * @param trans
+     * @throws InterruptedException 
+     */
+    public void EndTransition(InTransition trans) throws InterruptedException
+    {
+        if (startedTransition)
+        {
+            Display.transition(trans);
+        }
+    }
+    
+    /**
      * Waits for a specified interval
      * 
      * @param wait The time to wait in milliseconds
@@ -0,0 +1,21 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.transition;
+
+import java.awt.Graphics2D;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class DoNotEraseTransition implements OutTransition {
+    
+    public boolean render(Graphics2D g)
+    {
+        return true;
+    }
+
+}
@@ -0,0 +1,18 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.transition;
+
+import java.awt.image.BufferedImage;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface InTransition extends Transition {
+    
+    public void setPreTransition(BufferedImage preTransition);
+
+}
@@ -0,0 +1,16 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.transition;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface MultidirectionalTransition extends OutTransition, InTransition {
+    
+    public TransitionDirection getDirection();
+
+}
@@ -0,0 +1,14 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.transition;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface OutTransition extends Transition {
+
+}
@@ -7,19 +7,21 @@ package com.fourisland.fourpuzzle.transition;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
 
 /**
  *
  * @author hatkirby
  */
-public class SquareTransition extends Transition {
+public class SquareTransition implements MultidirectionalTransition {
     
     private int tick;
-    public SquareTransition(boolean from)
+    private TransitionDirection direction;
+    public SquareTransition(TransitionDirection direction)
     {
-        setDirection(from);
+        this.direction = direction;
         
-        if (from)
+        if (direction == TransitionDirection.Out)
         {
             tick = 160;
         } else {
@@ -27,24 +29,36 @@ public class SquareTransition extends Transition {
         }
     }
     
-    public void render(Graphics2D g)
+    public boolean render(Graphics2D g)
     {
-        if (((!getDirection()) && (tick == 0)) || ((getDirection()) && (tick == 160)))
+        if (((direction == TransitionDirection.Out) && (tick == 0)) || ((direction == TransitionDirection.In) && (tick == 160)))
         {
-            setRunning(false);
-            return;
+            return true;
         }
         
-        if (getDirection())
+        if (direction == TransitionDirection.In)
         {
             tick+=8;
         } else {
-            tick-=8;
+            tick-=8;    
         }
         
         g.setBackground(Color.BLACK);
         g.fillRect(0, 0, 320, 240);
         g.setClip(160-tick, 140-tick, tick*2, tick*2-40);
+        
+        return false;
+    }
+
+    public TransitionDirection getDirection()
+    {
+        return direction;
+    }
+    
+    private BufferedImage preTransition;
+    public void setPreTransition(BufferedImage preTransition)
+    {
+        this.preTransition = preTransition;
     }
 
 }
@@ -11,47 +11,14 @@ import java.awt.Graphics2D;
  *
  * @author hatkirby
  */
-public abstract class Transition {
-    
-    private boolean way;
-    protected void setDirection(boolean from)
-    {
-        if ((from) && !(isFromSupported()))
-        {
-            throw new TransitionUnsupportedException(this.getClass().getSimpleName(), "From");
-        } else if ((!from) && !(isToSupported()))
-        {
-            throw new TransitionUnsupportedException(this.getClass().getSimpleName(), "To");
-        } else {
-            way = from;
-        }
-    }
-    
-    public boolean getDirection()
-    {
-        return way;
-    }
+public interface Transition {
 
-    public boolean isFromSupported()
-    {
-        return true;
-    }
-    
-    public boolean isToSupported()
-    {
-        return true;
-    }
-    
-    public abstract void render(Graphics2D g);
-    
-    private boolean running = true;
-    public boolean isRunning()
-    {
-        return running;
-    }
-    public void setRunning(boolean running)
-    {
-        this.running = running;
-    }
+    /**
+     * Render the transition to the display
+     * 
+     * @param g The graphics device to render the transition to
+     * @return If the transition has completed, true. Otherwise false.
+     */
+    public boolean render(Graphics2D g);
     
-}
+}
\ No newline at end of file
@@ -1,38 +0,0 @@
-/*
- * To change this template, choose Tools | Templates
- * and open the template in the editor.
- */
-
-package com.fourisland.fourpuzzle.transition;
-
-import com.fourisland.fourpuzzle.Display;
-
-/**
- *
- * @author hatkirby
- */
-public class TransitionCallbackThread implements Runnable {
-    
-    private Runnable callback;
-    public TransitionCallbackThread(Runnable callback)
-    {
-        this.callback = callback;
-    }
-
-    public void run()
-    {
-        while (Display.getTransition().isRunning())
-        {
-            try {
-                Thread.sleep(300);
-            } catch (InterruptedException ex) {
-                Thread.currentThread().interrupt();
-            }
-        }
-        
-        //Display.setEnabled(false);
-
-        callback.run();
-    }
-
-}
@@ -0,0 +1,15 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.transition;
+
+/**
+ *
+ * @author hatkirby
+ */
+public enum TransitionDirection {
+    In,
+    Out
+}
@@ -11,9 +11,19 @@ package com.fourisland.fourpuzzle.transition;
  */
 public class TransitionUnsupportedException extends RuntimeException {
 
-    public TransitionUnsupportedException(String className, String direction)
+    private String className;
+    private TransitionDirection direction;
+    
+    public TransitionUnsupportedException(String className, TransitionDirection direction)
+    {
+        this.className = className;
+        this.direction = direction;
+    }
+    
+    @Override
+    public String getMessage()
     {
-        super("Transition \"" + className + "\" does not support the " + direction + " direction");
+        return "Transition \"" + className + "\" does not support the " + direction.toString() + " direction";
     }
     
 }