Imported sources

35 files changed, 2168 insertions, 0 deletions

@@ -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);
+    }
+
+}