Imported sources

58 files changed, 3225 insertions, 1 deletions

@@ -6,3 +6,8 @@ libs.junit_4.classpath=\
     ${base}/junit_4/junit-4.1.jar
 libs.CopyLibs.classpath=\
     ${base}/CopyLibs/org-netbeans-modules-java-j2seproject-copylibstask.jar
+libs.swing-app-framework.classpath=\
+    ${base}/swing-app-framework/appframework-1.0.3.jar:\
+    ${base}/swing-app-framework/swing-worker-1.1.jar
+libs.swing-app-framework.javadoc=\
+    ${base}/swing-app-framework/appframework-1.0.3-doc.zip
@@ -18,7 +18,8 @@ dist.javadoc.dir=${dist.dir}/javadoc
 excludes=
 includes=**
 jar.compress=false
-javac.classpath=
+javac.classpath=\
+    ${libs.swing-app-framework.classpath}
 # Space-separated list of extra javac options
 javac.compilerargs=
 javac.deprecation=false
@@ -0,0 +1,75 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle;
+
+import com.fourisland.fourpuzzle.util.ObjectLoader;
+import javax.sound.midi.MidiSystem;
+import javax.sound.midi.Sequencer;
+import javax.sound.midi.Track;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class Audio {
+
+    private static Sequencer seq;
+    
+    public static void init() throws Exception
+    {
+        seq = MidiSystem.getSequencer();
+        seq.open();
+
+        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
+            public void run() {
+                if (seq.isRunning())
+                {
+                    seq.stop();
+                }
+
+                seq.close();
+            }
+        }));
+    }
+    
+    public static void playMusic(String file) throws Exception
+    {
+        playMusic(file, true, 1F);
+    }
+    
+    public static void playMusic(String file, boolean loop) throws Exception
+    {
+        playMusic(file, loop, 1F);
+    }
+    
+    public static void playMusic(String file, boolean loop, float speed) throws Exception
+    {   
+        seq.setSequence(ObjectLoader.getMusic(file));
+
+        if (loop)
+        {
+            seq.setLoopCount(seq.LOOP_CONTINUOUSLY);
+        } else {
+            seq.setLoopCount(0);
+        }
+        
+        seq.setTempoFactor(speed);
+        
+        seq.start();
+    }
+    
+    public static void stopMusic() throws Exception
+    {
+        if (seq == null)
+        {
+            init();
+        }
+        
+        seq.stop();
+    }
+    
+}
+
@@ -0,0 +1,17 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle;
+
+/**
+ *
+ * @author hatkirby
+ */
+public enum Direction {
+    North,
+    East,
+    South,
+    West
+}
@@ -0,0 +1,105 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle;
+
+import com.fourisland.fourpuzzle.transition.Transition;
+import com.fourisland.fourpuzzle.transition.TransitionCallbackThread;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.Toolkit;
+import java.awt.image.VolatileImage;
+import javax.swing.JDialog;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class Display {
+    
+    public static int tileAnimationFrame = 0;
+
+    public static void render(JDialog gameFrame) throws Exception
+    {
+        if (enabled)
+        {
+            VolatileImage vImg = gameFrame.createVolatileImage(Game.WIDTH, Game.HEIGHT);
+            render(gameFrame, vImg);
+
+            Image img = null;
+            do
+            {
+                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);
+                }
+
+                img = vImg;
+            } while (vImg.contentsLost());
+
+            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++;
+            }
+        }
+    }
+
+    private static void render(JDialog gameFrame, VolatileImage vImg) throws Exception
+    {
+        if (vImg.validate(gameFrame.getGraphicsConfiguration()) == VolatileImage.IMAGE_INCOMPATIBLE)
+        {
+            vImg = gameFrame.createVolatileImage(Game.WIDTH, Game.HEIGHT);
+        }
+
+        Graphics2D g = vImg.createGraphics();
+        
+        if (transition != null)
+        {
+            transition.render(g);
+        }
+        
+        Game.getGameState().render(g);
+        g.dispose();
+    }
+    
+    public static void transition(Transition transition, Runnable callback)
+    {
+        setTransition(transition);
+        
+        new Thread(new TransitionCallbackThread(callback)).start();
+    }
+    
+    private static Transition transition;
+    public static Transition getTransition()
+    {
+        return transition;
+    }
+    public static void setTransition(Transition transition)
+    {
+        Display.transition = transition;
+    }
+    
+    private static boolean enabled = true;
+    public static boolean isEnabled()
+    {
+        return enabled;
+    }
+    public static void setEnabled(boolean aEnabled)
+    {
+        enabled = aEnabled;
+    }
+    
+}
@@ -0,0 +1,62 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle;
+
+import com.fourisland.fourpuzzle.gamestate.mapview.event.HeroEvent;
+import com.fourisland.fourpuzzle.gamestate.GameState;
+import java.awt.event.KeyEvent;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class Game {
+    
+    public static final int WIDTH = 320;
+    public static final int HEIGHT = 240;
+
+    private static SaveFile saveFile;
+    public static SaveFile getSaveFile()
+    {
+        return saveFile;
+    }
+    public static void setSaveFile(SaveFile saveFile)
+    {
+        Game.saveFile = saveFile;
+    }
+    
+    private static GameState gameState;
+    public static GameState getGameState()
+    {
+        return gameState;
+    }
+    public static void setGameState(GameState gameState) throws Exception
+    {
+        if (Game.gameState != null)
+        {
+            Game.gameState.deinitalize();
+        }
+        
+        Game.gameState = gameState;
+        Game.gameState.initalize();
+    }
+    
+    private static KeyEvent key;
+    public static KeyEvent getKey()
+    {
+        return key;
+    }
+    public static void setKey(KeyEvent key)
+    {
+        Game.key = key;
+    }
+    
+    public static HeroEvent getHeroEvent()
+    {
+        return getSaveFile().getHero();
+    }
+    
+}
@@ -0,0 +1,68 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class GameCharacter {
+    
+    public GameCharacter(String name)
+    {
+        this.name = name;
+    }
+    
+    private String name;
+    public String getName()
+    {
+        return name;
+    }
+    public void setName(String name)
+    {
+        this.name = name;
+    }
+    
+    private int level = 1;
+    public int getLevel() {
+        return level;
+    }
+    public void setLevel(int level)
+    {
+        this.level = level;
+    }
+    
+    private boolean inParty = false;
+    public boolean isInParty()
+    {
+        return inParty;
+    }
+    public void setInParty(boolean inParty)
+    {
+        this.inParty = inParty;
+    }
+    
+    private String graphic = "blank";
+    public String getGraphic()
+    {
+        return graphic;
+    }
+    public void setGraphic(String graphic)
+    {
+        this.graphic = graphic;
+    }
+
+    private int graphicOffset = 0;
+    public int getGraphicOffset()
+    {
+        return graphicOffset;
+    }
+    public void setGraphicOffset(int graphicOffset)
+    {
+        this.graphicOffset = graphicOffset;
+    }
+    
+}
@@ -0,0 +1,79 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle;
+
+import com.fourisland.fourpuzzle.gamestate.GameOverGameState;
+import java.util.ArrayList;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class GameCharacters implements Cloneable {
+    
+    private GameCharacters()
+    {
+    }
+    
+    public static GameCharacters INSTANCE = new GameCharacters();
+
+    public void add(GameCharacter e)
+    {
+        characters.add(e);
+    }
+
+    public GameCharacter getLeader() throws Exception
+    {
+        int i = 0;
+        for (i=0;i<characters.size();i++)
+        {
+            if (characters.get(i).isInParty())
+            {
+                return characters.get(i);
+            }
+        }
+        
+        Game.setGameState(new GameOverGameState());
+        throw new NoCharactersInPartyException();
+    }
+    public GameCharacters newInstance() throws CloneNotSupportedException
+    {
+        return (GameCharacters) clone();
+    }
+
+    private ArrayList<GameCharacter> characters = new ArrayList<GameCharacter>();
+    
+    public boolean exists(String heroName) {
+        int i=0;
+        for (i=0;i<characters.size();i++)
+        {
+            if (characters.get(i).getName().equals(heroName))
+            {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+
+    public GameCharacter get(Integer get) {
+        return characters.get(get);
+    }
+
+    public GameCharacter get(String heroName) throws NullPointerException {
+        int i=0;
+        for (i=0;i<characters.size();i++)
+        {
+            if (characters.get(i).getName().equals(heroName))
+            {
+                return characters.get(i);
+            }
+        }
+        
+        throw new NullPointerException("Could not find character \"" + heroName + "\"");
+    }
+
+}
@@ -0,0 +1,16 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle;
+
+/**
+ *
+ * @author hatkirby
+ */
+public enum Layer {
+    Above,
+    Middle,
+    Below
+}
@@ -0,0 +1,14 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class NoCharactersInPartyException extends Exception {
+
+}
@@ -0,0 +1,163 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.fourisland.fourpuzzle;
+
+import com.fourisland.fourpuzzle.gamestate.TitleScreenGameState;
+import java.awt.GraphicsEnvironment;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import org.jdesktop.application.Application;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class PuzzleApplication extends Application {
+
+    public static PuzzleApplication INSTANCE;
+    public static JDialog gameFrame;
+    public static boolean debugSpeed = false;
+    public static boolean stretchScreen = true;
+    public static boolean gameSleep = false;
+    
+    /**
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) {
+        launch(PuzzleApplication.class, args);
+    }
+
+    @Override
+    protected void startup() {
+        INSTANCE = this;
+        
+        gameFrame = new JDialog(new JFrame(), false);
+        gameFrame.setTitle("The Hat");
+        gameFrame.setSize(Game.WIDTH * 2, Game.HEIGHT * 2);
+        gameFrame.setResizable(false);
+        gameFrame.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                System.exit(0);
+            }
+
+            @Override
+            public void windowActivated(WindowEvent e) {
+                gameSleep = false;
+            }
+
+            @Override
+            public void windowDeactivated(WindowEvent e) {
+                gameSleep = true;
+            }
+        });
+        gameFrame.addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e)
+            {
+                if (e.getKeyCode() == KeyEvent.VK_F4)
+                {
+                    GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().setFullScreenWindow(gameFrame);
+                } else if (e.getKeyCode() == KeyEvent.VK_F5)
+                {
+                    stretchScreen = !stretchScreen;
+
+                    if (stretchScreen)
+                    {
+                        gameFrame.setSize(Game.WIDTH * 2, Game.HEIGHT * 2);
+                    } else {
+                        gameFrame.setSize(Game.WIDTH, Game.HEIGHT);
+                    }
+                } else if (e.getKeyCode() == KeyEvent.VK_SHIFT)
+                {
+                    if (INSTANCE.getContext().getResourceMap().getBoolean("debugMode"))
+                    {
+                        debugSpeed = true;
+                    }
+                } else {
+                    Game.setKey(e);
+                }
+            }
+            
+            @Override
+            public void keyReleased(KeyEvent e)
+            {
+                if (e.getKeyCode() == KeyEvent.VK_SHIFT)
+                {
+                    debugSpeed = false;
+                } else {
+                    e.setKeyCode(KeyEvent.VK_UNDEFINED);
+                    Game.setKey(e);
+                }
+            }
+        });
+        gameFrame.setVisible(true);
+
+        new Thread(new Runnable() {
+            public void run() {
+                try {
+                    Audio.init();
+                    Game.setGameState(new TitleScreenGameState());
+                    
+                    long iTickCount = System.currentTimeMillis();
+                    int iTickDelay = (1000 / 20); // 20 fps
+                    long iTickTrigger = iTickCount + iTickDelay;
+                    
+                    while (true)
+                    {
+                        iTickCount = System.currentTimeMillis();
+                        
+                        if ((iTickCount > iTickTrigger) && (!gameSleep))
+                        {
+                            if (Game.getKey() != null)
+                            {
+                                Game.getGameState().processInput();
+                            }
+                            
+                            Game.getGameState().doGameCycle();
+                            Display.render(gameFrame);
+                            
+                            if (!debugSpeed)
+                            {
+                                iTickTrigger = iTickCount + iTickDelay;
+                            }
+                        }
+                    }
+                } catch (Throwable ex) {
+                    JFrame errorBox = new JFrame(ex.getClass().getSimpleName());
+                    JLabel text = new JLabel();
+                    text.setText("<HTML><CENTER>I'm sorry, but " + INSTANCE.getContext().getResourceMap().getString("Application.title") +
+                            " has run into an error and been forced to quit.<BR>Your save file has not been kept. The error was:<BR><BR>" +
+                            ex.getMessage() + "</CENTER>");
+                    if (ex instanceof Error)
+                    {
+                        text.setText(text.getText() + "<P><CENTER>We have identified this problem as a serious error in the game.");
+                    }
+                    errorBox.add(text);
+                    errorBox.addWindowListener(new WindowAdapter() {
+                        @Override
+                        public void windowClosing(WindowEvent e) {
+                            System.exit(0);
+                        }
+                    });
+                    errorBox.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+                    errorBox.pack();
+                    errorBox.setVisible(true);
+                    ex.printStackTrace();
+                }
+            }
+        },"GameCycle").start();
+    }
+    
+    public String getGamePackage()
+    {
+        return INSTANCE.getContext().getResourceMap().getString("Application.package");
+    }
+}
@@ -0,0 +1,97 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.fourisland.fourpuzzle;
+
+import com.fourisland.fourpuzzle.gamestate.mapview.event.HeroEvent;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.io.Serializable;
+import java.util.HashMap;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class SaveFile implements Serializable {
+    
+    /**
+     * Creates a new SaveFile
+     * @throws java.lang.CloneNotSupportedException
+     */
+    public SaveFile() throws CloneNotSupportedException
+    {
+        switches = new HashMap<String, Boolean>();
+        party = GameCharacters.INSTANCE.newInstance();
+        variables = new HashMap<String, Integer>();
+        currentMap = new String();
+        hero = new HeroEvent();
+    }
+    
+    /**
+     * Loads a SaveFile
+     * @param file The ID of the SaveFile to load
+     * @throws java.io.IOException
+     * @throws java.lang.ClassNotFoundException
+     */
+    public SaveFile(int file) throws IOException, ClassNotFoundException
+    {
+        InputStream is = PuzzleApplication.INSTANCE.getContext().getLocalStorage().openInputFile("Save" + file + ".sav");
+        ObjectInputStream ois = new ObjectInputStream(is);
+        SaveFile temp = (SaveFile) ois.readObject();
+        
+        switches = temp.getSwitches();
+        variables = temp.getVariables();
+        party = temp.getParty();
+        currentMap = temp.getCurrentMap();
+        
+        ois.close();
+    }
+    
+    public void saveGame(int file) throws IOException
+    {
+        OutputStream os = PuzzleApplication.INSTANCE.getContext().getLocalStorage().openOutputFile("Save" + file + ".sav");
+        ObjectOutputStream oos = new ObjectOutputStream(os);
+        oos.writeObject(this);
+        oos.close();
+    }
+
+    private HashMap<String, Boolean> switches;
+    public HashMap<String, Boolean> getSwitches() {
+        return switches;
+    }
+    
+    private GameCharacters party;
+    public GameCharacters getParty() {
+        return party;
+    }
+    
+    private HashMap<String, Integer> variables;
+    public HashMap<String, Integer> getVariables() {
+        return variables;
+    }
+    
+    private String currentMap;
+    public String getCurrentMap()
+    {
+        return currentMap;
+    }
+    public void setCurrentMap(String currentMap)
+    {
+        this.currentMap = currentMap;
+    }
+    
+    private HeroEvent hero;
+    public HeroEvent getHero()
+    {
+        return hero;
+    }
+    public void setHero(HeroEvent hero)
+    {
+        this.hero = hero;
+    }
+}
@@ -0,0 +1,60 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate;
+
+import com.fourisland.fourpuzzle.Audio;
+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.util.ObjectLoader;
+import java.awt.Graphics2D;
+import java.awt.event.KeyEvent;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class GameOverGameState implements GameState {
+    
+    public void initalize() throws Exception
+    {
+        Audio.playMusic("GameOver");
+    }
+    
+    public void deinitalize() throws Exception
+    {
+        Audio.stopMusic();
+    }
+
+    public void processInput() throws Exception {
+        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() {
+                public void run() {
+                    try {
+                        Game.setGameState(new TitleScreenGameState());
+                    } catch (Exception ex) {
+                        Logger.getLogger(GameOverGameState.class.getName()).log(Level.SEVERE, null, ex);
+                    }
+                }
+            });
+        }
+    }
+
+    public void doGameCycle() throws Exception {
+        // Do nothing
+    }
+
+    public void render(Graphics2D g) throws Exception {
+        g.drawImage(ObjectLoader.getImage("Picture", "GameOver"), 0, 0, null);
+    }
+
+}
@@ -0,0 +1,34 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate;
+
+import java.awt.Graphics2D;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface GameState {
+    
+    public void initalize() throws Exception;
+    public void deinitalize() throws Exception;
+    
+    public void processInput() throws Exception;
+    public void doGameCycle() throws Exception;
+    public void render(Graphics2D g) throws Exception;
+    
+}
+
+/*
+    TitleScreen
+    MapView
+    Battle
+    GameOver
+    Menu
+    LoadFile
+    SaveFile
+    Transition
+*/
\ No newline at end of file
@@ -0,0 +1,49 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate;
+
+import com.fourisland.fourpuzzle.*;
+import com.fourisland.fourpuzzle.gamestate.mapview.MapViewGameState;
+import com.fourisland.fourpuzzle.util.ObjectLoader;
+import java.awt.Graphics2D;
+import java.awt.event.KeyEvent;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class TitleScreenGameState implements GameState {
+    
+    public void initalize() throws Exception
+    {
+        Audio.playMusic("Opening");
+    }
+    
+    public void deinitalize() throws Exception
+    {
+        Audio.stopMusic();
+    }
+
+    public void processInput() throws Exception {
+        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());
+        }
+    }
+
+    public void doGameCycle() throws Exception {
+        // Do nothing, yet
+    }
+
+    public void render(Graphics2D g) throws Exception {
+        g.drawImage(ObjectLoader.getImage("Picture", "Title"), 0, 0, null);
+    }
+
+}
@@ -0,0 +1,38 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview;
+
+import com.fourisland.fourpuzzle.*;
+import com.fourisland.fourpuzzle.util.ObjectLoader;
+import java.awt.image.BufferedImage;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class CharSet {
+    
+    private BufferedImage charSetImage;
+    
+    private CharSet()
+    {
+    }
+    
+    public BufferedImage getImage(int offset, Direction direction, int step)
+    {
+        int sx = ((offset % 4) * 72) + (step * 24);
+        int sy = ((offset / 4) * 128) + (direction.ordinal() * 32);
+     
+        return charSetImage.getSubimage(sx, sy, 24, 32);
+    }
+
+    public static CharSet getCharSet(String charSet) throws Exception {
+        CharSet temp = new CharSet();
+        temp.charSetImage = ObjectLoader.getImage("CharSet", charSet);
+        return temp;
+    }
+
+}
@@ -0,0 +1,50 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview;
+
+import com.fourisland.fourpuzzle.PuzzleApplication;
+import com.fourisland.fourpuzzle.util.ObjectLoader;
+import java.awt.Graphics;
+import java.awt.Image;
+import java.awt.image.BufferedImage;
+import java.util.HashMap;
+import java.util.Vector;
+
+/**
+ *
+ * @author hatkirby
+ */
+public abstract class ChipSet {
+    
+    public abstract void initalize();
+
+    private BufferedImage chipSetImage;
+    public BufferedImage getImage(int offset)
+    {
+        int sx = (offset % 8) * 16;
+        int sy = (offset / 8) * 16;
+        
+        return chipSetImage.getSubimage(sx, sy, 16, 16);
+    }
+
+    public static ChipSet getChipSet(String chipSet) throws Exception
+    {
+        Class chipSetClass = Class.forName(PuzzleApplication.INSTANCE.getGamePackage() + ".gamedata.chipset." + chipSet);
+        Object chipSetObject = chipSetClass.newInstance();
+        ChipSet temp = (ChipSet) chipSetObject;
+        temp.initalize();
+        temp.chipSetImage = ObjectLoader.getImage("ChipSet", chipSet);
+        
+        return temp;
+    }
+
+    private HashMap<Integer,ChipSetData> chipSetData = new HashMap<Integer,ChipSetData>(); //162
+    public HashMap<Integer,ChipSetData> getChipSetData()
+    {
+        return chipSetData;
+    }
+
+}
@@ -0,0 +1,83 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview;
+
+import com.fourisland.fourpuzzle.*;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class ChipSetData {
+    
+    private String terrain;
+    private Layer layer;
+    private boolean enableNorth;
+    private boolean enableWest;
+    private boolean enableSouth;
+    private boolean enableEast;
+
+    public ChipSetData(String terrain, Layer layer)
+    {
+        this.terrain = terrain;
+        this.layer = layer;
+        
+        if (layer == Layer.Middle)
+        {
+            enableNorth = false;
+            enableWest = false;
+            enableSouth = false;
+            enableEast = false;
+        } else {
+            enableNorth = true;
+            enableWest = true;
+            enableSouth = true;
+            enableEast = true;
+        }
+    }
+    
+    public ChipSetData(String terrain, boolean enableNorth, boolean enableWest, boolean enableSouth, boolean enableEast)
+    {
+        this.terrain = terrain;
+        
+        if (!enableNorth && !enableWest && !enableSouth && !enableEast)
+        {
+            layer = Layer.Middle;
+        } else {
+            layer = Layer.Below;
+        }
+        
+        this.enableNorth = enableNorth;
+        this.enableWest = enableWest;
+        this.enableSouth = enableSouth;
+        this.enableEast = enableEast;
+    }
+
+    public String getTerrain() {
+        return terrain;
+    }
+
+    public Layer getLayer() {
+        return layer;
+    }
+
+    public boolean isEnableNorth() {
+        return enableNorth;
+    }
+
+    public boolean isEnableWest() {
+        return enableWest;
+    }
+
+    public boolean isEnableSouth() {
+        return enableSouth;
+    }
+
+    public boolean isEnableEast() {
+        return enableEast;
+    }
+    
+}
@@ -0,0 +1,185 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview;
+
+import com.fourisland.fourpuzzle.*;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.LayerEvent;
+import java.awt.Dimension;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Vector;
+
+/**
+ *
+ * @author hatkirby
+ */
+public abstract class Map {
+
+    public abstract void initalize() throws Exception;
+    
+    public void initalize(Dimension size)
+    {
+        setSize(size);
+        mapData = new Vector<HashMap<Integer,Integer>>();
+    }
+    
+    private Dimension size;
+    public Dimension getSize()
+    {
+        return size;
+    }
+    public void setSize(Dimension size)
+    {
+        if ((size.width < 20) || (size.height < 15))
+        {
+            this.size = new Dimension(20,15);
+        } else {
+            this.size = size;
+        }
+    }
+    
+    private ArrayList<LayerEvent> events = new ArrayList<LayerEvent>();
+    public ArrayList<LayerEvent> getEvents()
+    {
+        return events;
+    }
+    public LayerEvent getEvent(String event)
+    {
+        int i=0;
+        for (i=0;i<events.size();i++)
+        {
+            if (events.get(i).getLabel().equals(event))
+            {
+                return events.get(i);
+            }
+        }
+        
+        return null;
+    }
+
+    public boolean checkForCollision(int x, int y, Direction toMove) throws Exception
+    {
+        if ((toMove == Direction.North) && (y == 0))
+        {
+            return true;
+        } else if ((toMove == Direction.West) && (x == 0))
+        {
+            return true;
+        } else if ((toMove == Direction.South) && (y == (size.height - 1)))
+        {
+            return true;
+        } else if ((toMove == Direction.East) && (x == (size.width - 1)))
+        {
+            return true;
+        }
+        
+        int i=0;
+        for (i=0;i<events.size();i++)
+        {
+            if (events.get(i).getLayer() == Layer.Middle)
+            {
+                if ((events.get(i).getLocation().y == (y - 1)) && (events.get(i).getLocation().x == x) && (toMove == Direction.North))
+                {
+                    return true;
+                }
+                
+                if ((events.get(i).getLocation().x == (x - 1)) && (events.get(i).getLocation().y == y) && (toMove == Direction.West))
+                {
+                    return true;
+                }
+                
+                if ((events.get(i).getLocation().y == (y + 1)) && (events.get(i).getLocation().x == x) && (toMove == Direction.South))
+                {
+                    return true;
+                }
+                
+                if ((events.get(i).getLocation().x == (x + 1)) && (events.get(i).getLocation().y == y) && (toMove == Direction.East))
+                {
+                    return true;
+                }
+            }
+        }
+        
+        if ((Game.getHeroEvent().getLocation().y == (y - 1)) && (Game.getHeroEvent().getLocation().x == x) && (toMove == Direction.North))
+        {
+            return true;
+        }
+
+        if ((Game.getHeroEvent().getLocation().x == (x - 1)) && (Game.getHeroEvent().getLocation().y == y) && (toMove == Direction.West))
+        {
+            return true;
+        }
+
+        if ((Game.getHeroEvent().getLocation().y == (y + 1)) && (Game.getHeroEvent().getLocation().x == x) && (toMove == Direction.South))
+        {
+            return true;
+        }
+
+        if ((Game.getHeroEvent().getLocation().x == (x + 1)) && (Game.getHeroEvent().getLocation().y == y) && (toMove == Direction.East))
+        {
+            return true;
+        }
+        
+        ChipSet cSI = ChipSet.getChipSet(chipSet);
+        HashMap<Integer,ChipSetData> cSID = cSI.getChipSetData();
+        for (i=0;i<getMapData().size();i++)
+        {
+            if ((toMove == Direction.North) && (!cSID.get(mapData.get(i).get(x+((y-1)*getSize().width))).isEnableSouth()))
+            {
+                return true;
+            } else if ((toMove == Direction.West) && (!cSID.get(mapData.get(i).get(x-1+(y*getSize().width))).isEnableEast()))
+            {
+                return true;
+            } else if ((toMove == Direction.South) && (!cSID.get(mapData.get(i).get(x+((y+1)*getSize().width))).isEnableNorth()))
+            {
+                return true;
+            } else if ((toMove == Direction.East) && (!cSID.get(mapData.get(i).get(x+1+(y*getSize().width))).isEnableWest()))
+            {
+                return true;
+            }
+
+            if ((toMove == Direction.North) && (!cSID.get(mapData.get(i).get(x+(y*getSize().width))).isEnableNorth()))
+            {
+                return true;
+            } else if ((toMove == Direction.West) && (!cSID.get(mapData.get(i).get(x+(y*getSize().width))).isEnableWest()))
+            {
+                return true;
+            } else if ((toMove == Direction.South) && (!cSID.get(mapData.get(i).get(x+(y*getSize().width))).isEnableSouth()))
+            {
+                return true;
+            } else if ((toMove == Direction.East) && (!cSID.get(mapData.get(i).get(x+(y*getSize().width))).isEnableEast()))
+            {
+                return true;
+            }    
+        }
+        
+        return false;
+    }
+
+    private String chipSet;
+    public String getChipSet() {
+        return chipSet;
+    }
+    public void setChipSet(String chipSet) {
+        this.chipSet = chipSet;
+    }
+
+    private Vector<HashMap<Integer,Integer>> mapData;
+    public Vector<HashMap<Integer, Integer>> getMapData() {
+        return mapData;
+    }
+    
+    private String music;
+    public String getMusic()
+    {
+        return music;
+    }
+    public void setMusic(String music)
+    {
+        this.music = music;
+    }
+    
+}
@@ -0,0 +1,226 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview;
+
+import com.fourisland.fourpuzzle.Audio;
+import com.fourisland.fourpuzzle.gamestate.*;
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.HeroEvent;
+import com.fourisland.fourpuzzle.Game;
+import com.fourisland.fourpuzzle.Layer;
+import com.fourisland.fourpuzzle.PuzzleApplication;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.EventCallTime;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.LayerEvent;
+import java.awt.Graphics2D;
+import java.awt.event.KeyEvent;
+import java.util.ArrayList;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class MapViewGameState implements GameState {
+    
+    boolean debugWalkthrough = false;
+    boolean processInput = true;
+    Map currentMap;
+    
+    public MapViewGameState(String map, int x, int y) throws Exception
+    {
+        //currentMap = ObjectLoader.getMap(map);
+        setCurrentMap(map);
+        Game.getSaveFile().getHero().setLocation(x, y);
+    }
+        
+    public void initalize() throws Exception
+    {
+        //if (!currentMap.getMusic().equals(""))
+        {
+          //  Audio.playMusic(currentMap.getMusic());
+        }
+    }
+    
+    public void deinitalize() throws Exception
+    {
+        //if (!currentMap.getMusic().equals(""))
+        {
+            Audio.stopMusic();
+        }
+    }
+
+    public void processInput() throws Exception
+    {
+        if (processInput)
+        {
+            HeroEvent hero = Game.getSaveFile().getHero();
+
+            if (Game.getKey().isControlDown() && !debugWalkthrough)
+            {
+                if (PuzzleApplication.INSTANCE.getContext().getResourceMap().getBoolean("debugMode"))
+                {
+                    debugWalkthrough = true;
+                }
+            } else {
+                debugWalkthrough = false;
+            }
+
+            if (!hero.isMoving())
+            {
+                Direction toMove = null;
+                Boolean letsMove = false;
+
+                switch (Game.getKey().getKeyCode())
+                {
+                    case KeyEvent.VK_UP:
+                        toMove = Direction.North;
+                        letsMove = true;
+                        break;
+                    case KeyEvent.VK_RIGHT:
+                        toMove = Direction.East;
+                        letsMove = true;
+                        break;
+                    case KeyEvent.VK_DOWN:
+                        toMove = Direction.South;
+                        letsMove = true;
+                        break;
+                    case KeyEvent.VK_LEFT:
+                        toMove = Direction.West;
+                        letsMove = true;
+                        break;
+                }
+
+                if (letsMove)
+                {
+                    if (debugWalkthrough || (!currentMap.checkForCollision(hero.getLocation().x, hero.getLocation().y, toMove)))
+                    {
+                        hero.startMoving(toMove);
+                    } else {
+                        hero.setDirection(toMove);
+                    }
+                }
+
+                if ((Game.getKey().getKeyCode() == KeyEvent.VK_ENTER) || (Game.getKey().getKeyCode() == KeyEvent.VK_SPACE))
+                {
+                    int i=0;
+                    for (i=0;i<currentMap.getEvents().size();i++)
+                    {
+                        LayerEvent ev = currentMap.getEvents().get(i);
+
+                        if (ev.getCalltime() == EventCallTime.PushKey)
+                        {
+                            if ((hero.getDirection() == Direction.North) && (ev.getLocation().x == hero.getLocation().x) && (ev.getLocation().y == (hero.getLocation().y - 1)))
+                            {
+                                ev.setDirection(Direction.South);
+                                ev.getCallback().run();
+                            } else if ((hero.getDirection() == Direction.West) && (ev.getLocation().x == (hero.getLocation().x - 1)) && (ev.getLocation().y == hero.getLocation().y))
+                            {
+                                ev.setDirection(Direction.East);
+                                ev.getCallback().run();
+                            } else if ((hero.getDirection() == Direction.South) && (ev.getLocation().x == hero.getLocation().x) && (ev.getLocation().y == (hero.getLocation().y + 1)))
+                            {
+                                ev.setDirection(Direction.North);
+                                ev.getCallback().run();
+                            } else if ((hero.getDirection() == Direction.East) && (ev.getLocation().x == (hero.getLocation().x + 1)) && (ev.getLocation().y == hero.getLocation().y))
+                            {
+                                ev.setDirection(Direction.West);
+                                ev.getCallback().run();
+                            }
+                        }
+                    }
+
+                    Game.getKey().setKeyCode(KeyEvent.VK_UNDEFINED);
+                }
+            }
+        }
+    }
+    
+    public void doGameCycle() throws Exception
+    {
+        HeroEvent hero = Game.getSaveFile().getHero();
+        if (hero.isMoving())
+        {
+            hero.processMoving();
+        }
+
+        int i=0;
+        for (i=0;i<currentMap.getEvents().size();i++)
+        {
+            if (!currentMap.getEvents().get(i).isMoving())
+            {
+                currentMap.getEvents().get(i).startMoving(currentMap);
+            } else {
+                currentMap.getEvents().get(i).processMoving();
+            }
+        }
+    }
+
+    public void render(Graphics2D g) throws Exception
+    {
+        ChipSet chipSet = ChipSet.getChipSet(currentMap.getChipSet());
+        int i,x,y;
+        for (i=0;i<currentMap.getMapData().size();i++)
+        {
+            for (y=0;y<currentMap.getSize().height;y++)
+            {
+                for (x=0;x<currentMap.getSize().width;x++)
+                {
+                    int tile = currentMap.getMapData().get(i).get(x+(y*currentMap.getSize().width));
+                    if (chipSet.getChipSetData().get(tile).getLayer() != Layer.Above)
+                    {
+                        g.drawImage(chipSet.getImage(tile), x*16, y*16, null);
+                    }
+                }
+            }
+        }
+/*
+        MapViewer mv = new MapViewer(currentMap, new com.alienfactory.javamappy.viewer.render.J2SE14Renderer(currentMap), Game.WIDTH, Game.HEIGHT);
+        mv.setBlockX(Game.getSaveFile().getHero().getLocation().x);
+        mv.setBlockY(Game.getSaveFile().getHero().getLocation().y);
+        mv.setPixelX((4 - Game.getSaveFile().getHero().getMoveTimer()) * 4);
+        mv.draw(g, true);*/
+        Game.getSaveFile().getHero().render(g);
+
+        ArrayList<LayerEvent> events = currentMap.getEvents();
+        for (i=0;i<events.size();i++)
+        {
+            events.get(i).render(g);
+        }
+
+        for (i=0;i<currentMap.getMapData().size();i++)
+        {
+            for (y=0;y<currentMap.getSize().height;y++)
+            {
+                for (x=0;x<currentMap.getSize().width;x++)
+                {
+                    int tile = currentMap.getMapData().get(i).get(x+(y*currentMap.getSize().width));
+                    if (chipSet.getChipSetData().get(tile).getLayer() == Layer.Above)
+                    {
+                        g.drawImage(chipSet.getImage(tile), x*16, y*16, null);
+                    }
+                }
+            }
+        }
+    }
+    
+    public void initCurrentMap(String mapName) throws Exception
+    {
+        Class mapClass = Class.forName(PuzzleApplication.INSTANCE.getGamePackage() + ".gamedata.map." + mapName);
+        Object mapObject = mapClass.newInstance();
+        Map map = (Map) mapObject;
+        map.initalize();
+        currentMap = map;
+    }
+    public void setCurrentMap(String mapName) throws Exception
+    {
+        Game.getSaveFile().setCurrentMap(mapName);
+        initCurrentMap(mapName);
+    }
+    public Map getCurrentMap()
+    {
+        return currentMap;
+    }
+
+}
@@ -0,0 +1,19 @@
+/*
+ * 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 AnimationType {
+    CommonWithoutStepping,
+    CommonWithStepping,
+    WithoutStepping,
+    FixedGraphic,
+    TurnLeft,
+    TurnRight
+}
@@ -0,0 +1,62 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+import com.fourisland.fourpuzzle.gamestate.mapview.event.precondition.Precondition;
+import java.util.ArrayList;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class CommonEvent {
+
+    private ArrayList<Precondition> preconditions;
+    private EventCallTime calltime;
+    private EventCall callback;
+    
+    public CommonEvent()
+    {
+        calltime = EventCallTime.ParallelProcess;
+        callback = EventCall.getEmptyEventCall();
+        
+        preconditions = new ArrayList<Precondition>();
+    }
+    
+    public void addPrecondition(Precondition precondition)
+    {
+        preconditions.add(precondition);
+    }
+    
+    public Precondition getPrecondition(int i)
+    {
+        return preconditions.get(i);
+    }
+    
+    public int preconditions()
+    {
+        return preconditions.size();
+    }
+
+    public EventCall getCallback()
+    {
+        return callback;
+    }
+    
+    public void setCallback(EventCall callback)
+    {
+        this.callback = callback;
+    }
+
+    public EventCallTime getCalltime() {
+        return calltime;
+    }
+
+    public void setCalltime(EventCallTime calltime) {
+        this.calltime = calltime;
+    }
+    
+}
@@ -0,0 +1,35 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.Layer;
+import java.awt.Graphics;
+import java.awt.Point;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface Event {
+    
+    public String getLabel();
+
+    public Point getLocation();
+
+    public void setLocation(Point location);
+    public void setLocation(int x, int y);
+    
+    public void render(Graphics g) throws Exception;
+    
+    public Direction getDirection() throws Exception;
+    public void setDirection(Direction direction) throws Exception;
+
+    public boolean isMoving();
+    public void startMoving(Direction direction) throws Exception;
+    
+    public Layer getLayer() throws Exception;
+}
@@ -0,0 +1,25 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+/**
+ *
+ * @author hatkirby
+ */
+public abstract class EventCall extends SpecialEvent implements Runnable {
+    
+    public static EventCall getEmptyEventCall()
+    {
+        return new EventCall() {
+            @Override
+            public void run() {
+            }
+        };
+    }
+
+    public abstract void run();
+    
+}
@@ -0,0 +1,16 @@
+/*
+ * 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 EventCallTime {
+    PushKey,
+    OnHeroTouch,
+    ParallelProcess
+}
@@ -0,0 +1,157 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+import com.fourisland.fourpuzzle.Layer;
+import java.awt.Graphics;
+import java.awt.Point;
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.Game;
+import com.fourisland.fourpuzzle.GameCharacter;
+import com.fourisland.fourpuzzle.gamestate.mapview.CharSet;
+import com.fourisland.fourpuzzle.NoCharactersInPartyException;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class HeroEvent implements Event {
+    
+    public HeroEvent()
+    {
+        location = new Point();
+    }
+    
+    public String getLabel()
+    {
+        return "Hero";
+    }
+    
+    private Point location;
+    public Point getLocation()
+    {
+        return location;
+    }
+    public void setLocation(Point location)
+    {
+        this.location = location;
+    }
+    public void setLocation(int x, int y)
+    {
+        location.setLocation(x, y);
+    }
+    
+    public void render(Graphics g) throws Exception
+    {
+        int x = (location.x * 16) - 4;
+        int y = (location.y * 16) - 16;
+        
+        if (moving)
+        {
+            if (moveDirection == Direction.North)
+            {
+                y -= (4 - moveTimer) * 4;
+            } else if (moveDirection == Direction.West)
+            {
+                x -= (4 - moveTimer) * 4;
+            } else if (moveDirection == Direction.South)
+            {
+                y += (4 - moveTimer) * 4;
+            } else if (moveDirection == Direction.East)
+            {
+                x += (4 - moveTimer) * 4;
+            }
+        }
+        
+        try
+        {
+            GameCharacter toDraw = Game.getSaveFile().getParty().getLeader();
+            if (!toDraw.getGraphic().equals("blank"))
+            {
+                g.drawImage(CharSet.getCharSet(toDraw.getGraphic()).getImage(toDraw.getGraphicOffset(), direction, animationStep), x, y, null);
+            }
+        } catch (NoCharactersInPartyException ex)
+        {
+        }
+    }
+    
+    
+    private boolean moving = false;
+    public boolean isMoving()
+    {
+        return moving;
+    }
+    public void setMoving(boolean moving)
+    {
+        this.moving = moving;
+    }
+    
+    private int moveTimer;
+    private Direction moveDirection;
+    public void startMoving(Direction toMove) throws Exception
+    {
+        setDirection(toMove);
+        setAnimationStep(2);
+        moveTimer = 4;
+        moving = true;
+        moveDirection = toMove;
+    }
+    public void processMoving() throws Exception
+    {
+        if (moving)
+        {
+            moveTimer--;
+            if (moveTimer == 2)
+            {
+                setAnimationStep(0);
+            } else if (moveTimer == 0)
+            {
+                setAnimationStep(1);
+                moving = false;
+                
+                if (moveDirection == Direction.North)
+                {
+                    setLocation(getLocation().x,getLocation().y-1);
+                } else if (moveDirection == Direction.West)
+                {
+                    setLocation(getLocation().x-1,getLocation().y);
+                } else if (moveDirection == Direction.South)
+                {
+                    setLocation(getLocation().x,getLocation().y+1);
+                } else if (moveDirection == Direction.East)
+                {
+                    setLocation(getLocation().x+1,getLocation().y);
+                }
+            }
+        }
+    }
+    
+    private Direction direction = Direction.South;
+    public Direction getDirection()
+    {
+        return direction;
+    }
+    public void setDirection(Direction direction)
+    {
+        this.direction = direction;
+    }
+
+    private int animationStep = 1;
+    public int getAnimationStep()
+    {
+        return animationStep;
+    }
+    public void setAnimationStep(int animationStep)
+    {
+        this.animationStep = animationStep;
+    }
+
+    public Layer getLayer() throws Exception
+    {
+        return Layer.Middle;
+    }
+
+}
@@ -0,0 +1,207 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+import com.fourisland.fourpuzzle.Layer;
+import java.awt.Graphics;
+import java.awt.Point;
+import java.util.ArrayList;
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.Map;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class LayerEvent implements Event {
+    
+    /** Create a new Event instance
+     * 
+     * @param x The horizontal location of the Event on the Map
+     * @param y The vertical location of the Event on the Map
+     */
+    public LayerEvent(int x, int y)
+    {
+        location = new Point(x,y);
+        events = new ArrayList<PossibleEvent>();
+    }
+    
+    /** Create a new Event instance
+     * 
+     * @param x The horizontal location of the Event on the Map
+     * @param y The vertical location of the Event on the Map
+     * @param label An identifying label for the Event
+     */
+    public LayerEvent(int x, int y, String label)
+    {
+        this(x,y);
+        this.label = label;
+    }
+    
+    private String label;
+    public String getLabel()
+    {
+        return label;
+    }
+    
+    private Point location;
+    public Point getLocation()
+    {
+        return location;
+    }
+    public void setLocation(Point location)
+    {
+        this.location = location;
+    }
+    public void setLocation(int x, int y)
+    {
+        location.setLocation(x, y);
+    }
+    
+    private ArrayList<PossibleEvent> events;
+    public void addEvent(PossibleEvent pe)
+    {
+        events.add(pe);
+    }
+    
+    private PossibleEvent getPossibleEvent() throws Exception
+    {
+        int i;
+        for (i=(events.size()-1);i>-1;i--)
+        {
+            boolean good = true;
+            int j;
+            for (j=0;j<events.get(i).preconditions();j++)
+            {
+                good = (good ? events.get(i).getPrecondition(j).match() : false);
+            }
+            
+            if (good)
+            {
+                return events.get(i);
+            }
+        }
+        
+        return new PossibleEvent();
+    }
+    
+    public void render(Graphics g) throws Exception
+    {
+        int x = (location.x * 16) - 4;
+        int y = (location.y * 16) - 16;
+        
+        if (moving)
+        {
+            if (moveDirection == Direction.North)
+            {
+                y -= (4 - moveTimer) * 4;
+            } else if (moveDirection == Direction.West)
+            {
+                x -= (4 - moveTimer) * 4;
+            } else if (moveDirection == Direction.South)
+            {
+                y += (4 - moveTimer) * 4;
+            } else if (moveDirection == Direction.East)
+            {
+                x += (4 - moveTimer) * 4;
+            }
+        }
+        
+        PossibleEvent toDraw = getPossibleEvent();
+        if (!toDraw.getGraphic().equals("blank"))
+        {
+            g.drawImage(toDraw.getImage(), x, y, null);
+        }
+    }
+    
+    
+    private boolean moving = false;
+    public boolean isMoving()
+    {
+        return moving;
+    }
+    public void setMoving(boolean moving)
+    {
+        this.moving = moving;
+    }
+    
+    private int moveTimer;
+    private Direction moveDirection;
+    public void startMoving(Map map) throws Exception
+    {
+        Direction toMove = getPossibleEvent().getMovement().startMoving();
+        
+        if (toMove != null)
+        {
+            if (!map.checkForCollision(getLocation().x, getLocation().y, toMove))
+            {
+                startMoving(toMove);
+            }
+        }
+    }
+    public void startMoving(Direction toMove) throws Exception
+    {
+        getPossibleEvent().setDirection(toMove);
+        getPossibleEvent().setAnimationStep(2);
+        moveTimer = 4;
+        moving = true;
+        moveDirection = toMove;
+    }
+    public void processMoving() throws Exception
+    {
+        if (moving)
+        {
+            moveTimer--;
+            if (moveTimer == 2)
+            {
+                getPossibleEvent().setAnimationStep(0);
+            } else if (moveTimer == 0)
+            {
+                getPossibleEvent().setAnimationStep(1);
+                moving = false;
+                
+                if (moveDirection == Direction.North)
+                {
+                    setLocation(getLocation().x,getLocation().y-1);
+                } else if (moveDirection == Direction.West)
+                {
+                    setLocation(getLocation().x-1,getLocation().y);
+                } else if (moveDirection == Direction.South)
+                {
+                    setLocation(getLocation().x,getLocation().y+1);
+                } else if (moveDirection == Direction.East)
+                {
+                    setLocation(getLocation().x+1,getLocation().y);
+                }
+            }
+        }
+    }
+    
+    public Direction getDirection() throws Exception
+    {
+        return getPossibleEvent().getDirection();
+    }
+    public void setDirection(Direction direction) throws Exception
+    {
+        getPossibleEvent().setDirection(direction);
+    }
+
+    public Layer getLayer() throws Exception
+    {
+        return getPossibleEvent().getLayer();
+    }
+    
+    public EventCallTime getCalltime() throws Exception
+    {
+        return getPossibleEvent().getCalltime();
+    }
+    
+    public EventCall getCallback() throws Exception
+    {
+        return getPossibleEvent().getCallback();
+    }
+
+}
@@ -0,0 +1,141 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+import com.fourisland.fourpuzzle.Layer;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.precondition.Precondition;
+import java.util.ArrayList;
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.graphic.BlankEventGraphic;
+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;
+
+/**
+ *w
+ * @author hatkirby
+ */
+public class PossibleEvent {
+
+    private EventGraphic graphic;
+    private Layer layer;
+    private AnimationType animation;
+    private MovementType movement;
+    private EventCallTime calltime;
+    private EventCall callback;
+    private ArrayList<Precondition> preconditions;
+    
+    private Direction direction;
+    private int animationStep;
+    
+    public PossibleEvent()
+    {   
+        graphic = new BlankEventGraphic();
+        layer = Layer.Below;
+        animation = AnimationType.CommonWithStepping;
+        movement = new StayStillMovementType();
+        calltime = EventCallTime.PushKey;
+        callback = EventCall.getEmptyEventCall();
+        preconditions = new ArrayList<Precondition>();
+        
+        direction = Direction.South;
+        animationStep = 1;
+    }
+        
+    public BufferedImage getImage() throws Exception
+    {        
+        return graphic.getImage();
+    }
+
+    public EventGraphic getGraphic() {
+        return graphic;
+    }
+
+    public void setGraphic(EventGraphic graphic) {
+        this.graphic = graphic;
+    }
+
+    public Layer getLayer() {
+        return layer;
+    }
+
+    public void setLayer(Layer layer) {
+        this.layer = layer;
+    }
+
+    public AnimationType getAnimation() {
+        return animation;
+    }
+
+    public void setAnimation(AnimationType animation) {
+        this.animation = animation;
+    }
+
+    public MovementType getMovement() {
+        return movement;
+    }
+
+    public void setMovement(MovementType movement) {
+        this.movement = movement;
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    public void setDirection(Direction direction) throws Exception {
+        if (Functions.canTurn(this))
+        {
+            this.direction = direction;
+            graphic.setDirection(direction);
+        }
+    }
+
+    public int getAnimationStep() {
+        return animationStep;
+    }
+
+    public void setAnimationStep(int animationStep) {
+        this.animationStep = animationStep;
+        graphic.setAnimationStep(animationStep);
+    }
+    
+    public void addPrecondition(Precondition precondition)
+    {
+        preconditions.add(precondition);
+    }
+    
+    public Precondition getPrecondition(int i)
+    {
+        return preconditions.get(i);
+    }
+    
+    public int preconditions()
+    {
+        return preconditions.size();
+    }
+
+    public EventCall getCallback()
+    {
+        return callback;
+    }
+    
+    public void setCallback(EventCall callback)
+    {
+        this.callback = callback;
+    }
+
+    public EventCallTime getCalltime() {
+        return calltime;
+    }
+
+    public void setCalltime(EventCallTime calltime) {
+        this.calltime = calltime;
+    }
+    
+}
@@ -0,0 +1,173 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+import com.fourisland.fourpuzzle.*;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove.MoveEvent;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove.MoveEventThread;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class SpecialEvent {
+
+    /**
+     * Display a message on the screen.
+     * 
+     * Usually used for dialogue. If SetFace() is
+     * 
+     * used prior to this, the face set is displayed
+     * on the left side.
+     * 
+     * Display of the message area can be modified using
+     * MessageDisplaySettings().
+     * 
+     * This function also automatically splits your
+     * message up into blocks that will fit on
+     * the screen (breaks at spaces). If there are too
+     * many words, they will be held and displayed in
+     * the message area after the prior message has
+     * been read.
+     * 
+     * @param message The message to display
+     */
+    public void DisplayMessage(String message)
+    {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    /**
+     * Sets the face used when displaying a message
+     * 
+     * See DisplayMessage() for more info
+     * 
+     * @param faceSet The name of the FaceSet to use
+     * @param face The number of the face in the FaceSet
+     *             to use. The faces are numbered
+     *             horizontally.
+     */
+    public void SetFace(String faceSet, int face)
+    {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+    
+    /**
+     * Clears the face used when displaying a message
+     * 
+     * See DisplayMessage() for more info
+     */
+    public void EraseFace()
+    {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+    
+    /**
+     * Sets a Switch to a [boolean] value
+     * 
+     * @param switchID The Switch to set
+     * @param value The value to set the Switch to
+     */
+    public void SetSwitch(String switchID, boolean value)
+    {
+        Game.getSaveFile().getSwitches().put(switchID, value);
+    }
+    
+    /**
+     * Toggles a Switch's [boolean] value
+     * 
+     * @param switchID The Switch to toggle
+     */
+    public void ToggleSwitch(String switchID)
+    {
+        if (Game.getSaveFile().getSwitches().containsKey(switchID))
+        {
+            Game.getSaveFile().getSwitches().put(switchID, !Game.getSaveFile().getSwitches().get(switchID));
+        } else {
+            Game.getSaveFile().getSwitches().put(switchID, true);
+        }
+    }
+    
+    /**
+     * Performs actions on the hero
+     * 
+     * @param actions An array of MoveEvents to perform on the hero
+     */
+    public void MoveEvent(MoveEvent[] actions)
+    {
+        MoveEvent(actions, Game.getHeroEvent());
+    }
+    
+    /**
+     * Performs actions on an event
+     * 
+     * @param actions An array of MoveEvents to perform on the event
+     * @param ev The event to act upon
+     */
+    public void MoveEvent(MoveEvent[] actions, Event ev)
+    {
+        new Thread(new MoveEventThread(ev, actions)).start();
+    }
+    
+    /**
+     * Waits until all previously called MoveEvent()s have finished
+     */
+    public void MoveEventWait()
+    {
+        try {
+            MoveEventThread.moveEventWait.await();
+        } catch (InterruptedException ex) {
+            Logger.getLogger(SpecialEvent.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+    
+    /**
+     * Triggers the Game Over sequence
+     * @throws Exception 
+     */
+    public void GameOver() throws Exception
+    {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+    
+    /**
+     * Returns the player to the Title Screen
+     * @throws Exception 
+     */
+    public void TitleScreen() throws Exception
+    {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+    
+    /**
+     * Moves the player to a different map
+     * 
+     * @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
+     * @throws java.lang.Exception
+     */
+    public void Teleport(String map, int x, int y) throws Exception
+    {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+    
+    /**
+     * Waits for a specified interval
+     * 
+     * @param wait The time to wait in milliseconds
+     * @throws java.lang.InterruptedException
+     */
+    public void Wait(int wait) throws InterruptedException
+    {
+        Thread.sleep(wait);
+    }
+    
+}
@@ -0,0 +1,40 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.graphic;
+
+import com.fourisland.fourpuzzle.Direction;
+import java.awt.image.BufferedImage;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class BlankEventGraphic implements EventGraphic {
+    
+    private Direction direction;
+    private int animationStep;
+
+    public BufferedImage getImage() throws Exception {
+        return null;
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    public void setDirection(Direction direction) {
+        this.direction = direction;
+    }
+
+    public int getAnimationStep() {
+        return animationStep;
+    }
+
+    public void setAnimationStep(int animationStep) {
+        this.animationStep = animationStep;
+    }
+
+}
@@ -0,0 +1,68 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.graphic;
+
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.CharSet;
+import java.awt.image.BufferedImage;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class CharSetEventGraphic implements EventGraphic {
+    
+    private Direction direction = Direction.South;
+    private int animationStep = 1;
+    private String graphic;
+    private int graphicOffset;
+    
+    public CharSetEventGraphic(String graphic, int graphicOffset)
+    {
+        this.graphic = graphic;
+        this.graphicOffset = graphicOffset;
+    }
+
+    public BufferedImage getImage() throws Exception
+    {
+        return CharSet.getCharSet(getGraphic()).getImage(getGraphicOffset(), getDirection(), getAnimationStep());
+    }
+
+    public Direction getDirection()
+    {
+        return direction;
+    }
+
+    public void setDirection(Direction direction)
+    {
+        this.direction = direction;
+    }
+
+    public String getGraphic() {
+        return graphic;
+    }
+
+    public void setGraphic(String graphic) {
+        this.graphic = graphic;
+    }
+
+    public int getGraphicOffset() {
+        return graphicOffset;
+    }
+
+    public void setGraphicOffset(int graphicOffset) {
+        this.graphicOffset = graphicOffset;
+    }
+
+    public int getAnimationStep() {
+        return animationStep;
+    }
+
+    public void setAnimationStep(int animationStep) {
+        this.animationStep = animationStep;
+    }
+
+}
@@ -0,0 +1,25 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.graphic;
+
+import com.fourisland.fourpuzzle.Direction;
+import java.awt.image.BufferedImage;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface EventGraphic {
+    
+    public BufferedImage getImage() throws Exception;
+    
+    public Direction getDirection();
+    public void setDirection(Direction direction);
+    
+    public int getAnimationStep();
+    public void setAnimationStep(int animationStep);
+
+}
@@ -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.movement;
+
+import com.fourisland.fourpuzzle.Direction;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class CustomMovementType implements MovementType {
+
+    private Direction[] moves;
+    private int step = 0;
+    
+    public CustomMovementType(Direction[] moves)
+    {
+        this.moves = moves;
+    }
+    
+    public Direction startMoving() throws Exception
+    {        
+        if (step >= moves.length)
+        {
+            step = 0;
+        }
+
+        return moves[step++];
+    }
+
+}
@@ -0,0 +1,25 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.movement;
+
+import com.fourisland.fourpuzzle.Direction;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface MovementType {
+    
+    public Direction startMoving() throws Exception;
+    
+}
+    
+/*
+    CycleUpDown
+    CycleLeftRight
+    StepTowardHero
+    StepAwayFromHero
+*/
\ No newline at end of file
@@ -0,0 +1,49 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.movement;
+
+import com.fourisland.fourpuzzle.Direction;
+import java.util.Random;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class RandomMovementType implements MovementType {
+
+    public Direction startMoving() throws Exception {
+        Random r = new Random();
+        int ra = r.nextInt(1000);
+        Direction toMove = null;
+        boolean letsMove = false;
+
+        if (ra < 25)
+        {
+            toMove = Direction.North;
+            letsMove = true;
+        } else if (ra < 50)
+        {
+            toMove = Direction.West;
+            letsMove = true;
+        } else if (ra < 75)
+        {
+            toMove = Direction.South;
+            letsMove = true;
+        } else if (ra < 100)
+        {
+            toMove = Direction.East;
+            letsMove = true;
+        }
+
+        if (letsMove)
+        {
+            return toMove;
+        }
+        
+        return null;
+    }
+
+}
@@ -0,0 +1,21 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.movement;
+
+import com.fourisland.fourpuzzle.Direction;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class StayStillMovementType implements MovementType {
+
+    public Direction startMoving() throws Exception
+    {
+        return null; // Do nothing, stay still
+    }
+    
+}
@@ -0,0 +1,27 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.precondition;
+
+import com.fourisland.fourpuzzle.Game;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class HeroInPartyPrecondition implements Precondition {
+
+    private String heroName;
+    
+    public HeroInPartyPrecondition(String heroName)
+    {
+        this.heroName = heroName;
+    }
+    
+    public boolean match() {
+        return Game.getSaveFile().getParty().exists(heroName);
+    }
+    
+}
@@ -0,0 +1,29 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.precondition;
+
+import com.fourisland.fourpuzzle.Game;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class HeroLevelPrecondition implements Precondition {
+
+    private String heroName;
+    private int level;
+    
+    public HeroLevelPrecondition(String heroName, int level)
+    {
+        this.heroName = heroName;
+        this.level = level;
+    }
+    
+    public boolean match() throws Exception {
+        return (Game.getSaveFile().getParty().exists(heroName) && (Game.getSaveFile().getParty().get(heroName).getLevel() == level));
+    }
+    
+}
@@ -0,0 +1,16 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.precondition;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface Precondition {
+
+    public boolean match() throws Exception;
+    
+}
@@ -0,0 +1,27 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.precondition;
+
+import com.fourisland.fourpuzzle.Game;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class SwitchPrecondition implements Precondition {
+    
+    private String switchID;
+    
+    public SwitchPrecondition(String switchID)
+    {
+        this.switchID = switchID;
+    }
+    
+    public boolean match() {
+        return (Game.getSaveFile().getSwitches().containsKey(switchID) && Game.getSaveFile().getSwitches().get(switchID));
+    }
+
+}
@@ -0,0 +1,45 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.precondition;
+
+import com.fourisland.fourpuzzle.util.Comparison;
+import com.fourisland.fourpuzzle.Game;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class VariableNumberPrecondition implements Precondition {
+    
+    private String variableID;
+    private Comparison comparison;
+    private int number;
+    
+    public VariableNumberPrecondition(String variableID, Comparison comparison, int number)
+    {
+        this.variableID = variableID;
+        this.comparison = comparison;
+        this.number = number;
+    }
+    
+    public boolean match() {
+        if (Game.getSaveFile().getVariables().containsKey(variableID))
+        {
+            int n1 = Game.getSaveFile().getVariables().get(variableID);
+            int n2 = number;
+            
+            switch (comparison)
+            {
+                case Less: return (n1 < n2);
+                case Greater: return (n1 > n2);
+                case Equal: return (n1 == n2);
+            }
+        }
+        
+        return false;
+    }
+
+}
@@ -0,0 +1,45 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.precondition;
+
+import com.fourisland.fourpuzzle.util.Comparison;
+import com.fourisland.fourpuzzle.Game;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class VariableVariablePrecondition implements Precondition {
+    
+    private String variableID;
+    private Comparison comparison;
+    private String variableID2;
+    
+    public VariableVariablePrecondition(String variableID, Comparison comparison, String variableID2)
+    {
+        this.variableID = variableID;
+        this.comparison = comparison;
+        this.variableID2 = variableID2;
+    }
+    
+    public boolean match() {
+        if (Game.getSaveFile().getVariables().containsKey(variableID))
+        {
+            int n1 = Game.getSaveFile().getVariables().get(variableID);
+            int n2 = Game.getSaveFile().getVariables().get(variableID2);
+            
+            switch (comparison)
+            {
+                case Less: return (n1 < n2);
+                case Greater: return (n1 > n2);
+                case Equal: return (n1 == n2);
+            }
+        }
+        
+        return false;
+    }
+
+}
@@ -0,0 +1,28 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove;
+
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.Event;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class FaceMoveEvent implements MoveEvent {
+
+    Direction direction;
+    public FaceMoveEvent(Direction direction)
+    {
+        this.direction = direction;
+    }
+    
+    public void doAction(Event ev) throws Exception
+    {
+        ev.setDirection(direction);
+    }
+
+}
@@ -0,0 +1,19 @@
+
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove;
+
+import com.fourisland.fourpuzzle.gamestate.mapview.event.Event;
+
+/**
+ *
+ * @author hatkirby
+ */
+public interface MoveEvent {
+
+    public void doAction(Event ev) throws Exception;
+    
+}
@@ -0,0 +1,50 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove;
+
+import com.fourisland.fourpuzzle.gamestate.mapview.event.Event;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CyclicBarrier;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class MoveEventThread implements Runnable {
+    
+    public static volatile CountDownLatch moveEventWait = new CountDownLatch(0);
+    public static volatile int countMoveEventThreads = 0;
+    
+    Event ev;
+    MoveEvent[] actions;
+    
+    public MoveEventThread(Event ev, MoveEvent[] actions)
+    {
+        this.ev = ev;
+        this.actions = actions;
+    }
+
+    public void run() {
+        MoveEventThread.countMoveEventThreads++;
+        moveEventWait = new CountDownLatch(countMoveEventThreads);
+        
+        int i=0;
+        for (i=0;i<actions.length;i++)
+        {
+            try {
+                actions[i].doAction(ev);
+            } catch (Exception ex) {
+                Logger.getLogger(MoveEventThread.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        }
+        
+        MoveEventThread.countMoveEventThreads--;
+        moveEventWait.countDown();
+    }
+
+}
@@ -0,0 +1,33 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove;
+
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.Event;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class StepMoveEvent implements MoveEvent {
+
+    Direction direction;
+    public StepMoveEvent(Direction direction)
+    {
+        this.direction = direction;
+    }
+    
+    public void doAction(Event ev) throws Exception
+    {
+        ev.startMoving(direction);
+
+        while (ev.isMoving())
+        {
+            Thread.sleep(2);
+        }
+    }
+
+}
@@ -0,0 +1,27 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.specialmove;
+
+import com.fourisland.fourpuzzle.gamestate.mapview.event.Event;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class WaitMoveEvent implements MoveEvent {
+
+    int wait;
+    public WaitMoveEvent(int wait)
+    {
+        this.wait = wait;
+    }
+    
+    public void doAction(Event ev) throws Exception
+    {
+        Thread.sleep(wait);
+    }
+
+}
@@ -0,0 +1,50 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.transition;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class SquareTransition extends Transition {
+    
+    private int tick;
+    public SquareTransition(boolean from) throws TransitionUnsupportedException
+    {
+        setDirection(from);
+        
+        if (from)
+        {
+            tick = 160;
+        } else {
+            tick = 0;
+        }
+    }
+    
+    public void render(Graphics2D g)
+    {
+        if (((!getDirection()) && (tick == 0)) || ((getDirection()) && (tick == 160)))
+        {
+            setRunning(false);
+            return;
+        }
+        
+        if (getDirection())
+        {
+            tick+=8;
+        } else {
+            tick-=8;
+        }
+        
+        g.setBackground(Color.BLACK);
+        g.fillRect(0, 0, 320, 240);
+        g.setClip(160-tick, 140-tick, tick*2, tick*2-40);
+    }
+
+}
@@ -0,0 +1,56 @@
+/*
+ * 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 abstract class Transition {
+    
+    private boolean way;
+    protected void setDirection(boolean from) throws TransitionUnsupportedException
+    {
+        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 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;
+    }
+    
+}
@@ -0,0 +1,40 @@
+/*
+ * 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 java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * @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) {
+                Logger.getLogger(TransitionCallbackThread.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        }
+        
+        //Display.setEnabled(false);
+
+        callback.run();
+    }
+
+}
@@ -0,0 +1,19 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.transition;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class TransitionUnsupportedException extends Exception {
+
+    public TransitionUnsupportedException(String className, String direction)
+    {
+        super("Transition \"" + className + "\" does not support the " + direction + " direction");
+    }
+    
+}
@@ -0,0 +1,20 @@
+package com.fourisland.fourpuzzle.util;
+
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+
+
+/**
+ *
+ * @author hatkirby
+ */
+public enum Comparison {
+    
+    Less,
+    Greater,
+    Equal
+
+}
@@ -0,0 +1,31 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.util;
+
+import com.fourisland.fourpuzzle.gamestate.mapview.event.PossibleEvent;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class Functions {
+
+    public static boolean canTurn(PossibleEvent ev) throws Exception
+    {
+        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;
+    }
+
+}
@@ -0,0 +1,92 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.util;
+
+//import com.alienfactory.javamappy.loader.MapLoader;
+import com.fourisland.fourpuzzle.PuzzleApplication;
+import java.awt.Image;
+import java.awt.Toolkit;
+import java.awt.image.BufferedImage;
+import java.awt.image.FilteredImageSource;
+import java.util.HashMap;
+import javax.imageio.ImageIO;
+import javax.sound.midi.MidiSystem;
+import javax.sound.midi.Sequence;
+import org.jdesktop.application.ResourceMap;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class ObjectLoader {
+    
+    private static HashMap<String,Object> objectCache = new HashMap<String,Object>();
+    
+    public static BufferedImage getImage(String type, String name) throws Exception
+    {
+        if (!objectCache.containsKey(type + "/" + name))
+        {
+            ResourceMap rm = PuzzleApplication.INSTANCE.getContext().getResourceManager().getResourceMap();
+            String filename = rm.getResourcesDir() + type.toLowerCase() + "/" + name + ".png";
+            BufferedImage bImg = ImageIO.read(rm.getClassLoader().getResourceAsStream(filename));
+            
+            addToObjectCache(type,name,bImg);
+        }
+        
+        return (BufferedImage) objectCache.get(type + "/" + name);
+    }
+    
+    public static BufferedImage getImage(String type, String name, int transparencyColor) throws Exception
+    {
+        if (!objectCache.containsKey(type + "/" + name))
+        {
+            ResourceMap rm = PuzzleApplication.INSTANCE.getContext().getResourceManager().getResourceMap();
+            String filename = rm.getResourcesDir() + type + "/" + name + ".png";
+            BufferedImage bImg = ImageIO.read(rm.getClassLoader().getResourceAsStream(filename));
+            bImg = new BufferedImage(bImg.getWidth(), bImg.getHeight(), BufferedImage.TYPE_INT_RGB);
+            Image image = Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(bImg.getSource(), new TransparentImageFilter(transparencyColor)));
+            bImg.createGraphics().drawImage(image, 0, 0, null);            
+            
+            addToObjectCache(type,name,bImg);
+        }
+        
+        return (BufferedImage) objectCache.get(type + "/" + name);
+    }
+    
+    /*public static com.alienfactory.javamappy.Map getMap(String name) throws Exception
+    {
+        ResourceMap rm = PuzzleApplication.getInstance().getContext().getResourceManager().getResourceMap();
+        String filename = rm.getResourcesDir() + "mapdata/" + name + ".fmp";
+        
+        //com.alienfactory.javamappy.Map map = MapLoader.loadMap(rm.getClassLoader().getResourceAsStream(filename));
+        return map;
+    }*/
+    
+    public static void addToObjectCache(String type, String name, Object object) throws Exception
+    {
+        if (objectCache.size() >= 100)
+        {
+            objectCache.clear();
+        }
+        
+        objectCache.put(type + "/" + name, object);
+    }
+    
+    public static Sequence getMusic(String name) throws Exception
+    {
+        if (!objectCache.containsKey("Music/" + name))
+        {
+            ResourceMap rm = PuzzleApplication.INSTANCE.getContext().getResourceManager().getResourceMap();
+            String filename = rm.getResourcesDir() + "music/" + name + ".mid";
+            Sequence seq = MidiSystem.getSequence(rm.getClassLoader().getResourceAsStream(filename));
+            
+            addToObjectCache("Music", name, seq);
+        }
+        
+        return (Sequence) objectCache.get("Music/" + name);
+    }
+    
+}
@@ -0,0 +1,46 @@
+/*
+ *  Tiled Map Editor, (c) 2004-2006
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Adam Turk <aturk@biggeruniverse.com>
+ *  Bjorn Lindeijer <b.lindeijer@xs4all.nl>
+ */
+
+package com.fourisland.fourpuzzle.util;
+
+import java.awt.image.RGBImageFilter;
+
+/**
+ * This filter is used for filtering out a given "transparent" color from an
+ * image. Sometimes known as magic pink.
+ */
+public class TransparentImageFilter extends RGBImageFilter
+{
+    int trans;
+
+    /**
+     * @param col the color to make transparent
+     */
+    public TransparentImageFilter(int col) {
+        trans = col;
+
+        // The filter doesn't depend on pixel location
+        canFilterIndexColorModel = true;
+    }
+
+    /**
+     * Filters the given pixel. It returns a transparent pixel for pixels that
+     * match the transparency color, or the existing pixel for anything else.
+     */
+    public int filterRGB(int x, int y, int rgb) {
+        if (rgb == trans) {
+            return 0;
+        } else {
+            return rgb;                 
+        }
+    }   
+}
\ No newline at end of file