7 files changed, 148 insertions, 13 deletions

@@ -5,6 +5,7 @@
 
 package com.fourisland.fourpuzzle.database;
 
+import com.fourisland.fourpuzzle.transition.FadeTransition;
 import com.fourisland.fourpuzzle.transition.InTransition;
 import com.fourisland.fourpuzzle.transition.MultidirectionalTransition;
 import com.fourisland.fourpuzzle.transition.OutTransition;
@@ -18,8 +19,15 @@ import com.fourisland.fourpuzzle.transition.TransitionUnsupportedException;
  * @author hatkirby
  */
 public enum Transitions {
+    TitleExit(TransitionDirection.Out, new FadeTransition(TransitionDirection.Out)),
+    TitleToMap(TransitionDirection.In, new FadeTransition(TransitionDirection.In)),
     MapExit(TransitionDirection.Out, new SquareTransition(TransitionDirection.Out)),
-    MapEnter(TransitionDirection.In, new SquareTransition(TransitionDirection.In));
+    MapEnter(TransitionDirection.In, new SquareTransition(TransitionDirection.In)),
+    MapToTitle(TransitionDirection.Out, new FadeTransition(TransitionDirection.Out)),
+    TitleEnter(TransitionDirection.In, new FadeTransition(TransitionDirection.In)),
+    MapToGameOver(TransitionDirection.Out, new FadeTransition(TransitionDirection.Out)),
+    GameOverEnter(TransitionDirection.In, new FadeTransition(TransitionDirection.In)),
+    GameOverToTitle(TransitionDirection.Out, new FadeTransition(TransitionDirection.Out));
     
     private final TransitionDirection dir;
     private Transition trans;
@@ -11,6 +11,7 @@ import com.fourisland.fourpuzzle.Display;
 import com.fourisland.fourpuzzle.Game;
 import com.fourisland.fourpuzzle.SaveFile;
 import com.fourisland.fourpuzzle.database.Music;
+import com.fourisland.fourpuzzle.database.Transitions;
 import com.fourisland.fourpuzzle.transition.SquareTransition;
 import com.fourisland.fourpuzzle.transition.TransitionDirection;
 import com.fourisland.fourpuzzle.util.ObjectLoader;
@@ -42,12 +43,18 @@ public class GameOverGameState implements GameState {
             new Thread(new Runnable() {
                 public void run() {
                     try {
-                        Display.transition(new SquareTransition(TransitionDirection.Out));
+                        Display.transition(Database.getTransition(Transitions.GameOverToTitle));
                     } catch (InterruptedException ex) {
                         Thread.currentThread().interrupt();
                     }
                     
                     Game.setGameState(new TitleScreenGameState());
+                    
+                    try {
+                        Display.transition(Database.getTransition(Transitions.TitleEnter));
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                    }
                 }
             }).start();
         }
@@ -9,10 +9,9 @@ import com.fourisland.fourpuzzle.database.Database;
 import com.fourisland.fourpuzzle.*;
 import com.fourisland.fourpuzzle.database.Music;
 import com.fourisland.fourpuzzle.database.Sound;
+import com.fourisland.fourpuzzle.database.Transitions;
 import com.fourisland.fourpuzzle.database.Vocabulary;
 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 com.fourisland.fourpuzzle.util.PauseTimer;
 import com.fourisland.fourpuzzle.window.ChoiceWindow;
@@ -59,7 +58,7 @@ public class TitleScreenGameState implements GameState {
                     new Thread(new Runnable() {
                         public void run() {
                             try {
-                                Display.transition(new SquareTransition(TransitionDirection.Out));
+                                Display.transition(Database.getTransition(Transitions.TitleExit));
                             } catch (InterruptedException ex) {
                                 Thread.currentThread().interrupt();
                             }
@@ -67,7 +66,7 @@ public class TitleScreenGameState implements GameState {
                             Game.setGameState(new MapViewGameState("TestMap", 1, 2));
 
                             try {
-                                Display.transition(new SquareTransition(TransitionDirection.In));
+                                Display.transition(Database.getTransition(Transitions.TitleToMap));
                             } catch (InterruptedException ex) {
                                 Thread.currentThread().interrupt();
                             }
@@ -81,7 +80,7 @@ public class TitleScreenGameState implements GameState {
                     new Thread(new Runnable() {
                         public void run() {
                             try {
-                                Display.transition(new SquareTransition(TransitionDirection.Out));
+                                Display.transition(Database.getTransition(Transitions.TitleExit));
                             } catch (InterruptedException ex) {
                                 Thread.currentThread().interrupt();
                             }
@@ -8,6 +8,8 @@ package com.fourisland.fourpuzzle.gamestate.mapview.event;
 import com.fourisland.fourpuzzle.database.Database;
 import com.fourisland.fourpuzzle.*;
 import com.fourisland.fourpuzzle.database.Transitions;
+import com.fourisland.fourpuzzle.gamestate.GameOverGameState;
+import com.fourisland.fourpuzzle.gamestate.TitleScreenGameState;
 import com.fourisland.fourpuzzle.gamestate.mapview.MapViewGameState;
 import com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove.MoveEvent;
 import com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove.MoveEventThread;
@@ -148,18 +150,32 @@ public class SpecialEvent {
     
     /**
      * Triggers the Game Over sequence
+     * 
+     * @throws InterruptedException
      */
-    public void GameOver()
+    public void GameOver() throws InterruptedException
     {
-        throw new UnsupportedOperationException("Not yet implemented");
+        Display.transition(Database.getTransition(Transitions.MapToGameOver));
+
+        Audio.stopMusic();
+        Game.setGameState(new GameOverGameState());
+
+        Display.transition(Database.getTransition(Transitions.GameOverEnter));
     }
     
     /**
      * Returns the player to the Title Screen
+     * 
+     * @throws InterruptedException
      */
-    public void TitleScreen()
+    public void TitleScreen() throws InterruptedException
     {
-        throw new UnsupportedOperationException("Not yet implemented");
+        Display.transition(Database.getTransition(Transitions.MapToTitle));
+
+        Audio.stopMusic();
+        Game.setGameState(new TitleScreenGameState());
+
+        Display.transition(Database.getTransition(Transitions.TitleEnter));
     }
     
     private boolean startedTransition = false;
@@ -0,0 +1,92 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.transition;
+
+import com.fourisland.fourpuzzle.Display;
+import com.fourisland.fourpuzzle.Game;
+import com.fourisland.fourpuzzle.util.PauseTimer;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class FadeTransition implements MultidirectionalTransition {
+    
+    private TransitionDirection direction;
+    public FadeTransition(TransitionDirection direction)
+    {
+        this.direction = direction;
+    }
+
+    public TransitionDirection getDirection()
+    {
+        return direction;
+    }
+
+    private int ticks = 750 / Game.FPS;
+    private PauseTimer pt = new PauseTimer(ticks);
+    public boolean render(Graphics2D g)
+    {
+        BufferedImage temp = Display.createCanvas(Game.WIDTH, Game.HEIGHT);
+        double alpha = 1.0 * pt.getTimer() / ticks * 0.75;
+
+        for (int i=0;i<Game.WIDTH;i++)
+        {
+            for (int j=0;j<Game.HEIGHT;j++)
+            {
+                if (direction == TransitionDirection.Out)
+                {
+                    temp.setRGB(i, j, combine(preTransition.getRGB(i, j), Color.BLACK.getRGB(), alpha));
+                } else if (direction == TransitionDirection.In)
+                {
+                    temp.setRGB(i, j, combine(preTransition.getRGB(i, j), postTransition.getRGB(i, j), alpha));
+                }
+            }
+        }
+        
+        g.drawImage(temp, 0, 0, null);
+        
+        if (pt.isElapsed())
+        {
+            return true;
+        }
+        
+        return false;
+    }
+    
+    public static int combine(int c1, int c2, double alpha)
+    {
+        Color co1 = new Color(c1);
+        Color co2 = new Color(c2);
+        
+        int r = (int) (alpha * co1.getRed() + (1 - alpha) * co2.getRed());
+        int g = (int) (alpha * co1.getGreen() + (1 - alpha) * co2.getGreen());
+        int b = (int) (alpha * co1.getBlue() + (1 - alpha) * co2.getBlue());
+
+        return new Color(r, g, b).getRGB();
+    }
+
+    private BufferedImage preTransition;
+    public void setPreTransition(BufferedImage preTransition)
+    {
+        this.preTransition = preTransition;
+    }
+
+    public Transition copy()
+    {
+        return new FadeTransition(direction);
+    }
+
+    private BufferedImage postTransition;
+    public void setPostTransition(BufferedImage postTransition)
+    {
+        this.postTransition = postTransition;
+    }
+
+}
@@ -86,14 +86,14 @@ public class ObjectLoader {
             }
             
             bImg.createGraphics().drawImage(bImg, 0, 0, new Color(transparencyColor, true), null);
-            
+
             addToObjectCache(imageCache, type + "/" + name, bImg);
         }
         
         return imageCache.get(type + "/" + name);
     }
     
-    public static void addToObjectCache(Map cacheMap, String name, Object object)
+    public static <T> void addToObjectCache(Map<String, T> cacheMap, String name, T object)
     {
         if (cacheMap.size() >= 100)
         {
@@ -37,5 +37,18 @@ public class PauseTimer {
     {
         this.ticks = ticks;
     }
+    
+    public int getTimer()
+    {
+        if (in.isElapsed())
+        {
+            if (ticks > 0)
+            {
+                ticks--;
+            }
+        }
+        
+        return ticks;
+    }
 
 }