welcome RustAndDust

97 files changed, 12831 insertions, 0 deletions

diff --git a/core/src/ch/asynk/rustanddust/RustAndDust.java b/core/src/ch/asynk/rustanddust/RustAndDust.java
new file mode 100644
index 0000000..52732a3
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/RustAndDust.java
@@ -0,0 +1,222 @@
+package ch.asynk.rustanddust;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Game;
+import com.badlogic.gdx.assets.AssetManager;
+import com.badlogic.gdx.audio.Sound;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+
+import ch.asynk.rustanddust.screens.MenuScreen;
+import ch.asynk.rustanddust.screens.GameScreen;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Config;
+import ch.asynk.rustanddust.game.battles.Factory;
+
+public class RustAndDust extends Game
+{
+    public AssetManager manager;
+    public Factory factory;
+    public Ctrl ctrl;
+    public Config config;
+    public int hudCorrection;
+
+    public TextureAtlas uiAtlas;
+    public TextureAtlas menuAtlas;
+    public BitmapFont fontB;
+    public BitmapFont fontW;
+
+    public enum State
+    {
+        MENU,
+        GAME,
+        NONE
+    }
+    private State state;
+
+    public static void debug(String msg)
+    {
+        debug("", msg);
+    }
+
+    public static void debug(String dom, String msg)
+    {
+        Gdx.app.debug(dom, msg);
+    }
+
+    @Override
+    public void create ()
+    {
+        Gdx.app.setLogLevel(Gdx.app.LOG_DEBUG);
+        this.hudCorrection = ((int) (125 * Gdx.graphics.getDensity()) - 75);
+        debug("RustAndDust", "create() [" + Gdx.graphics.getWidth() + ";" + Gdx.graphics.getHeight() + "] " + Gdx.graphics.getDensity() + " -> " + hudCorrection);
+
+        manager = new AssetManager();
+        factory = new Factory(this);
+        config = new Config();
+
+        state = State.NONE;
+        loadUiAssets();
+        switchToMenu();
+    }
+
+    public void switchToMenu()
+    {
+        if (state == State.GAME) {
+            unloadGameAssets();
+            factory.dispose();
+            ctrl.dispose();
+            getScreen().dispose();
+        }
+        loadMenuAssets();
+        state = State.MENU;
+        setScreen(new MenuScreen(this));
+    }
+
+    public void switchToGame()
+    {
+        unloadMenuAssets();
+        getScreen().dispose();
+        factory.assetsLoaded();
+        state = State.GAME;
+        setScreen(new GameScreen(this));
+    }
+
+    public void loadGameAssets()
+    {
+        if (config.battle.getMapType() == Factory.MapType.MAP_A)
+            manager.load("data/map_a.png", Texture.class);
+        if (config.battle.getMapType() == Factory.MapType.MAP_B)
+            manager.load("data/map_b.png", Texture.class);
+        int i = config.graphics.i;
+        manager.load(String.format("data/units%d.atlas",i), TextureAtlas.class);
+        manager.load(String.format("data/unit-overlays%d.atlas", i), TextureAtlas.class);
+        manager.load("data/hex.png", Texture.class);
+        manager.load("data/hud.atlas", TextureAtlas.class);
+        manager.load("data/hex-overlays.atlas", TextureAtlas.class);
+        manager.load("data/dice.png", Texture.class);
+        manager.load("data/infantry_fire.png", Texture.class);
+        manager.load("data/tank_fire.png", Texture.class);
+        manager.load("data/explosions.png", Texture.class);
+        manager.load("sounds/dice.mp3", Sound.class);
+        manager.load("sounds/tank_move.mp3", Sound.class);
+        manager.load("sounds/infantry_move.mp3", Sound.class);
+        manager.load("sounds/infantry_fire.mp3", Sound.class);
+        manager.load("sounds/tank_fire.mp3", Sound.class);
+        manager.load("sounds/tank_fire_short.mp3", Sound.class);
+        manager.load("sounds/explosion.mp3", Sound.class);
+        manager.load("sounds/explosion_short.mp3", Sound.class);
+        manager.load("sounds/promote_us.mp3", Sound.class);
+        manager.load("sounds/promote_ge.mp3", Sound.class);
+        debug("RustAndDust", "  assets loaded : " + (Gdx.app.getJavaHeap()/1024.0f) + "KB");
+    }
+
+    private void unloadGameAssets()
+    {
+        if (config.battle.getMapType() == Factory.MapType.MAP_A)
+            manager.unload("data/map_a.png");
+        if (config.battle.getMapType() == Factory.MapType.MAP_B)
+            manager.unload("data/map_b.png");
+        int i = config.graphics.i;
+        manager.unload(String.format("data/units%d.atlas",i));
+        manager.unload(String.format("data/unit-overlays%d.atlas", i));
+        manager.unload("data/hex.png");
+        manager.unload("data/hud.atlas");
+        manager.unload("data/hex-overlays.atlas");
+        manager.unload("data/dice.png");
+        manager.unload("data/infantry_fire.png");
+        manager.unload("data/tank_fire.png");
+        manager.unload("data/explosions.png");
+        manager.unload("sounds/dice.mp3");
+        manager.unload("sounds/tank_move.mp3");
+        manager.unload("sounds/infantry_move.mp3");
+        manager.unload("sounds/infantry_fire.mp3");
+        manager.unload("sounds/tank_fire.mp3");
+        manager.unload("sounds/tank_fire_short.mp3");
+        manager.unload("sounds/explosion.mp3");
+        manager.unload("sounds/explosion_short.mp3");
+        manager.unload("sounds/promote_us.mp3");
+        manager.unload("sounds/promote_ge.mp3");
+        debug("RustAndDust", "  assets unloaded : " + (Gdx.app.getJavaHeap()/1024.0f) + "KB");
+    }
+
+    private void loadUiAssets()
+    {
+        manager.load("data/ui.atlas", TextureAtlas.class);
+        manager.finishLoading();
+        uiAtlas = manager.get("data/ui.atlas", TextureAtlas.class);
+        fontB = new BitmapFont(Gdx.files.internal("skin/veteran.fnt"), uiAtlas.findRegion("veteran-black"));
+        fontW = new BitmapFont(Gdx.files.internal("skin/veteran.fnt"), uiAtlas.findRegion("veteran-white"));
+    }
+
+    private void unloadUiAssets()
+    {
+        fontB.dispose();
+        fontW.dispose();
+        manager.unload("data/ui.atlas");
+    }
+
+    private void loadMenuAssets()
+    {
+        manager.load("data/map_a.png", Texture.class);
+        manager.load("data/menu.atlas", TextureAtlas.class);
+        manager.finishLoading();
+        menuAtlas = manager.get("data/menu.atlas", TextureAtlas.class);
+    }
+
+    private void unloadMenuAssets()
+    {
+        manager.unload("data/map_a.png");
+        manager.unload("data/menu.atlas");
+    }
+
+    // @Override
+    // public void render ()
+    // {
+    //     Gdx.gl.glClearColor(0, 0, 0, 1);
+    //     Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+    //     super.render();
+    // }
+
+    // @Override
+    // public void resize(int width, int height)
+    // {
+    //     debug("RustAndDust", "resize(" + width + ", " + height + ")");
+    //     super.resize(width, height);
+    // }
+
+    @Override
+    public void dispose()
+    {
+        debug("RustAndDust", "dispose()");
+        debug("RustAndDust", "diagnostics:\n" + manager.getDiagnostics() );
+        getScreen().dispose();
+        unloadUiAssets();
+        switch(state) {
+            case MENU:
+                unloadMenuAssets();
+                break;
+            case GAME:
+                unloadGameAssets();
+                factory.dispose();
+                ctrl.dispose();
+                break;
+        }
+        debug("RustAndDust", "diagnostics:\n" + manager.getDiagnostics() );
+        manager.clear();
+        manager.dispose();
+    }
+
+    // @Override
+    // public void pause()
+    // {
+    //     debug("RustAndDust", "pause()");
+    // }
+
+    // @Override
+    // public void resume()
+    // {
+    //     debug("RustAndDust", "resume()");
+    // }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Attack.java b/core/src/ch/asynk/rustanddust/engine/Attack.java
new file mode 100644
index 0000000..e64399a
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Attack.java
@@ -0,0 +1,28 @@
+package ch.asynk.rustanddust.engine;
+
+public class Attack
+{
+    public Pawn attacker;
+    public Pawn target;
+    public int distance;
+    public boolean isClear;
+    public boolean isFlank;
+
+    public Attack(Pawn attacker)
+    {
+        this.attacker = attacker;
+    }
+
+    public String toString()
+    {
+        return String.format("attack : %s -> %s dist:%d clear:%b flank:%b", attacker, target, distance, isClear, isFlank);
+    }
+
+    public void reset()
+    {
+        target = null;
+        distance = 0;;
+        isClear = false;
+        isFlank = false;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Board.java b/core/src/ch/asynk/rustanddust/engine/Board.java
new file mode 100644
index 0000000..e4aba6d
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Board.java
@@ -0,0 +1,554 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.Iterator;
+import java.util.Collection;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+
+import com.badlogic.gdx.Gdx;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import com.badlogic.gdx.math.Matrix4;
+
+import ch.asynk.rustanddust.engine.gfx.Animation;
+import ch.asynk.rustanddust.engine.gfx.animations.AnimationSequence;
+import ch.asynk.rustanddust.engine.gfx.animations.RunnableAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.MoveToAnimation.MoveToAnimationCb;
+
+public abstract class Board implements Disposable, Animation
+{
+    private int cols;
+    private int rows;
+    private final Tile neighbours[] = new Tile[6];
+
+    public interface TileBuilder
+    {
+        public Tile getNewTile(float x, float y, int col, int row, boolean offmap);
+    }
+
+    public static class Config
+    {
+        public int cols;
+        public int rows;
+        public int x0;          // bottom left x offset
+        public int y0;          // bottom left y offset
+        public int w;           // hex width
+        public int dw;          // half hex : w/2
+        public int s;           // hex side
+        public float dh;        // hex top : s/2
+        public float h;         // square height : s + dh
+        public float slope;     // north-west side slope : (dh / (float) dw)
+    }
+
+    private Config cfg;
+    private Tile[] tiles;
+    private SearchBoard searchBoard;
+    private Sprite board;
+    private Orientation sides[];
+
+    private boolean transform;
+    private Matrix4 prevTransform;
+    private Matrix4 nextTransform;
+
+    private int tileCount = 0;
+    private int pawnCount = 0;
+    private int animationCount = 0;
+    private final ArrayList<Animation> animations = new ArrayList<Animation>(2);
+    private final ArrayList<Animation> nextAnimations = new ArrayList<Animation>(2);
+    private final LinkedHashSet<Tile> tilesToDraw = new LinkedHashSet<Tile>();
+
+    protected SelectedTile selectedTile;
+
+    protected Board(int cols, int rows)
+    {
+        // add a frame of OFFMAP Tiles
+        this.cols = (cols + 2);
+        this.rows = (rows + 2);
+        searchBoard = new SearchBoard(this, cols, rows);
+        initSides();
+    }
+
+    public Board(TileBuilder tileBuilder, Config cfg, Texture boardTexture,  SelectedTile selectedTile)
+    {
+        board = new Sprite(boardTexture);
+        this.cfg = cfg;
+        // add a frame of OFFMAP Tiles
+        this.cols = (cfg.cols + 2);
+        this.rows = (cfg.rows + 2);
+        this.tiles = new Tile[this.cols * this.rows];
+        searchBoard = new SearchBoard(this, cfg.cols, cfg.rows);
+
+        int idx = 0;
+        boolean evenRow = false;
+        float y = cfg.y0 - cfg.dh + cfg.s - cfg.h;
+        for (int i = -1; i < (cfg.rows + 1); i++) {
+            float x = cfg.x0 + cfg.dw - cfg.w;
+            if (!evenRow) x += cfg.dw;
+            for ( int j = -1; j < (cfg.cols + 1); j ++) {
+                boolean offmap = ((j < 0) || (i < 0) || (j >= cfg.cols) || (i >= cfg.rows));
+                this.tiles[idx] = tileBuilder.getNewTile(x, y, (j + ((i + 1) / 2)), i, offmap);
+                idx += 1;
+                x += cfg.w;
+            }
+            y += cfg.h;
+            evenRow = !evenRow;
+        }
+
+        initSides();
+
+        this.selectedTile = selectedTile;
+    }
+
+    private void initSides()
+    {
+        this.sides = new Orientation[6];
+        sides[0] = Orientation.NORTH;
+        sides[1] = Orientation.NORTH_EAST;
+        sides[2] = Orientation.SOUTH_EAST;
+        sides[3] = Orientation.SOUTH;
+        sides[4] = Orientation.SOUTH_WEST;
+        sides[5] = Orientation.NORTH_WEST;
+    }
+
+    @Override
+    public void dispose()
+    {
+        for (int i = 0; i < (this.cols * this.rows); i++)
+            tiles[i].dispose();
+        tilesToDraw.clear();
+        for (int i = 0, n = nextAnimations.size(); i < n; i++)
+            nextAnimations.get(i).dispose();
+        animations.clear();
+        for (int i = 0, n = animations.size(); i < n; i++)
+            animations.get(i).dispose();
+        animations.clear();
+        if (selectedTile != null)
+            selectedTile.dispose();
+        Move.clearPool();
+        Path.clearPool();
+    }
+
+    public float getWidth()
+    {
+        return board.getWidth();
+    }
+
+    public float getHeight()
+    {
+        return board.getHeight();
+    }
+
+    public void setPosition(float x, float y)
+    {
+        board.setPosition(x, y);
+        if ((x != 0.0f) || (y != 0.0f)) {
+            transform = true;
+            prevTransform = new Matrix4();
+            nextTransform = new Matrix4();
+            nextTransform.translate(x, y, 0);
+        } else
+            transform = false;
+    }
+
+    public Orientation getSide(int i)
+    {
+        return sides[i];
+    }
+
+    protected int getTileOffset(int col, int row)
+    {
+        col = (col + 1 - ((row + 1) / 2));
+        row = (row + 1);
+        if ((col < 0) || (row < 0) || (row >= this.rows) || (col >= this.cols))
+            return -1;
+
+        return (col + (row * this.cols));
+    }
+
+    protected Tile getTile(int col, int row)
+    {
+        int offset = getTileOffset(col, row);
+        if (offset < 0)
+            return null;
+        return tiles[offset];
+    }
+
+    public void setAdjacentTiles(Tile tile, Tile tiles[])
+    {
+        tiles[0] = getAdjTileAt(tile, sides[0].opposite());
+        tiles[1] = getAdjTileAt(tile, sides[1].opposite());
+        tiles[2] = getAdjTileAt(tile, sides[2].opposite());
+        tiles[3] = getAdjTileAt(tile, sides[3].opposite());
+        tiles[4] = getAdjTileAt(tile, sides[4].opposite());
+        tiles[5] = getAdjTileAt(tile, sides[5].opposite());
+    }
+
+    public Tile getAdjTileAt(Tile tile, Orientation o)
+    {
+        Tile t = null;
+        switch(o) {
+            case NORTH:
+                t = getTile((tile.col + 1), tile.row);
+                break;
+            case NORTH_EAST:
+                t = getTile(tile.col, (tile.row - 1));
+                break;
+            case SOUTH_EAST:
+                t = getTile((tile.col - 1), (tile.row - 1));
+                break;
+            case SOUTH:
+                t = getTile((tile.col - 1), tile.row);
+                break;
+            case SOUTH_WEST:
+                t = getTile(tile.col, (tile.row + 1));
+                break;
+            case NORTH_WEST:
+                t = getTile((tile.col + 1), (tile.row + 1));
+                break;
+        }
+        return t;
+    }
+
+    protected abstract void animationsOver();
+
+    protected void addAnimation(Animation a)
+    {
+        nextAnimations.add(a);
+    }
+
+    public int animationCount()
+    {
+        return animations.size();
+    }
+
+    private void stats()
+    {
+        boolean print = false;
+
+        if (tileCount != tilesToDraw.size()) {
+            tileCount = tilesToDraw.size();
+            print = true;
+        }
+
+        if (animationCount != animations.size()) {
+            animationCount = animations.size();
+            print = true;
+        }
+
+        if (print)
+            Gdx.app.debug("Board", " tiles:" + tileCount + " pawns:" + pawnCount + " animations:" + animationCount);
+    }
+
+    public boolean animate(float delta)
+    {
+        boolean over = (animations.size() > 0);
+        Iterator<Animation> iter = animations.iterator();
+        while (iter.hasNext()) {
+            Animation a = iter.next();
+            if (a.animate(delta))
+                iter.remove();
+        }
+        if (over && (animations.size() == 0))
+            animationsOver();
+
+        for (int i = 0, n = nextAnimations.size(); i < n; i++)
+            animations.add(nextAnimations.get(i));
+        nextAnimations.clear();
+
+        selectedTile.animate(delta);
+
+        return true;
+    }
+
+    public void draw(Batch batch)
+    {
+        board.draw(batch);
+
+        if (transform) {
+            prevTransform.set(batch.getTransformMatrix());
+            batch.setTransformMatrix(nextTransform);
+        }
+
+        Iterator<Tile> tileIter = tilesToDraw.iterator();
+        while (tileIter.hasNext())
+            tileIter.next().draw(batch);
+
+        Iterator<Animation> animationIter = animations.iterator();
+        while (animationIter.hasNext())
+            animationIter.next().draw(batch);
+
+        selectedTile.draw(batch);
+
+        if (transform)
+            batch.setTransformMatrix(prevTransform);
+    }
+
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        stats();
+        if (transform) {
+            prevTransform.set(debugShapes.getTransformMatrix());
+            debugShapes.setTransformMatrix(nextTransform);
+        }
+
+        Iterator<Tile> iter = tilesToDraw.iterator();
+        while (iter.hasNext())
+            iter.next().drawDebug(debugShapes);
+
+        Iterator<Animation> animationIter = animations.iterator();
+        while (animationIter.hasNext())
+            animationIter.next().drawDebug(debugShapes);
+
+        if (transform)
+            debugShapes.setTransformMatrix(prevTransform);
+    }
+
+    protected int collectPossibleMoves(Pawn pawn, Collection<Tile> moves)
+    {
+        return searchBoard.possibleMovesFrom(pawn, moves);
+    }
+
+    protected int collectPossibleTargets(Pawn pawn, Collection<Pawn> targets)
+    {
+        return searchBoard.possibleTargetsFrom(pawn, targets);
+    }
+
+    protected int collectPossibleTargets(Pawn pawn, Collection<Pawn> units, Collection<Pawn> targets)
+    {
+        targets.clear();
+        for (Pawn target : units) {
+            if (pawn.canEngage(target) && searchBoard.canAttack(pawn, target, true))
+                targets.add(target);
+        }
+
+        return targets.size();
+    }
+
+    protected int collectMoveAssists(Pawn pawn, Collection<Pawn> assists)
+    {
+        assists.clear();
+        setAdjacentTiles(pawn.getTile(), neighbours);
+        for (int i = 0; i < 6; i++) {
+            Tile tile = neighbours[i];
+            if (tile != null) {
+                Iterator<Pawn> pawns = tile.iterator();
+                while(pawns.hasNext()) {
+                    Pawn p = pawns.next();
+                    if (!pawn.isEnemy(p) && p.canMove())
+                        assists.add(p);
+                }
+            }
+        }
+        return assists.size();
+    }
+
+    protected int collectAttackAssists(Pawn pawn, Pawn target, Collection<Pawn> units, Collection<Pawn> assists)
+    {
+        assists.clear();
+        for (Pawn p : units) {
+            if ((p != pawn) && p.canEngage(target) && searchBoard.canAttack(p, target, !p.canAssistEngagementWithoutLos()))
+                assists.add(p);
+        }
+
+        return assists.size();
+    }
+
+    public Orientation findBestEntry(Pawn pawn, Tile to, int allowedMoves)
+    {
+        Orientation entry = Orientation.KEEP;
+        int cost = Integer.MAX_VALUE;
+        boolean road = false;
+
+        setAdjacentTiles(to, neighbours);
+        for (int i = 0; i < 6; i++) {
+            Tile t = neighbours[i];
+            if (t.isOffMap()) {
+                Orientation o = Orientation.fromAdj(t.col, t.row, to.col, to.row);
+                if (o.isInSides(allowedMoves)) {
+                    o = o.opposite();
+                    boolean r = to.road(o);
+                    int c = to.costFrom(pawn, o);
+                    if ((c < cost) || (r && (c == cost))) {
+                        entry = o;
+                        cost = c;
+                        road = r;
+                    }
+                }
+            }
+        }
+
+        return entry.opposite();
+    }
+
+    public void enableOverlayOn(Tile tile, int i, boolean enable)
+    {
+        if(tile.enableOverlay(i, enable))
+            tilesToDraw.add(tile);
+        else
+            tilesToDraw.remove(tile);
+    }
+
+    public void enableOverlayOn(Tile tile, int i, Orientation o, boolean enable)
+    {
+        if(tile.enableOverlay(i, enable, o.r()))
+            tilesToDraw.add(tile);
+        else
+            tilesToDraw.remove(tile);
+    }
+
+    private int pushPawnOnto(Pawn pawn, Tile tile)
+    {
+        if (!tile.isOffMap())
+            tilesToDraw.add(tile);
+        return tile.push(pawn);
+    }
+
+    public int removePawn(Pawn pawn)
+    {
+        Tile tile = pawn.getTile();
+        if (tile == null)
+            return 0;
+        int n = tile.remove(pawn);
+        if (!tile.mustBeDrawn())
+            tilesToDraw.remove(tile);
+        return n;
+    }
+
+    public Pawn setPawnOnto(Pawn pawn, Move move)
+    {
+        pawn.move(move);
+        return setPawnOnto(pawn, move.to, move.orientation);
+    }
+
+    public Pawn setPawnOnto(Pawn pawn, Tile tile, Orientation o)
+    {
+        pawn.setOnTile(tile, o.r());
+        pushPawnOnto(pawn, tile);
+        return pawn;
+    }
+
+    private RunnableAnimation getSetPawnOntoAnimation(final Pawn pawn)
+    {
+        return RunnableAnimation.get(pawn, new Runnable() {
+            @Override
+            public void run() {
+                Tile to = pawn.move.to;
+                if (!to.isOffMap())
+                    setPawnOnto(pawn, to, pawn.move.orientation);
+            }
+        });
+    }
+
+    protected void movePawn(final Pawn pawn, Move move, MoveToAnimationCb cb)
+    {
+        pawn.move(move);
+        removePawn(pawn);
+
+        AnimationSequence seq = pawn.getMoveAnimation(move.iterator(), (move.steps() + 1), cb);
+        seq.addAnimation(getSetPawnOntoAnimation(pawn));
+        addAnimation(seq);
+    }
+
+    protected void enterPawn(final Pawn pawn, Move move)
+    {
+        pawn.move(move);
+        setPawnOnto(pawn, move.to, move.orientation);
+    }
+
+    protected void revertLastPawnMove(final Pawn pawn)
+    {
+        removePawn(pawn);
+
+        addAnimation(RunnableAnimation.get(pawn, new Runnable() {
+            @Override
+            public void run() {
+                pushPawnOnto(pawn, pawn.getTile());
+            }
+        }));
+
+        pawn.revertLastMove();
+    }
+
+    public void attack(final Pawn pawn, final Pawn target, boolean clearVisibility)
+    {
+        if (!pawn.canEngage(target) || !searchBoard.canAttack(pawn, target, clearVisibility))
+            throw new RuntimeException(String.format("%s cannot attack %s", pawn, target));
+    }
+
+    public Tile getTileAt(float mx, float my)
+    {
+        // compute row
+        float y = (my - cfg.y0);
+        int row = (int) (y / cfg.h);
+        boolean oddRow = ((row % 2) == 1);
+        if (y < 0.f) {
+            row = -1;
+            oddRow = true;
+        }
+
+        // compute col
+        float x = (mx - cfg.x0);
+        if (oddRow) x -= cfg.dw;
+        int col = (int) (x / cfg.w);
+        if (x < 0.f)
+            col = -1;
+
+        int colOffset = ((row + 1) / 2);
+
+        // check upper boundaries
+        float dy = (y - (row * cfg.h));
+        if (dy > cfg.s) {
+            dy -= cfg.s;
+            float dx = (x - (col * cfg.w));
+            col += colOffset;
+            if (dx < cfg.dw) {
+                if ((dx * cfg.slope) < dy) {
+                    // upper left corner
+                    row += 1;
+                    colOffset = ((row +1) / 2);
+                }
+            } else {
+                if (((cfg.w - dx) * cfg.slope) < dy) {
+                    // upper right corner
+                    row += 1;
+                    col += 1;
+                    colOffset = ((row +1) / 2);
+                }
+            }
+        } else
+            col += colOffset;
+
+        return getTile(col, row);
+    }
+
+    public int distance(Tile from, Tile to)
+    {
+        return distance(from.col, from.row, to.col, to.row);
+    }
+
+    public int distance(int col0, int row0, int col1, int row1)
+    {
+        int dx = Math.abs(col1 - col0);
+        int dy = Math.abs(row1 - row0);
+        int dz = Math.abs((col0 - row0) - (col1 - row1));
+
+        if (dx > dy) {
+            if (dx > dz)
+                return dx;
+            else
+                return dz;
+        } else {
+            if (dy > dz)
+                return dy;
+            else
+                return dz;
+        }
+    }
+}
+
diff --git a/core/src/ch/asynk/rustanddust/engine/Faction.java b/core/src/ch/asynk/rustanddust/engine/Faction.java
new file mode 100644
index 0000000..e108fc4
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Faction.java
@@ -0,0 +1,6 @@
+package ch.asynk.rustanddust.engine;
+
+public interface Faction
+{
+    public boolean isEnemy(Faction other);
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/HeadedPawn.java b/core/src/ch/asynk/rustanddust/engine/HeadedPawn.java
new file mode 100644
index 0000000..67e1d44
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/HeadedPawn.java
@@ -0,0 +1,88 @@
+package ch.asynk.rustanddust.engine;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import com.badlogic.gdx.math.Vector3;
+
+public abstract class HeadedPawn extends Pawn
+{
+    private Sprite head;
+    protected Orientation orientation;
+
+    public HeadedPawn(Faction faction, String pawn, String head, TextureAtlas pawns, TextureAtlas overlays)
+    {
+        super(faction, pawn, pawns, overlays);
+        this.head = new Sprite(pawns.findRegion(head));
+        this.orientation = Orientation.KEEP;
+        this.descr += " " + orientation;
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+    }
+
+    @Override
+    public void setAlpha(float alpha)
+    {
+        super.setAlpha(alpha);
+        head.setAlpha(alpha);
+    }
+
+    @Override
+    public float getRotation()
+    {
+        return orientation.r();
+    }
+
+    @Override
+    public Orientation getOrientation()
+    {
+        return orientation;
+    }
+
+    @Override
+    public void setPosition(float x, float y)
+    {
+        super.setPosition(x, y);
+        float cx = x + (getWidth() / 2f);
+        float cy = y + (getHeight() / 2f);
+        head.setPosition((cx - (head.getWidth() / 2f)), (cy - (head.getHeight() / 2f)));
+    }
+
+    @Override
+    public void setRotation(float z)
+    {
+        getPosition().z = z;
+        head.setRotation(z);
+        this.orientation = Orientation.fromRotation(z);
+    }
+
+    @Override
+    public void setPosition(float x, float y, float z)
+    {
+        setPosition(x, y);
+        setRotation(z);
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        head.draw(batch);
+        super.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        float w = head.getWidth();
+        float h = head.getHeight();
+        debugShapes.rect(head.getX(), head.getY(), (w / 2f), (h / 2f), w, h, head.getScaleX(), head.getScaleY(), head.getRotation());
+        super.drawDebug(debugShapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Meteorology.java b/core/src/ch/asynk/rustanddust/engine/Meteorology.java
new file mode 100644
index 0000000..9addf63
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Meteorology.java
@@ -0,0 +1,24 @@
+package ch.asynk.rustanddust.engine;
+
+public class Meteorology
+{
+    public enum Day { DAY, NIGHT };
+    public enum Season { SUMMER, SPRING, WINTER, FALL };
+    public enum Weather { CLEAR, RAIN, SNOW, WIND };
+
+    public Day day;
+    public Season season;
+    public Weather weather;
+
+    public Meteorology()
+    {
+        clear();
+    }
+
+    public void clear()
+    {
+        day = Day.DAY;
+        season = Season.SUMMER;
+        weather = Weather.CLEAR;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Move.java b/core/src/ch/asynk/rustanddust/engine/Move.java
new file mode 100644
index 0000000..077823f
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Move.java
@@ -0,0 +1,158 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.Iterator;
+
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.math.Vector3;
+
+public class Move extends Path implements Iterable<Vector3>
+{
+    public enum MoveType
+    {
+        REGULAR,
+        SET,
+        ENTER,
+        EXIT;
+    }
+
+    private static final Pool<Move> movePool = new Pool<Move>()
+    {
+        @Override
+        protected Move newObject() {
+            return new Move();
+        }
+    };
+
+    public static Move get(Pawn pawn, Tile from, Tile to, Orientation orientation, Path path)
+    {
+        Move m = movePool.obtain();
+        m.pawn = pawn;
+        m.from = from;
+        m.to = to;
+        m.orientation = orientation;
+        if (path != null) {
+            m.init(path.tiles.size());
+            m.cost = path.cost;
+            m.roadMarch = path.roadMarch;
+            for (Tile tile : path.tiles)
+                m.tiles.add(tile);
+        } else {
+            m.init(0);
+        }
+
+        return m;
+    }
+
+    public static void clearPool()
+    {
+        movePool.clear();
+    }
+
+    public static Move getEnter(Pawn pawn, Tile to, Orientation orientation)
+    {
+        Move m = get(pawn, null, to, orientation, null);
+        m.type = MoveType.ENTER;
+        m.cost = to.costFrom(pawn, orientation);
+        return m;
+    }
+
+    public static Move getSet(Pawn pawn, Tile to, Orientation orientation)
+    {
+        Move m = get(pawn, null, to, orientation, null);
+        m.type = MoveType.SET;
+        m.cost = 0;
+        return m;
+    }
+
+    public Pawn pawn;
+    public Tile from;
+    public Tile to;
+    public Orientation orientation;
+    public MoveType type;
+
+    public Move()
+    {
+        super();
+        this.pawn = null;
+        this.from = null;
+        this.to = null;
+        this.orientation = Orientation.KEEP;
+        this.type = MoveType.REGULAR;
+    }
+
+    @Override
+    public void reset()
+    {
+        pawn = null;
+        from = null;
+        to = null;
+        orientation = Orientation.KEEP;
+        type = MoveType.REGULAR;
+        super.reset();
+    }
+
+    @Override
+    public void dispose()
+    {
+        tiles.clear();
+        movePool.free(this);
+    }
+
+    public boolean isSet()
+    {
+        return (type == MoveType.SET);
+    }
+
+    public boolean isEnter()
+    {
+        return (type == MoveType.ENTER);
+    }
+
+    public boolean isRegular()
+    {
+        return (type == MoveType.REGULAR);
+    }
+
+    public boolean isFinal()
+    {
+        return (type != MoveType.ENTER);
+    }
+
+    public int steps()
+    {
+        int steps = 0;
+
+        Tile tile = from;
+        Orientation o = pawn.getOrientation();
+        for (Tile next : tiles) {
+            Orientation nextO = Orientation.fromMove(tile.col, tile.row, next.col, next.row);
+            if (nextO != o) {
+                steps += 2;
+                o = nextO;
+            } else
+                steps += 1;
+            tile = next;
+        }
+        if (orientation != Orientation.fromMove(tile.col, tile.row, to.col, to.row))
+            steps += 2;
+        else
+            steps +=1;
+
+        return steps;
+    }
+
+    @Override
+    public String toString()
+    {
+        if (from == null)
+            return String.format("%s %s c:%d", to.toShort(), orientation, cost);
+        else
+            return String.format("%s->%s %s c:%d", from.toShort(), to.toShort(), orientation, cost);
+    }
+
+    @Override
+    public Iterator<Vector3> iterator()
+    {
+        return new PathIterator(pawn, from, to, orientation, tiles);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Objective.java b/core/src/ch/asynk/rustanddust/engine/Objective.java
new file mode 100644
index 0000000..de1c7d3
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Objective.java
@@ -0,0 +1,49 @@
+package ch.asynk.rustanddust.engine;
+
+public class Objective
+{
+    protected Faction curFaction;
+    protected Faction prevFaction;
+    private boolean persistent;
+
+    public Objective(Faction faction, boolean persistent)
+    {
+        this.curFaction = faction;
+        this.prevFaction = faction;
+        this.persistent = persistent;
+    }
+
+    public boolean is(Faction faction)
+    {
+        return (curFaction == faction);
+    }
+
+    public Faction faction()
+    {
+        return curFaction;
+    }
+
+    public boolean set(Faction faction)
+    {
+        if (faction == curFaction)
+            return false;
+
+        prevFaction = curFaction;
+        curFaction = faction;
+        return true;
+    }
+
+    public boolean unset()
+    {
+        if (persistent)
+            return false;
+        revert();
+        return true;
+    }
+
+    public Faction revert()
+    {
+        curFaction = prevFaction;
+        return curFaction;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/ObjectiveSet.java b/core/src/ch/asynk/rustanddust/engine/ObjectiveSet.java
new file mode 100644
index 0000000..5618a9d
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/ObjectiveSet.java
@@ -0,0 +1,78 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.Collection;
+import java.util.HashMap;
+
+public class ObjectiveSet extends HashMap<Tile, Objective>
+{
+    public interface ObjectiveCb
+    {
+        public void showObjective(Tile tile, Faction faction);
+    }
+
+    private final Board board;
+    private final HashMap<Objective, Tile> modified;
+
+    public ObjectiveSet(Board board, int n)
+    {
+        super(n);
+        this.board = board;
+        this.modified = new HashMap<Objective, Tile>(10);
+    }
+
+    public void add(Tile tile, Faction faction, boolean persistent)
+    {
+        put(tile, new Objective(faction, persistent));
+    }
+
+    public int count(Faction faction)
+    {
+        int n = 0;
+        for (Objective objective : values()) {
+            if (objective.is(faction))
+                n += 1;
+        }
+        return n;
+    }
+
+    public Faction claim(Tile tile, Faction faction)
+    {
+        Objective objective = get(tile);
+        if (objective == null)
+            return null;
+
+        if (objective.set(faction))
+            modified.put(objective, tile);
+        return objective.faction();
+    }
+
+    public Faction unclaim(Tile tile)
+    {
+        Objective objective = get(tile);
+        if (objective == null)
+            return null;
+
+        if (objective.unset())
+            modified.remove(objective);
+        return objective.faction();
+    }
+
+    public void forget()
+    {
+        modified.clear();
+    }
+
+    public int modifiedCount()
+    {
+        return modified.size();
+    }
+
+    public void revert(ObjectiveCb cb)
+    {
+        for (Objective objective : modified.keySet()) {
+            objective.revert();
+            cb.showObjective(modified.get(objective), objective.faction());
+        }
+        modified.clear();
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Order.java b/core/src/ch/asynk/rustanddust/engine/Order.java
new file mode 100644
index 0000000..960b126
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Order.java
@@ -0,0 +1,16 @@
+package ch.asynk.rustanddust.engine;
+
+import java.lang.Comparable;
+
+import com.badlogic.gdx.utils.Disposable;
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.utils.Json;
+
+public abstract class Order implements Disposable, Pool.Poolable, Json.Serializable, Comparable<Pawn>
+{
+    public interface OrderType
+    {
+    }
+
+    public abstract boolean isA(OrderType type);
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/OrderList.java b/core/src/ch/asynk/rustanddust/engine/OrderList.java
new file mode 100644
index 0000000..4488cfe
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/OrderList.java
@@ -0,0 +1,64 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.LinkedList;
+import java.util.Iterator;
+
+import com.badlogic.gdx.utils.Json;
+import com.badlogic.gdx.utils.JsonValue;
+import com.badlogic.gdx.utils.JsonWriter.OutputType;
+
+public class OrderList extends LinkedList<Order> implements Json.Serializable
+{
+    public void dispose(Pawn pawn)
+    {
+        Iterator<Order> it = iterator();
+        while(it.hasNext()) {
+            Order order = it.next();
+            if (order.compareTo(pawn) == 0) {
+                it.remove();
+                order.dispose();
+            }
+        }
+    }
+
+    public void dispose(Pawn pawn, Order.OrderType type)
+    {
+        Iterator<Order> it = iterator();
+        while(it.hasNext()) {
+            Order order = it.next();
+            if ((order.compareTo(pawn) == 0) && (order.isA(type))) {
+                it.remove();
+                order.dispose();
+            }
+        }
+    }
+
+    public void dispose()
+    {
+        for (Order o : this)
+            o.dispose();
+        clear();
+    }
+
+    public String toJson()
+    {
+        Json json = new Json();
+        json.setOutputType(OutputType.json);
+        return json.toJson(this);
+    }
+
+    @Override
+    public void write(Json json)
+    {
+        json.writeArrayStart("commands");
+        for (Order o : this)
+            json.writeValue(o);
+        json.writeArrayEnd();
+    }
+
+    @Override
+    public void read(Json json, JsonValue jsonMap)
+    {
+        // TODO read(Json json, JsonValue jsonMap)
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Orientation.java b/core/src/ch/asynk/rustanddust/engine/Orientation.java
new file mode 100644
index 0000000..2c3ef58
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Orientation.java
@@ -0,0 +1,134 @@
+package ch.asynk.rustanddust.engine;
+
+public enum Orientation
+{
+    ALL(0, 63),
+    KEEP(0, 0),
+    NORTH(270, 1),
+    NORTH_EAST(210, 2),
+    SOUTH_EAST(150, 4),
+    SOUTH(90, 8),
+    SOUTH_WEST (30, 16),
+    NORTH_WEST(330, 32);
+
+    public static int offset = 0;
+    public static float delta = 5f;
+    private final int r;
+    public final int s;
+
+    Orientation(int r, int s) { this.r = r; this.s = s; }
+
+    public float r() { return offset + r; }
+
+    public boolean isInSides(int sides)
+    {
+        return ((sides & s) == s);
+    }
+
+    public Orientation left()
+    {
+        if (this == NORTH) return NORTH_WEST;
+        else return fromSide(s >> 1);
+    }
+
+    public Orientation right()
+    {
+        if (this == NORTH_WEST) return NORTH;
+        else return fromSide(s << 1);
+    }
+
+    public Orientation opposite()
+    {
+        return left().left().left();
+    }
+
+    public int allBut()
+    {
+        return ALL.s & (s ^ 0xFFFF);
+    }
+
+    public int getFrontSides()
+    {
+        return s | left().s | right().s;
+    }
+
+    public int getBackSides()
+    {
+        return opposite().getFrontSides();
+    }
+
+    public static Orientation fromSide(int s)
+    {
+        if (s == NORTH.s) return NORTH;
+        else if (s == NORTH_EAST.s) return NORTH_EAST;
+        else if (s == SOUTH_EAST.s) return SOUTH_EAST;
+        else if (s == SOUTH.s) return SOUTH;
+        else if (s == SOUTH_WEST.s) return SOUTH_WEST;
+        else if (s == NORTH_WEST.s) return NORTH_WEST;
+        else return KEEP;
+    }
+
+    public static Orientation fromRotation(float r)
+    {
+        if (r < 0) r += 360f;
+        if ((r > (NORTH.r - 5f)) && (r < (NORTH.r + 5f))) return NORTH;
+        else if ((r > (NORTH_EAST.r - delta)) && (r < (NORTH_EAST.r + delta))) return NORTH_EAST;
+        else if ((r > (SOUTH_EAST.r - delta)) && (r < (SOUTH_EAST.r + delta))) return SOUTH_EAST;
+        else if ((r > (SOUTH.r - delta)) && (r < (SOUTH.r + delta))) return SOUTH;
+        else if ((r > (SOUTH_WEST.r - delta)) && (r < (SOUTH_WEST.r + delta))) return SOUTH_WEST;
+        else if ((r > (NORTH_WEST.r - delta)) && (r < (NORTH_WEST.r + delta))) return NORTH_WEST;
+        else return KEEP;
+    }
+
+    public static Orientation fromMove(int col0, int row0, int col1, int row1)
+    {
+        int dx = col1 - col0;
+        int dy = row1 - row0;
+
+        if (dy == 0) {
+            if (dx == 0) return KEEP;
+            if (dx > 0) return NORTH;
+            return SOUTH;
+        }
+        if (dy > 0) {
+            if (dx > 0) return NORTH_WEST;
+            return SOUTH_WEST;
+        } else {
+            if (dx < 0) return SOUTH_EAST;
+            return NORTH_EAST;
+        }
+    }
+
+    public static Orientation fromAdj(Tile from, Tile to)
+    {
+        return fromAdj(from.col, from.row, to.col, to.row);
+    }
+
+    public static Orientation fromAdj(int col0, int row0, int col1, int row1)
+    {
+        Orientation o = KEEP;
+
+        if (row1 == row0) {
+            if (col1 == (col0 - 1)) {
+                o = SOUTH;
+            } else if (col1 == (col0 + 1)) {
+                o = NORTH;
+            }
+        } else if (row1 == (row0 - 1)) {
+            if (col1 == (col0 - 1)) {
+                o = SOUTH_EAST;
+            } else if (col1 == col0) {
+                o = NORTH_EAST;
+            }
+
+        } else if (row1 == (row0 + 1)) {
+            if (col1 == col0) {
+                o = SOUTH_WEST;
+            } else if (col1 == (col0 + 1)) {
+                o = NORTH_WEST;
+            }
+        }
+
+        return o;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Path.java b/core/src/ch/asynk/rustanddust/engine/Path.java
new file mode 100644
index 0000000..2ddf3e5
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Path.java
@@ -0,0 +1,62 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.ArrayList;
+
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.utils.Disposable;
+
+public class Path implements Disposable, Pool.Poolable
+{
+    private static final Pool<Path> pathPool = new Pool<Path>() {
+        @Override
+        protected Path newObject() {
+            return new Path();
+        }
+    };
+
+    public static Path get(int size)
+    {
+        Path p = pathPool.obtain();
+        p.init(size);
+        return p;
+    }
+
+    public static void clearPool()
+    {
+        pathPool.clear();
+    }
+
+    public int cost;
+    public boolean roadMarch;
+    public ArrayList<Tile> tiles;
+
+    public Path()
+    {
+        this.cost = -1;
+        this.roadMarch = true;
+        this.tiles = null;
+    }
+
+    protected void init(int size)
+    {
+        if (tiles == null)
+            tiles = new ArrayList<Tile>(size);
+        else
+            tiles. ensureCapacity(size);
+    }
+
+    @Override
+    public void reset()
+    {
+        cost = -1;
+        roadMarch = true;
+        tiles.clear();
+    }
+
+    @Override
+    public void dispose()
+    {
+        tiles.clear();
+        pathPool.free(this);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/PathBuilder.java b/core/src/ch/asynk/rustanddust/engine/PathBuilder.java
new file mode 100644
index 0000000..3692a91
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/PathBuilder.java
@@ -0,0 +1,266 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.LinkedList;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+
+import com.badlogic.gdx.utils.Disposable;
+import com.badlogic.gdx.math.Vector2;
+import com.badlogic.gdx.math.Vector3;
+
+public class PathBuilder implements Disposable
+{
+    private final Board board;
+
+    public Pawn pawn;
+    public Tile from;
+    public Tile to;
+    public int distance;
+    public Orientation orientation;
+    private List<Tile> stack;
+    private List<Tile> ctrlTiles;
+    private List<Path> paths;
+    private List<Path> filteredPaths;
+    private HashSet<Tile> tiles;
+
+    public PathBuilder(Board board, int tSize, int stSize, int ftSize, int vectSize)
+    {
+        this.board = board;
+        this.tiles = new LinkedHashSet<Tile>(tSize);
+        this.stack = new ArrayList<Tile>(stSize);
+        this.ctrlTiles = new ArrayList<Tile>(ftSize);
+        this.paths = new LinkedList<Path>();
+        this.filteredPaths = new LinkedList<Path>();
+        this.to = null;
+        this.pawn = null;
+        this.orientation = Orientation.KEEP;
+    }
+
+    public void init(Pawn pawn, Tile from)
+    {
+        this.pawn = pawn;
+        this.from = from;
+    }
+
+    public void init(Pawn pawn)
+    {
+        init(pawn, pawn.getTile());
+    }
+
+    public void initRotation(Pawn pawn, Orientation o)
+    {
+        init(pawn, pawn.getTile());
+        build(pawn.getTile());
+        orientation = o;
+    }
+
+    public boolean isSet()
+    {
+        return (to != null);
+    }
+
+    @Override
+    public void dispose()
+    {
+        clear();
+    }
+
+    public void clear()
+    {
+        this.to = null;
+        this.distance = -1;
+        this.orientation = Orientation.KEEP;
+        for (Path path : this.paths) path.dispose();
+        this.tiles.clear();
+        this.stack.clear();
+        this.ctrlTiles.clear();
+        this.paths.clear();
+        this.filteredPaths.clear();
+    }
+
+    public int size()
+    {
+        if (ctrlTiles.size() == 0)
+            return paths.size();
+        return filteredPaths.size();
+    }
+
+    public boolean contains(Tile tile)
+    {
+        return tiles.contains(tile);
+    }
+
+    public void enable(int i, boolean enable)
+    {
+        for (Tile tile : tiles)
+            board.enableOverlayOn(tile, i, enable);
+    }
+
+    public int build(Tile to)
+    {
+        clear();
+        this.to = to;
+        // from and to are not part of the path
+        this.distance = board.distance(from, to);
+        if (distance < 2) {
+            Orientation o = Orientation.fromMove(to.col, to.row, from.col, from.row);
+            Path path = Path.get(0);
+            path.roadMarch = to.road(o);
+            path.cost = to.costFrom(pawn, o);
+            paths.add(path);
+        } else {
+            findAllPaths(from, pawn.getMovementPoints(), true);
+        }
+
+        // printToErr("paths", paths);
+        stack.clear();
+        return paths.size();
+    }
+
+    private void findAllPaths(Tile from, int mvtLeft, boolean roadMarch)
+    {
+        Tile moves[] = new Tile[6];
+        board.setAdjacentTiles(from, moves);
+
+        for(int i = 0; i < 6; i++) {
+            Tile next = moves[i];
+            if ((next == null) || next.isOffMap()) continue;
+
+            Orientation o = board.getSide(i);
+            int m = (mvtLeft - next.costFrom(pawn, o));
+            boolean r = roadMarch & next.road(o);
+
+            int l = (m + (r ? pawn.getRoadMarchBonus() : 0));
+
+            if ((board.distance(next, to) <= l)) {
+                if (next == to) {
+                    Path path = Path.get(stack.size() + 1);
+                    for (Tile t: stack) {
+                        path.tiles.add(t);
+                        tiles.add(t);
+                    }
+                    path.roadMarch = r;
+                    path.cost = (pawn.getMovementPoints() - m);
+                    paths.add(path);
+                } else {
+                    stack.add(next);
+                    findAllPaths(next, m, r);
+                    stack.remove(stack.size() - 1);
+                }
+            }
+        }
+    }
+
+    public int toggleCtrlTile(Tile tile)
+    {
+        if (ctrlTiles.contains(tile))
+            ctrlTiles.remove(tile);
+        else
+            ctrlTiles.add(tile);
+        return filterPaths();
+    }
+
+    private int filterPaths()
+    {
+        int s = ctrlTiles.size();
+
+        tiles.clear();
+        filteredPaths.clear();
+        for (Path path : paths) {
+            int ok = 0;
+            for (Tile filter : ctrlTiles) {
+                if (path.tiles.contains(filter))
+                    ok += 1;
+            }
+            if (ok == s) {
+                if (path.tiles.size() == (s + 0)) { // from and to are not part of the path
+                    filteredPaths.clear();
+                    filteredPaths.add(path);
+                    tiles.clear();
+                    for (Tile tile : path.tiles) tiles.add(tile);
+                    break;
+                } else {
+                    filteredPaths.add(path);
+                    for (Tile tile : path.tiles) tiles.add(tile);
+                }
+            }
+        }
+
+        // printToErr("filteredPaths", filteredPaths);
+        return filteredPaths.size();
+    }
+
+    public int pathCost(int i)
+    {
+        return paths.get(i).cost;
+    }
+
+    public Move getMove()
+    {
+        if (size() != 1) {
+            System.err.println("ask for only move but they are many");
+            return null;
+        }
+
+        return Move.get(pawn, from, to, orientation, getPath(0));
+    }
+
+    public Move getExitMove()
+    {
+        Move move = getMove();
+        move.type = Move.MoveType.EXIT;
+        return move;
+    }
+
+    public boolean canExit(Orientation o)
+    {
+        List<Path> ps;
+        if (ctrlTiles.size() == 0)
+            ps = paths;
+        else
+            ps = filteredPaths;
+
+        int mvt = pawn.getMovementPoints();
+        int rBonus = pawn.getRoadMarchBonus();
+        boolean road =  to.road(o);
+        int cost = to.exitCost();
+
+        for (Path p : ps) {
+            int c = (p.cost + cost);
+            if ((c <= mvt) || (p.roadMarch && road && (c <= (mvt + rBonus))))
+                return true;
+        }
+        return false;
+    }
+
+    public Path getPath(int i)
+    {
+        if (ctrlTiles.size() == 0)
+            return paths.get(i);
+        return filteredPaths.get(i);
+    }
+
+    public void setExit(Orientation o)
+    {
+        orientation = o;
+        Path path = getPath(0);
+        if (from != to) {
+            path.cost += 1;
+            path.tiles.add(to);
+        }
+        to = board.getAdjTileAt(to, o);
+    }
+
+    private void printToErr(String what, List<Path> paths)
+    {
+        System.err.println(what + pawn + " ("+paths.size()+") " + from + " -> " + to);
+        for (Path path : paths) {
+            System.err.println(String.format(" - path (l:%d c:%d r:%b)", path.tiles.size(), path.cost, path.roadMarch));
+            for(Tile tile : path.tiles)
+                System.err.println("   " + tile.toString());
+        }
+        System.err.println();
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/PathIterator.java b/core/src/ch/asynk/rustanddust/engine/PathIterator.java
new file mode 100644
index 0000000..53f2f82
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/PathIterator.java
@@ -0,0 +1,73 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.List;
+import java.util.Iterator;
+
+import com.badlogic.gdx.math.Vector2;
+import com.badlogic.gdx.math.Vector3;
+
+public class PathIterator implements Iterator<Vector3>
+{
+    private Pawn pawn;
+    private Tile to;
+    private Orientation o;
+    private Orientation orientation;
+    private Tile tile;
+    private Vector2 pos = new Vector2();
+    private Vector3 v = new Vector3();
+    private int i;
+    private List<Tile> path;
+
+    public PathIterator(Pawn pawn, Tile from, Tile to, Orientation orientation, List<Tile> path)
+    {
+        this.pawn = pawn;
+        this.to = to;
+        this.tile = from;
+        this.orientation = orientation;
+        this.path = path;
+        this.o = pawn.getOrientation();
+        this.v.set(pawn.getPosition().x, pawn.getPosition().y, o.r());
+        this.i = 0;
+    }
+
+    @Override
+    public boolean hasNext()
+    {
+        if ((tile == to) && (o == orientation))
+            return false;
+        return true;
+    }
+
+    @Override
+    public Vector3 next()
+    {
+        if (tile == to) {
+            v.z = orientation.r();
+            o = orientation;
+            return v;
+        }
+        Tile nextTile;
+        if (i < path.size())
+            nextTile = path.get(i);
+        else
+            nextTile = to;
+        Orientation nextO = Orientation.fromMove(tile.col, tile.row, nextTile.col, nextTile.row);
+        if (nextO != o) {
+            v.z = nextO.r();
+            o = nextO;
+            return v;
+        }
+        pawn.getPosAt(nextTile, pos);
+        v.x = pos.x;
+        v.y = pos.y;
+        tile = nextTile;
+        i += 1;
+        return v;
+    }
+
+    @Override
+    public void remove()
+    {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Pawn.java b/core/src/ch/asynk/rustanddust/engine/Pawn.java
new file mode 100644
index 0000000..f95347f
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Pawn.java
@@ -0,0 +1,365 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.Iterator;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import com.badlogic.gdx.math.Vector2;
+import com.badlogic.gdx.math.Vector3;
+
+import ch.asynk.rustanddust.engine.gfx.Moveable;
+import ch.asynk.rustanddust.engine.gfx.StackedImages;
+import ch.asynk.rustanddust.engine.gfx.animations.MoveToAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.RunnableAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.AnimationSequence;
+
+public abstract class Pawn implements Moveable, Disposable
+{
+    public interface PawnType
+    {
+    }
+
+    public interface PawnId
+    {
+    }
+
+    private static final float MOVE_TIME = 0.4f;
+
+    private Vector3 position;
+    private Vector3 prevPosition;
+    private Tile tile;
+    private Tile prevTile;
+    protected Faction faction;
+    protected String descr;
+    private Sprite sprite;
+    private StackedImages overlays;
+    protected Attack attack;
+    protected Move move;
+
+    public abstract int getMovementPoints();
+    public abstract int getRoadMarchBonus();
+    public abstract int getAngleOfAttack();
+    public abstract int getFlankSides();
+    public abstract int getEngagementRangeFrom(Tile tile);
+    public abstract int getDefense(Tile tile);
+
+    public abstract boolean isUnit();
+    public abstract boolean isA(PawnId id);
+    public abstract boolean isA(PawnType type);
+    public abstract boolean isHq();
+    public abstract boolean isHqOf(Pawn other);
+    public abstract boolean isHardTarget();
+
+    public abstract boolean canMove();
+    public abstract boolean canRotate();
+    public abstract boolean canEngage();
+    public abstract boolean canEngage(Pawn other);
+    public abstract boolean canAssistEngagementWithoutLos();
+
+    public abstract void move();
+    public abstract void engage();
+
+    public abstract void revertLastMove();
+
+    protected Pawn()
+    {
+        this.tile = null;
+        this.prevTile = null;
+        this.position = new Vector3(0f, 0f, 0f);
+        this.prevPosition = new Vector3(0f, 0f, 0f);
+        this.attack = new Attack(this);
+    }
+
+    public Pawn(Faction faction, String name, TextureAtlas pawns, TextureAtlas overlays)
+    {
+        this();
+        this.faction = faction;
+        this.descr = descr;
+        this.sprite = new Sprite(pawns.findRegion(name));
+        this.overlays = new StackedImages(overlays);
+    }
+
+    @Override
+    public String toString()
+    {
+        return descr;
+    }
+
+    @Override
+    public void dispose()
+    {
+    }
+
+    @Override
+    public Faction getFaction()
+    {
+        return faction;
+    }
+
+    public void reset()
+    {
+        move = null;
+        attack.reset();
+    }
+
+    public void move(Move move)
+    {
+        switch(move.type)
+        {
+            case REGULAR:
+                if ((this.move != null) && (!this.move.isEnter()))
+                    throw new RuntimeException("try to override an existing move instance");
+                break;
+            case ENTER:
+                if (this.move != null)
+                    throw new RuntimeException("try to override an existing move instance");
+                break;
+            case SET:
+                break;
+            default:
+                throw new RuntimeException("unsupported MoveType");
+        }
+
+        this.move = move;
+        move();
+    }
+
+    public void setAttack(Pawn target, int distance)
+    {
+        attack.reset();
+        attack.target = target;
+        attack.distance = distance;
+    }
+
+    public boolean justEntered()
+    {
+        return ((move != null) && move.isEnter());
+    }
+
+    public boolean is(Faction faction)
+    {
+        return (this.faction == faction);
+    }
+
+    public boolean isEnemy(Faction other)
+    {
+        return faction.isEnemy(other);
+    }
+
+    public boolean isEnemy(Pawn other)
+    {
+        return faction.isEnemy(other.faction);
+    }
+
+    public boolean isFlankAttack()
+    {
+        return (attack.isClear && attack.isFlank);
+    }
+
+    public int attackDistance()
+    {
+        return attack.distance;
+    }
+
+    public Tile getTile()
+    {
+        return tile;
+    }
+
+    public Tile getPreviousTile()
+    {
+        return prevTile;
+    }
+
+    public Vector3 getPosition()
+    {
+        return position;
+    }
+
+    public Vector3 getPreviousPosition()
+    {
+        return prevPosition;
+    }
+
+    private void revertPosition()
+    {
+        this.tile = this.prevTile;
+        this.prevTile = null;
+        position.set(prevPosition);
+        prevPosition.set(0f, 0f, 0f);
+        setPosition(position.x, position.y, position.z);
+    }
+
+    public float getCenterX()
+    {
+        return (getX() + (getWidth() / 2f));
+    }
+
+    public float getCenterY()
+    {
+        return (getY() + (getHeight() / 2f));
+    }
+
+    public Vector2 getPosAt(Tile tile, Vector2 pos)
+    {
+        float x = (tile.getX() - (getWidth() / 2f));
+        float y = (tile.getY() - (getHeight() / 2f));
+        if (pos == null)
+            return new Vector2(x, y);
+        else
+            pos.set(x, y);
+        return pos;
+    }
+
+    public void setOnTile(Tile tile, float z)
+    {
+        this.prevTile = this.tile;
+        this.tile = tile;
+        float x = (tile.getX() - (getWidth() / 2f));
+        float y = (tile.getY() - (getHeight() / 2f));
+        setPosition(x, y, z);
+    }
+
+    @Override
+    public void setAlpha(float alpha)
+    {
+        sprite.setAlpha(alpha);
+        overlays.setAlpha(alpha);
+    }
+
+    @Override
+    public float getX()
+    {
+        return sprite.getX();
+    }
+
+    @Override
+    public float getY()
+    {
+        return sprite.getY();
+    }
+
+    @Override
+    public float getWidth()
+    {
+        return sprite.getWidth();
+    }
+
+    @Override
+    public float getHeight()
+    {
+        return sprite.getHeight();
+    }
+
+    @Override
+    public float getRotation()
+    {
+        return sprite.getRotation();
+    }
+
+    public Orientation getOrientation()
+    {
+        return Orientation.fromRotation(getRotation());
+    }
+
+    public void translate(float dx, float dy)
+    {
+        setPosition((getX() + dx), (getY() + dy));
+    }
+
+    public void centerOn(float x, float y)
+    {
+        setPosition((x - (getWidth() / 2f)), (y - (getHeight() / 2f)));
+    }
+
+    @Override
+    public void setPosition(float x, float y)
+    {
+        position.set(x, y, 0f);
+        sprite.setPosition(x, y);
+        float cx = x + (getWidth() / 2f);
+        float cy = y + (getHeight() / 2f);
+        overlays.centerOn(cx, cy);
+    }
+
+    public void setRotation(float z)
+    {
+        position.z = z;
+        sprite.setRotation(z);
+        overlays.setRotation(z);
+    }
+
+    @Override
+    public void setPosition(float x, float y, float z)
+    {
+        setPosition(x, y);
+        setRotation(z);
+    }
+
+    public boolean hasOverlayEnabled()
+    {
+        return overlays.isEnabled();
+    }
+
+    public boolean enableOverlay(int i, boolean enable)
+    {
+        overlays.enable(i, enable);
+        if (enable) return true;
+        return hasOverlayEnabled();
+    }
+
+    public AnimationSequence getRotateAnimation(float z, int size)
+    {
+        prevPosition.set(position);
+        AnimationSequence seq = AnimationSequence.get(1 + size);
+        seq.addAnimation(MoveToAnimation.get(this, position.x, position.y, z, MOVE_TIME));
+
+        return seq;
+    }
+
+    public AnimationSequence getMoveAnimation(Iterator<Vector3> vectors, int size, MoveToAnimation.MoveToAnimationCb cb)
+    {
+        prevPosition.set(position);
+        AnimationSequence seq = AnimationSequence.get(size);
+        while (vectors.hasNext())
+            seq.addAnimation(MoveToAnimation.get(this, vectors.next(), MOVE_TIME, cb));
+
+        return seq;
+    }
+
+    public AnimationSequence getRevertLastMoveAnimation(int size)
+    {
+        AnimationSequence seq = AnimationSequence.get(2 + size);
+        seq.addAnimation(MoveToAnimation.get(this, prevPosition, MOVE_TIME));
+        seq.addAnimation(RunnableAnimation.get(this, new Runnable() {
+            @Override
+            public void run() {
+                revertPosition();
+            }
+        }));
+
+        return seq;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        sprite.draw(batch);
+        overlays.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        float w = sprite.getWidth();
+        float h = sprite.getHeight();
+        debugShapes.rect(sprite.getX(), sprite.getY(), (w / 2f), (h / 2f), w, h, sprite.getScaleX(), sprite.getScaleY(), sprite.getRotation());
+        overlays.drawDebug(debugShapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/SearchBoard.java b/core/src/ch/asynk/rustanddust/engine/SearchBoard.java
new file mode 100644
index 0000000..1d8ed88
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/SearchBoard.java
@@ -0,0 +1,545 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.ArrayDeque;
+import java.util.Iterator;
+import java.util.Collection;
+
+public class SearchBoard
+{
+    public class Node
+    {
+        public int col;
+        public int row;
+        public int search;
+        public int remaining;
+        public Node parent;
+        public boolean roadMarch;
+
+        public Node(int col, int row)
+        {
+            this.col = col;
+            this.row = row;
+        }
+
+        @Override
+        public String toString()
+        {
+            return col + ";" + row;
+        }
+    }
+
+    private int cols;
+    private int rows;
+    private Board board;
+    private int searchCount;
+    private Node nodes[];
+
+    private ArrayDeque<Node> stack;
+    private LinkedList<Node> queue;
+    private ArrayDeque<Node> roadMarch;
+    private List<Node> los;
+
+    public SearchBoard(Board board, int cols, int rows)
+    {
+        this.cols = cols;
+        this.rows = rows;
+        this.board = board;
+        this.searchCount = 0;
+
+        this.nodes = new Node[cols * rows];
+        for (int j = 0; j < rows; j++) {
+            int dx = ((j + 1) / 2);
+            for (int i = 0; i < cols; i++)
+                nodes[i + (j * cols)] = new Node((i + dx), j);
+        }
+
+        this.queue = new LinkedList<Node>();
+        this.stack = new ArrayDeque<Node>(20);
+        this.roadMarch = new ArrayDeque<Node>(5);
+        this.los = new ArrayList<Node>(10);
+    }
+
+    private boolean inMap(int col, int row)
+    {
+        if ((row < 0) || (row >= rows))
+            return false;
+
+        int colOffset = ((row + 1) / 2);
+        if ((col < colOffset) || ((col - colOffset) >= cols))
+            return false;
+
+        return true;
+    }
+
+    private Tile getTile(Node node)
+    {
+        return board.getTile(node.col, node.row);
+    }
+
+    private Node getNode(Tile tile)
+    {
+        return getNode(tile.col, tile.row);
+    }
+
+    protected Node getNode(int col, int row)
+    {
+        int colOffset = ((row + 1) / 2);
+        if ((col < colOffset) || (row < 0) || (row >= rows) || ((col - colOffset) >= cols))
+            return null;
+
+        return nodes[((col - colOffset)) + (row * cols)];
+    }
+
+    public int distance(Node from, Node to)
+    {
+        return board.distance(from.col, from.row, to.col, to.row);
+    }
+
+    public void adjacentMoves(Node src, Node a[])
+    {
+        // move to enter dst by sides[i]
+        a[0] = getNode((src.col - 1), src.row);
+        a[1] = getNode(src.col, (src.row + 1));
+        a[2] = getNode((src.col + 1), (src.row + 1));
+        a[3] = getNode((src.col + 1), src.row);
+        a[4] = getNode(src.col, (src.row - 1));
+        a[5] = getNode((src.col - 1), (src.row - 1));
+    }
+
+    public int possibleMovesFrom(Pawn pawn, Collection<Tile> moves)
+    {
+        moves.clear();
+        searchCount += 1;
+
+        Node adjacents[] = new Node[6];
+
+        Node from = getNode(pawn.getTile());
+        from.parent = null;
+        from.search = searchCount;
+        from.remaining = pawn.getMovementPoints();
+        from.roadMarch = true;
+
+        if (from.remaining <= 0)
+            return moves.size();
+
+        int roadMarchBonus = pawn.getRoadMarchBonus();
+        boolean first = true;
+
+        stack.push(from);
+
+        while (stack.size() != 0) {
+            Node src = stack.pop();
+
+            if (src.remaining < 0)
+                continue;
+            if (src.remaining == 0) {
+                if (src.roadMarch)
+                    roadMarch.push(src);
+                continue;
+            }
+
+            adjacentMoves(src, adjacents);
+
+            for(int i = 0; i < 6; i++) {
+                Node dst = adjacents[i];
+                if (dst != null) {
+
+                    Tile t = getTile(dst);
+                    int cost = t.costFrom(pawn, board.getSide(i));
+                    boolean mayMoveOne = first && t.atLeastOneMove(pawn);
+                    int r = src.remaining - cost;
+                    boolean roadMarch = (src.roadMarch && t.road(board.getSide(i)));
+
+                    if (dst.search == searchCount) {
+                        if ((r >= 0) && ((r > dst.remaining) || (roadMarch && ((r + roadMarchBonus) >= dst.remaining)))) {
+                            dst.remaining = r;
+                            dst.parent = src;
+                            dst.roadMarch = roadMarch;
+                            stack.push(dst);
+                            moves.add(getTile(dst));
+                        }
+                    } else {
+                        dst.search = searchCount;
+                        if ((r >= 0) || mayMoveOne) {
+                            dst.parent = src;
+                            dst.remaining = r;
+                            dst.roadMarch = roadMarch;
+                            stack.push(dst);
+                            moves.add(getTile(dst));
+                        } else {
+                            dst.parent = null;
+                            dst.remaining = -1;
+                        }
+                    }
+                }
+            }
+            first = false;
+        }
+
+        for (Node n : roadMarch) n.remaining = roadMarchBonus;
+        while(roadMarch.size() != 0) {
+            Node src = roadMarch.pop();
+
+            adjacentMoves(src, adjacents);
+
+            for(int i = 0; i < 6; i++) {
+                Node dst = adjacents[i];
+                if (dst != null) {
+
+                    Tile t = getTile(dst);
+                    if (!t.road(board.getSide(i)))
+                        continue;
+                    int cost = t.costFrom(pawn, board.getSide(i));
+                    int r = src.remaining - cost;
+
+                    if (dst.search == searchCount) {
+                        if ((r >= 0) && (r > dst.remaining)) {
+                            dst.remaining = r;
+                            dst.parent = src;
+                            dst.roadMarch = true;
+                            roadMarch.push(dst);
+                            moves.add(getTile(dst));
+                        }
+                    } else {
+                        dst.search = searchCount;
+                        if (r >= 0) {
+                            dst.parent = src;
+                            dst.remaining = r;
+                            dst.roadMarch = true;
+                            roadMarch.push(dst);
+                            moves.add(getTile(dst));
+                        } else {
+                            dst.parent = null;
+                            dst.remaining = -1;
+                        }
+                    }
+                }
+            }
+        }
+
+        return moves.size();
+    }
+
+    private void adjacentTargets(Node src, int angle, Node a[])
+    {
+        // move in allowed directions
+        if (Orientation.NORTH.isInSides(angle))
+            a[0] = getNode((src.col + 1), src.row);
+        else
+            a[0] = null;
+
+        if (Orientation.NORTH_EAST.isInSides(angle))
+            a[1] = getNode(src.col, (src.row - 1));
+        else
+            a[1] = null;
+
+        if (Orientation.SOUTH_EAST.isInSides(angle))
+            a[2] = getNode((src.col - 1), (src.row - 1));
+        else
+            a[2] = null;
+
+        if (Orientation.SOUTH.isInSides(angle))
+            a[3] = getNode((src.col - 1), src.row);
+        else
+            a[3] = null;
+
+        if (Orientation.SOUTH_WEST.isInSides(angle))
+            a[4] = getNode(src.col, (src.row + 1));
+        else
+            a[4] = null;
+
+        if (Orientation.NORTH_WEST.isInSides(angle))
+            a[5] = getNode((src.col + 1), (src.row + 1));
+        else
+            a[5] = null;
+    }
+
+    public int possibleTargetsFrom(Pawn pawn, Collection<Pawn> targets)
+    {
+        targets.clear();
+        searchCount += 1;
+
+        Node adjacents[] = new Node[6];
+
+        int range = pawn.getEngagementRangeFrom(pawn.getTile());
+        int angle = pawn.getAngleOfAttack();
+        int extendedAngle = pawn.getOrientation().opposite().allBut();
+
+        Node from = getNode(pawn.getTile());
+        from.search = searchCount;
+        from.remaining = range;
+
+        if (range <= 0)
+            return targets.size();
+
+        queue.add(from);
+
+        boolean first = true;
+        while (queue.size() != 0) {
+            Node src = queue.remove();
+
+            if (src.remaining <= 0)
+                continue;
+
+            if (!first && (((range - src.remaining) % 2) == 0))
+                adjacentTargets(src, extendedAngle, adjacents);
+            else
+                adjacentTargets(src, angle, adjacents);
+
+            first = false;
+            int rangeLeft = src.remaining - 1;
+
+            for(int i = 0; i < 6; i++) {
+                Node dst = adjacents[i];
+                if (dst != null) {
+                    if (dst.search == searchCount) {
+                        if ((rangeLeft > dst.remaining))
+                            dst.remaining = rangeLeft;
+                    } else {
+                        dst.search = searchCount;
+                        dst.remaining = rangeLeft;
+                        queue.add(dst);
+                        Tile t = getTile(dst);
+                        if (hasClearLineOfSight(from, dst, angle)) {
+                            Iterator<Pawn> it = t.iterator();
+                            while (it.hasNext()) {
+                                Pawn target = it.next();
+                                if (pawn.canEngage(target))
+                                    targets.add(target);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return targets.size();
+    }
+
+    public boolean canAttack(Pawn pawn, Pawn target, boolean clearVisibility)
+    {
+        Node from = getNode(pawn.getTile());
+        Node to = getNode(target.getTile());
+
+        pawn.setAttack(target, distance(from, to));
+
+        if (pawn.attack.distance > pawn.getEngagementRangeFrom(pawn.getTile()))
+            return false;
+
+        List<Node> los = lineOfSight(from.col, from.row, to.col, to.row, clearVisibility);
+        Node last = los.get(los.size() -1);
+        if (last != to)
+            return false;
+
+        if (!validatePathAngle(pawn.getAngleOfAttack(), los))
+            return false;
+
+        pawn.attack.isClear = isClearAttack(getTile(from), los);
+        pawn.attack.isFlank = isFlankAttack(target.getFlankSides(), los);
+
+        return true;
+    }
+
+    private boolean hasClearLineOfSight(Node from, Node to, int angleOfAttack)
+    {
+        List<Node> los = lineOfSight(from.col, from.row, to.col, to.row, true);
+        Node last = los.get(los.size() -1);
+        if ((last.col != to.col) || (last.row != to.row))
+            return false;
+        return validatePathAngle(angleOfAttack, los);
+    }
+
+    private boolean isFlankAttack(int angle, List<Node> los)
+    {
+        Node from = los.get(los.size() - 2);
+        Node to = los.get(los.size() - 1);
+        Orientation o = Orientation.fromMove(to.col, to.row, from.col, from.row);
+        return o.isInSides(angle);
+    }
+
+    private boolean isClearAttack(Tile from, List<Node> los)
+    {
+        int n = los.size() - 1;
+        for (int i = 1; i < n; i++) {
+            if (getTile(los.get(i)).blockLineOfSightFrom(from))
+                return false;
+        }
+        return true;
+    }
+
+    private boolean validatePathAngle(int angle, List<Node> los)
+    {
+        int forth = 0;
+        Node prev = null;
+        for (Node next : los) {
+            if (prev != null) {
+                Orientation o = Orientation.fromMove(prev.col, prev.row, next.col, next.row);
+                if (!o.isInSides(angle)) {
+                    forth -= 1;
+                    if (forth < 0)
+                        return false;
+                }
+                forth += 1;
+            }
+            prev = next;
+        }
+
+        return true;
+    }
+
+    public List<Node> lineOfSight(int x0, int y0, int x1, int y1, boolean clearVisibility)
+    {
+        los.clear();
+        Tile from = board.getTile(x0, y0);
+
+        // orthogonal axis
+        int ox0 = x0 - ((y0 +1) / 2);
+        int ox1 = x1 - ((y1 +1) / 2);
+
+        int dy = y1 - y0;
+        int dx = ox1 - ox0;
+
+        int xs = 1;
+        int ys = 1;
+        if (dx < 0) xs = -1;
+        if (dy < 0) ys = -1;
+        boolean sig = !(((dx < 0) && (dy >= 0)) || ((dx >= 0) && (dy < 0)));
+
+        dy = Math.abs(dy);
+        dx = Math.abs(2 * dx);
+        if ((dy % 2) == 1) {
+            if ((y0 % 2) == 0) dx += xs;
+            else {
+                dx -= xs;
+                Math.abs(dx);
+            }
+        }
+
+        if (dx == 0)
+            return verticalLineOfSight(x0, y0, x1, y1, clearVisibility);
+        if (dx == (3 * dy))
+            return diagonalLineOfSight(x0, y0, x1, y1, clearVisibility);
+
+        int dx3 = 3 * dx;
+        int dy3 = 3 * dy;
+
+        int x = x0;
+        int y = y0;
+        int e = -2 * dx;
+
+        boolean flat = (dx > (3 * dy));
+        boolean diag = (dx == (3 * dy));
+
+        los.add(getNode(x, y));
+        while((x != x1) || (y != y1)) {
+            if (e > 0) {
+                e -= (dy3 + dx3);
+                y += ys;
+                if (!sig)
+                    x -= xs;
+            } else {
+                e += dy3;
+                if ((e > -dx) || (!flat && (e == -dx))) {
+                    e -= dx3;
+                    y += ys;
+                    if (sig)
+                        x += xs;
+                } else if ((e < -dx3) || (diag && (e == -dx3))) {
+                    e += dx3;
+                    y -= ys;
+                    if (!sig)
+                        x += xs;
+                } else {
+                    e += dy3;
+                    x += xs;
+                }
+            }
+            los.add(getNode(x, y));
+            if(clearVisibility && board.getTile(x, y).blockLineOfSightFrom(from)) return los;
+        }
+
+        return los;
+    }
+
+    private List<Node> verticalLineOfSight(int x0, int y0, int x1, int y1, boolean clearVisibility)
+    {
+        Tile from = board.getTile(x0, y0);
+
+        int d = ( (y1 > y0) ? 1 : -1);
+        int x = x0;
+        int y = y0;
+
+        Tile t = null;
+        los.add(getNode(x, y));
+        while((x != x1) || (y != y1)) {
+            boolean ok = false;
+
+            y += d;
+            t = board.getTile(x, y);
+            if (!t.isOffMap()) los.add(getNode(x, y));
+            if (!clearVisibility || !t.blockLineOfSightFrom(from))
+                ok = true;
+
+            x += d;
+            t = board.getTile(x, y);
+            if (!t.isOffMap()) los.add(getNode(x, y));
+            if (!clearVisibility || !t.blockLineOfSightFrom(from))
+                ok = true;
+
+            if (!ok)
+                return los;
+
+            y += d;
+            t = board.getTile(x, y);
+            if (!t.isOffMap()) los.add(getNode(x, y));
+        }
+
+        return los;
+    }
+
+    private List<Node> diagonalLineOfSight(int x0, int y0, int x1, int y1, boolean clearVisibility)
+    {
+        Tile from = board.getTile(x0, y0);
+
+        int dy = ( (y1 > y0) ? 1 : -1);
+        int dx = ( (x1 > x0) ? 1 : -1);
+        boolean sig = !(((dx < 0) && (dy >= 0)) || ((dx >= 0) && (dy < 0)));
+
+        int x = x0;
+        int y = y0;
+
+        Tile t = null;
+        los.add(getNode(x, y));
+        while((x != x1) || (y != y1)) {
+            boolean ok = false;
+
+            x += dx;
+            t = board.getTile(x, y);
+            if (!t.isOffMap()) los.add(getNode(x, y));
+            if (!clearVisibility || !t.blockLineOfSightFrom(from))
+                ok = true;
+
+            y += dy;
+            if (!sig)
+                x -= dx;
+            t = board.getTile(x, y);
+            if (!t.isOffMap()) los.add(getNode(x, y));
+            if (!clearVisibility || !t.blockLineOfSightFrom(from))
+                ok = true;
+
+            if (!ok)
+                return los;
+
+            x += dx;
+            t = board.getTile(x, y);
+            if (!t.isOffMap()) los.add(getNode(x, y));
+        }
+
+        return los;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/SelectedTile.java b/core/src/ch/asynk/rustanddust/engine/SelectedTile.java
new file mode 100644
index 0000000..0e1d8ac
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/SelectedTile.java
@@ -0,0 +1,80 @@
+package ch.asynk.rustanddust.engine;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+import ch.asynk.rustanddust.engine.gfx.animations.Sprites;
+
+public class SelectedTile implements Disposable, Drawable, Animation
+{
+    private Sprites sprites;
+    public Tile tile;
+    public boolean visible;
+    public float x;
+    public float y;
+    private float elapsed;
+    private int frame;
+    private float[] seq;
+
+    public SelectedTile(Texture texture, float[] seq)
+    {
+        this.sprites = new Sprites(texture, seq.length, 1);
+        this.visible = false;
+        this.tile = null;
+        this.elapsed = 0f;
+        this.seq = seq;
+    }
+
+    public void hide()
+    {
+        tile = null;
+        visible = false;
+    }
+
+    public void set(Tile tile)
+    {
+        this.visible = true;
+        this.tile = tile;
+        this.frame = 0;
+        this.elapsed = 0f;
+        this.x = (tile.getX() - (sprites.width / 2f));
+        this.y = (tile.getY() - (sprites.height / 2f));
+    }
+
+    public void dispose()
+    {
+        sprites.dispose();
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        if (visible) {
+            elapsed += delta;
+            if (elapsed > seq[frame]) {
+                frame = ((frame + 1) % sprites.frames.length);
+                elapsed = 0f;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (visible)
+            batch.draw(sprites.frames[frame], x, y);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        if (visible)
+            debugShapes.rect(x, y, sprites.width, sprites.height);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/Tile.java b/core/src/ch/asynk/rustanddust/engine/Tile.java
new file mode 100644
index 0000000..f44e763
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/Tile.java
@@ -0,0 +1,175 @@
+package ch.asynk.rustanddust.engine;
+
+import java.util.List;
+import java.util.Iterator;
+import java.util.ArrayDeque;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.math.Vector2;
+
+import ch.asynk.rustanddust.engine.Board;
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+import ch.asynk.rustanddust.engine.gfx.StackedImages;
+
+public abstract class Tile implements Drawable, Disposable, Iterable<Pawn>
+{
+    public interface TileTerrain
+    {
+    }
+
+    protected int col;
+    protected int row;
+    protected float x;
+    protected float y;
+    private StackedImages overlays;
+    protected ArrayDeque<Pawn> stack;
+
+    public abstract int defense();
+    public abstract int exitCost();
+    public abstract int costFrom(Pawn pawn, Orientation side);
+
+    public abstract boolean isOffMap();
+    public abstract boolean isA(TileTerrain terrain);
+    public abstract boolean road(Orientation side);
+    public abstract boolean atLeastOneMove(Pawn pawn);
+    public abstract boolean blockLineOfSightFrom(Tile tile);
+
+    protected Tile(int col, int row)
+    {
+        this.col = col;
+        this.row = row;
+    }
+
+    public Tile(float x, float y, int col, int row, TextureAtlas atlas)
+    {
+        this.stack = new ArrayDeque<Pawn>();
+        this.x = x;
+        this.y = y;
+        this.col = col;
+        this.row = row;
+        this.overlays = new StackedImages(atlas);
+        this.overlays.centerOn(x, y);
+    }
+
+    public float getX() { return x; }
+    public float getY() { return y; }
+    public int getCol() { return col; }
+    public int getRow() { return row; }
+
+    @Override
+    public String toString()
+    {
+        return String.format("(%d;%d) %s", col, row, (isOffMap() ? "x" : ""));
+    }
+
+    public String toShort()
+    {
+        return String.format("(%d;%d)", col, row);
+    }
+
+    @Override
+    public void dispose()
+    {
+        stack.clear();
+        overlays.dispose();
+    }
+
+    public boolean isEmpty()
+    {
+        return stack.isEmpty();
+    }
+
+    public Iterator<Pawn> iterator()
+    {
+        return stack.iterator();
+    }
+
+    public int push(Pawn pawn)
+    {
+        if (!stack.contains(pawn))
+            stack.push(pawn);
+        return stack.size();
+    }
+
+    public int remove(Pawn pawn)
+    {
+        stack.remove(pawn);
+        return stack.size();
+    }
+
+    private Pawn getTopPawn()
+    {
+        if (isEmpty()) return null;
+        return stack.getFirst();
+    }
+
+    public boolean hasUnits()
+    {
+        if (isEmpty()) return false;
+        Iterator<Pawn> itr = iterator();
+        while(itr.hasNext()) {
+            if (itr.next().isUnit())
+                return true;
+        }
+        return false;
+    }
+
+    public boolean mustBeDrawn()
+    {
+        if (!isEmpty()) return true;
+        return hasOverlayEnabled();
+    }
+
+    public boolean disableOverlays()
+    {
+        overlays.disableAll();
+        return !isEmpty();
+    }
+
+    public boolean hasOverlayEnabled()
+    {
+        return overlays.isEnabled();
+    }
+
+    public boolean isOverlayEnabled(int i)
+    {
+        return overlays.isEnabled(i);
+    }
+
+    public boolean enableOverlay(int i, boolean enable)
+    {
+        overlays.enable(i, enable);
+        if (enable) return true;
+        return mustBeDrawn();
+    }
+
+    public boolean enableOverlay(int i, boolean enable, float r)
+    {
+        overlays.enable(i, enable);
+        overlays.rotate(i, r);
+        if (enable) return true;
+        return mustBeDrawn();
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        overlays.draw(batch);
+        Pawn pawn = getTopPawn();
+        if (pawn != null)
+            pawn.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        overlays.drawDebug(debugShapes);
+        Pawn pawn = getTopPawn();
+        if (pawn != null)
+            pawn.drawDebug(debugShapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/Animation.java b/core/src/ch/asynk/rustanddust/engine/gfx/Animation.java
new file mode 100644
index 0000000..eb973de
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/Animation.java
@@ -0,0 +1,8 @@
+package ch.asynk.rustanddust.engine.gfx;
+
+import com.badlogic.gdx.utils.Disposable;
+
+public interface Animation extends Disposable, Drawable
+{
+    public boolean animate(float delta);
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/Drawable.java b/core/src/ch/asynk/rustanddust/engine/gfx/Drawable.java
new file mode 100644
index 0000000..d405faa
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/Drawable.java
@@ -0,0 +1,10 @@
+package ch.asynk.rustanddust.engine.gfx;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+public interface Drawable
+{
+    public void draw(Batch batch);
+    public void drawDebug(ShapeRenderer debugShapes);
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/Moveable.java b/core/src/ch/asynk/rustanddust/engine/gfx/Moveable.java
new file mode 100644
index 0000000..e8790ab
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/Moveable.java
@@ -0,0 +1,16 @@
+package ch.asynk.rustanddust.engine.gfx;
+
+import ch.asynk.rustanddust.engine.Faction;
+
+public interface Moveable extends Drawable
+{
+    public void setAlpha(float alpha);
+    public float getX();
+    public float getY();
+    public float getWidth();
+    public float getHeight();
+    public float getRotation();
+    public void setPosition(float x, float y);
+    public void setPosition(float x, float y, float r);
+    public Faction getFaction();
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/StackedImages.java b/core/src/ch/asynk/rustanddust/engine/gfx/StackedImages.java
new file mode 100644
index 0000000..6d4fd1f
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/StackedImages.java
@@ -0,0 +1,99 @@
+package ch.asynk.rustanddust.engine.gfx;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.utils.Array;
+
+public class StackedImages implements Drawable, Disposable
+{
+    private boolean enabled[];
+    private Array<Sprite> sprites;
+
+    public StackedImages(TextureAtlas atlas)
+    {
+        this.sprites = atlas.createSprites();
+        this.enabled = new boolean[sprites.size];
+    }
+
+    @Override
+    public void dispose()
+    {
+    }
+
+    public void disableAll()
+    {
+        for (int i = 0; i < sprites.size; i++)
+            enabled[i] = false;
+    }
+
+    public void enable(int i, boolean enable)
+    {
+        enabled[i] = enable;
+    }
+
+    public boolean isEnabled(int i)
+    {
+        return enabled[i];
+    }
+
+    public boolean isEnabled()
+    {
+        for (int i = 0; i < sprites.size; i++)
+            if (enabled[i]) return true;
+        return false;
+    }
+
+    public void setAlpha(float alpha)
+    {
+        for (int i = 0, n = sprites.size; i < n; i++)
+            sprites.get(i).setAlpha(alpha);
+    }
+
+    public void rotate(int i, float r)
+    {
+        sprites.get(i).setRotation(r);
+    }
+
+    public void setRotation(float r)
+    {
+        for (int i = 0, n = sprites.size; i < n; i++)
+            sprites.get(i).setRotation(r);
+    }
+
+    public void translate(float dx, float dy)
+    {
+        for (int i = 0, n =  sprites.size; i < n; i++)
+            sprites.get(i).translate(dx, dy);
+    }
+
+    public void centerOn(float cx, float cy)
+    {
+        for (int i = 0, n = sprites.size; i < n; i++) {
+            float x = (cx - (sprites.get(i).getWidth() / 2f));
+            float y = (cy - (sprites.get(i).getHeight() / 2f));
+            sprites.get(i).setPosition(x, y);
+        }
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        for (int i = 0, n = sprites.size; i < n; i++) {
+            if (enabled[i])
+                sprites.get(i).draw(batch);
+        }
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        Sprite sprite = sprites.get(0);
+        float w = sprite.getWidth();
+        float h = sprite.getHeight();
+        shapes.rect(sprite.getX(), sprite.getY(), (w / 2f), (h / 2f), w, h, sprite.getScaleX(), sprite.getScaleY(), sprite.getRotation());
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/AnimationSequence.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/AnimationSequence.java
new file mode 100644
index 0000000..fdd1e80
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/AnimationSequence.java
@@ -0,0 +1,76 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import java.util.ArrayList;
+
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class AnimationSequence implements Animation, Pool.Poolable
+{
+    private ArrayList<Animation> animations;
+
+    private static final Pool<AnimationSequence> animationSequencePool = new Pool<AnimationSequence>() {
+        @Override
+        protected AnimationSequence newObject() {
+            return new AnimationSequence();
+        }
+    };
+
+    public static AnimationSequence get(int capacity)
+    {
+        AnimationSequence seq = animationSequencePool.obtain();
+        if (seq.animations == null)
+            seq.animations = new ArrayList<Animation>(capacity);
+        else
+            seq.animations.ensureCapacity(capacity);
+
+        return seq;
+    }
+
+    @Override
+    public void reset()
+    {
+        for (int i = 0, n = animations.size(); i < n; i++)
+            animations.get(i).dispose();
+        animations.clear();
+    }
+
+    @Override
+    public void dispose()
+    {
+        animationSequencePool.free(this);
+    }
+
+    public void addAnimation(Animation animation)
+    {
+        animations.add(animation);
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        if(animations.isEmpty()) return true;
+
+        Animation animation = animations.get(0);
+        if (animation.animate(delta)) {
+            animations.remove(0);
+        }
+
+        return (animations.isEmpty());
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        animations.get(0).draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        animations.get(0).drawDebug(debugShapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/DestroyAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/DestroyAnimation.java
new file mode 100644
index 0000000..d1fc1bb
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/DestroyAnimation.java
@@ -0,0 +1,62 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import com.badlogic.gdx.utils.Disposable;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Moveable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class DestroyAnimation implements Disposable, Animation
+{
+    private static final float DELAY = 1.5f;
+    private static final float DURATION = 1.5f;
+
+    private Moveable moveable;
+    private float x;
+    private float y;
+    private int alphaP;
+    private float elapsed;
+
+    @Override
+    public void dispose()
+    {
+    }
+
+    public void set(float duration, Moveable moveable)
+    {
+        this.moveable = moveable;
+        this.alphaP = 0;
+        this.elapsed = 0f;
+        this.x = (moveable.getX() + (moveable.getWidth() / 2f));
+        this.y = (moveable.getY() + (moveable.getHeight() / 2f));
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        elapsed += delta;
+        if (elapsed < DELAY)
+            return false;
+
+        int a = (int) (((elapsed - DELAY) / DURATION) * 10);
+        if (a != alphaP) {
+            alphaP = a;
+            moveable.setAlpha(1f - (alphaP / 10f));
+        }
+
+        return (elapsed >= (DELAY + DURATION));
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        moveable.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        moveable.drawDebug(debugShapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/DiceAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/DiceAnimation.java
new file mode 100644
index 0000000..1a0a3bb
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/DiceAnimation.java
@@ -0,0 +1,141 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import java.util.Random;
+
+import com.badlogic.gdx.audio.Sound;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class DiceAnimation implements Animation, Drawable
+{
+    private static final float DURATION = 0.7f;
+    private static final float DURATION_SCATTERING = 0.5f;
+    private static final int DICE_DIMENSION = 24;
+
+    private static Random random = new Random();
+    private static Sprites dice;
+    private static Sound sound;
+    private static double sndId;
+    private static float volume;
+    private static int[][] rolls = new int[][]{
+        { 25, 40, 55, 70, 85, 100, 115, 99, 83, 67, 51, 36, 37, 52, 67, 66, 65, 64 },
+        { 58, 74, 59, 60, 45, 62, 78, 94, 109, 108, 123, 106, 89, 71, 70, 69, 68 },
+        { 106, 121, 120, 103, 86, 70, 54, 37, 20, 19, 18, 34, 50, 51, 52, 69, 86, 103, 119, 128 },
+        { 95, 79, 93, 92, 91, 90, 104, 103, 102, 85, 84, 67, 66, 65, 49, 32, 16, 0 },
+        { 22, 39, 56, 73, 90, 107, 124, 128, 113, 98, 83, 68, 53, 38, 23, 0, 25, 42, 59, 76 },
+        { 79, 78, 61, 76, 91, 106, 121, 120, 119, 102, 101, 84, 68, 52, 37, 38, 39, 40, 41, 58, 75, 74, 73, 72 },
+    };
+
+    private float x;
+    private float y;
+    private int frame;
+    private int[] roll;
+    private float elapsed;
+    private float duration;
+    // public boolean stop;
+
+    public static void init(Texture texture, int cols, int rows, Sound s)
+    {
+        dice = new Sprites(texture, cols, rows);
+        sound = s;
+        sndId = -1;
+    }
+
+    public static void initSound(float v)
+    {
+        sndId = -1;
+        volume = v;
+    }
+
+    public static void free()
+    {
+        sound.dispose();
+        dice.dispose();
+    }
+
+    public void translate(float dx, float dy)
+    {
+        x += dx;
+        y += dy;
+    }
+
+    public float getX()
+    {
+        return x;
+    }
+
+    public float getY()
+    {
+        return y;
+    }
+
+    public int getWidth()
+    {
+        return DICE_DIMENSION;
+    }
+
+    public int getHeight()
+    {
+        return DICE_DIMENSION;
+    }
+
+    public void setPosition(float x, float y)
+    {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void set(int result)
+    {
+        this.frame = 0;
+        this.elapsed = 0f;
+        this.roll = rolls[result - 1];
+        this.duration = DURATION + (DURATION_SCATTERING * random.nextFloat());
+        // this.stop = false;
+    }
+
+    public boolean isDone()
+    {
+        return (elapsed >= duration);
+    }
+
+    @Override
+    public void dispose()
+    {
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        // if (stop)
+            // return true;
+        elapsed += delta;
+        if (elapsed < duration) {
+            int idx = (int) (roll.length * elapsed / duration);
+            if (idx >= roll.length)
+                idx = (roll.length -1);
+            frame = roll[idx];
+        }
+        if (sndId == -1)
+            sndId = sound.play(volume);
+
+        return false;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        batch.draw(dice.frames[frame], x, y, DICE_DIMENSION, DICE_DIMENSION);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        debugShapes.rect(x, y, dice.frames[frame].getRegionWidth(), dice.frames[frame].getRegionHeight());
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/FireAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/FireAnimation.java
new file mode 100644
index 0000000..5835525
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/FireAnimation.java
@@ -0,0 +1,87 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import java.util.Random;
+
+import com.badlogic.gdx.audio.Sound;
+import com.badlogic.gdx.graphics.Texture;
+
+public class FireAnimation
+{
+    public static Random random = new Random();
+
+    public static Sprites infantryFire;
+    public static Sprites tankFire;
+    public static Sprites explosion;
+
+    public static Sound infantryFireSnd;
+    public static Sound tankFireSnd;
+    public static Sound tankFireSndLong;
+    public static Sound explosionSnd;
+    public static Sound explosionSndLong;
+
+    public static double infantryFireSndLongId;
+    public static double tankFireSndLongId;
+    public static double explosionSndLongId;
+
+    public static void init(
+            Texture infantryFireT, int iCols, int iRows,
+            Texture tankFireT, int sCols, int sRows,
+            Texture explosionT, int eCols, int eRows,
+            Sound infantryFireS,
+            Sound tankFireS,
+            Sound tankFireLongS,
+            Sound explosionS,
+            Sound explosionLongS)
+    {
+        infantryFire = new Sprites(infantryFireT, iCols, iRows);
+        tankFire = new Sprites(tankFireT, sCols, sRows);
+        explosion = new Sprites(explosionT, eCols, eRows);
+        infantryFireSnd = infantryFireS;
+        tankFireSnd = tankFireS;
+        tankFireSndLong = tankFireLongS;
+        explosionSnd = explosionS;
+        explosionSndLong = explosionLongS;
+
+        reset();
+    }
+
+    public static void reset()
+    {
+        infantryFireSndLongId = -1;
+        tankFireSndLongId = -1;
+        explosionSndLongId = -1;
+    }
+
+    public static void free()
+    {
+        tankFire.dispose();
+        explosion.dispose();
+
+        tankFireSnd.dispose();
+        tankFireSndLong.dispose();
+        explosionSnd.dispose();
+        explosionSndLong.dispose();
+    }
+
+    public static void infantryFireSndPlay(float volume)
+    {
+        if (infantryFireSndLongId == -1)
+            infantryFireSndLongId = infantryFireSnd.play(volume);
+    }
+
+    public static void tankFireSndPlay(float volume)
+    {
+        if (tankFireSndLongId == -1)
+            tankFireSndLongId = tankFireSndLong.play(volume);
+        else
+            tankFireSnd.play(volume);
+    }
+
+    public static void explosionSndPlay(float volume)
+    {
+        if (explosionSndLongId == -1)
+            explosionSndLongId = explosionSndLong.play(volume);
+        else
+            explosionSnd.play(volume);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/InfantryFireAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/InfantryFireAnimation.java
new file mode 100644
index 0000000..233305a
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/InfantryFireAnimation.java
@@ -0,0 +1,222 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import java.util.Random;
+
+import com.badlogic.gdx.utils.Disposable;
+import com.badlogic.gdx.utils.Pool;
+
+import com.badlogic.gdx.audio.Sound;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class InfantryFireAnimation implements Disposable, Animation, Pool.Poolable
+{
+    class Shot
+    {
+        public TextureRegion fireRegion;
+        public float fire_a;
+        public float fire_x;
+        public float fire_y;
+        public float fire_w;
+        public float fire_dx;
+        public float fire_dy;
+        public float fire_dw;
+
+        public boolean fired;
+        public boolean hit;
+        public boolean completed;
+
+        public float fire_time;
+        public float hit_time;
+        public float end_time;
+
+        public int hit_frame;
+
+        public Shot(TextureRegion region)
+        {
+            this.fireRegion = region;
+        }
+
+        public void set(float delay, float x0, float y0, float x1, float y1, float w, float a)
+        {
+            float dx = (x1 - x0);
+            float dy = (y1 - y0);
+
+            // timing
+            float fire_duration = ((FireAnimation.random.nextFloat() * TIME_SCATTERING) + (w / SHOT_SPEED));
+            float hit_duration = (FireAnimation.infantryFire.rows * HIT_FRAME_DURATION);
+
+            this.fired = false;
+            this.fire_time = delay;
+            this.hit_time = (this.fire_time + fire_duration);
+            this.end_time = (this.hit_time + hit_duration);
+
+            // fire vars
+            this.fire_a = a;
+            this.fire_x = x0;
+            this.fire_y = y0;
+            this.fire_w = 0;
+            this.fire_dx = (dx / fire_duration);
+            this.fire_dy = (dy / fire_duration);
+            this.fire_dw = (w  / fire_duration);
+            this.hit_frame = 0;
+        }
+
+        public boolean animate(float delta)
+        {
+            if (!fired && (elapsed < fire_time))
+                return false;
+
+            if (!fired) {
+                fired = true;
+                FireAnimation.infantryFireSndPlay(volume);
+            }
+
+            if (!hit && (elapsed < hit_time)) {
+                fire_w += (fire_dw * delta);
+                fire_x += (fire_dx * delta);
+                fire_y += (fire_dy * delta);
+                fireRegion.setRegionWidth((int) fire_w);
+                return false;
+            }
+
+            if (!hit)
+                hit = true;
+
+            if (elapsed < end_time) {
+                int frame = (int) ((elapsed - hit_time) / HIT_FRAME_DURATION);
+                if (frame != hit_frame) {
+                    hit_frame = frame;
+                    fireRegion.setRegion(FireAnimation.infantryFire.frames[hit_frame]);
+                    fireRegion.setRegionWidth((int) fire_w);
+                }
+                return false;
+            }
+
+            completed = true;
+            return true;
+        }
+
+        public void draw(Batch batch)
+        {
+            if (fired && !completed)
+                batch.draw(fireRegion, fire_x, fire_y, 0, 0, fireRegion.getRegionWidth(), fireRegion.getRegionHeight(), 1f, 1f, fire_a);
+        }
+    }
+
+    private static final int SHOT_COUNT = 19;
+    private static final float SHOT_DELAY = (1.6f / SHOT_COUNT);
+    private static final float SHOT_SCATTERING = 40f;
+    private static final float TIME_SCATTERING = 0.6f;
+    private static final float START_DELAY = 0.8f;
+    private static final float SHOT_SPEED = 1000f;
+    private static final float HIT_FRAME_DURATION = 0.05f;
+
+    private Shot[] shots;
+
+    private float elapsed;
+
+    private float volume;
+
+    private static final Pool<InfantryFireAnimation> fireAnimationPool = new Pool<InfantryFireAnimation>() {
+        @Override
+        protected InfantryFireAnimation newObject() {
+            return new InfantryFireAnimation();
+        }
+    };
+
+    public static InfantryFireAnimation get(float volume, float x0, float y0, float x1, float y1, float halfWidth)
+    {
+        InfantryFireAnimation a = fireAnimationPool.obtain();
+        a.set(volume, x0, y0, x1, y1, halfWidth);
+        return a;
+    }
+
+    public InfantryFireAnimation()
+    {
+        this.shots = new Shot[SHOT_COUNT];
+        for (int i = 0; i < shots.length; i++)
+            shots[i] = new Shot(new TextureRegion(FireAnimation.infantryFire.frames[0]));
+    }
+
+    private void set(float volume, float x0, float y0, float x1, float y1, float halfWidth)
+    {
+        this.volume = volume;
+        this.elapsed = 0f;
+
+        float delay = START_DELAY + (FireAnimation.random.nextFloat() * TIME_SCATTERING);
+
+        y0 -= (FireAnimation.infantryFire.height / 2.0f);
+        double r = Math.atan2((y0 - y1), (x0 - x1));
+        x0 -= ((float) (Math.cos(r) * halfWidth));
+        y0 -= ((float) (Math.sin(r) * halfWidth));
+
+        float dx = (x1 - x0);
+        float dy = (y1 - y0);
+        float w = (float) Math.sqrt((dx * dx) + (dy * dy));
+        double dr = (Math.atan2(halfWidth, w) / 2f);
+
+        double a = (r + (dr / 2f));
+        double da = (dr / (float) SHOT_COUNT);
+
+        for (Shot shot : shots) {
+            float x = (float) (x0 - (Math.cos(a) * w));
+            float y = (float) (y0 - (Math.sin(a) * w));
+
+            shot.set(delay, x0, y0, x, y, w, (float) Math.toDegrees(a));
+
+            delay += SHOT_DELAY;
+            a -= 2 * (da * FireAnimation.random.nextFloat());
+        }
+    }
+
+    @Override
+    public void reset()
+    {
+    }
+
+    @Override
+    public void dispose()
+    {
+        fireAnimationPool.free(this);
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        elapsed += delta;
+
+        boolean completed = true;
+        for (Shot shot : shots)
+            completed &= shot.animate(delta);
+
+        return completed;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        for (Shot shot : shots)
+            shot.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        // debugShapes.end();
+        // debugShapes.begin(ShapeRenderer.ShapeType.Line);
+        // debugShapes.identity();
+        // debugShapes.translate(fire_x, fire_y, 0);
+        // debugShapes.rotate(0, 0, 1, fire_a);
+        // debugShapes.translate(-fire_x, -fire_y, 0);
+        // debugShapes.rect(fire_x, fire_y, fire_w, FireAnimation.infantryFire.height);
+        // debugShapes.end();
+        // debugShapes.begin(ShapeRenderer.ShapeType.Line);
+        // debugShapes.identity();
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/MoveToAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/MoveToAnimation.java
new file mode 100644
index 0000000..f6380bc
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/MoveToAnimation.java
@@ -0,0 +1,126 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import com.badlogic.gdx.math.Vector3;
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Moveable;
+
+public class MoveToAnimation extends TimedAnimation
+{
+    public interface MoveToAnimationCb {
+        void moveToAnimationLeave(Moveable moveable, float x, float y, float r);
+        void moveToAnimationEnter(Moveable moveable, float x, float y, float r);
+        void moveToAnimationDone(Moveable moveable, float x, float y, float r);
+    }
+
+    private Moveable moveable;
+    private float fromX;
+    private float fromY;
+    private float fromR;
+    private float toX;
+    private float toY;
+    private float toR;
+    private float rDelta;
+    private boolean notified;
+    private MoveToAnimationCb cb;
+
+    private static final Pool<MoveToAnimation> moveToAnimationPool = new Pool<MoveToAnimation>() {
+        @Override
+        protected MoveToAnimation newObject() {
+            return new MoveToAnimation();
+        }
+    };
+
+    public static MoveToAnimation get(Moveable moveable, Vector3 v, float duration)
+    {
+        return get(moveable, v.x, v.y, v.z, duration);
+    }
+
+    public static MoveToAnimation get(Moveable moveable, Vector3 v, float duration, MoveToAnimationCb cb)
+    {
+        return get(moveable, v.x, v.y, v.z, duration, cb);
+    }
+
+    public static MoveToAnimation get(Moveable moveable, float x, float y, float r, float duration)
+    {
+        return get(moveable, x, y, r, duration, null);
+    }
+
+    public static MoveToAnimation get(Moveable moveable, float x, float y, float r, float duration, MoveToAnimationCb cb)
+    {
+        MoveToAnimation a = moveToAnimationPool.obtain();
+
+        a.moveable = moveable;
+        a.toX = x;
+        a.toY = y;
+        a.toR = r;
+        a.duration = duration;
+        a.cb = cb;
+        a.rDelta = 0;
+        a.notified = false;
+
+        return a;
+    }
+
+    @Override
+    public void dispose()
+    {
+        moveToAnimationPool.free(this);
+    }
+
+    @Override
+    protected void begin()
+    {
+        fromX = moveable.getX();
+        fromY = moveable.getY();
+        fromR = moveable.getRotation();
+        notified = ((fromX == toX) && (fromY == toY));
+
+        if (Math.abs(toR - fromR) <= 180.f)
+            rDelta = (toR - fromR);
+        else {
+            if (toR > fromR)
+                rDelta = (toR - 360 - fromR);
+            else
+                rDelta = (toR + 360 - fromR);
+        }
+    }
+
+    @Override
+    protected void end()
+    {
+        if (cb != null)
+            cb.moveToAnimationDone(moveable, (toX + (moveable.getWidth() / 2)), (toY + (moveable.getHeight() / 2)), toR);
+        dispose();
+    }
+
+    @Override
+    protected void update(float percent)
+    {
+        if ((cb != null) && !notified && (percent >= 0.5)) {
+            float dw = (moveable.getWidth() / 2);
+            float dh = (moveable.getHeight() / 2);
+            cb.moveToAnimationLeave(moveable, (fromX + dw), (fromY + dh), fromR);
+            cb.moveToAnimationEnter(moveable, (toX + dw), (toY + dh), toR);
+            notified = true;
+        }
+        if (percent == 1f)
+            moveable.setPosition(toX, toY, (int) toR);
+        else
+            moveable.setPosition(fromX + ((toX - fromX) * percent), fromY + ((toY - fromY) * percent), (fromR + (rDelta * percent)));
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        moveable.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        moveable.drawDebug(debugShapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/PromoteAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/PromoteAnimation.java
new file mode 100644
index 0000000..24eac18
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/PromoteAnimation.java
@@ -0,0 +1,98 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import java.lang.Math;
+
+import com.badlogic.gdx.audio.Sound;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class PromoteAnimation implements Animation, Drawable
+{
+    private static PromoteAnimation instance = new PromoteAnimation();
+
+    private static final float DURATION = 0.3f;
+    private static final float MAX_SCALE = 2f;
+
+    private static Sound usSound;
+    private static Sound geSound;
+    private static Sound snd;
+    private static TextureRegion region;
+
+    private float x0;
+    private float y0;
+    private float x;
+    private float y;
+    private float scale;
+    private float step;
+    private float volume;
+    private float elapsed;
+
+    public static void init(TextureAtlas atlas, Sound usSnd, Sound geSnd)
+    {
+        region = atlas.findRegion("stars");
+        usSound = usSnd;
+        geSound = geSnd;
+    }
+
+    public static void free()
+    {
+    }
+
+    protected void PromoteAnimation()
+    {
+    }
+
+    public static PromoteAnimation get(boolean us, float x, float y, float v)
+    {
+        x = (x - (region.getRegionWidth() / 2.0f));
+        y = (y - (region.getRegionHeight() / 2.0f));
+
+        instance.volume = v;
+        instance.x0 = x;
+        instance.y0 = y;
+        instance.scale = 0f;
+        instance.elapsed = 0f;
+        snd = (us ? usSound : geSound);
+
+        return instance;
+    }
+
+    @Override
+    public void dispose()
+    {
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        elapsed += delta;
+        if (elapsed >= DURATION) {
+            snd.play(volume);
+            return true;
+        }
+
+        float s = MAX_SCALE * (float) Math.sin(Math.PI / DURATION * elapsed);
+        scale = 1f + s;
+        x = x0 - ((region.getRegionWidth() * scale) / 4f);
+        y = y0 - ((region.getRegionHeight() * scale) / 4f);
+
+        return false;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        batch.draw(region, x, y, 0, 0, region.getRegionWidth(), region.getRegionHeight(), scale, scale, 0f);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        debugShapes.rect(x, y, region.getRegionWidth(), region.getRegionHeight());
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/RunnableAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/RunnableAnimation.java
new file mode 100644
index 0000000..231f859
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/RunnableAnimation.java
@@ -0,0 +1,67 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Moveable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class RunnableAnimation implements Animation, Pool.Poolable
+{
+    private Runnable runnable;
+    private Moveable moveable;
+    private boolean ran;
+
+    private static final Pool<RunnableAnimation> runnableAnimationPool = new Pool<RunnableAnimation>() {
+        @Override
+        protected RunnableAnimation newObject() {
+            return new RunnableAnimation();
+        }
+    };
+
+    public static RunnableAnimation get(Moveable moveable, Runnable runnable)
+    {
+        RunnableAnimation a = runnableAnimationPool.obtain();
+        a.runnable = runnable;
+        a.moveable = moveable;
+        return a;
+    }
+
+    @Override
+    public void reset()
+    {
+        ran = false;
+    }
+
+    @Override
+    public void dispose()
+    {
+        runnableAnimationPool.free(this);
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        if (ran) return true;
+
+        runnable.run();
+        runnable = null;
+        ran = true;
+        dispose();
+
+        return true;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        moveable.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        moveable.drawDebug(debugShapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/SoundAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/SoundAnimation.java
new file mode 100644
index 0000000..7e83f38
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/SoundAnimation.java
@@ -0,0 +1,83 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.audio.Sound;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+public class SoundAnimation extends TimedAnimation
+{
+    public enum Action
+    {
+        FADE_IN,
+        FADE_OUT
+    };
+
+    private Sound sound;
+    private long soundId;
+    private Action action;
+    private float volume;
+
+    private static final Pool<SoundAnimation> soundAnimationPool = new Pool<SoundAnimation>() {
+        @Override
+        protected SoundAnimation newObject() {
+            return new SoundAnimation();
+        }
+    };
+
+    public static SoundAnimation get(Action action, Sound sound, long soundId, float volume, float duration)
+    {
+        SoundAnimation a = soundAnimationPool.obtain();
+
+        a.action = action;
+        a.sound = sound;
+        a.soundId = soundId;
+        a.volume = volume;
+        a.duration = duration;
+
+        return a;
+    }
+
+    @Override
+    public void dispose()
+    {
+        soundAnimationPool.free(this);
+    }
+
+    @Override
+    protected void begin()
+    {
+    }
+
+    @Override
+    protected void end()
+    {
+        dispose();
+    }
+
+    @Override
+    protected void update(float percent)
+    {
+        float v;
+        switch(action) {
+            case FADE_IN:
+                v = ( volume * percent);
+                sound.setVolume(soundId, v);
+                break;
+            case FADE_OUT:
+                v = (volume - ( volume * percent));
+                sound.setVolume(soundId, v);
+                break;
+        }
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/SpriteAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/SpriteAnimation.java
new file mode 100644
index 0000000..4d10210
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/SpriteAnimation.java
@@ -0,0 +1,76 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import java.util.Random;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class SpriteAnimation implements Disposable, Animation
+{
+    private static Random random = new Random();
+    private Sprites sprites;
+    private float duration;
+    private float frameDuration;
+    private float elapsed;
+    private float x0;
+    private float y0;
+    private float x1;
+    private float y1;
+    private int randFreq;
+
+    public SpriteAnimation(Texture texture, int cols, int rows, int randFreq)
+    {
+        this.sprites = new Sprites(texture, cols, rows);
+        this.randFreq = randFreq;
+    }
+
+    @Override
+    public void dispose()
+    {
+        sprites.dispose();
+    }
+
+    public void init(float duration, float x, float y)
+    {
+        this.duration = duration;
+        this.frameDuration = (duration / (float) sprites.frames.length);
+        this.x0 = x - (sprites.width / 2f);
+        this.y0 = y - (sprites.height / 2f);
+        this.elapsed = 0f;
+        randPos();
+    }
+
+    private void randPos()
+    {
+        this.x1 = this.x0 + (random.nextInt(sprites.width) - (sprites.width / 2));
+        this.y1 = this.y0 + (random.nextInt(sprites.height) - (sprites.height / 2));
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        elapsed += delta;
+        return (elapsed >= duration);
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        int n = (((int)(elapsed / frameDuration)) % sprites.frames.length);
+        if ((n > 0) && (n % randFreq) == 0)
+            randPos();
+        batch.draw(sprites.frames[n], x1, y1);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/Sprites.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/Sprites.java
new file mode 100644
index 0000000..2d2a0c1
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/Sprites.java
@@ -0,0 +1,38 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import com.badlogic.gdx.utils.Disposable;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+
+public class Sprites implements Disposable
+{
+    public Texture texture;
+    public TextureRegion[] frames;
+    public final int width;
+    public final int height;
+    public final int cols;
+    public final int rows;
+
+    public Sprites(Texture texture, int cols, int rows)
+    {
+        this.cols = cols;
+        this.rows = rows;
+        this.width = (texture.getWidth() / cols);
+        this.height = (texture.getHeight() / rows);
+        this.texture = texture;
+        TextureRegion[][] tmp = TextureRegion.split(texture, width, height);
+        frames = new TextureRegion[cols * rows];
+        int idx = 0;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                frames[idx++] = tmp[i][j];
+            }
+        }
+    }
+
+    @Override
+    public void dispose()
+    {
+        texture.dispose();
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/TankFireAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/TankFireAnimation.java
new file mode 100644
index 0000000..82a87fd
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/TankFireAnimation.java
@@ -0,0 +1,196 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import java.util.Random;
+
+import com.badlogic.gdx.utils.Disposable;
+import com.badlogic.gdx.utils.Pool;
+
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class TankFireAnimation implements Disposable, Animation, Pool.Poolable
+{
+    private static final float SHOT_SCATTERING = 60f;
+    private static final float TIME_SCATTERING = 0.6f;
+    private static final float START_DELAY = 0.8f;
+    private static final float SHOT_SPEED = 900f;
+    private static final float EXPLOSION_FRAME_DURATION = 0.07f;
+
+    private TextureRegion fireRegion;
+    private float fire_a;
+    private float fire_x;
+    private float fire_y;
+    private float fire_w;
+    private float fire_dx;
+    private float fire_dy;
+    private float fire_dw;
+
+    private float smoke_df;
+    private int smoke_frame;
+
+    private float explosion_x;
+    private float explosion_y;
+    private float explosion_df;
+    private int explosion_frame;
+
+    private boolean fired;
+    private boolean hit;
+    private float elapsed;
+    private float fire_time;
+    private float hit_time;
+    private float end_time;
+
+    private float volume;
+
+    private static final Pool<TankFireAnimation> fireAnimationPool = new Pool<TankFireAnimation>() {
+        @Override
+        protected TankFireAnimation newObject() {
+            return new TankFireAnimation();
+        }
+    };
+
+    public static TankFireAnimation get(float volume, float x0, float y0, float x1, float y1, float halfWidth)
+    {
+        TankFireAnimation a = fireAnimationPool.obtain();
+        a.set(volume, x0, y0, x1, y1, halfWidth);
+        return a;
+    }
+
+    public TankFireAnimation()
+    {
+        this.fireRegion = new TextureRegion(FireAnimation.tankFire.frames[0]);
+    }
+
+    private void set(float volume, float x0, float y0, float x1, float y1, float halfWidth)
+    {
+        this.fired = false;
+        this.hit = false;
+        this.volume = volume;
+
+        // fire geometry
+        y0 -= (FireAnimation.tankFire.height / 2.0f);
+        x1 += ((SHOT_SCATTERING * FireAnimation.random.nextFloat()) - (SHOT_SCATTERING / 2f));
+        y1 += ((SHOT_SCATTERING * FireAnimation.random.nextFloat()) - (SHOT_SCATTERING / 2f));
+
+        double r = Math.atan2((y0 - y1), (x0 - x1));
+        float xadj = (float) (Math.cos(r) * halfWidth);
+        float yadj = (float) (Math.sin(r) * halfWidth);
+        x0 -= xadj;
+        y0 -= yadj;
+
+        float a = (float) Math.toDegrees(r);
+        float dx = (x1 - x0);
+        float dy = (y1 - y0);
+        float w = (float) Math.sqrt((dx * dx) + (dy * dy));
+
+        // timing
+        float delay = START_DELAY + (FireAnimation.random.nextFloat() * TIME_SCATTERING);
+        float fire_duration = ((FireAnimation.random.nextFloat() * TIME_SCATTERING) + (w / SHOT_SPEED));
+        float explosion_duration = (FireAnimation.explosion.cols * EXPLOSION_FRAME_DURATION);
+
+        this.elapsed = 0f;
+        this.fire_time = delay;
+        this.hit_time = (fire_time + fire_duration);
+        this.end_time = (hit_time + explosion_duration);
+
+        // fire vars
+        this.fire_a = a;
+        this.fire_x = x0;
+        this.fire_y = y0;
+        this.fire_w = 0;
+        this.fire_dx = (dx / fire_duration);
+        this.fire_dy = (dy / fire_duration);
+        this.fire_dw = (w  / fire_duration);
+
+        // smoke var
+        this.smoke_df = (FireAnimation.tankFire.rows / explosion_duration);
+        this.smoke_frame = 0;
+
+        // explosion vars
+        this.explosion_x = (x1 - (FireAnimation.explosion.width / 2.0f));
+        this.explosion_y = (y1 - (FireAnimation.explosion.height / 2.0f));
+        this.explosion_df = (FireAnimation.explosion.cols / explosion_duration);
+        this.explosion_frame = (FireAnimation.random.nextInt(FireAnimation.explosion.rows) * FireAnimation.explosion.cols);
+    }
+
+    @Override
+    public void reset()
+    {
+    }
+
+    @Override
+    public void dispose()
+    {
+        fireAnimationPool.free(this);
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        elapsed += delta;
+
+        if (!fired && (elapsed < fire_time))
+            return false;
+
+        if (!fired) {
+            fired = true;
+            FireAnimation.tankFireSndPlay(volume);
+        }
+
+        if (!hit && (elapsed < hit_time)) {
+            fire_w += (fire_dw * delta);
+            fire_x += (fire_dx * delta);
+            fire_y += (fire_dy * delta);
+            fireRegion.setRegionWidth((int) fire_w);
+            return false;
+        }
+
+        if (!hit) {
+            hit = true;
+            FireAnimation.explosionSndPlay(volume);
+        }
+
+        if (elapsed < end_time) {
+            int frame = (int) ((elapsed - hit_time) * smoke_df);
+            if (frame != smoke_frame) {
+                smoke_frame = frame;
+                fireRegion.setRegion(FireAnimation.tankFire.frames[smoke_frame]);
+                fireRegion.setRegionWidth((int) fire_w);
+            }
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (fired)
+            batch.draw(fireRegion, fire_x, fire_y, 0, 0, fireRegion.getRegionWidth(), fireRegion.getRegionHeight(), 1f, 1f, fire_a);
+
+        if (hit) {
+            int frame = (explosion_frame + (int) ((elapsed - hit_time) * explosion_df));
+            batch.draw(FireAnimation.explosion.frames[frame], explosion_x, explosion_y);
+        }
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        debugShapes.end();
+        debugShapes.begin(ShapeRenderer.ShapeType.Line);
+        debugShapes.identity();
+        debugShapes.translate(fire_x, fire_y, 0);
+        debugShapes.rotate(0, 0, 1, fire_a);
+        debugShapes.translate(-fire_x, -fire_y, 0);
+        debugShapes.rect(fire_x, fire_y, fire_w, FireAnimation.tankFire.height);
+        debugShapes.end();
+        debugShapes.begin(ShapeRenderer.ShapeType.Line);
+        debugShapes.identity();
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/engine/gfx/animations/TimedAnimation.java b/core/src/ch/asynk/rustanddust/engine/gfx/animations/TimedAnimation.java
new file mode 100644
index 0000000..0c0d14d
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/engine/gfx/animations/TimedAnimation.java
@@ -0,0 +1,48 @@
+package ch.asynk.rustanddust.engine.gfx.animations;
+
+import com.badlogic.gdx.utils.Pool;
+
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public abstract class TimedAnimation implements Animation, Pool.Poolable
+{
+    private float time;
+    private boolean began;
+    private boolean completed;
+    protected float duration;
+
+    abstract protected void begin();
+    abstract protected void end();
+    abstract protected void update(float percent);
+
+    @Override
+    public void reset()
+    {
+        time = 0f;
+        began = false;
+        completed = false;
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        if (completed) return true;
+
+        if (!began) {
+            begin();
+            began = true;
+        }
+
+        time += delta;
+        completed = (time >= duration);
+
+        if (!completed) {
+            update(time / duration);
+            return false;
+        }
+
+        update(1);
+        end();
+        return true;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Army.java b/core/src/ch/asynk/rustanddust/game/Army.java
new file mode 100644
index 0000000..21cad9f
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Army.java
@@ -0,0 +1,30 @@
+package ch.asynk.rustanddust.game;
+
+import ch.asynk.rustanddust.engine.Faction;
+
+public enum Army implements Faction
+{
+    NONE("None"),
+    GE("German"),
+    US("US"),
+    USSR("Soviet"),
+    EN("English");
+
+    private String s;
+
+    Army(String s) {
+        this.s = s;
+    }
+
+    @Override
+    public String toString()
+    {
+        return s;
+    }
+
+    @Override
+    public boolean isEnemy(Faction other)
+    {
+        return (this != other);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Battle.java b/core/src/ch/asynk/rustanddust/game/Battle.java
new file mode 100644
index 0000000..242e147
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Battle.java
@@ -0,0 +1,40 @@
+package ch.asynk.rustanddust.game;
+
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.battles.Factory.MapType;
+import ch.asynk.rustanddust.ui.Position;
+
+public interface Battle
+{
+    public void init();
+
+    public String getName();
+
+    public String getDescription();
+
+    public Player getPlayer();
+
+    public Player opponent(Player player);
+
+    public MapType getMapType();
+
+    public Map getMap();
+
+    public Player checkVictory(Ctrl ctrl);
+
+    public boolean getReinforcement(Ctrl ctrl, Map map);
+
+    public Zone getEntryZone(Unit unit);
+
+    public Zone getExitZone(Unit unit);
+
+    public Position getHudPosition(Player player);
+
+    public State.StateType getState(Player player);
+
+    public boolean deploymentDone(Player player);
+
+    public void setup(Ctrl ctrl, Map map);
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Command.java b/core/src/ch/asynk/rustanddust/game/Command.java
new file mode 100644
index 0000000..40d467a
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Command.java
@@ -0,0 +1,225 @@
+package ch.asynk.rustanddust.game;
+
+import java.util.List;
+
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.utils.Json;
+import com.badlogic.gdx.utils.JsonValue;
+
+import ch.asynk.rustanddust.engine.Order;
+import ch.asynk.rustanddust.engine.Move;
+import ch.asynk.rustanddust.engine.Pawn;
+import ch.asynk.rustanddust.engine.Tile;
+
+public  class Command extends Order
+{
+    public enum CommandType implements Order.OrderType
+    {
+        NONE,
+        MOVE,
+        ENGAGE,
+        PROMOTE,
+        END_OF_TURN;
+    }
+
+    private static final Pool<Command> commandPool = new Pool<Command>()
+    {
+        @Override
+        protected Command newObject() {
+            return new Command();
+        }
+    };
+
+    public static void clearPool()
+    {
+        commandPool.clear();
+    }
+
+    public static Command get(Player player)
+    {
+        Command c = commandPool.obtain();
+        c.player = player;
+        c.ap = player.getAp();
+        c.turn = player.getCurrentTurn();
+        return c;
+    }
+
+    public CommandType type;
+    public Player player;
+    public int ap;
+    public int turn;
+    public Unit unit;
+    public Unit.UnitId unitId;
+    public Unit.UnitType unitType;
+    public Tile unitTile;
+    public Move move;
+    public Engagement engagement;
+
+    private Command()
+    {
+        reset();
+    }
+
+    @Override
+    public void dispose()
+    {
+        commandPool.free(this);
+    }
+
+    @Override
+    public void reset()
+    {
+        this.type = CommandType.NONE;
+        this.player = null;
+        this.unit = null;
+        if (this.move != null) {
+            this.move.dispose();
+            this.move = null;
+        }
+        if (this.engagement != null) {
+            this.engagement.dispose();
+            this.engagement = null;
+        }
+    }
+
+    @Override
+    public int compareTo(Pawn pawn)
+    {
+        if (pawn == unit)
+            return 0;
+        return 1;
+    }
+
+    @Override
+    public boolean isA(OrderType type)
+    {
+        return (type == this.type);
+    }
+
+    @Override
+    public String toString()
+    {
+        return String.format("%s : %s", type, unit.id);
+    }
+
+    public void setMove(Unit unit, Move move)
+    {
+        this.type = CommandType.MOVE;
+        this.move = move;
+        setUnit(unit);
+    }
+
+    public void setPromote(Unit unit)
+    {
+        this.type = CommandType.PROMOTE;
+        setUnit(unit);
+    }
+
+    public void setEngage(Unit unit, Unit target)
+    {
+        this.type = CommandType.ENGAGE;
+        this.engagement = Engagement.get(unit, target);
+        setUnit(unit);
+    }
+
+    private void setUnit(Unit unit)
+    {
+        this.unit = unit;
+        this.unitId = unit.id;
+        this.unitType = unit.type;
+        this.unitTile = unit.getTile();
+    }
+
+    @Override
+    public void write(Json json)
+    {
+        json.writeValue("type", type);
+        json.writeObjectStart("player");
+        json.writeValue("army", player.getName());
+        json.writeValue("turn", turn);
+        json.writeValue("aps", ap);
+        json.writeObjectEnd();
+        json.writeObjectStart("unit");
+        json.writeValue("id", unitId);
+        json.writeValue("type", unitType);
+        json.writeValue("ace", unit.ace);
+        writeTile(json, "tile", unitTile);
+        json.writeObjectEnd();
+        if (move != null) writeMove(json, "move", move);
+        if (engagement != null) writeEngagement(json, "engagement", engagement);
+    }
+
+    private void writeMove(Json json, String key, Move m)
+    {
+        json.writeObjectStart(key);
+        json.writeValue("type", move.type);
+        writeTile(json, "from", move.from);
+        writeTile(json, "to", move.to);
+        json.writeValue("orientation", move.orientation.r());
+        writeTiles(json, "path", move.tiles);
+        json.writeObjectEnd();
+    }
+
+    private void writeEngagement(Json json, String key, Engagement e)
+    {
+        json.writeObjectStart(key);
+        writeUnit(json, "attacker", e.attacker);
+        writeUnit(json, "defender", e.defender);
+        writeUnits(json, "assists", e.assists);
+        json.writeObjectStart("dice");
+        json.writeValue("d1", e.d1);
+        json.writeValue("d2", e.d2);
+        json.writeValue("d3", e.d3);
+        json.writeValue("d4", e.d4);
+        json.writeObjectEnd();
+        json.writeObjectStart("results");
+        json.writeValue("success", e.success);
+        json.writeValue("attackSum", e.attackSum);
+        json.writeValue("defenseSum", e.defenseSum);
+        json.writeObjectEnd();
+        json.writeObjectEnd();
+    }
+
+    private void writeUnit(Json json, String key, Unit u)
+    {
+        if (key != null) json.writeObjectStart(key);
+        else json.writeObjectStart();
+        json.writeValue("id", u.id);
+        json.writeValue("ace", u.ace);
+        json.writeValue("army", u.getArmy());
+        writeTile(json, "tile", u.getTile());
+        json.writeObjectEnd();
+    }
+
+    private void writeUnits(Json json, String key, List<Unit> units)
+    {
+        json.writeArrayStart(key);
+        for (Unit u : units)
+            writeUnit(json, null, u);
+        json.writeArrayEnd();
+    }
+
+    private void writeTile(Json json, String key, Tile t)
+    {
+        if (t == null) return;
+        if (key != null) json.writeObjectStart(key);
+        else json.writeObjectStart();
+        json.writeValue("col", t.getCol());
+        json.writeValue("row", t.getRow());
+        json.writeObjectEnd();
+    }
+
+    private void writeTiles(Json json, String key, List<Tile> tiles)
+    {
+        json.writeArrayStart(key);
+        for (Tile t : tiles)
+            writeTile(json, null, t);
+        json.writeArrayEnd();
+    }
+
+    @Override
+    public void read(Json json, JsonValue jsonMap)
+    {
+        // FIXME Command.read(Json, JsonValue);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Config.java b/core/src/ch/asynk/rustanddust/game/Config.java
new file mode 100644
index 0000000..2c27c35
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Config.java
@@ -0,0 +1,76 @@
+package ch.asynk.rustanddust.game;
+
+public class Config
+{
+    public enum Graphics {
+        MINE("mine", 0),
+        ORIGINAL("original", 1);
+        public String s;
+        public int i;
+        Graphics(String s, int i)
+        {
+            this.s = s;
+            this.i = i;
+        }
+        public Graphics next()
+        {
+            if (this == ORIGINAL)
+                return MINE;
+            return ORIGINAL;
+        }
+    };
+
+    public enum GameMode
+    {
+        SOLO("Solo", 0),
+        PVE("Player vs AI", 1),
+        PVP("Player vs Player", 2);
+        public String s;
+        public int i;
+        GameMode(String s, int i)
+        {
+            this.s = s;
+            this.i = i;
+        }
+        public GameMode next()
+        {
+            if (this == SOLO)
+                return PVE;
+            if(this == PVE)
+                return PVP;
+            return SOLO;
+        }
+    };
+
+    public GameMode gameMode;
+    public boolean showMoves;
+    public boolean showTargets;
+    public boolean showMoveAssists;
+    public boolean canCancel;
+    public boolean mustValidate;
+    public boolean showEnemyPossibilities;
+    public boolean debug;
+    public Battle battle;
+    public float fxVolume;
+    public Graphics graphics;
+
+    public Config()
+    {
+        this.gameMode = GameMode.SOLO;
+        this.debug = false;
+        this.showMoves = true;
+        this.showTargets = true;
+        this.showMoveAssists = true;
+        this.canCancel = false;
+        this.mustValidate = false;
+        this.showEnemyPossibilities = false;
+        this.graphics = Graphics.MINE;
+        this.battle = null;
+        this.fxVolume = 1f;
+    }
+
+    public boolean gameModeImplemented()
+    {
+        return (gameMode == GameMode.SOLO);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Ctrl.java b/core/src/ch/asynk/rustanddust/game/Ctrl.java
new file mode 100644
index 0000000..3b93ad8
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Ctrl.java
@@ -0,0 +1,336 @@
+package ch.asynk.rustanddust.game;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.math.Vector3;
+
+import ch.asynk.rustanddust.RustAndDust;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.game.State.StateType;
+import ch.asynk.rustanddust.game.states.StateSelect;
+import ch.asynk.rustanddust.game.states.StateMove;
+import ch.asynk.rustanddust.game.states.StateRotate;
+import ch.asynk.rustanddust.game.states.StatePromote;
+import ch.asynk.rustanddust.game.states.StateEngage;
+import ch.asynk.rustanddust.game.states.StateBreak;
+import ch.asynk.rustanddust.game.states.StateAnimation;
+import ch.asynk.rustanddust.game.states.StateReinforcement;
+import ch.asynk.rustanddust.game.states.StateDeployment;
+import ch.asynk.rustanddust.game.states.StateWithdraw;
+
+public class Ctrl implements Disposable
+{
+    private final RustAndDust game;
+    public final Battle battle;
+
+    public Map map;
+    public Hud hud;
+    public Config cfg;
+    public Player player;
+    public Player opponent;
+    public boolean blockMap;
+    public boolean blockHud;
+
+    public Vector3 mapTouch = new Vector3();
+    public Vector3 hudTouch = new Vector3();
+
+    private State selectState;
+    private State pathState;
+    private State rotateState;
+    private State promoteState;
+    private State engageState;
+    private State breakState;
+    private State animationState;
+    private State reinforcementState;
+    private State deploymentState;
+    private State withdrawState;
+
+    private int animationCount = 0;
+
+    private State state;
+    private StateType stateType;
+    private StateType stateAfterAnimation;
+
+    public Ctrl(final RustAndDust game, final Battle battle)
+    {
+        this.game = game;
+        this.battle = battle;
+        this.cfg = game.config;
+        game.ctrl = this;
+
+        battle.init();
+
+        this.map = battle.getMap();
+        battle.setup(this, map);
+        this.map.init();
+        this.player = battle.getPlayer();
+        this.opponent = battle.opponent(player);
+
+        this.selectState = new StateSelect(this, map);
+        this.pathState = new StateMove();
+        this.rotateState = new StateRotate();
+        this.promoteState = new StatePromote();
+        this.engageState = new StateEngage();
+        this.breakState = new StateBreak();
+        this.animationState = new StateAnimation();
+        this.reinforcementState = new StateReinforcement();
+        this.deploymentState = new StateDeployment();
+        this.withdrawState = new StateWithdraw();
+
+        this.state = selectState;
+        this.stateType = StateType.DONE;
+
+        this.hud = new Hud(this, game);
+        this.blockMap = false;
+        this.blockHud = false;
+
+        hud.notify(battle.toString(), 2, Position.MIDDLE_CENTER, false);
+        startPlayerTurn();
+    }
+
+    @Override
+    public void dispose()
+    {
+        hud.dispose();
+        map.dispose();
+    }
+
+    public Player getPlayer(Army army)
+    {
+        return (player.is(army) ? player : opponent);
+    }
+
+    public boolean isInAction()
+    {
+        return (state != selectState);
+    }
+
+    public void animationsOver()
+    {
+        if (hud.dialogActive())
+            return;
+        if (stateType == StateType.ANIMATION)
+            leaveAnimationState();
+    }
+
+    private void leaveAnimationState()
+    {
+
+        StateType tmp = stateAfterAnimation;
+        stateAfterAnimation = StateType.DONE;
+        setState(tmp);
+    }
+
+    private void startPlayerTurn()
+    {
+        player.turnStart();
+        // hud.notify(player.getName() + "'s turn", 2, Position.MIDDLE_CENTER, true);
+        if (battle.getReinforcement(this, map))
+            hud.notify("You have reinforcement", 2, Position.MIDDLE_CENTER, true);
+        hud.update();
+        setState(battle.getState(player));
+    }
+
+    private void endPlayerTurn()
+    {
+        player.turnEnd();
+        Player winner = battle.checkVictory(this);
+        if (winner != null)
+            hud.victory(winner, ((winner == player) ? opponent : player));
+    }
+
+    private StateType actionAborted()
+    {
+        hud.notify("Action canceled");
+        StateType nextState = this.state.abort();
+
+        if (nextState == StateType.ABORT)
+            nextState = battle.getState(player);
+
+        return nextState;
+    }
+
+    private void turnDone()
+    {
+        map.turnDone();
+        endPlayerTurn();
+        player = battle.getPlayer();
+        opponent = battle.opponent(player);
+        startPlayerTurn();
+    }
+
+    private StateType actionDone()
+    {
+        StateType nextState = this.state.execute();
+
+        if (nextState == StateType.DONE) {
+            map.actionDone();
+            if (map.activatedUnits.size() > 0) {
+                RustAndDust.debug("Ctrl", "burn down 1AP");
+                hud.notify("1 Action Point burnt", 0.6f, Position.BOTTOM_CENTER, false);
+                player.burnDownOneAp();
+                hud.update();
+            }
+            if (player.apExhausted())
+                hud.notifyNoMoreAP();
+        }
+
+        if (nextState == StateType.DONE)
+            nextState = battle.getState(player);
+
+        return nextState;
+    }
+
+    private StateType deploymentDone()
+    {
+        map.actionDone();
+        return this.state.execute();
+    }
+
+    public void setState(StateType nextState)
+    {
+        if (nextState == StateType.ABORT)
+            nextState = actionAborted();
+        else if (nextState == StateType.DONE) {
+            if (stateType == StateType.DEPLOYMENT)
+                nextState = deploymentDone();
+            else
+                nextState = actionDone();
+        }
+
+        if (stateType == StateType.ANIMATION) {
+            this.blockMap = hud.dialogActive();
+        }
+        hud.playerInfo.blockEndOfTurn(nextState != StateType.SELECT);
+
+        this.state.leave(nextState);
+
+        RustAndDust.debug("Ctrl", String.format("  %s -> %s : %s", stateType, nextState, player));
+
+        switch(nextState) {
+            case SELECT:
+                this.state = selectState;
+                break;
+            case MOVE:
+                this.state = pathState;
+                break;
+            case ROTATE:
+                this.state = rotateState;
+                break;
+            case PROMOTE:
+                this.state = promoteState;
+                break;
+            case ENGAGE:
+                this.state = engageState;
+                break;
+            case BREAK:
+                this.state = breakState;
+                break;
+            case WITHDRAW:
+                this.state = withdrawState;
+                break;
+            case ANIMATION:
+                this.blockMap = true;
+                this.state = animationState;
+                break;
+            case REINFORCEMENT:
+                this.state = reinforcementState;
+                break;
+            case DEPLOYMENT:
+                this.state = deploymentState;
+                break;
+            default:
+                break;
+        }
+
+        StateType tmp = stateType;
+        stateType = nextState;
+
+        this.state.enter(tmp);
+
+    }
+
+    public void touchDown()
+    {
+        if (!blockHud && hud.touchDown(hudTouch.x, hudTouch.y))
+            return;
+
+        if (!blockMap && state.downInMap(mapTouch.x, mapTouch.y))
+            state.touchDown();
+    }
+
+    public void touchUp()
+    {
+        if (!blockHud && hud.touchUp(hudTouch.x, hudTouch.y))
+            return;
+
+        if (!blockMap && state.upInMap(mapTouch.x, mapTouch.y))
+            state.touchUp();
+    }
+
+    public void stateTouchUp()
+    {
+        state.downInMap(-1, -1);
+        state.upInMap(-1, -1);
+        state.touchUp();
+    }
+
+    public boolean isInAnimation()
+    {
+        return (this.stateType == StateType.ANIMATION);
+    }
+
+    public void setAfterAnimationState(StateType after)
+    {
+        stateAfterAnimation = after;
+    }
+
+    public boolean checkDeploymentDone()
+    {
+        boolean done = battle.deploymentDone(player);
+        if (done)
+            hud.askEndDeployment();
+        return done;
+    }
+
+    public void reinforcementHit()
+    {
+        if (this.stateType == StateType.SELECT)
+            setState(StateType.REINFORCEMENT);
+        else if (this.stateType == StateType.REINFORCEMENT)
+            setState(StateType.SELECT);
+    }
+
+    // Hud callbacks
+    public void engagementPanelClosed()
+    {
+        if (animationCount == 0)
+            leaveAnimationState();
+    }
+
+    public void endDeployment()
+    {
+        setState(StateType.DONE);
+        turnDone();
+    }
+
+    public void endGame()
+    {
+        game.switchToMenu();
+    }
+
+    public void endPlayerTurn(boolean abort)
+    {
+        if (abort)
+            state.abort();
+        turnDone();
+    }
+
+    public void exitBoard(boolean doit)
+    {
+        if (doit)
+            setState(StateType.DONE);
+        else
+            setState(StateType.ABORT);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Engagement.java b/core/src/ch/asynk/rustanddust/game/Engagement.java
new file mode 100644
index 0000000..b7630ed
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Engagement.java
@@ -0,0 +1,114 @@
+package ch.asynk.rustanddust.game;
+
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Random;
+
+import com.badlogic.gdx.utils.Pool;
+import com.badlogic.gdx.utils.Disposable;
+
+public class Engagement implements Disposable, Pool.Poolable
+{
+    private static Random rand = new Random();
+
+    private static final Pool<Engagement> engagementPool = new Pool<Engagement>() {
+        @Override
+        protected Engagement newObject() {
+            return new Engagement();
+        }
+    };
+
+    public static Engagement get(Unit attacker, Unit defender)
+    {
+        Engagement e = engagementPool.obtain();
+        e.attacker = attacker;
+        e.defender = defender;
+        e.diceRoll();
+
+        return e;
+    }
+
+    public static void clearPool()
+    {
+        engagementPool.clear();
+    }
+
+    public Unit attacker;
+    public Unit defender;
+    public List<Unit> assists;
+    public boolean success;
+    public int d1;
+    public int d2;
+    public int d3;
+    public int d4;
+    public int unitCount;
+    public int flankBonus;
+    public int unitDefense;
+    public int terrainDefense;
+    public int weatherDefense;
+    public int attackSum;
+    public int defenseSum;
+
+    public Engagement()
+    {
+        assists = new LinkedList<Unit>();
+        reset();
+    }
+
+    @Override
+    public void reset()
+    {
+        attacker = null;
+        defender = null;
+        assists.clear();
+    }
+
+    @Override
+    public void dispose()
+    {
+        assists.clear();
+        engagementPool.free(this);
+    }
+
+    public void addAssist(Unit unit)
+    {
+        assists.add(unit);
+    }
+
+    private void diceRoll()
+    {
+        d1 = rand.nextInt(6) + 1;
+        d2 = rand.nextInt(6) + 1;
+        d3 = rand.nextInt(6) + 1;
+        d4 = rand.nextInt(6) + 1;
+    }
+
+    public void set(int cnt, int flk, int def, int tdf, int wdf)
+    {
+        this.unitCount = cnt;
+        this.flankBonus = flk;
+        this.unitDefense = def;
+        this.terrainDefense = tdf;
+        this.weatherDefense = wdf;
+        if (d3 == 0)
+            this.attackSum = (d1 + d2 + unitCount + flankBonus);
+        else
+            this.attackSum = (d3 + d4 + unitCount + flankBonus);
+        this.defenseSum = (unitDefense + terrainDefense + weatherDefense);
+    }
+
+
+    @Override
+    public String toString()
+    {
+        int a, b;
+        if (d3 == 0) {
+            a = d1;
+            b = d2;
+        } else {
+            a = d3;
+            b = d4;
+        }
+        return String.format("Engagement : (%d + %d + %d + %d) vs (%d + %d + %d) -> %b", a, b, unitCount, flankBonus, unitDefense, terrainDefense, weatherDefense, success);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Hex.java b/core/src/ch/asynk/rustanddust/game/Hex.java
new file mode 100644
index 0000000..b805146
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Hex.java
@@ -0,0 +1,138 @@
+package ch.asynk.rustanddust.game;
+
+import java.util.List;
+import java.util.Iterator;
+
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+
+import ch.asynk.rustanddust.engine.Board;
+import ch.asynk.rustanddust.engine.Pawn;
+import ch.asynk.rustanddust.engine.Tile;
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.game.Unit.UnitType;
+
+public class Hex extends Tile
+{
+    public enum Terrain implements TileTerrain
+    {
+        OFFMAP,
+        BLOCKED,
+        CLEAR,
+        HILLS,
+        WOODS,
+        TOWN
+    }
+
+    public static final int FOG         = 0;
+    public static final int SELECT      = 1;
+    public static final int AREA        = 2;
+    public static final int MOVE        = 3;
+    public static final int DIRECTIONS  = 4;
+    public static final int ORIENTATION = 5;
+    public static final int OBJECTIVE       = 6;
+    public static final int OBJECTIVE_HOLD  = 7;
+    public static final int OBJECTIVE_GE    = 8;
+    public static final int OBJECTIVE_US    = 9;
+    public static final int EXIT        = 10;
+
+    public Terrain terrain;
+    public int roads;
+
+    public String toString()
+    {
+        return String.format("(%d;%d) [%f;%f] t:%s r:%d", col, row, x, y, terrain, roads);
+    }
+
+    public String toShort()
+    {
+        return String.format("(%d;%d)", col, row);
+    }
+
+    public Hex(float x, float y, int col, int row, TextureAtlas atlas)
+    {
+        super(x, y, col, row, atlas);
+        this.terrain = Terrain.CLEAR;
+        this.roads = 0;
+    }
+
+    public Unit getUnit()
+    {
+        return (Unit) stack.peekFirst();
+    }
+
+    @Override
+    public boolean isA(TileTerrain terrain)
+    {
+        return (this.terrain == terrain);
+    }
+
+    @Override
+    public boolean isOffMap()
+    {
+        return isA(Terrain.OFFMAP);
+    }
+
+    @Override
+    public boolean blockLineOfSightFrom(Tile tile)
+    {
+        if (isA(Terrain.CLEAR) && !hasUnits())
+            return false;
+
+        if (tile.isA(Terrain.HILLS) && isA(Terrain.CLEAR))
+            return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean atLeastOneMove(Pawn pawn)
+    {
+        if (hasUnits() || isA(Terrain.BLOCKED) || isA(Terrain.OFFMAP))
+            return false;
+        return true;
+    }
+
+    @Override
+    public boolean road(Orientation side)
+    {
+        return (side.s == (roads & side.s));
+    }
+
+    @Override
+    public int exitCost()
+    {
+        return 1;
+    }
+
+    @Override
+    public int costFrom(Pawn pawn, Orientation side)
+    {
+        if (side == Orientation.KEEP) return 0;
+        if (hasUnits()) return (Integer.MAX_VALUE / 2);
+        if (road(side)) return 1;
+
+        int c = 0;
+        switch(terrain) {
+            case CLEAR:
+            case HILLS:
+                c = 1;
+                break;
+            case WOODS:
+            case TOWN:
+                c = 2;
+                break;
+            case OFFMAP:
+            case BLOCKED:
+                c = (Integer.MAX_VALUE / 2);
+                break;
+        }
+
+        return c;
+    }
+
+    @Override
+    public int defense()
+    {
+        return (isA(Terrain.TOWN) ? 1 : 0);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/HexSet.java b/core/src/ch/asynk/rustanddust/game/HexSet.java
new file mode 100644
index 0000000..4382fdb
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/HexSet.java
@@ -0,0 +1,29 @@
+package ch.asynk.rustanddust.game;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+
+import ch.asynk.rustanddust.engine.Tile;
+
+public class HexSet extends LinkedHashSet<Hex>
+{
+    private final Map map;
+
+    public HexSet(Map map, int n)
+    {
+        super(n);
+        this.map = map;
+    }
+
+    public void enable(int i, boolean enable)
+    {
+        for (Hex hex : this)
+            map.enableOverlayOn(hex, i, enable);
+    }
+
+    @SuppressWarnings("unchecked")
+    public Collection<Tile> asTiles()
+    {
+        return (Collection) this;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Hud.java b/core/src/ch/asynk/rustanddust/game/Hud.java
new file mode 100644
index 0000000..8f9343c
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Hud.java
@@ -0,0 +1,307 @@
+package ch.asynk.rustanddust.game;
+
+import java.util.LinkedList;
+
+import com.badlogic.gdx.Gdx;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Animation;
+import ch.asynk.rustanddust.game.State.StateType;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.ui.Msg;
+import ch.asynk.rustanddust.ui.OkCancel;
+import ch.asynk.rustanddust.ui.Widget;
+import ch.asynk.rustanddust.game.hud.PlayerInfo;
+import ch.asynk.rustanddust.game.hud.ActionButtons;
+import ch.asynk.rustanddust.game.hud.StatisticsPanel;
+import ch.asynk.rustanddust.game.hud.EngagementPanel;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class Hud implements Disposable, Animation
+{
+    public static final float OFFSET = 10f;
+    public static final float NOTIFY_DURATION = 2f;
+
+    private final RustAndDust game;
+    private final Ctrl ctrl;
+
+    private Object hit;
+
+    public PlayerInfo playerInfo;
+    public ActionButtons actionButtons;
+
+    private Msg msg;
+    private StatisticsPanel stats;
+    private EngagementPanel engagement;
+    private OkCancel okCancel;
+    private LinkedList<Widget> dialogs = new LinkedList<Widget>();
+
+    public enum OkCancelAction
+    {
+        EXIT_BOARD,
+        ABORT_TURN,
+        END_TURN,
+        END_DEPLOYMENT,
+    }
+    private OkCancelAction okCancelAction;
+
+    public Hud(final Ctrl ctrl, final RustAndDust game)
+    {
+        this.game = game;
+        this.ctrl = ctrl;
+
+        TextureAtlas hudAtlas = game.factory.hudAtlas;
+        playerInfo = new PlayerInfo(ctrl, game.fontW, game.uiAtlas, hudAtlas);
+        actionButtons = new ActionButtons(ctrl, game.uiAtlas, hudAtlas);
+        actionButtons.hide();
+        msg = new Msg(game.fontB, game.uiAtlas);
+        okCancel = new OkCancel(game.fontB, game.uiAtlas);
+        stats = new StatisticsPanel(game.fontB, game.uiAtlas);
+        engagement = new EngagementPanel(game.fontB, game.uiAtlas, hudAtlas);
+    }
+
+    @Override
+    public void dispose()
+    {
+        playerInfo.dispose();
+        actionButtons.dispose();
+        msg.dispose();
+        okCancel.dispose();
+        engagement.dispose();
+        stats.dispose();
+    }
+
+    public void resize(int left, int bottom, int width, int height)
+    {
+        Position.update(left, bottom, width, height);
+        playerInfo.updatePosition();
+        actionButtons.updatePosition();
+        msg.updatePosition();
+        stats.updatePosition();
+        engagement.updatePosition();
+        okCancel.updatePosition();
+    }
+
+    public void update()
+    {
+        Position position = ctrl.battle.getHudPosition(ctrl.player);
+        playerInfo.update(ctrl.player, position);
+        actionButtons.update(position.horizontalMirror());
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        msg.animate(delta);
+        playerInfo.animate(delta);
+        engagement.animate(delta);
+        return false;
+    }
+
+    public void draw(Batch batch, boolean debug)
+    {
+        draw(batch);
+        if (debug)
+            game.fontB.draw(batch, String.format("FPS: %d", Gdx.graphics.getFramesPerSecond()), 80, 25);
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        playerInfo.draw(batch);
+        actionButtons.draw(batch);
+        msg.draw(batch);
+        okCancel.draw(batch);
+        engagement.draw(batch);
+        stats.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        playerInfo.drawDebug(debugShapes);
+        actionButtons.drawDebug(debugShapes);
+        msg.drawDebug(debugShapes);
+        okCancel.drawDebug(debugShapes);
+        engagement.drawDebug(debugShapes);
+        stats.drawDebug(debugShapes);
+    }
+
+    public void pushNotify(String s)
+    {
+        notify(s, NOTIFY_DURATION, Position.TOP_CENTER, true);
+    }
+
+    public void notify(String s)
+    {
+        notify(s, NOTIFY_DURATION, Position.TOP_CENTER, false);
+    }
+
+    public void notify(String s, float duration, Position position, boolean push)
+    {
+        if (push) msg.pushWrite(s, duration, position);
+        else msg.write(s, duration, position);
+    }
+
+    public boolean touchDown(float x, float y)
+    {
+        hit = null;
+
+        if (dialogs.size() > 0) {
+            Widget dialog = dialogs.getFirst();
+            if (dialog.hit(x, y)) {
+                hit = dialog;
+                return true;
+            }
+            return false;
+        }
+
+        if (ctrl.isInAnimation())
+            return false;
+
+        if (hit == null) {
+            if (actionButtons.touchDown(x, y))
+                hit = actionButtons;
+            else if (playerInfo.touchDown(x, y))
+                hit = playerInfo;
+        }
+
+        return (hit != null);
+    }
+
+    public boolean touchUp(float x, float y)
+    {
+        if (hit == null)
+            return false;
+
+        if (dialogs.size() > 0) {
+            Widget dialog = dialogs.getFirst();
+            if (hit == dialog) {
+                if (dialog.hit(x, y))
+                    closeDialog();
+                hit = null;
+            }
+        } else {
+            if (hit == actionButtons) {
+                actionButtons.touchUp(x, y);
+            }
+            else if (hit == playerInfo) {
+                playerInfo.touchUp(x, y);
+            }
+
+            hit = null;
+        }
+
+        return true;
+    }
+
+    private void closeDialog()
+    {
+        Widget dialog = dialogs.removeFirst();
+        dialog.visible = false;
+
+        if (dialog == okCancel)
+            closeOkCancel();
+        else if (dialog == stats)
+            ctrl.endGame();
+        else if (dialog == engagement)
+            ctrl.engagementPanelClosed();
+
+        if (dialogs.size() > 0)
+            dialogs.getFirst().visible = true;
+        else
+            ctrl.blockMap = false;
+    }
+
+    private void closeOkCancel()
+    {
+        boolean ok = okCancel.ok;
+
+        switch(okCancelAction) {
+            case EXIT_BOARD:
+                ctrl.exitBoard(ok);
+                break;
+            case END_TURN:
+                if (ok)
+                    ctrl.endPlayerTurn(false);
+                break;
+            case ABORT_TURN:
+                if (ok)
+                    ctrl.endPlayerTurn(true);
+                break;
+            case END_DEPLOYMENT:
+                if (ok)
+                    ctrl.endDeployment();
+                break;
+        }
+    }
+
+    public boolean dialogActive()
+    {
+        return (dialogs.size() > 0);
+    }
+
+    private void pushDialog(Widget dialog)
+    {
+        ctrl.blockMap = true;
+        if (dialogs.size() != 0)
+            dialog.visible = false;
+        dialogs.addLast(dialog);
+    }
+
+    public void notifyDeploymentDone()
+    {
+        this.okCancelAction = OkCancelAction.END_TURN;
+        okCancel.show("Deployment Phase completed.");
+        okCancel.noCancel();
+        pushDialog(okCancel);
+    }
+
+    public void notifyNoMoreAP()
+    {
+        this.okCancelAction = OkCancelAction.END_TURN;
+        okCancel.show("No more Action Point left.");
+        okCancel.noCancel();
+        pushDialog(okCancel);
+    }
+
+    public void askExitBoard()
+    {
+        this.okCancelAction = OkCancelAction.EXIT_BOARD;
+        okCancel.show("Do you want this unit to escape the battle field ?");
+        pushDialog(okCancel);
+    }
+
+    public void askEndOfTurn()
+    {
+        this.okCancelAction = OkCancelAction.ABORT_TURN;
+        okCancel.show("You still have Action Points left.\nEnd your Turn anyway ?");
+        pushDialog(okCancel);
+    }
+
+    public void askEndDeployment()
+    {
+        this.okCancelAction = OkCancelAction.END_DEPLOYMENT;
+        okCancel.show("Deployment unit count reached.\nEnd Deployment phase ?");
+        pushDialog(okCancel);
+    }
+
+    public void engagementSummary(Engagement e, float volume)
+    {
+        engagement.show(e, Position.BOTTOM_CENTER, volume);
+        pushDialog(engagement);
+    }
+
+    public void victory(Player winner, Player loser)
+    {
+        stats.show(winner, loser, Position.MIDDLE_CENTER);
+        pushDialog(stats);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Map.java b/core/src/ch/asynk/rustanddust/game/Map.java
new file mode 100644
index 0000000..62f5723
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Map.java
@@ -0,0 +1,659 @@
+package ch.asynk.rustanddust.game;
+
+import com.badlogic.gdx.audio.Sound;
+import com.badlogic.gdx.assets.AssetManager;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.RustAndDust;
+import ch.asynk.rustanddust.engine.Pawn;
+import ch.asynk.rustanddust.engine.Board;
+import ch.asynk.rustanddust.engine.Tile;
+import ch.asynk.rustanddust.engine.Faction;
+import ch.asynk.rustanddust.engine.Move;
+import ch.asynk.rustanddust.engine.SelectedTile;
+import ch.asynk.rustanddust.engine.ObjectiveSet;
+import ch.asynk.rustanddust.engine.OrderList;
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.engine.Meteorology;
+import ch.asynk.rustanddust.engine.PathBuilder;
+import ch.asynk.rustanddust.engine.gfx.Moveable;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+import ch.asynk.rustanddust.engine.gfx.animations.AnimationSequence;
+import ch.asynk.rustanddust.engine.gfx.animations.DiceAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.FireAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.TankFireAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.InfantryFireAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.PromoteAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.DestroyAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.SoundAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.RunnableAnimation;
+import ch.asynk.rustanddust.engine.gfx.animations.MoveToAnimation.MoveToAnimationCb;
+
+import ch.asynk.rustanddust.ui.Position;
+
+public abstract class Map extends Board implements MoveToAnimationCb, ObjectiveSet.ObjectiveCb
+{
+    private final Ctrl ctrl;
+
+    public final HexSet possibleMoves;
+    public final PathBuilder pathBuilder;
+
+    public final UnitList moveableUnits;
+    public final UnitList possibleTargets;
+    public final UnitList engagementAssists;
+    public final UnitList activatedUnits;
+    public final UnitList breakUnits;
+    public final ObjectiveSet objectives;
+
+    public final Meteorology meteorology;
+
+    private final DestroyAnimation destroy;
+    private final Sound tankMoveSound;
+    private final Sound infantryMoveSound;
+    private Sound sound;
+    private long soundId = -1;
+
+    private OrderList commands;
+
+    protected abstract void setup();
+
+    public Map(final RustAndDust game, Board.Config cfg, String textureName)
+    {
+        super(game.factory, cfg, game.manager.get(textureName, Texture.class),
+                new SelectedTile(game.manager.get("data/hex.png", Texture.class), new float[] {.2f, .1f, .1f, .1f, .2f, .1f} ));
+        this.ctrl = game.ctrl;
+        this.destroy = new DestroyAnimation();
+        this.tankMoveSound = game.manager.get("sounds/tank_move.mp3", Sound.class);
+        this.infantryMoveSound = game.manager.get("sounds/infantry_move.mp3", Sound.class);
+        DiceAnimation.init(game.manager.get("data/dice.png", Texture.class), 16, 9, game.manager.get("sounds/dice.mp3", Sound.class));
+        PromoteAnimation.init(game.manager.get("data/hud.atlas", TextureAtlas.class),
+                game.manager.get("sounds/promote_us.mp3", Sound.class),
+                game.manager.get("sounds/promote_ge.mp3", Sound.class));
+        FireAnimation.init(
+                game.manager.get("data/infantry_fire.png", Texture.class), 1, 8,
+                game.manager.get("data/tank_fire.png", Texture.class), 1, 8,
+                game.manager.get("data/explosions.png", Texture.class), 16, 8,
+                game.manager.get("sounds/infantry_fire.mp3", Sound.class),
+                game.manager.get("sounds/tank_fire.mp3", Sound.class),
+                game.manager.get("sounds/tank_fire_short.mp3", Sound.class),
+                game.manager.get("sounds/explosion.mp3", Sound.class),
+                game.manager.get("sounds/explosion_short.mp3", Sound.class)
+                );
+
+        setup();
+
+        possibleMoves = new HexSet(this, 40);
+        pathBuilder = new PathBuilder(this, 10, 20, 5, 10);
+        moveableUnits = new UnitList(6);
+
+        possibleTargets = new UnitList(10);
+        engagementAssists = new UnitList(6);
+        activatedUnits = new UnitList(7);
+        breakUnits = new UnitList(4);
+
+        objectives = new ObjectiveSet(this, 4);
+
+        meteorology = new Meteorology();
+        commands = new OrderList();
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        clearAll();
+        destroy.dispose();
+        pathBuilder.dispose();
+        DiceAnimation.free();
+        PromoteAnimation.free();
+        FireAnimation.free();
+        commands.dispose();
+        Command.clearPool();
+        Engagement.clearPool();
+    }
+
+    public void clearAll()
+    {
+        possibleMoves.clear();
+        possibleTargets.clear();
+        pathBuilder.clear();
+        moveableUnits.clear();
+        engagementAssists.clear();
+        activatedUnits.clear();
+        breakUnits.clear();
+    }
+
+    public Hex getHexAt(float x, float y)
+    {
+        return (Hex) getTileAt(x, y);
+    }
+
+    public Hex getHex(int col, int row)
+    {
+        return (Hex) getTile(col, row);
+    }
+
+    public void addObjective(int col, int row, Army army)
+    {
+        addObjective(col, row, army, true);
+    }
+
+    public void addHoldObjective(int col, int row, Army army)
+    {
+        addObjective(col, row, army, false);
+    }
+
+    private void addObjective(int col, int row, Army army, boolean persistent)
+    {
+        Hex hex = getHex(col, row);
+        objectives.add(hex, army, persistent);
+        showObjective(hex, army, !persistent);
+    }
+
+    private void claim(Hex hex, Army army)
+    {
+        showObjective(hex, objectives.claim(hex, army));
+    }
+
+    private void unclaim(Hex hex)
+    {
+        showObjective(hex, objectives.unclaim(hex));
+    }
+
+    public int collectPossibleMoves(Unit unit)
+    {
+        if (!unit.canMove()) {
+            possibleMoves.clear();
+            return 0;
+        }
+        return collectPossibleMoves(unit, possibleMoves.asTiles());
+    }
+
+    public int togglePathBuilderHex(Hex hex)
+    {
+        return pathBuilder.toggleCtrlTile(hex);
+    }
+
+    public int collectPossibleTargets(Unit unit, UnitList foes)
+    {
+        if (!unit.canEngage()) {
+            possibleTargets.clear();
+            return 0;
+        }
+        // return collectPossibleTargets(unit, possibleTargets);
+        return collectPossibleTargets(unit, foes.asPawns(), possibleTargets.asPawns());
+    }
+
+    public int collectMoveableUnits(Unit unit)
+    {
+        if (unit.canHQMove()) {
+            collectMoveAssists(unit, moveableUnits.asPawns());
+        } else {
+            moveableUnits.clear();
+        }
+        if (unit.canMove())
+            moveableUnits.add(unit);
+        return moveableUnits.size();
+    }
+
+    public int collectAttackAssists(Unit unit, Unit target, UnitList units)
+    {
+        int s = collectAttackAssists(unit, target, units.asPawns(), engagementAssists.asPawns());
+        activatedUnits.add(unit);
+        return s;
+    }
+
+    public boolean toggleAttackAssist(Unit unit)
+    {
+        if (activatedUnits.contains(unit)) {
+            activatedUnits.remove(unit);
+            unit.hideAttack();
+            unit.showAttackAssist();
+            return false;
+        } else {
+            activatedUnits.add(unit);
+            unit.showAttack();
+            unit.hideAttackAssist();
+            return true;
+        }
+    }
+
+    public void collectAndShowMovesAndAssits(Unit unit)
+    {
+        hidePossibleMoves();
+        hideMoveableUnits();
+        collectPossibleMoves(unit);
+        collectMoveableUnits(unit);
+        showPossibleMoves();
+        showMoveableUnits();
+        activatedUnits.clear();
+    }
+
+    // -> implement MoveToAnimationCb
+
+    @Override
+    public void moveToAnimationEnter(Moveable moveable, float x, float y, float r)
+    {
+        claim(getHexAt(x, y), (Army) moveable.getFaction());
+    }
+
+    @Override
+    public void moveToAnimationLeave(Moveable moveable, float x, float y, float r)
+    {
+        unclaim(getHexAt(x, y));
+    }
+
+    @Override
+    public void moveToAnimationDone(Moveable moveable, float x, float y, float r)
+    {
+    }
+
+    // <- implement MoveToAnimationCb
+
+    private int process(Unit unit, Move move)
+    {
+        RustAndDust.debug("  Move", String.format("%s %s", move.type, move.toString()));
+
+        int r = 1;
+
+        switch(move.type) {
+            case REGULAR:
+                initMove(unit);
+                movePawn(unit, move, this);
+                r = moveableUnits.size();
+                break;
+            case EXIT:
+                initMove(unit);
+                movePawn(unit, move, this);
+                ctrl.player.unitWithdraw(unit);
+                r = moveableUnits.size();
+                break;
+            case SET:
+                setPawnOnto(unit, move);
+                ctrl.player.unitEntry(unit);
+                claim((Hex) move.to, unit.getArmy());
+                break;
+            case ENTER:
+                enterPawn(unit, move);
+                ctrl.player.unitEntry(unit);
+                claim((Hex) move.to, unit.getArmy());
+                break;
+            default:
+                System.err.println(String.format("process wrong Move type %s", move.type));
+                r = -1;
+                break;
+        }
+
+        return r;
+    }
+
+    private int promoteUnit(final Unit unit, final Player player)
+    {
+        activatedUnits.add(unit);
+
+        Hex hex = unit.getHex();
+        AnimationSequence seq = AnimationSequence.get(2);
+        seq.addAnimation(PromoteAnimation.get((unit.getArmy() == Army.US), hex.getX(), hex.getY(), ctrl.cfg.fxVolume));
+        seq.addAnimation ( RunnableAnimation.get(unit, new Runnable() {
+            @Override
+            public void run() {
+                player.promote(unit);
+            }
+        }));
+        addAnimation(seq);
+        return 1;
+    }
+
+    private int process(Command cmd)
+    {
+        RustAndDust.debug("Command", cmd.toString());
+
+        int r = 1;
+
+        switch(cmd.type) {
+            case MOVE:
+                r = process(cmd.unit, cmd.move);
+                break;
+            case PROMOTE:
+                r = promoteUnit(cmd.unit, cmd.player);
+                break;
+            case ENGAGE:
+                resolveEngagement(cmd.engagement);
+                r = doEngagement(cmd.engagement);
+                break;
+            default:
+                System.err.println(String.format("process wrong Command type %s", cmd.type));
+                r = -1;
+                break;
+        }
+
+        if (r != -1)
+            commands.add(cmd);
+
+        return r;
+    }
+
+    // Ctrl Methods
+
+    public void init()
+    {
+        actionDone();
+    }
+
+    public void turnDone()
+    {
+        RustAndDust.debug("TurnDone", String.format(" Processed Commands : %d", commands.size()));
+
+        if (objectives.modifiedCount() > 0)
+            throw new RuntimeException("objectives not cleared");
+
+        // FIXME do something with these Commands
+        commands.dispose();
+    }
+
+    public void actionDone()
+    {
+        objectives.forget();
+    }
+
+    // STATES ENTRY ->
+
+    public void showOnBoard(final Unit unit, Hex to, Orientation o)
+    {
+        setPawnOnto(unit, to, o);
+    }
+
+    public boolean setOnBoard(final Unit unit, Hex to, Orientation entry)
+    {
+        commands.dispose(unit);
+        return (process(getMoveCommand(unit, Move.getSet(unit, to, entry))) == 1);
+    }
+
+    public boolean enterBoard(final Unit unit, Hex to, int allowedMoves)
+    {
+        Orientation entry = findBestEntry(unit, to, allowedMoves);
+        if (entry == Orientation.KEEP)
+            return false;
+
+        return (process(getMoveCommand(unit, Move.getEnter(unit, to, entry))) == 1);
+    }
+
+    public int exitBoard(final Unit unit)
+    {
+        return process(getMoveCommand(unit, pathBuilder.getExitMove()));
+    }
+
+    public int moveUnit(final Unit unit)
+    {
+        return process(getMoveCommand(unit, pathBuilder.getMove()));
+    }
+
+    public void revertMoves()
+    {
+        for (Unit unit: activatedUnits) {
+            RustAndDust.debug("    revertMove() " + unit);
+            revertLastPawnMove(unit);
+            commands.dispose(unit, Command.CommandType.MOVE);
+        }
+        activatedUnits.clear();
+        objectives.revert(this);
+    }
+
+    public void revertEnter(final Unit unit)
+    {
+        RustAndDust.debug("    revertEnter() "+ unit);
+        removePawn(unit);
+        objectives.revert(this);
+        ctrl.player.revertUnitEntry(unit);
+        commands.dispose(unit);
+        unit.reset();
+    }
+
+    public boolean engageUnit(final Unit unit, final Unit target)
+    {
+        attack(unit, target, true);
+
+        Command cmd = Command.get(ctrl.player);
+        cmd.setEngage(unit, target);
+        return (process(cmd) == 1);
+    }
+
+    public void promoteUnit(final Unit unit)
+    {
+        Command cmd = Command.get(ctrl.player);
+        cmd.setPromote(unit);
+        process(cmd);
+    }
+
+    // STATES ENTRY <-
+
+    private Command getMoveCommand(Unit unit, Move move)
+    {
+        Command cmd = Command.get(ctrl.player);
+        cmd.setMove(unit, move);
+        return cmd;
+    }
+
+    private void initMove(Unit unit)
+    {
+        moveableUnits.remove(unit);
+        activatedUnits.add(unit);
+        playMoveSound(unit);
+    }
+
+    private void playMoveSound(Unit unit)
+    {
+        if (unit.isA(Unit.UnitType.INFANTRY))
+            sound = infantryMoveSound;
+        else
+            sound = tankMoveSound;
+        soundId = sound.play(ctrl.cfg.fxVolume);
+    }
+
+    @Override
+    protected void animationsOver()
+    {
+        if (soundId >= 0) {
+            addAnimation( SoundAnimation.get(SoundAnimation.Action.FADE_OUT, sound, soundId, ctrl.cfg.fxVolume, 0.5f));
+            soundId = -1;
+            return;
+        }
+        ctrl.animationsOver();
+    }
+
+    private void addEngagementAnimation(Unit target)
+    {
+        FireAnimation.reset();
+        Hex to = target.getHex();
+        for (Unit u : activatedUnits) {
+            Hex from = u.getHex();
+            float halfWidth = (u.getWidth() / 2f);
+            if (u.isA(Unit.UnitType.INFANTRY))
+                addAnimation(InfantryFireAnimation.get(ctrl.cfg.fxVolume, from.getX(), from.getY(), to.getX(), to.getY(), halfWidth));
+            else
+                addAnimation(TankFireAnimation.get(ctrl.cfg.fxVolume, from.getX(), from.getY(), to.getX(), to.getY(), halfWidth));
+        }
+    }
+
+    private void resolveEngagement(Engagement e)
+    {
+        int dice = e.d1 + e.d2;
+
+        int distance = 0;
+        boolean mayReroll = false;
+        boolean night = (meteorology.day == Meteorology.Day.NIGHT);
+        boolean flankAttack = false;
+        boolean terrainBonus = true;
+
+        for (Unit unit : activatedUnits) {
+            if (unit != e.attacker)
+                e.addAssist(unit);
+            if (unit.isAce())
+                mayReroll = true;
+            if (unit.isFlankAttack())
+                flankAttack = true;
+            if (unit.isA(Unit.UnitType.INFANTRY))
+                terrainBonus = false;
+            if (night) {
+                if (distance < unit.attackDistance())
+                    distance = unit.attackDistance();
+            }
+        }
+
+        int cnt = activatedUnits.size();
+        int def = e.defender.getDefense(e.attacker.getTile());
+        int flk = (flankAttack ? Unit.FLANK_ATTACK_BONUS : 0);
+        int tdf = (terrainBonus ? e.defender.getTile().defense() : 0);
+        int wdf = 0;
+        if (night) {
+            if (distance > 3)
+                wdf = 3;
+            else if (distance > 2)
+                wdf = 2;
+            else if (distance > 1)
+                wdf = 1;
+        }
+        int s1 = (dice + cnt + flk);
+        int s2 = (def + tdf + wdf);
+
+        boolean success = false;
+        if (dice == 2) {
+            success = false;
+        } else if (dice == 12) {
+            success = true;
+        } else {
+            success = (s1 >= s2);
+        }
+        if (!success && mayReroll) {
+            dice = e.d3 + e.d4;
+            s1 = (dice + cnt + flk);
+            if (dice == 2) {
+                success = false;
+            } else if (dice == 12) {
+                success = true;
+            } else {
+                success = (s1 >= s2);
+            }
+        } else {
+            e.d3 = 0;
+            e.d4 = 0;
+        }
+
+        e.set(cnt, flk, def, tdf, wdf);
+        e.success = success;
+    }
+
+    private int doEngagement(Engagement e)
+    {
+        breakUnits.clear();
+        activatedUnits.clear();
+
+        activatedUnits.add(e.attacker);
+        for (Unit u : e.assists)
+            activatedUnits.add(u);
+
+        for (Unit u : activatedUnits) {
+            u.engage();
+            if (u.isA(Unit.UnitType.INFANTRY))
+                breakUnits.add(u);
+        }
+
+        if (e.success) {
+            unclaim(e.defender.getHex());
+            removePawn(e.defender);
+            destroy.set(2f, e.defender);
+            addAnimation(destroy);
+        }
+
+        if ((activatedUnits.size() == 1) && e.attacker.isA(Unit.UnitType.AT_GUN) && e.defender.isHardTarget())
+            activatedUnits.clear();
+
+        ctrl.hud.engagementSummary(e, ctrl.cfg.fxVolume);
+        addEngagementAnimation(e.defender);
+
+        return (e.success ? 1 : 0);
+    }
+
+    // SHOW / HIDE
+
+    public void togglePathOverlay(Hex hex)
+    {
+        boolean enable= !hex.isOverlayEnabled(Hex.MOVE);
+        enableOverlayOn(hex, Hex.MOVE, enable);
+    }
+
+    private void showUnitsOverlay(UnitList units, int overlay, boolean on)
+    {
+        for (Unit unit : units)
+            unit.enableOverlay(overlay, on);
+    }
+
+    public void showMoveableUnits()     { showUnitsOverlay(moveableUnits, Unit.MOVE, true); }
+    public void hideMoveableUnits()     { showUnitsOverlay(moveableUnits, Unit.MOVE, false); }
+    public void showPossibleTargets()   { showUnitsOverlay(possibleTargets, Unit.TARGET, true); }
+    public void hidePossibleTargets()   { showUnitsOverlay(possibleTargets, Unit.TARGET, false); }
+    public void showAttackAssists()     { showUnitsOverlay(engagementAssists, Unit.MAY_FIRE, true); }
+    public void hideAttackAssists()     { showUnitsOverlay(engagementAssists, Unit.FIRE, false);
+                                          showUnitsOverlay(engagementAssists, Unit.MAY_FIRE, false); }
+    public void showBreakUnits()        { showUnitsOverlay(breakUnits, Unit.MOVE, true); }
+    public void hideBreakUnits()        { showUnitsOverlay(breakUnits, Unit.MOVE, false); }
+
+    public void showPossibleMoves()     { possibleMoves.enable(Hex.AREA, true); }
+    public void hidePossibleMoves()     { possibleMoves.enable(Hex.AREA, false); }
+    public void showPathBuilder()       { pathBuilder.enable(Hex.AREA, true); }
+    public void hidePathBuilder()       { pathBuilder.enable(Hex.AREA, false); }
+    public void showPath(Hex dst)       { pathBuilder.enable(Hex.MOVE, true); showMove(dst); }
+    public void hidePath(Hex dst)       { pathBuilder.enable(Hex.MOVE, false); hideMove(dst); }
+
+    public void selectHex(Hex hex)      { selectedTile.set(hex); }
+    public void unselectHex(Hex hex)    { selectedTile.hide(); }
+    public void showMove(Hex hex)       { enableOverlayOn(hex, Hex.MOVE, true); }
+    public void hideMove(Hex hex)       { enableOverlayOn(hex, Hex.MOVE, false); }
+    public void showDirections(Hex hex) { enableOverlayOn(hex, Hex.DIRECTIONS, true); }
+    public void hideDirections(Hex hex) { enableOverlayOn(hex, Hex.DIRECTIONS, false); }
+    public void showOrientation(Hex hex, Orientation o) { enableOverlayOn(hex, Hex.ORIENTATION, o, true); }
+    public void hideOrientation(Hex hex) { enableOverlayOn(hex, Hex.ORIENTATION, false); }
+    public void showExit(Hex hex)       { enableOverlayOn(hex, Hex.EXIT, true); }
+    public void hideExit(Hex hex)       { enableOverlayOn(hex, Hex.EXIT, false); }
+
+    public void showObjective(Hex hex, Army army, boolean hold)
+    {
+        if (hold)
+            enableOverlayOn(hex, Hex.OBJECTIVE_HOLD, true);
+        else
+            enableOverlayOn(hex, Hex.OBJECTIVE, true);
+    }
+
+
+    // -> implement ObjectiveSet.ObjectiveCb
+
+    public void showObjective(Tile tile, Faction faction)
+    {
+        showObjective((Hex) tile, (Army) faction);
+    }
+
+    // <- implement MoveToAnimationCb
+
+    public void showObjective(Hex hex, Army army)
+    {
+        if (army == null)
+            army = Army.NONE;
+        switch(army) {
+            case GE:
+                enableOverlayOn(hex, Hex.OBJECTIVE_GE, true);
+                enableOverlayOn(hex, Hex.OBJECTIVE_US, false);
+                break;
+            case US:
+                enableOverlayOn(hex, Hex.OBJECTIVE_GE, false);
+                enableOverlayOn(hex, Hex.OBJECTIVE_US, true);
+                break;
+            case NONE:
+            default:
+                enableOverlayOn(hex, Hex.OBJECTIVE_GE, false);
+                enableOverlayOn(hex, Hex.OBJECTIVE_US, false);
+                break;
+        }
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Player.java b/core/src/ch/asynk/rustanddust/game/Player.java
new file mode 100644
index 0000000..e368101
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Player.java
@@ -0,0 +1,213 @@
+package ch.asynk.rustanddust.game;
+
+import java.util.Random;
+import java.util.List;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class Player
+{
+    private static final float MOVE_TIME = 0.4f;
+
+    private static Random rand = new Random();
+
+    private int turn;
+    private int apSpent;
+    private int actionPoints;
+    private boolean deploymentDone;
+
+    public Army army;
+    public UnitList units;
+    public UnitList casualties;
+    public UnitList reinforcement;
+    public UnitList withdrawed;
+
+    public int actionCount;
+    public int lostEngagementCount;
+    public int wonEngagementCount;
+
+    public Player(final RustAndDust game, Army army, int n)
+    {
+        this.army = army;
+        this.units = new UnitList(n);
+        this.casualties = new UnitList(n);
+        this.reinforcement = new UnitList(n);
+        this.withdrawed = new UnitList(n);
+        this.turn = 0;
+        this.apSpent = 0;
+        this.actionPoints = 0;
+        this.deploymentDone = false;
+        this.actionCount = 0;
+        this.lostEngagementCount = 0;
+        this.wonEngagementCount = 0;
+    }
+
+    public String getName()
+    {
+        return army.toString();
+    }
+
+    public String toString()
+    {
+        return String.format("%s Turn:%d AP:%d units:%d casualties:%d", army, turn, actionPoints, units.size(), casualties.size());
+    }
+
+    public String getStats()
+    {
+        return String.format("%s\n%4d\n%4d\n%4d\n%4d\n%4d\n%4d", getName(), actionCount, unitsLeft(), withdrawed(), casualties(), wonEngagementCount, lostEngagementCount);
+    }
+
+    public boolean is(Army army)
+    {
+        return (this.army == army);
+    }
+
+    public boolean isEnemy(Unit unit)
+    {
+        return unit.isEnemy(army);
+    }
+
+    public boolean isEnemy(Army other)
+    {
+        return army.isEnemy(other);
+    }
+
+    public int unitsLeft()
+    {
+        return (units.size() + reinforcement.size());
+    }
+
+    public int reinforcement()
+    {
+        return reinforcement.size();
+    }
+
+    public int casualties()
+    {
+        return casualties.size();
+    }
+
+    public int withdrawed()
+    {
+        return withdrawed.size();
+    }
+
+    public void addUnit(Unit unit)
+    {
+        units.add(unit);
+    }
+
+    public void addReinforcement(Unit unit)
+    {
+        reinforcement.add(unit);
+    }
+
+    public void unitEntry(Unit unit)
+    {
+        reinforcement.remove(unit);
+        units.add(unit);
+    }
+
+    public void revertUnitEntry(Unit unit)
+    {
+        units.remove(unit);
+        reinforcement.add(unit);
+    }
+
+    public void casualty(Unit unit)
+    {
+        units.remove(unit);
+        casualties.add(unit);
+    }
+
+    public void unitWithdraw(Unit unit)
+    {
+        units.remove(unit);
+        withdrawed.add(unit);
+    }
+
+    public int getAp()
+    {
+        return ((apSpent < actionPoints) ? (apSpent + 1) : apSpent);
+    }
+
+    public int getTurnDone()
+    {
+        return turn;
+    }
+
+    public int getCurrentTurn()
+    {
+        return (turn + 1);
+    }
+
+    public boolean apExhausted()
+    {
+        return (apSpent == actionPoints);
+    }
+
+    public boolean isDeploymentDone()
+    {
+        return (deploymentDone || (reinforcement.size() == 0));
+    }
+
+    public void burnDownOneAp()
+    {
+        apSpent += 1;
+        actionCount += 1;
+        if (apSpent > actionPoints) RustAndDust.debug("ERROR: spent too much AP, please report");
+    }
+
+    public void turnEnd()
+    {
+        if (deploymentDone)
+            turn += 1;
+        else
+            deploymentDone = (reinforcement.size() == 0);
+        for (Unit unit : units)
+            unit.reset();
+    }
+
+    public void turnStart()
+    {
+        if (isDeploymentDone())
+            computeActionPoints();
+    }
+
+    public int d6()
+    {
+        return rand.nextInt(6) + 1;
+    }
+
+    private void computeActionPoints()
+    {
+        this.actionPoints = 2;
+        if (d6() > 2) {
+            this.actionPoints += 1;
+            if (d6() > 3)
+                this.actionPoints += 1;
+        }
+        apSpent = 0;
+    }
+
+    public boolean canPromote(Unit unit)
+    {
+        if (unit.isHq()) return false;
+        for (Unit p: casualties)
+            if (p.isHqOf(unit)) return true;
+        return false;
+    }
+
+    public boolean promote(Unit unit)
+    {
+        for (Unit p: casualties) {
+            if (p.isHqOf(unit)) {
+                unit.promote();
+                p.degrade();
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/State.java b/core/src/ch/asynk/rustanddust/game/State.java
new file mode 100644
index 0000000..db0d6af
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/State.java
@@ -0,0 +1,35 @@
+package ch.asynk.rustanddust.game;
+
+public interface State
+{
+    enum StateType {
+        SELECT,
+        MOVE,
+        ROTATE,
+        ENGAGE,
+        BREAK,
+        PROMOTE,
+        ANIMATION,
+        REINFORCEMENT,
+        DEPLOYMENT,
+        WITHDRAW,
+        ABORT,
+        DONE
+    };
+
+    public void enter(StateType prevState);
+
+    public void leave(StateType nextState);
+
+    public StateType abort();
+
+    public StateType execute();
+
+    public void touchDown();
+
+    public void touchUp();
+
+    public boolean downInMap(float x, float y);
+
+    public boolean upInMap(float x, float y);
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Unit.java b/core/src/ch/asynk/rustanddust/game/Unit.java
new file mode 100644
index 0000000..472bd20
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Unit.java
@@ -0,0 +1,361 @@
+package ch.asynk.rustanddust.game;
+
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+
+import ch.asynk.rustanddust.engine.Pawn;
+import ch.asynk.rustanddust.engine.Tile;
+import ch.asynk.rustanddust.engine.HeadedPawn;
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.game.Hex.Terrain;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class Unit extends HeadedPawn
+{
+    public static final int MOVE        = 0;
+    public static final int TARGET      = 1;
+    public static final int FIRE        = 2;
+    public static final int MAY_FIRE    = 3;
+    public static final int ACE         = 4;
+    public static final int HQ          = 5;
+    public static final int HAS_FIRED   = 6;
+    public static final int HAS_MOVED   = 7;
+
+    public static final int FLANK_ATTACK_BONUS = 1;
+
+    public enum UnitType implements Pawn.PawnType
+    {
+        HARD_TARGET,
+        HARD_TARGET_HQ,
+        INFANTRY,
+        AT_GUN,
+        ARTILLERY
+    }
+
+    public enum UnitId implements Pawn.PawnId
+    {
+        GE_AT_GUN("German Anti-Tank Gun"),
+        GE_INFANTRY("German Infantry"),
+        GE_KINGTIGER("German King Tiger"),
+        GE_PANZER_IV("German Panzer IV"),
+        GE_PANZER_IV_HQ("German Panzer IV HQ"),
+        GE_TIGER("German Tiger"),
+        GE_WESPE("German Wespe"),
+
+        US_AT_GUN("US Anti-Tank Gun"),
+        US_INFANTRY("US Infantry"),
+        US_PERSHING("US Pershing"),
+        US_PERSHING_HQ("US Pershing HQ"),
+        US_PRIEST("US Priest"),
+        US_SHERMAN("US Sherman"),
+        US_SHERMAN_HQ("US Sherman HQ"),
+        US_WOLVERINE("US Wolverine");
+
+        private String s;
+        UnitId(String s) { this.s = s; }
+        public String toString() { return s; }
+    }
+
+    public int rng;
+    public int def;
+    public int cdef;
+    public int mp;
+    public int mpLeft;
+    public UnitType type;
+    public UnitId id;
+    public boolean ace;
+    private boolean hasMoved;
+    private boolean hasFired;
+
+    protected Unit(Army army, String pawn, String head, TextureAtlas pawns, TextureAtlas overlays)
+    {
+        super(army, pawn, head, pawns, overlays);
+        ace = false;
+
+    }
+
+    private void commonSetup()
+    {
+        mpLeft = mp;
+        enableOverlay(HQ, isHq());
+        this.hasMoved = false;
+        this.hasFired = false;
+        updateDescr();
+    }
+
+    private void updateDescr()
+    {
+        if (cdef == -1)
+            this.descr = id.toString() + (ace ? " Ace " : "") + " (" + rng + "-" + def + "-" + mp + ")";
+        else
+            this.descr = id.toString() + (ace ? " Ace " : "") + " (" + rng + "-" + def + "/" + cdef + "-" + mp + ")";
+    }
+
+    // hard tager
+    public Unit(Army army, UnitId id, UnitType type, int range, int defense, int movementPoints, String unit, String head, TextureAtlas pawns, TextureAtlas overlays)
+    {
+        this(army, unit, head, pawns, overlays);
+        this.rng = range;
+        this.def = defense;
+        this.cdef = -1;
+        this.mp = movementPoints;
+        this.id = id;
+        this.type = type;
+        commonSetup();
+    }
+
+    // soft tager
+    public Unit(Army army, UnitId id, UnitType type, int range, int defense, int concealedDefense, int movementPoints, String unit, String head, TextureAtlas pawns, TextureAtlas overlays)
+    {
+        this(army, unit, head, pawns, overlays);
+        this.rng = range;
+        this.def = defense;
+        this.cdef = concealedDefense;
+        this.mp = movementPoints;
+        this.id = id;
+        this.type = type;
+        commonSetup();
+    }
+
+    public Army getArmy()
+    {
+        return (Army) getFaction();
+    }
+
+    public Hex getHex()
+    {
+        return (Hex) getTile();
+    }
+
+    public boolean isAce()
+    {
+        return ace;
+    }
+
+    public void setAce(boolean ace)
+    {
+        this.ace = ace;
+        updateDescr();
+        enableOverlay(ACE, ace);
+    }
+
+    @Override
+    public int getMovementPoints()
+    {
+        return mpLeft;
+    }
+
+    @Override
+    public int getRoadMarchBonus()
+    {
+        return 1;
+    }
+
+    @Override
+    public int getEngagementRangeFrom(Tile tile)
+    {
+        if (!isA(UnitType.INFANTRY) && tile.isA(Terrain.HILLS))
+            return rng + 1;
+        return rng;
+    }
+
+    @Override
+    public int getAngleOfAttack()
+    {
+        return orientation.getFrontSides();
+    }
+
+    @Override
+    public int getFlankSides()
+    {
+        return orientation.getBackSides();
+    }
+
+    @Override
+    public int getDefense(Tile tile)
+    {
+        if (!isHardTarget() && (tile.isA(Terrain.HILLS) || tile.isA(Terrain.WOODS) || tile.isA(Terrain.TOWN)))
+            return cdef;
+
+        return def;
+    }
+
+    @Override
+    public boolean isUnit()
+    {
+        return true;
+    }
+
+    @Override
+    public boolean isA(PawnId i)
+    {
+        return (id == i);
+    }
+
+    @Override
+    public boolean isA(PawnType t)
+    {
+        return (type == t);
+    }
+
+    @Override
+    public boolean isHq()
+    {
+        return isA(UnitType.HARD_TARGET_HQ);
+    }
+
+    @Override
+    public boolean isHqOf(Pawn other)
+    {
+        if (isA(UnitId.GE_PANZER_IV_HQ) && other.isA(UnitId.GE_PANZER_IV)) return true;
+        if (isA(UnitId.US_PERSHING_HQ) && other.isA(UnitId.US_PERSHING)) return true;
+        if (isA(UnitId.US_SHERMAN_HQ) && other.isA(UnitId.US_SHERMAN)) return true;
+        return false;
+    }
+
+    public void promote()
+    {
+        if (isA(UnitId.GE_PANZER_IV))
+            id = UnitId.GE_PANZER_IV_HQ;
+        else if (isA(UnitId.US_PERSHING))
+            id = UnitId.US_PERSHING_HQ;
+        else if (isA(UnitId.US_SHERMAN))
+            id = UnitId.US_SHERMAN_HQ;
+        else
+            return;
+
+        type = UnitType.HARD_TARGET_HQ;
+        enableOverlay(HQ, true);
+        updateDescr();
+    }
+
+    public void degrade()
+    {
+        if (isA(UnitId.GE_PANZER_IV_HQ))
+            id = UnitId.GE_PANZER_IV;
+        else if (isA(UnitId.US_PERSHING_HQ))
+            id = UnitId.US_PERSHING;
+        else if (isA(UnitId.US_SHERMAN_HQ))
+            id = UnitId.US_SHERMAN;
+        else
+            return;
+
+        type = UnitType.HARD_TARGET;
+        enableOverlay(HQ, false);
+        updateDescr();
+    }
+
+    @Override
+    public boolean isHardTarget()
+    {
+        return (isA(UnitType.HARD_TARGET) || isA(UnitType.HARD_TARGET_HQ) || isA(UnitType.ARTILLERY));
+    }
+
+    @Override
+    public boolean canRotate()
+    {
+        return canMove();
+    }
+
+    @Override
+    public boolean canMove()
+    {
+        if (isHardTarget()) return !hasMoved;
+        return (!hasMoved && !hasFired);
+    }
+
+    @Override
+    public boolean canEngage()
+    {
+        if (isHardTarget()) return !hasFired;
+        return (!hasMoved && !hasFired);
+    }
+
+    @Override
+    public boolean canAssistEngagementWithoutLos()
+    {
+        return isA(UnitType.ARTILLERY);
+    }
+
+    @Override
+    public boolean canEngage(Pawn other)
+    {
+        return (isEnemy(other) && canEngage());
+    }
+
+    public boolean canHQMove()
+    {
+        return (isHq() && ((move == null) || (!move.isEnter())));
+    }
+
+    public void setMoved()
+    {
+        hasMoved = true;
+        updateOverlays();
+    }
+
+    @Override
+    public void move()
+    {
+        int cost = move.cost;
+
+        if (move.roadMarch && (cost > mpLeft))
+            cost -= getRoadMarchBonus();
+
+        if (cost > mpLeft)
+            RustAndDust.debug("ERROR: Movement point exceeded: " + cost + "/" + mpLeft + " please report");
+
+        if (move.isFinal())
+            setMoved();
+
+        mpLeft -= cost;
+    }
+
+    @Override
+    public void engage()
+    {
+        hasFired = true;
+        updateOverlays();
+    }
+
+    @Override
+    public void reset()
+    {
+        super.reset();
+        mpLeft = mp;
+        hasFired = false;
+        hasMoved = false;
+        hideHasMoved();
+        hideHasFired();
+    }
+
+    @Override
+    public void revertLastMove()
+    {
+        hasMoved = false;
+        mpLeft = mp;
+        updateOverlays();
+        move = null;
+    }
+
+    private void updateOverlays()
+    {
+        enableOverlay(HAS_MOVED, !canMove());
+        enableOverlay(HAS_FIRED, !canEngage());
+    }
+
+    // SHOW / HIDE
+    public void showMoveable()      { enableOverlay(MOVE, true); }
+    public void hideMoveable()      { enableOverlay(MOVE, false); }
+    public void showTarget()        { enableOverlay(TARGET, true); }
+    public void hideTarget()        { enableOverlay(TARGET, false); }
+    public void showAttack()        { enableOverlay(FIRE, true); }
+    public void hideAttack()        { enableOverlay(FIRE, false); }
+    public void showAttackAssist()  { enableOverlay(MAY_FIRE, true); }
+    public void hideAttackAssist()  { enableOverlay(MAY_FIRE, false); }
+    public void showHasMoved()      { enableOverlay(HAS_MOVED, true); }
+    public void hideHasMoved()      { enableOverlay(HAS_MOVED, false); }
+    public void showHasFired()      { enableOverlay(HAS_FIRED, true); }
+    public void hideHasFired()      { enableOverlay(HAS_FIRED, false); }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/UnitList.java b/core/src/ch/asynk/rustanddust/game/UnitList.java
new file mode 100644
index 0000000..9637036
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/UnitList.java
@@ -0,0 +1,20 @@
+package ch.asynk.rustanddust.game;
+
+import java.util.Collection;
+import java.util.ArrayList;
+
+import ch.asynk.rustanddust.engine.Pawn;
+
+public class UnitList extends ArrayList<Unit>
+{
+    public UnitList(int n)
+    {
+        super(n);
+    }
+
+    @SuppressWarnings("unchecked")
+    public Collection<Pawn> asPawns()
+    {
+        return (Collection) this;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/Zone.java b/core/src/ch/asynk/rustanddust/game/Zone.java
new file mode 100644
index 0000000..ff15299
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/Zone.java
@@ -0,0 +1,14 @@
+package ch.asynk.rustanddust.game;
+
+import ch.asynk.rustanddust.engine.Orientation;
+
+public class Zone extends HexSet
+{
+    public int allowedMoves;
+    public Orientation orientation;
+
+    public Zone(Map map, int n)
+    {
+        super(map, n);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleCommon.java b/core/src/ch/asynk/rustanddust/game/battles/BattleCommon.java
new file mode 100644
index 0000000..731c616
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/BattleCommon.java
@@ -0,0 +1,151 @@
+package ch.asynk.rustanddust.game.battles;
+
+import java.util.Random;
+import java.util.HashMap;
+import java.util.ArrayList;
+
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Battle;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.HexSet;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.game.State.StateType;
+
+public abstract class BattleCommon implements Battle
+{
+    protected final static Random random = new Random();
+
+    protected Factory.MapType mapType;
+    protected String name;
+    protected String description;
+    protected Factory factory;
+    protected Player usPlayer;
+    protected Player gePlayer;
+    protected ArrayList<Zone> entryZone = new ArrayList<Zone>();
+    protected ArrayList<Zone> exitZone = new ArrayList<Zone>();
+    protected HashMap<Unit, Zone> unitEntry = new HashMap<Unit, Zone>();
+    protected HashMap<Unit, Zone> unitExit = new HashMap<Unit, Zone>();
+
+    public BattleCommon(Factory factory)
+    {
+        this.factory = factory;
+    }
+
+    @Override
+    public void init()
+    {
+        this.usPlayer = factory.getPlayer(Army.US);
+        this.gePlayer = factory.getPlayer(Army.GE);
+    }
+
+    @Override
+    public String toString()
+    {
+        return getName();
+    }
+
+    @Override
+    public String getName()
+    {
+        return name;
+    }
+
+    @Override
+    public String getDescription()
+    {
+        return description;
+    }
+
+    @Override
+    public Factory.MapType getMapType()
+    {
+        return mapType;
+    }
+
+    @Override
+    public Map getMap()
+    {
+        return factory.getMap(mapType);
+    }
+
+    @Override
+    public Player opponent(Player player)
+    {
+        if (player == usPlayer)
+            return gePlayer;
+        return usPlayer;
+    }
+
+    @Override
+    public boolean deploymentDone(Player player)
+    {
+        return player.isDeploymentDone();
+    }
+
+    @Override
+    public StateType getState(Player player)
+    {
+        if (!player.isDeploymentDone())
+            return StateType.DEPLOYMENT;
+        return StateType.SELECT;
+    }
+
+    @Override
+    public boolean getReinforcement(Ctrl ctrl, Map map)
+    {
+        return false;
+    }
+
+    @Override
+    public Zone getEntryZone(Unit unit)
+    {
+        return unitEntry.get(unit);
+    }
+
+    @Override
+    public Zone getExitZone(Unit unit)
+    {
+        return unitExit.get(unit);
+    }
+
+    public void addEntryZone(Zone entry)
+    {
+        entryZone.add(entry);
+    }
+
+    public void addExitZone(Zone exit)
+    {
+        exitZone.add(exit);
+        exit.enable(Hex.EXIT, true);
+    }
+
+    public void addReinforcement(Player player, Zone entryZone, UnitId unitId)
+    {
+        addReinforcement(player, entryZone, unitId, false);
+    }
+
+    public void addReinforcement(Player player, Zone entryZone, Zone exitZone, UnitId unitId)
+    {
+        addReinforcement(player, entryZone, exitZone, unitId, false);
+    }
+
+    public void addReinforcement(Player player, Zone entryZone, UnitId unitId, boolean ace)
+    {
+        addReinforcement(player, entryZone, null, unitId, ace);
+    }
+
+    public void addReinforcement(Player player, Zone entryZone, Zone exitZone, UnitId unitId, boolean ace)
+    {
+        Unit unit = factory.getUnit(unitId);
+        unit.setAce(ace);
+        player.addReinforcement(unit);
+        unitEntry.put(unit, entryZone);
+        if (exitZone != null)
+            unitExit.put(unit, exitZone);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleCounterAttack.java b/core/src/ch/asynk/rustanddust/game/battles/BattleCounterAttack.java
new file mode 100644
index 0000000..cea1d13
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/BattleCounterAttack.java
@@ -0,0 +1,150 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.engine.Orientation;
+
+public class BattleCounterAttack extends BattleCommon
+{
+    public BattleCounterAttack(Factory factory)
+    {
+        super(factory);
+        name = "Counterattack";
+        mapType = Factory.MapType.MAP_B;
+    }
+
+    @Override
+    public Position getHudPosition(Player player)
+    {
+        return (player.is(Army.US) ? Position.TOP_RIGHT: Position.TOP_LEFT);
+    }
+
+    @Override
+    public Player getPlayer()
+    {
+        if (!gePlayer.isDeploymentDone())
+            return gePlayer;
+        if (!usPlayer.isDeploymentDone())
+            return usPlayer;
+        if (gePlayer.getTurnDone() == usPlayer.getTurnDone())
+            return gePlayer;
+        return usPlayer;
+    }
+
+    public Player checkVictory(Ctrl ctrl)
+    {
+        if (ctrl.opponent.unitsLeft() == 0)
+            return ctrl.player;
+
+        if (gePlayer.withdrawed() >= 3)
+            return gePlayer;
+
+        if ((ctrl.player.getTurnDone() < 9) || (ctrl.opponent.getTurnDone() < 9))
+            return null;
+
+        return usPlayer;
+    }
+
+    @Override
+    public boolean getReinforcement(Ctrl ctrl, Map map)
+    {
+        if (ctrl.player.is(Army.GE))
+            return false;
+        if (ctrl.player.getCurrentTurn() != 5)
+            return false;
+
+        // hex row 1
+        Zone usEntry = new Zone(map, 9);
+        usEntry.allowedMoves = (Orientation.SOUTH.s | Orientation.SOUTH_EAST.s | Orientation.SOUTH_WEST.s);
+        usEntry.add(map.getHex(9, 0));
+        usEntry.add(map.getHex(9, 1));
+        usEntry.add(map.getHex(10, 2));
+        usEntry.add(map.getHex(10, 3));
+        usEntry.add(map.getHex(11, 4));
+        usEntry.add(map.getHex(11, 5));
+        usEntry.add(map.getHex(12, 6));
+        usEntry.add(map.getHex(12, 7));
+        usEntry.add(map.getHex(13, 8));
+        addEntryZone(usEntry);
+
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_PRIEST);
+
+        return true;
+    }
+
+    @Override
+    public void setup(Ctrl ctrl, Map map)
+    {
+        // hex row 1
+        Zone geExit = new Zone(map, 9);
+        geExit.orientation = Orientation.NORTH;
+        geExit.add(map.getHex(9, 0));
+        geExit.add(map.getHex(9, 1));
+        geExit.add(map.getHex(10, 2));
+        geExit.add(map.getHex(10, 3));
+        geExit.add(map.getHex(11, 4));
+        geExit.add(map.getHex(11, 5));
+        geExit.add(map.getHex(12, 6));
+        geExit.add(map.getHex(12, 7));
+        geExit.add(map.getHex(13, 8));
+        addExitZone(geExit);
+
+        // hex rows 8-9
+        Zone geEntry = new Zone(map, 18);
+        geEntry.orientation = Orientation.NORTH;
+        for (int i = 0; i < 2; i++) {
+            geEntry.add(map.getHex((1 + i), 0));
+            geEntry.add(map.getHex((1 + i), 1));
+            geEntry.add(map.getHex((2 + i), 2));
+            geEntry.add(map.getHex((2 + i), 3));
+            geEntry.add(map.getHex((3 + i), 4));
+            geEntry.add(map.getHex((3 + i), 5));
+            geEntry.add(map.getHex((4 + i), 6));
+            geEntry.add(map.getHex((4 + i), 7));
+            geEntry.add(map.getHex((5 + i), 8));
+        }
+        addEntryZone(geEntry);
+
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, geExit, UnitId.GE_WESPE);
+
+        // hex rows 1-4
+        Zone usEntry = new Zone(map, 36);
+        usEntry.orientation = Orientation.SOUTH;
+        for (int i = 0; i < 4; i++) {
+            usEntry.add(map.getHex((6 + i), 0));
+            usEntry.add(map.getHex((6 + i), 1));
+            usEntry.add(map.getHex((7 + i), 2));
+            usEntry.add(map.getHex((7 + i), 3));
+            usEntry.add(map.getHex((8 + i), 4));
+            usEntry.add(map.getHex((8 + i), 5));
+            usEntry.add(map.getHex((9 + i), 6));
+            usEntry.add(map.getHex((9 + i), 7));
+            usEntry.add(map.getHex((10 + i), 8));
+        }
+        addEntryZone(usEntry);
+
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleFrontalAssault.java b/core/src/ch/asynk/rustanddust/game/battles/BattleFrontalAssault.java
new file mode 100644
index 0000000..372e045
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/BattleFrontalAssault.java
@@ -0,0 +1,124 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.HexSet;
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.engine.Orientation;
+
+public class BattleFrontalAssault extends BattleCommon
+{
+    public BattleFrontalAssault(Factory factory)
+    {
+        super(factory);
+        name = "Frontal Assault";
+        mapType = Factory.MapType.MAP_A;
+    }
+
+
+    @Override
+    public Player getPlayer()
+    {
+        if (!gePlayer.isDeploymentDone()) {
+            int n = gePlayer.reinforcement();
+            if (n > 4)
+                return gePlayer;
+            else {
+                if (usPlayer.isDeploymentDone())
+                    return gePlayer;
+                else
+                    return usPlayer;
+            }
+        }
+        if (gePlayer.getTurnDone() == usPlayer.getTurnDone())
+            return usPlayer;
+        return gePlayer;
+    }
+
+    @Override
+    public Position getHudPosition(Player player)
+    {
+        return (player.is(Army.US) ? Position.TOP_RIGHT: Position.TOP_LEFT);
+    }
+
+    @Override
+    public boolean deploymentDone(Player player)
+    {
+        if (player.isDeploymentDone())
+            return true;
+        return ((player.is(Army.GE) && (gePlayer.reinforcement.size() == 4)));
+    }
+
+    @Override
+    public Player checkVictory(Ctrl ctrl)
+    {
+        if (ctrl.opponent.unitsLeft() == 0)
+            return ctrl.player;
+
+        if ((ctrl.player.getTurnDone() < 10) || (ctrl.opponent.getTurnDone() < 10))
+            return null;
+
+        if (ctrl.map.objectives.count(Army.US) >= 2)
+            return usPlayer;
+        else
+            return gePlayer;
+    }
+
+    @Override
+    public void setup(Ctrl ctrl, Map map)
+    {
+        // G9, E6, H4
+        map.addObjective(2, 2, Army.NONE);
+        map.addObjective(6, 4, Army.NONE);
+        map.addObjective(6, 1, Army.NONE);
+
+        // hex rows E-H
+        Zone geEntry = new Zone(map, 38);
+        geEntry.orientation = Orientation.NORTH_WEST;
+        for (int i = 2; i < 12; i++)
+            geEntry.add(map.getHex(i, 4));
+        for (int i = 2; i < 11; i++)
+            geEntry.add(map.getHex(i, 3));
+        for (int i = 1; i < 11; i++)
+            geEntry.add(map.getHex(i, 2));
+        for (int i = 1; i < 10; i++)
+            geEntry.add(map.getHex(i, 1));
+        addEntryZone(geEntry);
+
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+
+        // hex rows A-B
+        Zone usEntry = new Zone(map, 19);
+        usEntry.orientation = Orientation.SOUTH_EAST;
+        for (int i = 4; i < 14; i++)
+            usEntry.add(map.getHex(i, 8));
+        for (int i = 4; i < 13; i++)
+            usEntry.add(map.getHex(i, 7));
+        addEntryZone(usEntry);
+
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_PRIEST);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleHeadToHead.java b/core/src/ch/asynk/rustanddust/game/battles/BattleHeadToHead.java
new file mode 100644
index 0000000..0d88846
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/BattleHeadToHead.java
@@ -0,0 +1,118 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.HexSet;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.engine.Orientation;
+
+public class BattleHeadToHead extends BattleCommon
+{
+    private Army firstArmy;
+
+    public BattleHeadToHead(Factory factory)
+    {
+        super(factory);
+        name = "Head To Head";
+        firstArmy = ((random.nextInt(2) == 0) ? Army.US : Army.GE);
+        mapType = Factory.MapType.MAP_A;
+    }
+
+    @Override
+    public Player getPlayer()
+    {
+        if (gePlayer.getTurnDone() == usPlayer.getTurnDone())
+            return ((firstArmy == Army.US) ? usPlayer : gePlayer);
+        else
+            return ((firstArmy == Army.US) ? gePlayer : usPlayer);
+    }
+
+    @Override
+    public Position getHudPosition(Player player)
+    {
+        return (player.is(Army.US) ? Position.TOP_RIGHT: Position.TOP_LEFT);
+    }
+
+    @Override
+    public Player checkVictory(Ctrl ctrl)
+    {
+        if (ctrl.opponent.unitsLeft() == 0)
+            return ctrl.player;
+
+        if ((ctrl.player.getTurnDone() < 10) || (ctrl.opponent.getTurnDone() < 10))
+            return null;
+
+        if (ctrl.map.objectives.count(Army.US) >= 2)
+            return usPlayer;
+        if (ctrl.map.objectives.count(Army.GE) >= 2)
+            return gePlayer;
+
+        return null;
+    }
+
+    @Override
+    public void setup(Ctrl ctrl, Map map)
+    {
+        // end deployment
+        usPlayer.turnEnd();
+        gePlayer.turnEnd();
+
+        // B6, E6, H4
+        map.addObjective(7, 7, Army.NONE);
+        map.addObjective(6, 4, Army.NONE);
+        map.addObjective(6, 1, Army.NONE);
+
+        // southern hex row
+        Zone geEntry = new Zone(map, 9);
+        geEntry.allowedMoves = (Orientation.NORTH.s | Orientation.NORTH_EAST.s | Orientation.NORTH_WEST.s);
+        geEntry.add(map.getHex(0, 0));
+        geEntry.add(map.getHex(1, 1));
+        geEntry.add(map.getHex(1, 2));
+        geEntry.add(map.getHex(2, 3));
+        geEntry.add(map.getHex(2, 4));
+        geEntry.add(map.getHex(3, 5));
+        geEntry.add(map.getHex(3, 6));
+        geEntry.add(map.getHex(4, 7));
+        geEntry.add(map.getHex(4, 8));
+        addEntryZone(geEntry);
+
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+
+        // northern hex row
+        Zone usEntry = new Zone(map, 9);
+        usEntry.allowedMoves = (Orientation.SOUTH.s | Orientation.SOUTH_EAST.s | Orientation.SOUTH_WEST.s);
+        usEntry.add(map.getHex(9, 0));
+        usEntry.add(map.getHex(9, 1));
+        usEntry.add(map.getHex(10, 2));
+        usEntry.add(map.getHex(10, 3));
+        usEntry.add(map.getHex(11, 4));
+        usEntry.add(map.getHex(11, 5));
+        usEntry.add(map.getHex(12, 6));
+        usEntry.add(map.getHex(12, 7));
+        usEntry.add(map.getHex(13, 8));
+        addEntryZone(usEntry);
+
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_PRIEST);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleLastStand.java b/core/src/ch/asynk/rustanddust/game/battles/BattleLastStand.java
new file mode 100644
index 0000000..f898ce9
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/BattleLastStand.java
@@ -0,0 +1,136 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.HexSet;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.engine.Orientation;
+
+public class BattleLastStand extends BattleCommon
+{
+    public BattleLastStand(Factory factory)
+    {
+        super(factory);
+        name = "Last Stand";
+        mapType = Factory.MapType.MAP_B;
+    }
+
+    @Override
+    public Position getHudPosition(Player player)
+    {
+        return (player.is(Army.US) ? Position.TOP_RIGHT: Position.TOP_LEFT);
+    }
+
+    @Override
+    public Player getPlayer()
+    {
+        if (!gePlayer.isDeploymentDone())
+            return gePlayer;
+        if (!usPlayer.isDeploymentDone())
+            return usPlayer;
+        if (gePlayer.getTurnDone() == usPlayer.getTurnDone())
+            return usPlayer;
+        return gePlayer;
+    }
+
+    public Player checkVictory(Ctrl ctrl)
+    {
+        if (ctrl.opponent.unitsLeft() == 0)
+            return ctrl.player;
+
+        if ((ctrl.player.getTurnDone() < 8) || (ctrl.opponent.getTurnDone() < 8))
+            return null;
+
+        int gePoints = usPlayer.casualties();
+        int usPoints = gePlayer.casualties();
+        usPoints += ctrl.map.objectives.count(Army.US);
+        for (Unit unit : gePlayer.casualties) {
+            if (unit.isAce())
+                usPoints += 1;
+        }
+
+        if (usPoints > gePoints)
+            return usPlayer;
+        else
+            return gePlayer;
+    }
+
+    @Override
+    public void setup(Ctrl ctrl, Map map)
+    {
+        // A7, E6, F6, G10
+        map.addObjective(7, 8, Army.NONE);
+        map.addObjective(6, 4, Army.NONE);
+        map.addObjective(5, 3, Army.NONE);
+        map.addObjective(1, 2, Army.NONE);
+
+        // 1 hex of E7
+        Zone geEntry = new Zone(map, 7);
+        geEntry.orientation = Orientation.NORTH;
+        geEntry.add(map.getHex(5, 5));
+        geEntry.add(map.getHex(4, 4));
+        geEntry.add(map.getHex(4, 3));
+        geEntry.add(map.getHex(5, 3));
+        geEntry.add(map.getHex(6, 4));
+        geEntry.add(map.getHex(6, 5));
+        geEntry.add(map.getHex(5, 4));
+        addEntryZone(geEntry);
+
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER, true);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER);
+
+        // hex rows 7-10
+        geEntry = new Zone(map, 32);
+        geEntry.orientation = Orientation.NORTH;
+        for (int i = 0; i < 4; i++) {
+            geEntry.add(map.getHex(i, 0));
+            geEntry.add(map.getHex((i + 1), 2));
+            geEntry.add(map.getHex((i + 2), 4));
+            geEntry.add(map.getHex((i + 3), 6));
+            geEntry.add(map.getHex((i + 4), 8));
+        }
+        for (int i = 0; i < 3; i++) {
+            geEntry.add(map.getHex((i + 1), 1));
+            geEntry.add(map.getHex((i + 2), 3));
+            geEntry.add(map.getHex((i + 3), 5));
+            geEntry.add(map.getHex((i + 4), 7));
+        }
+        addEntryZone(geEntry);
+
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_WESPE);
+
+        // hex rows hex row 1 + E2 + C2
+        Zone usEntry = new Zone(map, 11);
+        usEntry.orientation = Orientation.SOUTH;
+        usEntry.add(map.getHex(9, 0));
+        usEntry.add(map.getHex(9, 1));
+        usEntry.add(map.getHex(10, 2));
+        usEntry.add(map.getHex(10, 3));
+        usEntry.add(map.getHex(11, 4));
+        usEntry.add(map.getHex(11, 5));
+        usEntry.add(map.getHex(12, 6));
+        usEntry.add(map.getHex(12, 7));
+        usEntry.add(map.getHex(13, 8));
+        usEntry.add(map.getHex(10, 4));
+        usEntry.add(map.getHex(11, 6));
+        addEntryZone(usEntry);
+
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleNightAction.java b/core/src/ch/asynk/rustanddust/game/battles/BattleNightAction.java
new file mode 100644
index 0000000..f9817db
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/BattleNightAction.java
@@ -0,0 +1,153 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.HexSet;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.engine.Meteorology;
+
+public class BattleNightAction extends BattleCommon
+{
+    public BattleNightAction(Factory factory)
+    {
+        super(factory);
+        name = "Night Action";
+        mapType = Factory.MapType.MAP_B;
+    }
+
+    @Override
+    public Position getHudPosition(Player player)
+    {
+        return (player.is(Army.US) ? Position.TOP_RIGHT: Position.TOP_LEFT);
+    }
+
+    @Override
+    public Player getPlayer()
+    {
+        if (!gePlayer.isDeploymentDone() || gePlayer.getCurrentTurn() == 1)
+            return gePlayer;
+        if (gePlayer.getTurnDone() > usPlayer.getTurnDone())
+            return usPlayer;
+        return gePlayer;
+    }
+
+    private boolean isClear(Map map, int col, int row)
+    {
+        Hex hex = map.getHex(col, row);
+        Unit unit = hex.getUnit();
+        if ((unit != null) && unit.is(Army.GE)) {
+            map.selectHex(hex);
+            return false;
+        }
+            map.showMove(hex);
+        return true;
+    }
+
+    public Player checkVictory(Ctrl ctrl)
+    {
+        if (ctrl.opponent.unitsLeft() == 0)
+            return ctrl.player;
+
+        if ((ctrl.player.getTurnDone() < 9) || (ctrl.opponent.getTurnDone() < 9))
+            return null;
+
+        Map map = ctrl.map;
+        boolean clear = true;
+        clear &= isClear(map, 4, 8);
+        clear &= isClear(map, 5, 8);
+        clear &= isClear(map, 6, 8);
+        clear &= isClear(map, 7, 8);
+        clear &= isClear(map, 8, 8);
+        clear &= isClear(map, 8, 7);
+        clear &= isClear(map, 8, 6);
+        boolean upLeft = clear;
+        clear = true;
+        clear &= isClear(map, 8, 6);
+        clear &= isClear(map, 9, 6);
+        clear &= isClear(map, 10, 6);
+        clear &= isClear(map, 11, 6);
+        clear &= isClear(map, 12, 6);
+        boolean upRight = clear;
+        clear = true;
+        clear &= isClear(map, 1, 2);
+        clear &= isClear(map, 2, 3);
+        clear &= isClear(map, 3, 3);
+        clear &= isClear(map, 4, 3);
+        clear &= isClear(map, 5, 3);
+        clear &= isClear(map, 6, 4);
+        clear &= isClear(map, 7, 4);
+        clear &= isClear(map, 8, 4);
+        boolean bottomLeft = clear;
+        clear &= isClear(map, 8, 4);
+        clear &= isClear(map, 9, 4);
+        clear &= isClear(map, 10, 4);
+        clear &= isClear(map, 11, 4);
+        clear = true;
+        boolean bottomRight = clear;
+        // clear &= isClear(map, 8, 6);
+        // clear &= isClear(map, 8, 5);
+        // clear &= isClear(map, 8, 4);
+        // clear = true;
+        // boolean link = clear;
+
+        if ((!upLeft || !upRight) && (!bottomLeft || !bottomRight))
+            return gePlayer;
+        return usPlayer;
+    }
+
+    @Override
+    public void setup(Ctrl ctrl, Map map)
+    {
+        map.meteorology.day = Meteorology.Day.NIGHT;
+
+        // hex row I
+        Zone geEntry = new Zone(map, 10);
+        geEntry.orientation = Orientation.NORTH_EAST;
+        for (int i = 0; i < 10; i++)
+            geEntry.add(map.getHex(i, 0));
+        addEntryZone(geEntry);
+
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_INFANTRY);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_INFANTRY);
+
+        // hex rows A-B
+        Zone usEntry = new Zone(map, 19);
+        usEntry.orientation = Orientation.SOUTH;
+        for (int i = 0; i < 10; i++) {
+            usEntry.add(map.getHex((4 + i), 8));
+            usEntry.add(map.getHex((3 + i), 6));
+            usEntry.add(map.getHex((2 + i), 4));
+            usEntry.add(map.getHex((1 + i), 2));
+        }
+        for (int i = 0; i < 9; i++) {
+            usEntry.add(map.getHex((4 + i), 7));
+            usEntry.add(map.getHex((3 + i), 5));
+            usEntry.add(map.getHex((2 + i), 3));
+        }
+        addEntryZone(usEntry);
+
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_WOLVERINE);
+        addReinforcement(usPlayer, usEntry, UnitId.US_AT_GUN);
+        addReinforcement(usPlayer, usEntry, UnitId.US_INFANTRY);
+        addReinforcement(usPlayer, usEntry, UnitId.US_INFANTRY);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleStabToTheFlank.java b/core/src/ch/asynk/rustanddust/game/battles/BattleStabToTheFlank.java
new file mode 100644
index 0000000..c45bac4
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/BattleStabToTheFlank.java
@@ -0,0 +1,143 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.HexSet;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.engine.Orientation;
+
+public class BattleStabToTheFlank extends BattleCommon
+{
+    public BattleStabToTheFlank(Factory factory)
+    {
+        super(factory);
+        name = "Stab To The Flank";
+        mapType = Factory.MapType.MAP_B;
+    }
+
+    @Override
+    public Position getHudPosition(Player player)
+    {
+        return (player.is(Army.US) ? Position.TOP_RIGHT: Position.TOP_LEFT);
+    }
+
+    @Override
+    public Player getPlayer()
+    {
+        if (!usPlayer.isDeploymentDone() || usPlayer.getCurrentTurn() == 1)
+            return usPlayer;
+        if (usPlayer.getTurnDone() > gePlayer.getTurnDone())
+            return gePlayer;
+        return usPlayer;
+    }
+
+    public Player checkVictory(Ctrl ctrl)
+    {
+        if (ctrl.opponent.unitsLeft() == 0)
+            return ctrl.player;
+
+        if ((ctrl.player.getTurnDone() < 9) || (ctrl.opponent.getTurnDone() < 9))
+            return null;
+
+        int gePoints = usPlayer.casualties();
+        int usPoints = gePlayer.casualties();
+        usPoints += ctrl.map.objectives.count(Army.US);
+
+        int withdrawed = usPlayer.withdrawed();
+        if (withdrawed == 0)
+            gePoints += 1;
+        else
+            usPoints += withdrawed;
+
+        if (usPoints > gePoints)
+            return usPlayer;
+        else
+            return gePlayer;
+    }
+
+    @Override
+    public boolean getReinforcement(Ctrl ctrl, Map map)
+    {
+        if (ctrl.player.is(Army.US))
+            return false;
+        if (ctrl.player.getCurrentTurn() != 3)
+            return false;
+
+        // hex rows I
+        Zone geEntry = new Zone(map, 9);
+        geEntry.allowedMoves = (Orientation.SOUTH_WEST.s | Orientation.NORTH_WEST.s);
+        for (int i = 0; i < 10; i++)
+            geEntry.add(map.getHex(i, 0));
+        addEntryZone(geEntry);
+
+        addReinforcement(gePlayer, geEntry, UnitId.GE_TIGER, true);
+
+        return true;
+    }
+
+    @Override
+    public void setup(Ctrl ctrl, Map map)
+    {
+        // F6, E6
+        map.addHoldObjective(5, 3, Army.NONE);
+        map.addObjective(6, 4, Army.NONE);
+
+        // hex rows D-I
+        Zone geEntry = new Zone(map, 57);
+        geEntry.orientation = Orientation.NORTH;
+        for (int i = 3; i < 12; i++)
+            geEntry.add(map.getHex(i, 5));
+        for (int i = 2; i < 12; i++)
+            geEntry.add(map.getHex(i, 4));
+        for (int i = 2; i < 11; i++)
+            geEntry.add(map.getHex(i, 3));
+        for (int i = 1; i < 11; i++)
+            geEntry.add(map.getHex(i, 2));
+        for (int i = 1; i < 10; i++)
+            geEntry.add(map.getHex(i, 1));
+        for (int i = 0; i < 10; i++)
+            geEntry.add(map.getHex(i, 0));
+
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV_HQ);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_PANZER_IV);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_AT_GUN);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_INFANTRY);
+
+        // hex row I
+        Zone usExit = new Zone(map, 10);
+        usExit.orientation = Orientation.NORTH_EAST;
+        for (int i = 0; i < 10; i++)
+            geEntry.add(map.getHex(i, 0));
+        addExitZone(usExit);
+
+        // hex rows A-B
+        Zone usEntry = new Zone(map, 19);
+        usEntry.orientation = Orientation.SOUTH_EAST;
+        for (int i = 4; i < 13; i++) {
+            usEntry.add(map.getHex(i, 8));
+            usEntry.add(map.getHex(i, 7));
+        }
+        usEntry.add(map.getHex(13, 8));
+        addEntryZone(usEntry);
+
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_SHERMAN_HQ);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_SHERMAN);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_INFANTRY);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_INFANTRY);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_PRIEST);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleTest.java b/core/src/ch/asynk/rustanddust/game/battles/BattleTest.java
new file mode 100644
index 0000000..a237bca
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/BattleTest.java
@@ -0,0 +1,128 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.HexSet;
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.engine.Orientation;
+
+public class BattleTest extends BattleCommon
+{
+    private Zone usExit;
+
+    public BattleTest(Factory factory)
+    {
+        super(factory);
+        name = "*** Test ***";
+        mapType = Factory.MapType.MAP_B;
+    }
+
+    @Override
+    public Player getPlayer()
+    {
+        if (!gePlayer.isDeploymentDone())
+            return gePlayer;
+
+        if (gePlayer.getTurnDone() == usPlayer.getTurnDone())
+            return usPlayer;
+        return gePlayer;
+    }
+
+    @Override
+    public Position getHudPosition(Player player)
+    {
+        return (player.is(Army.US) ? Position.TOP_RIGHT: Position.TOP_LEFT);
+    }
+
+    @Override
+    public Player checkVictory(Ctrl ctrl)
+    {
+        if (usPlayer.getTurnDone() > 2)
+                return usPlayer;
+        return null;
+    }
+
+    @Override
+    public boolean getReinforcement(Ctrl ctrl, Map map)
+    {
+        if (ctrl.player.is(Army.GE))
+            return false;
+        if (ctrl.player.getCurrentTurn() != 2)
+            return false;
+
+        Zone usEntry = new Zone(map, 1);
+        usEntry.allowedMoves = (Orientation.SOUTH.s | Orientation.SOUTH_EAST.s | Orientation.SOUTH_WEST.s);
+        usEntry.add(map.getHex(12, 6));
+        addEntryZone(usEntry);
+        addReinforcement(usPlayer, usEntry, usExit, UnitId.US_WOLVERINE);
+
+        return true;
+    }
+
+    private Unit setUnit(Map map, Player player, UnitId unitId, int col, int row, Orientation orientation, Zone exitZone)
+    {
+        return setUnit(map, player, unitId, col, row, orientation, false, exitZone);
+    }
+
+    private Unit setUnit(Map map, Player player, UnitId unitId, int col, int row, Orientation orientation, boolean ace, Zone exitZone)
+    {
+        Unit u = factory.getUnit(unitId);
+        u.setAce(ace);
+        if (exitZone != null)
+            unitExit.put(u, exitZone);
+        map.setOnBoard(u, map.getHex(col, row), orientation);
+        return u;
+    }
+
+    @Override
+    public void setup(Ctrl ctrl, Map map)
+    {
+        map.addObjective(6, 4, Army.NONE);
+        map.addHoldObjective(5, 3, Army.NONE);
+        map.addObjective(3, 4, Army.NONE);
+        map.addHoldObjective(3, 3, Army.NONE);
+
+        ctrl.player = gePlayer;
+        setUnit(map, gePlayer, UnitId.GE_WESPE, 5, 8, Orientation.NORTH, null);
+        setUnit(map, gePlayer, UnitId.GE_TIGER, 6, 4, Orientation.NORTH, null);
+        setUnit(map, gePlayer, UnitId.GE_PANZER_IV, 4, 5, Orientation.NORTH_WEST, null);
+        setUnit(map, gePlayer, UnitId.GE_INFANTRY, 1, 2, Orientation.NORTH_WEST, null);
+        setUnit(map, gePlayer, UnitId.GE_KINGTIGER, 1, 1, Orientation.NORTH_WEST, null);
+        Zone geEntry = new Zone(map, 6);
+        geEntry.orientation = Orientation.NORTH;
+        geEntry.add(map.getHex(1, 2));
+        geEntry.add(map.getHex(1, 1));
+        geEntry.add(map.getHex(3, 3));
+        geEntry.add(map.getHex(3, 4));
+        geEntry.add(map.getHex(4, 0));
+        geEntry.add(map.getHex(5, 0));
+        addEntryZone(geEntry);
+        addReinforcement(gePlayer, geEntry, UnitId.GE_AT_GUN);
+
+        usExit = new Zone(map, 9);
+        usExit.orientation = Orientation.NORTH;
+        usExit.add(map.getHex(11, 4));
+        usExit.add(map.getHex(11, 5));
+        usExit.add(map.getHex(12, 6));
+        addExitZone(usExit);
+
+        ctrl.player = usPlayer;
+        usPlayer.casualty(factory.getUnit(UnitId.US_SHERMAN_HQ));
+        setUnit(map, usPlayer, UnitId.US_PRIEST, 10, 8, Orientation.SOUTH_EAST, usExit);
+        setUnit(map, usPlayer, UnitId.US_SHERMAN, 7, 3, Orientation.SOUTH, true, usExit);
+        setUnit(map, usPlayer, UnitId.US_SHERMAN_HQ, 8, 4, Orientation.SOUTH, usExit);
+        setUnit(map, usPlayer, UnitId.US_WOLVERINE, 9, 7, Orientation.SOUTH_EAST, usExit);
+        setUnit(map, usPlayer, UnitId.US_PERSHING, 6, 6, Orientation.NORTH_EAST, usExit);
+        setUnit(map, usPlayer, UnitId.US_INFANTRY, 5, 3, Orientation.NORTH_WEST, usExit);
+        setUnit(map, usPlayer, UnitId.US_AT_GUN, 10, 3, Orientation.SOUTH, usExit);
+        usPlayer.turnEnd();
+        map.init();
+        map.turnDone();
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/Factory.java b/core/src/ch/asynk/rustanddust/game/battles/Factory.java
new file mode 100644
index 0000000..4390663
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/Factory.java
@@ -0,0 +1,192 @@
+package ch.asynk.rustanddust.game.battles;
+
+import com.badlogic.gdx.utils.Disposable;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+
+import ch.asynk.rustanddust.RustAndDust;
+import ch.asynk.rustanddust.engine.Board;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Unit.UnitId;
+import ch.asynk.rustanddust.game.Unit.UnitType;
+import ch.asynk.rustanddust.game.Battle;
+import ch.asynk.rustanddust.game.battles.BattleHeadToHead;
+import ch.asynk.rustanddust.game.battles.BattleFrontalAssault;
+import ch.asynk.rustanddust.game.battles.BattleLastStand;
+import ch.asynk.rustanddust.game.battles.BattleCounterAttack;
+import ch.asynk.rustanddust.game.battles.BattleStabToTheFlank;
+import ch.asynk.rustanddust.game.battles.BattleNightAction;
+import ch.asynk.rustanddust.game.battles.BattleTest;
+
+public class Factory implements Board.TileBuilder, Disposable
+{
+    public enum MapType
+    {
+        MAP_A,
+        MAP_B
+    }
+
+    public enum Scenarios
+    {
+        FAKE
+    }
+
+    public boolean assetsLoaded;
+    public TextureAtlas hudAtlas;
+    public TextureAtlas pawnsAtlas;
+    public TextureAtlas pawnOverlaysAtlas;
+    public TextureAtlas tileOverlaysAtlas;
+    public Battle battles[];
+    private final RustAndDust game;
+
+    public Factory(final RustAndDust game)
+    {
+        this.game = game;
+        this.assetsLoaded = false;
+        battles = new Battle[] {
+            new BattleHeadToHead(this),
+            new BattleFrontalAssault(this),
+            new BattleLastStand(this),
+            new BattleCounterAttack(this),
+            new BattleStabToTheFlank(this),
+            new BattleNightAction(this),
+            new BattleTest(this),
+        };
+    }
+
+    public void assetsLoaded()
+    {
+        if (assetsLoaded) return;
+        int i = game.config.graphics.i;
+        this.hudAtlas = game.manager.get("data/hud.atlas", TextureAtlas.class);
+        this.tileOverlaysAtlas = game.manager.get("data/hex-overlays.atlas", TextureAtlas.class);
+        this.pawnsAtlas = game.manager.get(String.format("data/units%d.atlas", i), TextureAtlas.class);
+        this.pawnOverlaysAtlas = game.manager.get(String.format("data/unit-overlays%d.atlas", i), TextureAtlas.class);
+        this.assetsLoaded = true;
+    }
+
+    @Override
+    public void dispose()
+    {
+        if (!assetsLoaded) return;
+        hudAtlas.dispose();
+        pawnsAtlas.dispose();
+        pawnOverlaysAtlas.dispose();
+        tileOverlaysAtlas.dispose();
+        this.assetsLoaded = false;
+    }
+
+    private Board.Config config()
+    {
+        Board.Config cfg = new Board.Config();
+        cfg.cols = 10;
+        cfg.rows = 9;
+        cfg.x0 = 86;
+        cfg.y0 = 182;
+        cfg.w = 189;
+        cfg.dw = 94;
+        cfg.s = 110;
+        cfg.dh = 53.6f;
+        cfg.h = cfg.s + cfg.dh;
+        cfg.slope = (cfg.dh / (float) cfg.dw);
+
+        return cfg;
+    }
+
+    public Map getMap(MapType t)
+    {
+        Board.Config cfg = config();
+
+        Map m = null;
+        switch(t) {
+            case MAP_A:
+                m = new MapA(game, config(), "data/map_a.png");
+                break;
+            case MAP_B:
+                m = new MapB(game, config(), "data/map_b.png");
+                break;
+        }
+
+        return m;
+    }
+
+    public Player getPlayer(Army army)
+    {
+        if (army == Army.US)
+            return new Player(game, Army.US, 10);
+        else
+            return new Player(game, Army.GE, 10);
+    }
+
+    public Unit getUnit(UnitId id)
+    {
+        Unit u = null;
+        UnitType ut = UnitType.HARD_TARGET;
+        UnitType utHq = UnitType.HARD_TARGET_HQ;
+        switch(id) {
+            case GE_AT_GUN:
+                ut = UnitType.AT_GUN;
+                u = new Unit(Army.GE, id, ut, 3, 8, 9, 1, "ge-at-gun", "ge-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case GE_INFANTRY:
+                ut = UnitType.INFANTRY;
+                u = new Unit(Army.GE, id, ut, 1, 7, 10, 1, "ge-infantry", "ge-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case GE_KINGTIGER:
+                u = new Unit(Army.GE, id, ut, 3, 12, 1, "ge-kingtiger", "ge-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case GE_PANZER_IV:
+                u = new Unit(Army.GE, id, ut, 2, 9, 2, "ge-panzer-iv", "ge-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case GE_PANZER_IV_HQ:
+                u = new Unit(Army.GE, id, utHq, 2, 9, 2, "ge-panzer-iv", "ge-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case GE_TIGER:
+                u = new Unit(Army.GE, id, ut, 3, 11, 1, "ge-tiger", "ge-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case GE_WESPE:
+                ut = UnitType.ARTILLERY;
+                u = new Unit(Army.GE, id, ut, 5, 8, 1, "ge-wespe", "ge-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case US_AT_GUN:
+                ut = UnitType.AT_GUN;
+                u = new Unit(Army.US, id, ut, 1, 7, 10, 1, "us-at-gun", "us-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case US_INFANTRY:
+                ut = UnitType.INFANTRY;
+                u = new Unit(Army.US, id, ut, 1, 7, 10, 1, "us-infantry", "us-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case US_PERSHING:
+                u = new Unit(Army.US, id, ut, 3, 10, 2, "us-pershing", "us-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case US_PERSHING_HQ:
+                u = new Unit(Army.US, id, utHq, 3, 10, 2, "us-pershing", "us-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case US_PRIEST:
+                ut = UnitType.ARTILLERY;
+                u = new Unit(Army.US, id, ut, 5, 8, 1, "us-priest", "us-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case US_SHERMAN:
+                    u = new Unit(Army.US, id, ut, 2, 9, 2, "us-sherman", "us-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case US_SHERMAN_HQ:
+                u = new Unit(Army.US, id, utHq, 2, 9, 2, "us-sherman", "us-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+            case US_WOLVERINE:
+                u = new Unit(Army.US, id, ut, 3, 8, 3, "us-wolverine", "us-head", pawnsAtlas, pawnOverlaysAtlas);
+                break;
+        }
+
+        return u;
+    }
+
+    public Hex getNewTile(float x, float y, int col, int row, boolean offmap)
+    {
+        Hex hex = new Hex(x, y, col, row, tileOverlaysAtlas);
+        if (offmap) hex.terrain = Hex.Terrain.OFFMAP;
+        return hex;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/MapA.java b/core/src/ch/asynk/rustanddust/game/battles/MapA.java
new file mode 100644
index 0000000..491b370
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/MapA.java
@@ -0,0 +1,77 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.RustAndDust;
+import ch.asynk.rustanddust.engine.Board;
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+
+public class MapA extends Map
+{
+    public MapA(final RustAndDust game, Board.Config cfg, String textureName)
+    {
+        super(game, cfg, textureName);
+    }
+
+    @Override
+    protected void setup()
+    {
+        getHex(5, 1).terrain = Hex.Terrain.HILLS;
+        getHex(7, 3).terrain = Hex.Terrain.HILLS;
+        getHex(7, 8).terrain = Hex.Terrain.HILLS;
+        getHex(8, 8).terrain = Hex.Terrain.HILLS;
+
+        getHex(5, 0).terrain = Hex.Terrain.WOODS;
+        getHex(6, 0).terrain = Hex.Terrain.WOODS;
+        getHex(3, 3).terrain = Hex.Terrain.WOODS;
+        getHex(4, 3).terrain = Hex.Terrain.WOODS;
+        getHex(10, 7).terrain = Hex.Terrain.WOODS;
+        getHex(11, 7).terrain = Hex.Terrain.WOODS;
+        getHex(11, 8).terrain = Hex.Terrain.WOODS;
+
+        getHex(6, 1).terrain = Hex.Terrain.TOWN;
+        getHex(2, 2).terrain = Hex.Terrain.TOWN;
+        getHex(6, 4).terrain = Hex.Terrain.TOWN;
+        getHex(10, 5).terrain = Hex.Terrain.TOWN;
+        getHex(7, 7).terrain = Hex.Terrain.TOWN;
+        getHex(4, 6).terrain = Hex.Terrain.TOWN;
+
+        getHex(10, 1).terrain = Hex.Terrain.OFFMAP;
+        getHex(11, 3).terrain = Hex.Terrain.OFFMAP;
+        getHex(12, 5).terrain = Hex.Terrain.OFFMAP;
+        getHex(13, 7).terrain = Hex.Terrain.OFFMAP;
+
+        int N = Orientation.NORTH.s;
+        int S = Orientation.SOUTH.s;
+        int NE = Orientation.NORTH_EAST.s;
+        int NW = Orientation.NORTH_WEST.s;
+        int SE = Orientation.SOUTH_EAST.s;
+        int SW = Orientation.SOUTH_WEST.s;
+
+        getHex(6, 1).roads = (NW | SW);
+        for (int i = 1; i < 11; i++) {
+            if (i == 6)
+                getHex(i, 2).roads = (NE | S | SW);
+            else if (i == 7)
+                getHex(i, 2).roads = (N | SE);
+            else
+                getHex(i, 2).roads = (N | S);
+        }
+        getHex(6, 3).roads = (NE | SW);
+        getHex(6, 4).roads = (N | NE | SW);
+        getHex(7, 4).roads = (N | S);
+        getHex(8, 4).roads = (NW | S);
+        getHex(6, 5).roads = (NE | SW);
+        getHex(8, 5).roads = (N | SW);
+        getHex(9, 5).roads = (N | S | NE);
+        getHex(10, 5).roads = (N | S);
+        getHex(11, 5).roads = (N | S);
+        getHex(3, 6).roads = (N | S);
+        getHex(4, 6).roads = (N | S);
+        getHex(5, 6).roads = (N | S);
+        getHex(6, 6).roads = (NE | NW | S);
+        getHex(8, 6).roads = (NE | SW);
+        getHex(7, 7).roads = (N | SE);
+        getHex(8, 7).roads = (NE | S);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/battles/MapB.java b/core/src/ch/asynk/rustanddust/game/battles/MapB.java
new file mode 100644
index 0000000..8636481
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/battles/MapB.java
@@ -0,0 +1,75 @@
+package ch.asynk.rustanddust.game.battles;
+
+import ch.asynk.rustanddust.RustAndDust;
+import ch.asynk.rustanddust.engine.Board;
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+
+public class MapB extends Map
+{
+    public MapB(final RustAndDust game, Board.Config cfg, String textureName)
+    {
+        super(game, cfg, textureName);
+    }
+
+    @Override
+    protected void setup()
+    {
+        getHex(4, 0).terrain = Hex.Terrain.HILLS;
+        getHex(5, 0).terrain = Hex.Terrain.HILLS;
+        getHex(1, 1).terrain = Hex.Terrain.HILLS;
+        getHex(9, 7).terrain = Hex.Terrain.HILLS;
+        getHex(10, 7).terrain = Hex.Terrain.HILLS;
+
+        getHex(3, 0).terrain = Hex.Terrain.WOODS;
+        getHex(6, 0).terrain = Hex.Terrain.WOODS;
+        getHex(8, 1).terrain = Hex.Terrain.WOODS;
+        getHex(9, 2).terrain = Hex.Terrain.WOODS;
+        getHex(4, 5).terrain = Hex.Terrain.WOODS;
+        getHex(5, 6).terrain = Hex.Terrain.WOODS;
+        getHex(6, 6).terrain = Hex.Terrain.WOODS;
+        getHex(11, 8).terrain = Hex.Terrain.WOODS;
+
+        getHex(1, 2).terrain = Hex.Terrain.TOWN;
+        getHex(5, 3).terrain = Hex.Terrain.TOWN;
+        getHex(6, 4).terrain = Hex.Terrain.TOWN;
+        getHex(7, 8).terrain = Hex.Terrain.TOWN;
+
+        getHex(10, 1).terrain = Hex.Terrain.OFFMAP;
+        getHex(11, 3).terrain = Hex.Terrain.OFFMAP;
+        getHex(12, 5).terrain = Hex.Terrain.OFFMAP;
+        getHex(13, 7).terrain = Hex.Terrain.OFFMAP;
+
+        int N = Orientation.NORTH.s;
+        int S = Orientation.SOUTH.s;
+        int NE = Orientation.NORTH_EAST.s;
+        int NW = Orientation.NORTH_WEST.s;
+        int SE = Orientation.SOUTH_EAST.s;
+        int SW = Orientation.SOUTH_WEST.s;
+
+        getHex(1, 2).roads = (S | NW);
+        getHex(2, 3).roads = (SE | N);
+        getHex(3, 3).roads = (S | N);
+        getHex(4, 3).roads = (S | N);
+        getHex(5, 3).roads = (S | NW);
+        getHex(6, 4).roads = (SE | N);
+        getHex(7, 4).roads = (S | N);
+        getHex(8, 4).roads = (S | SW | N);
+        getHex(9, 4).roads = (S | N);
+        getHex(10, 4).roads = (S | N);
+        getHex(11, 4).roads = (S | N);
+        getHex(4, 8).roads = (S | N);
+        getHex(5, 8).roads = (S | N);
+        getHex(6, 8).roads = (S | N);
+        getHex(7, 8).roads = (S | N);
+        getHex(8, 8).roads = (S | NE);
+        getHex(8, 7).roads = (SW | NE);
+        getHex(8, 6).roads = (SW | NE | N);
+        getHex(8, 5).roads = (SW | NE);
+        getHex(9, 6).roads = (S | N);
+        getHex(10, 6).roads = (S | N);
+        getHex(11, 6).roads = (S | N);
+        getHex(12, 6).roads = (S | N);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/hud/ActionButtons.java b/core/src/ch/asynk/rustanddust/game/hud/ActionButtons.java
new file mode 100644
index 0000000..323767f
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/hud/ActionButtons.java
@@ -0,0 +1,185 @@
+package ch.asynk.rustanddust.game.hud;
+
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.State.StateType;
+import ch.asynk.rustanddust.ui.Widget;
+import ch.asynk.rustanddust.ui.Bg;
+import ch.asynk.rustanddust.ui.Position;
+
+public class ActionButtons extends Widget
+{
+    public static int PADDING = 5;
+
+    private final Ctrl ctrl;
+
+    public enum Buttons {
+        NONE(-1, 0),
+        PROMOTE(0, 1),
+        DONE(1, 2),
+        ABORT(2, 4),
+        LAST(3, 0);
+
+        Buttons(int i, int b)
+        {
+            this.i = i;
+            this.b = b;
+        }
+
+        public int i;
+        public int b;
+    }
+
+    private Sprite bg;
+    private int idx;
+    private Bg buttons [];
+    private StateType states [];
+
+    public ActionButtons(Ctrl ctrl, TextureAtlas uiAtlas, TextureAtlas hudAtlas)
+    {
+        this.bg = new Sprite(uiAtlas.findRegion("disabled"));
+        this.ctrl = ctrl;
+        this.visible = false;
+        this.position = Position.BOTTOM_RIGHT;
+        this.idx = Buttons.NONE.i;
+
+
+        this.buttons = new Bg[Buttons.LAST.i];
+        this.buttons[Buttons.DONE.i] = new Bg(uiAtlas.findRegion("ok"));
+        this.buttons[Buttons.ABORT.i] = new Bg(uiAtlas.findRegion("cancel"));
+        this.buttons[Buttons.PROMOTE.i] = new Bg(hudAtlas.findRegion("promote"));
+
+        this.states = new StateType[Buttons.LAST.i];
+        this.states[Buttons.DONE.i] = StateType.DONE;
+        this.states[Buttons.ABORT.i] = StateType.ABORT;
+        this.states[Buttons.PROMOTE.i] = StateType.PROMOTE;
+    }
+
+    @Override
+    public void dispose()
+    {
+        for (int i = 0; i < Buttons.LAST.i; i++)
+            buttons[i].dispose();
+    }
+
+    public void update(Position position)
+    {
+        setPosition(position);
+        updatePosition();
+    }
+
+    public void updatePosition()
+    {
+        if (!visible) return;
+        float dx = (position.getX(rect.width) - rect.x);
+        float dy = (position.getY(rect.height) - rect.y);
+        translate(dx, dy);
+        for (int i = 0; i < Buttons.LAST.i; i++)
+            buttons[i].translate(dx, dy);
+    }
+
+    public void hide()
+    {
+        for (int i = 0; i < Buttons.LAST.i; i++)
+            buttons[i].visible = false;
+        this.visible = false;
+    }
+
+    private float setButton(Bg btn, float x, float y)
+    {
+        btn.visible = true;
+        btn.setPosition(x, y);
+        return (y + btn.getHeight() + PADDING);
+    }
+
+    public void show(int bits)
+    {
+        int b = bits;
+        int count = 0;
+        while (b > 0) {
+            if ((b & 0x01) == 1)
+                count += 1;
+            b /= 2;
+        }
+
+        if (count == 0) {
+            this.visible = false;
+            return;
+        }
+
+        rect.width = (buttons[0].getWidth() + (2 * PADDING));
+        rect.height = ((buttons[0].getHeight() * count) + ((count + 1) * PADDING));
+        rect.x =  position.getX(rect.width);
+        rect.y =  position.getY(rect.height);
+
+        float x = (rect.x + PADDING);
+        float y = (rect.y + PADDING);
+
+        b = 1;
+        for (int i = 0; i < Buttons.LAST.i; i++) {
+            if ((bits & b) == b)
+                y = setButton(buttons[i], x, y);
+            else
+                buttons[i].visible = false;
+            b *= 2;
+        }
+
+        this.visible = true;
+    }
+
+    public boolean touchDown(float x, float y)
+    {
+        idx = Buttons.NONE.i;
+
+        if (!super.hit(x,y))
+            return false;
+
+        for (int i = 0; i < Buttons.LAST.i; i++) {
+            if (buttons[i].hit(x, y)) {
+                idx = i;
+                break;
+            }
+        }
+
+        return (idx != Buttons.NONE.i);
+    }
+
+    public boolean touchUp(float x, float y)
+    {
+        if (idx == Buttons.NONE.i)
+            return false;
+
+        boolean ret = false;
+
+        if (super.hit(x,y) && buttons[idx].hit(x, y)) {
+            ctrl.setState(states[idx]);
+            ret = true;
+        }
+
+        idx = Buttons.NONE.i;
+
+        return ret;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        batch.draw(bg, rect.x, rect.y, rect.width, rect.height);
+        for (int i = 0; i < Buttons.LAST.i; i++)
+            buttons[i].draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        if (!visible) return;
+        super.drawDebug(shapes);
+        for (int i = 0; i < Buttons.LAST.i; i++)
+            buttons[i].drawDebug(shapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/hud/EngagementPanel.java b/core/src/ch/asynk/rustanddust/game/hud/EngagementPanel.java
new file mode 100644
index 0000000..790c8b5
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/hud/EngagementPanel.java
@@ -0,0 +1,255 @@
+package ch.asynk.rustanddust.game.hud;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.game.Engagement;
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.engine.gfx.Animation;
+import ch.asynk.rustanddust.engine.gfx.animations.DiceAnimation;
+import ch.asynk.rustanddust.ui.Bg;
+import ch.asynk.rustanddust.ui.Label;
+import ch.asynk.rustanddust.ui.Patch;
+import ch.asynk.rustanddust.ui.Position;
+
+public class EngagementPanel extends Patch implements Animation
+{
+    private enum State { ROLL1, MOVE, ROLL2, RESULT };
+
+    public static int FLAG_HEIGHT = 24;
+    public static int OK_OFFSET = 10;
+    public static int PADDING = 20;
+    public static int VSPACING = 10;
+    public static int HSPACING = 5;
+    public static float MOVE_STEP = 2f;
+
+    private State state;
+    private boolean reroll;
+    private float rerollY;
+    private Sprite usFlag;
+    private Sprite geFlag;
+    private Sprite winner;
+    private Sprite attackImg;
+    private Sprite defenseImg;
+    private Label attack;
+    private Label defense;
+    private Label attackR;
+    private Label defenseR;
+    private Bg okBtn;
+    private DiceAnimation d1Animation;
+    private DiceAnimation d2Animation;
+    private DiceAnimation d3Animation;
+    private DiceAnimation d4Animation;
+
+    public EngagementPanel(BitmapFont font, TextureAtlas uiAtlas, TextureAtlas hudAtlas)
+    {
+        super(uiAtlas.createPatch("typewriter"));
+        usFlag = new Sprite(hudAtlas.findRegion("us-flag"));
+        geFlag = new Sprite(hudAtlas.findRegion("ge-flag"));
+        attackImg = new Sprite(hudAtlas.findRegion("attack"));
+        defenseImg = new Sprite(hudAtlas.findRegion("defense"));
+        this.attack = new Label(font);
+        this.defense = new Label(font);
+        this.attackR = new Label(font);
+        this.defenseR = new Label(font);
+        this.okBtn = new Bg(uiAtlas.findRegion("ok"));
+        this.visible = false;
+        this.d1Animation = new DiceAnimation();
+        this.d2Animation = new DiceAnimation();
+        this.d3Animation = new DiceAnimation();
+        this.d4Animation = new DiceAnimation();
+    }
+
+    public void updatePosition()
+    {
+        if (!visible) return;
+        float dx = (position.getX(rect.width) - rect.x);
+        float dy = (position.getY(rect.height) - rect.y);
+        translate(dx, dy);
+        winner.translate(dx, dy);
+        attackImg.translate(dx, dy);
+        defenseImg.translate(dx, dy);
+        attack.translate(dx, dy);
+        defense.translate(dx, dy);
+        attackR.translate(dx, dy);
+        defenseR.translate(dx, dy);
+        okBtn.translate(dx, dy);
+        d1Animation.translate(dx, dy);
+        d2Animation.translate(dx, dy);
+        d3Animation.translate(dx, dy);
+        d4Animation.translate(dx, dy);
+    }
+
+    public void show(Engagement e, Position position, float volume)
+    {
+        DiceAnimation.initSound(volume);
+        attack.write(String.format(" + %d + %d =", e.unitCount, e.flankBonus));
+        if (e.weatherDefense == 0)
+            defense.write(String.format("%d + %d =", e.unitDefense, e.terrainDefense));
+        else
+            defense.write(String.format("%d + %d + %d =", e.unitDefense, e.terrainDefense, e.weatherDefense));
+        attackR.write(String.format(" %2d", e.attackSum));
+        defenseR.write(String.format(" %2d", e.defenseSum));
+        if (e.success)
+            winner = ((e.attacker.getArmy() == Army.US) ? usFlag : geFlag);
+        else
+            winner = ((e.attacker.getArmy() == Army.US) ? geFlag : usFlag);
+
+        this.position = position;
+        placeElements();
+
+        state = State.ROLL1;
+        reroll = (e.d3 != 0);
+
+        d1Animation.set(e.d1);
+        d2Animation.set(e.d2);
+        if (reroll) {
+            d3Animation.set(e.d3);
+            d4Animation.set(e.d4);
+        }
+
+        visible = true;
+    }
+
+    private void placeElements()
+    {
+        float w = attackR.getWidth();
+        float w2 = defenseR.getWidth();
+        if (w2 > w)
+            w = w2;
+        float height = (okBtn.getHeight() + attackImg.getHeight() + defenseImg.getHeight() + (2 * VSPACING) + (2 * PADDING));
+        float width = (attackImg.getWidth() + (2 * d1Animation.getWidth()) + attack.getWidth() + w + (4 * HSPACING) + (2 * PADDING));
+        float x = position.getX(width);
+        float y = position.getY(height);
+        setPosition(x, y, width, height);
+
+        okBtn.setPosition((x + width - okBtn.getWidth() + OK_OFFSET), (y - OK_OFFSET));
+
+        x = getX() + PADDING;
+        y = getY() + PADDING;
+        winner.setPosition((getX() + (width / 2f) - (winner.getWidth() / 2f)), y);
+        y += (winner.getHeight() + VSPACING);
+
+        defenseImg.setPosition(x, y);
+        y = (y + (defenseImg.getHeight() / 2f) - (defense.getHeight() / 2f));
+        defenseR.setPosition((getX() + width - w - PADDING), y);
+        // x += (defenseImg.getWidth() + HSPACING);
+        defense.setPosition((defenseR.getX() - defense.getWidth() - HSPACING), y);
+
+        x = getX() + PADDING;
+        y += defenseImg.getHeight() + VSPACING;
+        attackImg.setPosition(x, y);
+        x += (attackImg.getWidth() + HSPACING);
+        d1Animation.setPosition(x, y);
+        d3Animation.setPosition(x, y);
+        x += (d1Animation.getWidth() + HSPACING);
+        d2Animation.setPosition(x, (y));
+        d4Animation.setPosition(x, y);
+        x += (d1Animation.getWidth() + HSPACING);
+        y = (y + (attackImg.getHeight() / 2f) - (attack.getHeight() / 2f));
+        attack.setPosition(x, y);
+        attackR.setPosition(defenseR.getX(), y);
+
+        rerollY = (d1Animation.getY() + d1Animation.getHeight() + VSPACING);
+    }
+
+    @Override
+    public boolean hit(float x, float y)
+    {
+        return rect.contains(x, y);
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        if (!visible) return true;
+        if (state == State.ROLL1) {
+            d1Animation.animate(delta);
+            d2Animation.animate(delta);
+            if (d1Animation.isDone() && d2Animation.isDone()) {
+                if (reroll)
+                    state = State.MOVE;
+                else
+                    state = State.RESULT;
+            }
+        }
+
+        if (state == State.MOVE) {
+            float y = (d1Animation.getY() + MOVE_STEP);
+            if (y >= rerollY) {
+                y = rerollY;
+                state = State.ROLL2;
+            }
+            setPosition(getX(), getY(), getWidth(), (y + d1Animation.getHeight() + VSPACING - getY()));
+            d1Animation.setPosition(d1Animation.getX(), y);
+            d2Animation.setPosition(d2Animation.getX(), y);
+        }
+
+        if (state == State.ROLL2) {
+            if (d1Animation.getY() < rerollY) {
+                d1Animation.setPosition(d1Animation.getX(), (d1Animation.getY() + d1Animation.getHeight() + VSPACING));
+                d2Animation.setPosition(d2Animation.getX(), (d2Animation.getY() + d2Animation.getHeight() + VSPACING));
+            } else {
+                d3Animation.animate(delta);
+                d4Animation.animate(delta);
+                if (d3Animation.isDone() && d4Animation.isDone())
+                    state = State.RESULT;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        attack.dispose();
+        defense.dispose();
+        attackR.dispose();
+        defenseR.dispose();
+        d1Animation.dispose();
+        d2Animation.dispose();
+        d3Animation.dispose();
+        d4Animation.dispose();
+        okBtn.dispose();
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        super.draw(batch);
+        attackImg.draw(batch);
+        d1Animation.draw(batch);
+        d2Animation.draw(batch);
+        if ((state == State.ROLL2) || (reroll && (state == State.RESULT))) {
+            d3Animation.draw(batch);
+            d4Animation.draw(batch);
+        }
+        attack.draw(batch);
+        defenseImg.draw(batch);
+        defense.draw(batch);
+        defenseR.draw(batch);
+        okBtn.draw(batch);
+        if (state == State.RESULT) {
+            attackR.draw(batch);
+            winner.draw(batch);
+        }
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        if (!visible) return;
+        super.drawDebug(shapes);
+        attack.drawDebug(shapes);
+        defense.drawDebug(shapes);
+        attackR.drawDebug(shapes);
+        defenseR.drawDebug(shapes);
+        okBtn.drawDebug(shapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/hud/PlayerInfo.java b/core/src/ch/asynk/rustanddust/game/hud/PlayerInfo.java
new file mode 100644
index 0000000..dd77c8e
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/hud/PlayerInfo.java
@@ -0,0 +1,202 @@
+package ch.asynk.rustanddust.game.hud;
+
+import com.badlogic.gdx.utils.Disposable;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Animation;
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+
+import ch.asynk.rustanddust.game.State.StateType;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Hud;
+import ch.asynk.rustanddust.game.Army;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.ui.LabelImage;
+import ch.asynk.rustanddust.ui.Position;
+
+public class PlayerInfo implements Disposable, Drawable, Animation
+{
+    public static int PADDING = 5;
+
+    private final Ctrl ctrl;
+
+    private Object hit;
+
+    private Sprite flag;
+    private Sprite usFlag;
+    private Sprite geFlag;
+    private LabelImage turns;
+    private LabelImage aps;
+    private LabelImage reinforcement;
+    public UnitDock unitDock;
+    private Position position;
+
+    public PlayerInfo(Ctrl ctrl, BitmapFont font, TextureAtlas uiAtlas, TextureAtlas hudAtlas)
+    {
+        this.ctrl = ctrl;
+        this.position = Position.MIDDLE_CENTER;
+        usFlag = new Sprite(hudAtlas.findRegion("us-flag"));
+        geFlag = new Sprite(hudAtlas.findRegion("ge-flag"));
+        turns = new LabelImage(hudAtlas.findRegion("turns"), font, 5f);
+        aps = new LabelImage(hudAtlas.findRegion("aps"), font, 5f);
+        reinforcement = new LabelImage(hudAtlas.findRegion("reinforcement"), font, 5f);
+        unitDock = new UnitDock(ctrl, uiAtlas.findRegion("disabled"), hudAtlas.findRegion("reinforcement-selected"), 10f);
+    }
+
+    @Override
+    public void dispose()
+    {
+        turns.dispose();
+        aps.dispose();
+        reinforcement.dispose();
+        unitDock.dispose();
+    }
+
+    public void updatePosition()
+    {
+        float dx = (position.getX(usFlag.getWidth()) - usFlag.getX());
+        float dy = (position.getY(usFlag.getHeight()) - usFlag.getY());
+        usFlag.translate(dx, dy);
+        geFlag.translate(dx, dy);
+        turns.translate(dx, dy);
+        aps.translate(dx, dy);
+        reinforcement.translate(dx, dy);
+        unitDock.translate(dx, dy);
+    }
+
+    public void setPosition(Position position)
+    {
+        if (this.position == position)
+            return;
+        this.position = position;
+
+        float width = (usFlag.getWidth() + turns.getWidth() + aps.getWidth() + (2 * PADDING));
+        float height = (usFlag.getHeight() + reinforcement.getHeight() + (1 * PADDING));
+        float x = position.getX(width);
+        float y = position.getY(height);
+
+        if (position.isLeft()) {
+            reinforcement.setPosition(x, y);
+            y += (reinforcement.getHeight() + PADDING);
+            usFlag.setPosition(x, y);
+            geFlag.setPosition(x, y);
+            x += (usFlag.getWidth() + PADDING);
+            turns.setPosition(x, y);
+            x += (turns.getWidth() + PADDING);
+            aps.setPosition(x, y);
+        } else {
+            x = (x + width);
+            reinforcement.setPosition((x - reinforcement.getWidth()), y);
+            y += (reinforcement.getHeight() + PADDING);
+            x -= usFlag.getWidth();
+            usFlag.setPosition(x, y);
+            geFlag.setPosition(x, y);
+            x -= (turns.getWidth() + PADDING);
+            turns.setPosition(x, y);
+            x -= (aps.getWidth() + PADDING);
+            aps.setPosition(x, y);
+        }
+        aps.setLabelPosition(Position.TOP_RIGHT);
+        turns.setLabelPosition(Position.MIDDLE_CENTER);
+        reinforcement.setLabelPosition(Position.TOP_LEFT);
+        unitDock.setPosition(position, reinforcement.getY() - PADDING);
+    }
+
+    public void update(Player player, Position position)
+    {
+        unitDock.hide();
+        turns.write(String.format("%d", player.getCurrentTurn()));
+        aps.write(String.format("%d", player.getAp()));
+        int r = player.reinforcement();
+        if (r == 0) {
+            reinforcement.visible = false;
+        } else {
+            reinforcement.visible = true;
+            reinforcement.write(String.format("%d",  r));
+        }
+
+        if (player.is(Army.GE))
+            flag = geFlag;
+        else
+            flag = usFlag;
+
+        setPosition(position);
+    }
+
+    public void blockEndOfTurn(boolean blocked)
+    {
+        turns.blocked = blocked;
+    }
+
+    public boolean touchDown(float x, float y)
+    {
+        hit = null;
+
+        if (reinforcement.hit(x, y))
+            hit = reinforcement;
+        else if (unitDock.hit(x, y))
+            hit = unitDock;
+        else if (turns.hit(x,y))
+            hit = turns;
+
+        return (hit != null);
+    }
+
+    public boolean touchUp(float x, float y)
+    {
+        if (hit == null)
+            return false;
+
+        if (hit == turns) {
+            if (turns.hit(x, y))
+                ctrl.hud.askEndOfTurn();
+        }
+        else if (hit == reinforcement) {
+            if (reinforcement.hit(x, y))
+                ctrl.reinforcementHit();
+        }
+        else if (hit == unitDock) {
+            if (unitDock.hit(x, y)) {
+                ctrl.hud.notify(unitDock.select(x, y).toString());
+                ctrl.stateTouchUp();
+            }
+        }
+
+        hit = null;
+
+        return true;
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        unitDock.animate(delta);
+        return false;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        flag.draw(batch);
+        turns.draw(batch);
+        aps.draw(batch);
+        reinforcement.draw(batch);
+        unitDock.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer debugShapes)
+    {
+        turns.drawDebug(debugShapes);
+        aps.drawDebug(debugShapes);
+        reinforcement.drawDebug(debugShapes);
+        unitDock.drawDebug(debugShapes);
+        debugShapes.rect(flag.getX(), flag.getY(), flag.getWidth(), flag.getHeight());
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/hud/StatisticsPanel.java b/core/src/ch/asynk/rustanddust/game/hud/StatisticsPanel.java
new file mode 100644
index 0000000..2e6546b
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/hud/StatisticsPanel.java
@@ -0,0 +1,120 @@
+package ch.asynk.rustanddust.game.hud;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.game.Player;
+import ch.asynk.rustanddust.ui.Bg;
+import ch.asynk.rustanddust.ui.Label;
+import ch.asynk.rustanddust.ui.Patch;
+import ch.asynk.rustanddust.ui.Position;
+
+public class StatisticsPanel extends Patch
+{
+    public static int OK_OFFSET = 10;
+    public static int PADDING = 20;
+    public static int VSPACING = 10;
+    public static int HSPACING = 10;
+
+    private Label title;
+    private Label header;
+    private Label stats1;
+    private Label stats2;
+    private Bg okBtn;
+
+    public StatisticsPanel(BitmapFont font, TextureAtlas atlas)
+    {
+        super(atlas.createPatch("typewriter"));
+        this.title = new Label(font);
+        this.header = new Label(font);
+        this.stats1 = new Label(font);
+        this.stats2 = new Label(font);
+        this.okBtn = new Bg(atlas.findRegion("ok"));
+        this.visible = false;
+        this.header.write("\nActions\nUnits Left\nUnits Withrawed\nCasualties\nWon Attacks\nLost Attacks");
+    }
+
+    public void updatePosition()
+    {
+        if (!visible) return;
+        float dx = (position.getX(rect.width) - rect.x);
+        float dy = (position.getY(rect.height) - rect.y);
+        translate(dx, dy);
+        title.translate(dx, dy);
+        header.translate(dx, dy);
+        stats1.translate(dx, dy);
+        stats2.translate(dx, dy);
+        okBtn.translate(dx, dy);
+    }
+
+    public void show(Player winner, Player loser, Position position)
+    {
+        title.write(winner.getName() + " player won the battle in " + winner.getTurnDone() + " turns.");
+        stats1.write(winner.getStats());
+        stats2.write(loser.getStats());
+
+        float height = (title.getHeight() + header.getHeight() + (2 * PADDING) + (1 * VSPACING));
+        float width = (header.getWidth() + stats1.getWidth() + stats2.getWidth() + (2 * PADDING) + (4 * HSPACING));
+        float w2 = (title.getWidth() + (2 * PADDING));
+        if (w2 > width) width = w2;
+        float x = position.getX(width);
+        float y = position.getY(height);
+        setPosition(x, y, width, height);
+
+        okBtn.setPosition((x + width - okBtn.getWidth() + OK_OFFSET), (y - OK_OFFSET));
+
+        y += PADDING;
+        x += PADDING;
+        header.setPosition(x, y);
+        stats1.setPosition((x + header.getWidth() + (2 * HSPACING)), y);
+        stats2.setPosition((stats1.getX() + stats1.getWidth() + (2 * HSPACING)), y);
+        y += (header.getHeight() + VSPACING);
+        title.setPosition(x, y);
+        visible = true;
+    }
+
+    @Override
+    public boolean hit(float x, float y)
+    {
+        if (okBtn.hit(x, y))
+            return true;
+        return false;
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        title.dispose();
+        header.dispose();
+        stats1.dispose();
+        stats2.dispose();
+        okBtn.dispose();
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        super.draw(batch);
+        title.draw(batch);
+        header.draw(batch);
+        stats1.draw(batch);
+        stats2.draw(batch);
+        okBtn.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        if (!visible) return;
+        super.drawDebug(shapes);
+        title.drawDebug(shapes);
+        header.drawDebug(shapes);
+        stats1.drawDebug(shapes);
+        stats2.drawDebug(shapes);
+        okBtn.drawDebug(shapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/hud/UnitDock.java b/core/src/ch/asynk/rustanddust/game/hud/UnitDock.java
new file mode 100644
index 0000000..11895ba
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/hud/UnitDock.java
@@ -0,0 +1,226 @@
+package ch.asynk.rustanddust.game.hud;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.math.Vector3;
+import com.badlogic.gdx.math.Matrix4;
+import com.badlogic.gdx.math.Rectangle;
+
+import ch.asynk.rustanddust.engine.gfx.Animation;
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.UnitList;
+import ch.asynk.rustanddust.ui.Bg;
+import ch.asynk.rustanddust.ui.Position;
+
+public class UnitDock extends Bg implements Animation
+{
+    private static final float SCALE = 0.4f;
+    private static final float STEP = 5f;
+    private final Ctrl ctrl;
+
+    private int n;
+    private float y;
+    private float to;
+    private float dx;
+    private float step;
+    private boolean show;
+    private boolean mvtDone;
+    public Unit selectedUnit;
+    private Sprite selected;
+    private UnitList units;
+    private Vector3 point;
+    private Matrix4 saved;
+    private Matrix4 transform;
+    private Rectangle scaledRect;
+
+    public UnitDock(Ctrl ctrl, TextureRegion region, TextureRegion selected, float padding)
+    {
+        super(region);
+        this.ctrl = ctrl;
+        this.padding = padding;
+        this.mvtDone = true;
+        this.point = new Vector3();
+        this.saved = new Matrix4();
+        this.transform = new Matrix4();
+        this.scaledRect = new Rectangle();
+        this.selected = new Sprite(selected);
+        this.visible = false;
+        this.dx = 0f;
+    }
+
+    @Override
+    public void translate(float _dx, float _dy)
+    {
+        this.y += _dy;
+        if (!visible) return;
+        super.translate(_dx, _dy);
+        for (Unit unit : units)
+            unit.translate(_dx, _dy);
+        to = position.getX(rect.width * SCALE);
+        transform.idt();
+        transform.translate((rect.x + dx), (rect.y + rect.height), 0).scale(SCALE, SCALE, 0).translate(-rect.x, - (rect.y + rect.height), 0);
+        point.set(rect.x, rect.y, 0).mul(transform);
+        scaledRect.x = point.x;
+        scaledRect.y = point.y;
+        point.set((rect.x + rect.width), (rect.y + rect.height), 0).mul(transform);
+        scaledRect.width = point.x - scaledRect.x;
+        scaledRect.height = point.y - scaledRect.y;
+    }
+
+    public void setPosition(Position position, float y)
+    {
+        if (this.position == position)
+            return;
+        this.position = position;
+        this.y = y;
+        this.step = (position.isLeft() ? STEP : -STEP);
+        this.mvtDone = true;
+        this.visible = false;
+        this.dx = 0f;
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+    }
+
+    @Override
+    public boolean hit(float x, float y)
+    {
+        return (visible && scaledRect.contains(x, y));
+    }
+
+    public Unit select(float x, float y)
+    {
+        int i = (int) ((scaledRect.y + scaledRect.height - y) / (scaledRect.height / units.size()));
+        selectedUnit = units.get(i);
+        return selectedUnit;
+    }
+
+    public void hide()
+    {
+        if (!visible) return;
+        resize();
+        to = rect.x;
+
+        show = false;
+        mvtDone = false;
+        selectedUnit = null;
+    }
+
+    public void show()
+    {
+        if (!resize())
+            return;
+        to = position.getX(rect.width * SCALE);
+
+        show = true;
+        mvtDone = false;
+        selectedUnit = null;
+        visible = true;
+    }
+
+    private boolean resize()
+    {
+        int count = ctrl.player.reinforcement();
+        if (count == 0) {
+            n = 0;
+            return false;
+        }
+        if (count == n) return true;
+        n = count;
+
+        units = ctrl.player.reinforcement;
+        rect.width = units.get(0).getWidth() + (2 * padding);
+        rect.height = ((units.get(0).getHeight() * n) + ((n + 1) * padding));
+        float scaledWidth = (rect.width * SCALE);
+        to = position.getX(scaledWidth);
+        rect.x = to + (position.isLeft() ? -scaledWidth : scaledWidth);
+        rect.y = y - rect.height;
+
+        float px = rect.x;
+        float py = rect.y + rect.height;
+        float ph = units.get(0).getHeight();
+        for (Unit unit : units) {
+            py -= (ph + padding);
+            // unit.setPosition(px, py, Orientation.SOUTH.r());
+            unit.centerOn((px + (rect.width / 2)), py + (ph / 2));
+            unit.setRotation(position.isLeft() ? Orientation.NORTH.r() : Orientation.SOUTH.r());
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        if (!visible) return true;
+        if (mvtDone) return true;
+
+        float x = (rect.x + dx);
+        if (show) {
+            if ((position.isLeft() && (x < to)) || (!position.isLeft() && x > to))
+                dx += step;
+            else {
+                dx = (to - rect.x);
+                mvtDone = true;
+            }
+        } else {
+            if ((position.isLeft() && (x > to)) || (!position.isLeft() && x < to))
+                dx -= step;
+            else {
+                dx = (to - rect.x);
+                mvtDone = true;
+                visible = false;
+            }
+        }
+
+        transform.idt();
+        transform.translate((rect.x + dx), (rect.y + rect.height), 0).scale(SCALE, SCALE, 0).translate(-rect.x, - (rect.y + rect.height), 0);
+        point.set(rect.x, rect.y, 0).mul(transform);
+        scaledRect.x = point.x;
+        scaledRect.y = point.y;
+        point.set((rect.x + rect.width), (rect.y + rect.height), 0).mul(transform);
+        scaledRect.width = point.x - scaledRect.x;
+        scaledRect.height = point.y - scaledRect.y;
+        return false;
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+
+        saved.set(batch.getTransformMatrix());
+        batch.setTransformMatrix(transform);
+
+        super.draw(batch);
+        for (Unit unit : units) {
+            unit.draw(batch);
+            if (unit == selectedUnit) {
+                selected.setCenter((unit.getX() + (unit.getWidth() / 2)), (unit.getY() + (unit.getHeight() / 2)));
+                selected.draw(batch);
+            }
+        }
+
+        batch.setTransformMatrix(saved);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        if (!visible) return;
+
+        saved.set(shapes.getTransformMatrix());
+        shapes.setTransformMatrix(transform);
+
+        shapes.rect(rect.x, rect.y, rect.width, rect.height);
+
+        shapes.setTransformMatrix(saved);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateAnimation.java b/core/src/ch/asynk/rustanddust/game/states/StateAnimation.java
new file mode 100644
index 0000000..41831e0
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateAnimation.java
@@ -0,0 +1,37 @@
+package ch.asynk.rustanddust.game.states;
+
+public class StateAnimation extends StateCommon
+{
+    @Override
+    public void enter(StateType prevState)
+    {
+        ctrl.hud.actionButtons.hide();
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+    }
+
+    @Override
+    public StateType abort()
+    {
+        return StateType.ABORT;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        return StateType.DONE;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateBreak.java b/core/src/ch/asynk/rustanddust/game/states/StateBreak.java
new file mode 100644
index 0000000..f1e40f6
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateBreak.java
@@ -0,0 +1,90 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class StateBreak extends StateCommon
+{
+    private Orientation o = Orientation.KEEP;
+
+    @Override
+    public void enter(StateType prevState)
+    {
+        activeUnit = null;
+        ctrl.hud.actionButtons.show(Buttons.DONE.b);
+        ctrl.hud.pushNotify("Break move possible");
+        map.showBreakUnits();
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+        map.hideBreakUnits();
+        map.hideMove(to);
+        map.hideDirections(to);
+        map.hideOrientation(to);
+        if (activeUnit != null) map.hideMove(activeUnit.getHex());
+    }
+
+    @Override
+    public StateType abort()
+    {
+        return StateType.ABORT;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        return StateType.DONE;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+        // TODO : cancel preview move before showing rotation
+        if (activeUnit == null) {
+            Unit unit = upHex.getUnit();
+            if (map.breakUnits.contains(unit)) {
+                activeUnit = unit;
+                map.showMove(upHex);
+                map.showMove(to);
+                map.showDirections(to);
+                map.hideBreakUnits();
+            }
+        } else {
+            o = Orientation.fromAdj(to, upHex);
+
+            if (o == Orientation.KEEP) return;
+
+            if (ctrl.cfg.mustValidate) {
+                map.hideDirections(to);
+                map.showOrientation(to, o);
+                ctrl.hud.actionButtons.show(Buttons.DONE.b);
+            } else {
+                doRotation(o);
+                ctrl.setState(StateType.ANIMATION);
+            }
+        }
+    }
+
+    private void doRotation(Orientation o)
+    {
+        if (activeUnit == null) return;
+
+        map.pathBuilder.init(activeUnit);
+        if (map.pathBuilder.build(to) == 1) {
+            map.pathBuilder.orientation = o;
+            map.moveUnit(activeUnit);
+            ctrl.setAfterAnimationState(StateType.DONE);
+        } else
+            RustAndDust.debug("That's very wrong there should be only one path");
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateCommon.java b/core/src/ch/asynk/rustanddust/game/states/StateCommon.java
new file mode 100644
index 0000000..443182d
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateCommon.java
@@ -0,0 +1,68 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.State;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public abstract class StateCommon implements State
+{
+    protected static Ctrl ctrl;
+    protected static Map map;
+
+    protected static Hex selectedHex = null;
+    protected static Hex downHex = null;
+    protected static Hex upHex = null;
+    protected static Hex to = null;
+
+    protected boolean isEnemy;
+    protected static Unit activeUnit;
+    protected static Unit selectedUnit;
+
+    protected StateCommon()
+    {
+    }
+
+    public StateCommon(Ctrl ctrl, Map map)
+    {
+        this.ctrl = ctrl;
+        this.map = map;
+    }
+
+    @Override
+    public boolean downInMap(float x, float y)
+    {
+        downHex = map.getHexAt(x, y);
+        return (downHex != null);
+    }
+
+    @Override
+    public boolean upInMap(float x, float y)
+    {
+        upHex = map.getHexAt(x, y);
+        return (upHex != null);
+    }
+
+    protected boolean hasUnit()
+    {
+        return (selectedUnit != null);
+    }
+
+    protected void showPossibilities(Unit unit)
+    {
+        if (ctrl.cfg.showMoves && unit.canMove()) map.showPossibleMoves();
+        if (ctrl.cfg.showTargets && unit.canEngage()) map.showPossibleTargets();
+        if (ctrl.cfg.showMoveAssists && unit.canMove()) map.showMoveableUnits();
+        unit.enableOverlay(Unit.MOVE, false);
+    }
+
+    protected void hidePossibilities()
+    {
+        map.hidePossibleMoves();
+        map.hidePossibleTargets();
+        map.hideMoveableUnits();
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateDeployment.java b/core/src/ch/asynk/rustanddust/game/states/StateDeployment.java
new file mode 100644
index 0000000..9528d2a
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateDeployment.java
@@ -0,0 +1,138 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.UnitList;
+import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class StateDeployment extends StateCommon
+{
+    private boolean completed;
+    private Zone entryZone;
+    private UnitList deployedUnits = new UnitList(10);
+
+    @Override
+    public void enter(StateType prevState)
+    {
+        if (selectedHex != null)
+            map.unselectHex(selectedHex);
+        completed = false;
+        entryZone = null;
+        selectedHex = null;
+        selectedUnit = null;
+        ctrl.hud.actionButtons.hide();
+        ctrl.hud.playerInfo.unitDock.show();
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+        selectedUnit = null;
+        if (selectedHex != null)
+            map.unselectHex(selectedHex);
+        if (entryZone != null)
+            entryZone.enable(Hex.AREA, false);
+        ctrl.hud.playerInfo.unitDock.hide();
+    }
+
+    @Override
+    public StateType abort()
+    {
+        if (activeUnit != null)
+            undo();
+        return StateType.DEPLOYMENT;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        deployedUnits.clear();
+        return StateType.DONE;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+        Unit unit = ctrl.hud.playerInfo.unitDock.selectedUnit;
+        if (!completed && (unit != null) && (unit != activeUnit)) {
+            showEntryZone(unit);
+        } else if (selectedUnit != null) {
+            doRotation(Orientation.fromAdj(selectedHex, upHex));
+        } else if (!completed && (entryZone != null) && (upHex != null)) {
+            if (upHex.isEmpty() && entryZone.contains(upHex))
+                unitEnter(activeUnit);
+        } else {
+            unit = downHex.getUnit();
+            if (deployedUnits.contains(unit)) {
+                showRotation(unit, downHex);
+                activeUnit = unit;
+            }
+        }
+    }
+
+    private void showEntryZone(Unit unit)
+    {
+        activeUnit = unit;
+        if (entryZone != null) entryZone.enable(Hex.AREA, false);
+        entryZone = ctrl.battle.getEntryZone(activeUnit);
+        entryZone.enable(Hex.AREA, true);
+    }
+
+    private void undo()
+    {
+        map.unselectHex(selectedHex);
+        map.hideDirections(selectedHex);
+        map.revertEnter(activeUnit);
+        activeUnit = null;
+        selectedUnit = null;
+        ctrl.hud.update();
+    }
+
+    private void unitEnter(Unit unit)
+    {
+        selectedUnit = unit;
+        selectedHex = upHex;
+        ctrl.player.reinforcement.remove(unit);
+        map.showOnBoard(unit, upHex, entryZone.orientation);
+        deployedUnits.add(unit);
+        entryZone.enable(Hex.AREA, false);
+        showRotation(unit, upHex);
+        ctrl.hud.update();
+    }
+
+    private void showRotation(Unit unit, Hex hex)
+    {
+        selectedUnit = unit;
+        selectedHex = hex;
+        map.selectHex(selectedHex);
+        map.showDirections(selectedHex);
+        ctrl.hud.playerInfo.unitDock.hide();
+        ctrl.hud.actionButtons.show(Buttons.ABORT.b);
+    }
+
+    private void doRotation(Orientation o)
+    {
+        map.unselectHex(selectedHex);
+        map.hideDirections(selectedHex);
+
+        if (o != Orientation.KEEP)
+            map.setOnBoard(selectedUnit, selectedHex, o);
+
+        ctrl.hud.actionButtons.hide();
+        ctrl.hud.playerInfo.unitDock.show();
+        entryZone = null;
+        activeUnit = null;
+        selectedUnit = null;
+        if (ctrl.checkDeploymentDone())
+            completed = true;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateEngage.java b/core/src/ch/asynk/rustanddust/game/states/StateEngage.java
new file mode 100644
index 0000000..4588cb2
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateEngage.java
@@ -0,0 +1,105 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class StateEngage extends StateCommon
+{
+    @Override
+    public void enter(StateType prevState)
+    {
+        map.possibleTargets.clear();
+        ctrl.hud.actionButtons.show(ctrl.cfg.canCancel ? Buttons.ABORT.b : 0);
+
+        // activeUnit is the target
+        if (prevState == StateType.SELECT) {
+            activeUnit = null;
+            // use selectedHex and selectedUnit
+            map.hidePossibleTargets();
+            map.collectPossibleTargets(selectedUnit, ctrl.opponent.units);
+            map.showPossibleTargets();
+            if (to != null) {
+                // quick fire -> replay touchUp
+                upHex = to;
+                touchUp();
+            }
+            selectedUnit.showAttack();
+            map.selectHex(selectedHex);
+        } else
+            RustAndDust.debug("should not happen");
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+        selectedUnit.hideAttack();
+        map.hideAttackAssists();
+        map.hidePossibleTargets();
+        map.unselectHex(selectedHex);
+        if (to != null)
+            map.unselectHex(to);
+    }
+
+    @Override
+    public StateType abort()
+    {
+        map.activatedUnits.clear();
+        return StateType.ABORT;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        StateType nextState = StateType.DONE;
+        if (map.engageUnit(selectedUnit, activeUnit)) {
+            ctrl.player.wonEngagementCount += 1;
+            ctrl.opponent.casualty(activeUnit);
+            if (map.breakUnits.size() > 0) {
+                nextState = StateType.BREAK;
+            }
+        } else {
+            ctrl.player.lostEngagementCount += 1;
+        }
+
+        activeUnit.showTarget();
+        ctrl.setAfterAnimationState(nextState);
+        return StateType.ANIMATION;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+        Unit unit = upHex.getUnit();
+
+        // activeUnit is the target, selectedTarget is the engagement leader
+        if (unit == selectedUnit) {
+            ctrl.setState(StateType.ABORT);
+        } else if ((activeUnit == null) && map.possibleTargets.contains(unit)) {
+            // ctrl.hud.notify("Engage " + unit);
+            map.hidePossibleTargets();
+            to = upHex;
+            activeUnit = unit;
+            activeUnit.showTarget();
+            map.collectAttackAssists(selectedUnit, activeUnit, ctrl.player.units);
+            map.showAttackAssists();
+            ctrl.hud.actionButtons.show((ctrl.cfg.mustValidate ? Buttons.DONE.b : 0) | (ctrl.cfg.canCancel ? Buttons.ABORT.b : 0));
+        }
+        else if (unit == activeUnit) {
+            ctrl.setState(StateType.DONE);
+        }
+        else if ((activeUnit != null) && map.engagementAssists.contains(unit)) {
+            map.toggleAttackAssist(unit);
+            // if(map.toggleAttackAssist(unit))
+            //     ctrl.hud.notify(unit + " will fire");
+            // else
+            //     ctrl.hud.notify(unit + " wont fire");
+        }
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateMove.java b/core/src/ch/asynk/rustanddust/game/states/StateMove.java
new file mode 100644
index 0000000..b59b133
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateMove.java
@@ -0,0 +1,193 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons;
+
+public class StateMove extends StateCommon
+{
+    @Override
+    public void enter(StateType prevState)
+    {
+        ctrl.hud.actionButtons.show(
+                ((map.activatedUnits.size() > 0) ? Buttons.DONE.b : 0)
+                | (ctrl.cfg.canCancel ? Buttons.ABORT.b : 0));
+
+        if (prevState == StateType.WITHDRAW) {
+            if (map.pathBuilder.size() == 1)
+                ctrl.setState(StateType.ROTATE);
+            return;
+        }
+
+        map.pathBuilder.clear();
+
+        if (prevState == StateType.SELECT) {
+            // use selectedHex and selectedUnit
+            activeUnit = selectedUnit;
+            activeUnit.showMoveable();
+            map.pathBuilder.init(activeUnit);
+            map.collectAndShowMovesAndAssits(activeUnit);
+            if (to != null) {
+                // quick move -> replay touchUp
+                upHex = to;
+                touchUp();
+            } else
+                checkExit(activeUnit, activeUnit.getHex());
+        } else {
+            // back from rotation -> chose next Pawn
+            if (selectedUnit.canMove()) {
+                changeUnit(selectedUnit);
+            } else {
+                changeUnit(map.moveableUnits.get(0));
+            }
+        }
+
+        activeUnit.enableOverlay(Unit.MOVE, false);
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+        if (nextState == StateType.WITHDRAW)
+            return;
+
+        // hide all but assists : want them when in rotation
+        activeUnit.hideMoveable();
+        map.hidePossibleMoves();
+        map.unselectHex(activeUnit.getHex());
+        if (to != null)
+            map.hidePath(to);
+
+        if (nextState != StateType.SELECT) {
+            if (to == null)
+                to = activeUnit.getHex();
+        }
+    }
+
+    @Override
+    public StateType abort()
+    {
+        hideAssists();
+        if (activeUnit.justEntered()) {
+            map.revertEnter(activeUnit);
+            return StateType.ABORT;
+        }
+        int n = map.activatedUnits.size();
+        if (n == 0)
+            return StateType.ABORT;
+        map.revertMoves();
+        return StateType.ANIMATION;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        hideAssists();
+        // be sure that the hq is activated
+        if (selectedUnit.canMove() && (map.activatedUnits.size() > 0))
+            selectedUnit.setMoved();
+
+        return StateType.DONE;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+        if (upHex == activeUnit.getHex()) {
+            if (to != null)
+                map.hidePath(to);
+            to = null;
+            map.pathBuilder.clear();
+            ctrl.setState(StateType.ROTATE);
+            return;
+        }
+
+        int s = map.pathBuilder.size();
+
+        Unit unit = upHex.getUnit();
+
+        if (map.moveableUnits.contains(unit)) {
+            if(unit != activeUnit)
+                changeUnit(unit);
+        } else if ((s == 0) && map.possibleMoves.contains(upHex)) {
+            s = collectPaths(upHex);
+        } else if (map.pathBuilder.contains(upHex)) {
+            s = togglePoint(downHex, s);
+        }
+
+        if (s == 1) {
+            if (!checkExit(activeUnit, upHex))
+                ctrl.setState(StateType.ROTATE);
+        }
+    }
+
+    private void hideAssists()
+    {
+        map.hideMoveableUnits();
+    }
+
+    private void changeUnit(Unit unit)
+    {
+        if (activeUnit != null ) {
+            map.unselectHex(activeUnit.getHex());
+            if (activeUnit.canMove())
+                activeUnit.enableOverlay(Unit.MOVE, true);
+        }
+        activeUnit = unit;
+        Hex hex = activeUnit.getHex();
+        map.pathBuilder.init(activeUnit, hex);
+        activeUnit.showMoveable();
+        map.hidePossibleMoves();
+        map.collectPossibleMoves(activeUnit);
+        map.showPossibleMoves();
+        map.selectHex(hex);
+        activeUnit.enableOverlay(Unit.MOVE, false);
+        ctrl.hud.notify(activeUnit.toString());
+        checkExit(activeUnit, hex);
+    }
+
+    private int collectPaths(Hex hex)
+    {
+        to = hex;
+        int s = map.pathBuilder.build(to);
+        map.showMove(to);
+        map.hidePossibleMoves();
+        map.showPathBuilder();
+        return s;
+    }
+
+    private int togglePoint(Hex hex, int s)
+    {
+        if (hex == activeUnit.getHex()) {
+            //
+        } else if (hex == to) {
+            //
+        } else {
+            map.hidePathBuilder();
+            map.togglePathOverlay(hex);
+            s = map.togglePathBuilderHex(hex);
+            map.showPathBuilder();
+        }
+
+        return s;
+    }
+
+    private boolean checkExit(Unit unit, Hex hex)
+    {
+        if ((hex == unit.getHex()) && (unit.justEntered()))
+            return false;
+        Zone exitZone = ctrl.battle.getExitZone(unit);
+        if ((exitZone == null) || !exitZone.contains(hex))
+            return false;
+        if ((unit.getHex() != hex) && !map.pathBuilder.canExit(exitZone.orientation))
+            return false;
+        ctrl.setState(StateType.WITHDRAW);
+        return true;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StatePromote.java b/core/src/ch/asynk/rustanddust/game/states/StatePromote.java
new file mode 100644
index 0000000..8543c89
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StatePromote.java
@@ -0,0 +1,42 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.game.Unit;
+
+public class StatePromote extends StateCommon
+{
+    @Override
+    public void enter(StateType prevState)
+    {
+        ctrl.setAfterAnimationState(StateType.DONE);
+        ctrl.setState(StateType.ANIMATION);
+        map.promoteUnit(selectedUnit);
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+        map.unselectHex(selectedHex);
+    }
+
+    @Override
+    public StateType abort()
+    {
+        return StateType.ABORT;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        return StateType.DONE;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateReinforcement.java b/core/src/ch/asynk/rustanddust/game/states/StateReinforcement.java
new file mode 100644
index 0000000..77ff826
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateReinforcement.java
@@ -0,0 +1,87 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons;
+
+public class StateReinforcement extends StateCommon
+{
+    private Zone entryZone;
+
+    @Override
+    public void enter(StateType prevState)
+    {
+        map.clearAll();
+        if (selectedHex != null)
+            map.unselectHex(selectedHex);
+        entryZone = null;
+        selectedHex = null;
+        ctrl.hud.playerInfo.unitDock.show();
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+        if (selectedHex != null)
+            map.unselectHex(selectedHex);
+        if (entryZone != null)
+            entryZone.enable(Hex.AREA, false);
+        ctrl.hud.playerInfo.unitDock.hide();
+    }
+
+    @Override
+    public StateType abort()
+    {
+        return StateType.ABORT;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        return StateType.DONE;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+        Unit unit = ctrl.hud.playerInfo.unitDock.selectedUnit;
+        if ((unit != null) && (unit != activeUnit))
+            changeUnit(unit);
+        else if ((entryZone != null) && upHex.isEmpty() && entryZone.contains(upHex))
+            unitEnter(activeUnit);
+        else
+            ctrl.setState(StateType.SELECT);
+    }
+
+    private void changeUnit(Unit unit)
+    {
+        activeUnit = unit;
+        if (entryZone != null)
+            entryZone.enable(Hex.AREA, false);
+        entryZone = ctrl.battle.getEntryZone(activeUnit);
+        entryZone.enable(Hex.AREA, true);
+        ctrl.hud.actionButtons.show(((ctrl.cfg.canCancel) ? Buttons.ABORT.b : 0));
+    }
+
+    private void unitEnter(Unit unit)
+    {
+        selectedUnit = unit;
+        selectedHex = upHex;
+        map.selectHex(selectedHex);
+        entryZone.enable(Hex.AREA, false);
+        if (map.enterBoard(unit, upHex, entryZone.allowedMoves)) {
+            if (unit.getMovementPoints() > 0)
+                ctrl.setState(StateType.MOVE);
+            else
+                ctrl.setState(StateType.ROTATE);
+        } else {
+            ctrl.hud.notify("Can not enter the map at that position");
+        }
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateRotate.java b/core/src/ch/asynk/rustanddust/game/states/StateRotate.java
new file mode 100644
index 0000000..4d91740
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateRotate.java
@@ -0,0 +1,111 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.engine.Orientation;
+import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class StateRotate extends StateCommon
+{
+    private boolean rotateOnly;
+    private boolean rotationSet;
+
+    @Override
+    public void enter(StateType prevState)
+    {
+        ctrl.hud.actionButtons.show((ctrl.cfg.canCancel && (map.moveableUnits.size() > 1))? Buttons.ABORT.b : 0);
+
+        if (activeUnit == null)
+            activeUnit = selectedUnit;
+        if (to == null)
+            to = activeUnit.getHex();
+
+        if (!map.pathBuilder.isSet()) {
+            map.pathBuilder.init(activeUnit);
+            map.pathBuilder.build(to);
+        }
+
+        if (map.pathBuilder.size() != 1)
+            RustAndDust.debug("ERROR: pathBuilder.size() == " + map.pathBuilder.size());
+
+        rotateOnly = (to == activeUnit.getHex());
+
+        if (!rotateOnly)
+            map.showPath(to);
+        map.selectHex(activeUnit.getHex());
+        map.showDirections(to);
+
+        rotationSet = false;
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+        map.unselectHex(activeUnit.getHex());
+        map.hidePath(to);
+        map.hideDirections(to);
+        map.hideOrientation(to);
+        map.pathBuilder.clear();
+        to = null;
+    }
+
+    @Override
+    public StateType abort()
+    {
+        StateType nextState = StateType.ABORT;
+        ctrl.hud.actionButtons.hide();
+        if (activeUnit.justEntered()) {
+            map.revertEnter(activeUnit);
+            nextState = StateType.ABORT;
+        } else if (map.activatedUnits.size() == 0) {
+            map.hideMoveableUnits();
+        } else {
+            nextState = StateType.MOVE;
+        }
+        return nextState;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        StateType whenDone = StateType.DONE;
+
+        if (map.moveUnit(activeUnit) > 0)
+            whenDone = StateType.MOVE;
+
+        ctrl.setAfterAnimationState(whenDone);
+        return StateType.ANIMATION;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+        if (rotationSet) return;
+
+        Orientation o = Orientation.fromAdj(to, upHex);
+        if (o == Orientation.KEEP) {
+            ctrl.setState(StateType.ABORT);
+            return;
+        }
+
+        if (!activeUnit.justEntered() && rotateOnly && (o == activeUnit.getOrientation()))
+            return;
+
+        map.pathBuilder.orientation = o;
+        rotationSet = true;
+
+        if (ctrl.cfg.mustValidate) {
+            map.hideDirections(to);
+            map.showOrientation(to, o);
+            ctrl.hud.actionButtons.show(Buttons.DONE.b | ((ctrl.cfg.canCancel) ? Buttons.ABORT.b : 0));
+        } else {
+            execute();
+            ctrl.setState(StateType.ANIMATION);
+        }
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateSelect.java b/core/src/ch/asynk/rustanddust/game/states/StateSelect.java
new file mode 100644
index 0000000..9161a6b
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateSelect.java
@@ -0,0 +1,132 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.game.Map;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.Unit;
+import ch.asynk.rustanddust.game.Ctrl;
+import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class StateSelect extends StateCommon
+{
+    public StateSelect(Ctrl ctrl, Map map)
+    {
+        super(ctrl, map);
+    }
+
+    @Override
+    public void enter(StateType prevState)
+    {
+        to = null;
+        selectedHex = null;
+        selectedUnit = null;
+        activeUnit = null;
+        map.clearAll();
+        ctrl.hud.actionButtons.hide();
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+        hidePossibilities();
+    }
+
+    @Override
+    public StateType abort()
+    {
+        if (selectedHex != null)
+            map.unselectHex(selectedHex);
+        hidePossibilities();
+        map.clearAll();
+        return StateType.ABORT;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        return StateType.DONE;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+        if (!isEnemy) {
+            if (map.possibleMoves.contains(upHex)) {
+                // quick move
+                to = upHex;
+                ctrl.setState(StateType.MOVE);
+                return;
+            }
+            if (map.possibleTargets.contains(upHex.getUnit())) {
+                // quick fire
+                to = upHex;
+                ctrl.setState(StateType.ENGAGE);
+                return;
+            }
+        }
+
+        if (selectedHex != null)
+            map.unselectHex(selectedHex);
+
+        hidePossibilities();
+        if (upHex.isOffMap()) {
+            selectedUnit = null;
+            return;
+        }
+
+        Unit unit = upHex.getUnit();
+
+        if (unit == null) {
+            isEnemy = false;
+            ctrl.hud.actionButtons.hide();
+            map.clearAll();
+            selectedUnit = null;
+            return;
+        }
+
+        isEnemy = ctrl.player.isEnemy(unit);
+        if (!isEnemy && (unit == selectedUnit) && unit.canMove()) {
+            if (unit.isHq()) {
+                ctrl.hud.notify("HQ activation");
+                select(upHex, unit, isEnemy);
+                ctrl.setState(StateType.MOVE);
+            } else {
+                // quick rotate
+                to = upHex;
+                ctrl.setState(StateType.ROTATE);
+            }
+        } else {
+            select(upHex, unit, isEnemy);
+            ctrl.hud.notify(selectedUnit.toString());
+        }
+    }
+
+    private void select(Hex hex, Unit unit, boolean isEnemy)
+    {
+        selectedHex = hex;
+        selectedUnit = unit;
+
+        if (isEnemy && !ctrl.cfg.showEnemyPossibilities)
+            return;
+
+        int moves = map.collectPossibleMoves(selectedUnit);
+        int targets = map.collectPossibleTargets(selectedUnit, (isEnemy ? ctrl.player.units : ctrl.opponent.units));
+
+        if (moves > 0)
+            map.collectMoveableUnits(selectedUnit);
+
+        if ((moves > 0) || (targets > 0)) {
+            map.selectHex(selectedHex);
+            showPossibilities(selectedUnit);
+        }
+
+        ctrl.hud.actionButtons.show((ctrl.player.canPromote(selectedUnit)) ? Buttons.PROMOTE.b : 0 );
+        RustAndDust.debug("Select", selectedHex.toString() + " " + selectedUnit + (isEnemy ? " enemy " : " friend "));
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/game/states/StateWithdraw.java b/core/src/ch/asynk/rustanddust/game/states/StateWithdraw.java
new file mode 100644
index 0000000..f4f11a6
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/game/states/StateWithdraw.java
@@ -0,0 +1,71 @@
+package ch.asynk.rustanddust.game.states;
+
+import ch.asynk.rustanddust.game.Zone;
+import ch.asynk.rustanddust.game.Hex;
+import ch.asynk.rustanddust.game.Unit;
+
+public class StateWithdraw extends StateCommon
+{
+    @Override
+    public void enter(StateType prevState)
+    {
+        ctrl.hud.askExitBoard();
+    }
+
+    @Override
+    public void leave(StateType nextState)
+    {
+    }
+
+    @Override
+    public StateType abort()
+    {
+        return StateType.MOVE;
+    }
+
+    @Override
+    public StateType execute()
+    {
+        if (activeUnit == null)
+            activeUnit = selectedUnit;
+
+        ctrl.setAfterAnimationState(withdraw(activeUnit));
+        return StateType.ANIMATION;
+    }
+
+    @Override
+    public void touchDown()
+    {
+    }
+
+    @Override
+    public void touchUp()
+    {
+    }
+
+    private StateType withdraw(Unit unit)
+    {
+        Zone exitZone = ctrl.battle.getExitZone(unit);
+        Hex hex = unit.getHex();
+
+        // rotation
+        if (map.pathBuilder.to == null)
+            map.pathBuilder.build(hex);
+
+        Hex exitHex = (Hex) map.pathBuilder.to;
+        if (!exitZone.contains(exitHex))
+            throw new RuntimeException(String.format("%s not in exitZone", exitHex));
+
+        map.pathBuilder.setExit(exitZone.orientation);
+
+        unit.hideMoveable();
+        if (to != null)
+            map.hidePath(to);
+        map.hidePossibleMoves();
+        map.unselectHex(hex);
+
+        if (map.exitBoard(unit) > 0)
+            return StateType.MOVE;
+        return StateType.DONE;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/loading/LoadingBar.java b/core/src/ch/asynk/rustanddust/loading/LoadingBar.java
new file mode 100644
index 0000000..5a6181a
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/loading/LoadingBar.java
@@ -0,0 +1,32 @@
+package ch.asynk.rustanddust.loading;
+
+import com.badlogic.gdx.graphics.g2d.Animation;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.scenes.scene2d.Actor;
+
+public class LoadingBar extends Actor
+{
+    Animation animation;
+    TextureRegion reg;
+    float stateTime;
+
+    public LoadingBar(Animation animation)
+    {
+        this.animation = animation;
+        reg = animation.getKeyFrame(0);
+    }
+
+    @Override
+    public void act(float delta)
+    {
+        stateTime += delta;
+        reg = animation.getKeyFrame(stateTime);
+    }
+
+    @Override
+    public void draw(Batch batch, float parentAlpha)
+    {
+        batch.draw(reg, getX(), getY());
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/menu/MainMenu.java b/core/src/ch/asynk/rustanddust/menu/MainMenu.java
new file mode 100644
index 0000000..769adb3
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/menu/MainMenu.java
@@ -0,0 +1,67 @@
+package ch.asynk.rustanddust.menu;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+
+import ch.asynk.rustanddust.ui.Menu;
+
+public class MainMenu extends Menu
+{
+    public enum Items implements Menu.MenuItem
+    {
+        EXIT(0),
+        OPTIONS(1),
+        TUTORIALS(2),
+        SCENARIOS(3),
+        NONE(4);
+        public int i;
+        Items(int i)
+        {
+            this.i = i;
+        }
+        public int i() { return i; }
+        public int last() { return NONE.i; }
+    };
+
+    public MainMenu(BitmapFont font, TextureAtlas atlas)
+    {
+        super(Items.NONE, font, atlas.createPatch("typewriter"));
+
+        label(Items.OPTIONS).write("Options");
+        label(Items.TUTORIALS).write("Tutorials");
+        label(Items.SCENARIOS).write("Scenarios");
+        label(Items.EXIT).write("Exit");
+
+        this.visible = true;
+    }
+
+    public Items getMenu()
+    {
+        return (Items) menuItem;
+    }
+
+    @Override
+    public boolean hit(float x, float y)
+    {
+        boolean ret = false;
+        menuItem = Items.NONE;
+
+        if (!visible) return ret;
+
+        if (label(Items.SCENARIOS).hit(x, y)) {
+            menuItem = Items.SCENARIOS;
+            ret = true;
+        } else if (label(Items.TUTORIALS).hit(x, y)) {
+            menuItem = Items.TUTORIALS;
+            ret = true;
+        } else if (label(Items.OPTIONS).hit(x, y)) {
+            menuItem = Items.OPTIONS;
+            ret = true;
+        } else if (label(Items.EXIT).hit(x, y)) {
+            Gdx.app.exit();
+        }
+
+        return ret;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/menu/OptionsMenu.java b/core/src/ch/asynk/rustanddust/menu/OptionsMenu.java
new file mode 100644
index 0000000..9a7c675
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/menu/OptionsMenu.java
@@ -0,0 +1,257 @@
+package ch.asynk.rustanddust.menu;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.GlyphLayout;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+
+import ch.asynk.rustanddust.ui.Label;
+import ch.asynk.rustanddust.ui.Bg;
+import ch.asynk.rustanddust.ui.Patch;
+import ch.asynk.rustanddust.ui.OkCancel;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+public class OptionsMenu extends Patch
+{
+    public static int PADDING = 40;
+    public static int OK_PADDING = 10;
+    public static int TITLE_PADDING = 30;
+    public static int VSPACING = 5;
+    public static int HSPACING = 30;
+    public static String CHECK = "#";
+
+    private final RustAndDust game;
+    private final BitmapFont font;
+
+    private String [] checkStrings = {
+        "Debug",
+        "Must Validate",
+        "Can Cancel",
+        "Show Enemy Possibilities",
+        "Show Moves Assists",
+        "Show Targets",
+        "Show Moves",
+    };
+    private String [] fxStrings = { "OFF", "10%", "20%", "30%", "40%", "50%", "60%", "70%", "80%", "90%", "ON" };
+
+    private float checkDy;
+    private Label title;
+    private Label fxVolume;
+    private Label fxVolumeValue;
+    private Label graphics;
+    private Label graphicsValue;
+    private Label gameMode;
+    private Label gameModeValue;
+    private Label [] checkLabels;
+    private boolean [] checkValues;
+    private OkCancel okCancel;
+    protected Bg okBtn;
+
+    public OptionsMenu(RustAndDust game, BitmapFont font, TextureAtlas atlas)
+    {
+        super(atlas.createPatch("typewriter"));
+        this.game = game;
+        this.font = font;
+        this.okCancel = new OkCancel(font, atlas);
+        this.okBtn = new Bg(atlas.findRegion("ok"));
+        this.title = new Label(font);
+        this.title.write("- Options");
+        this.fxVolume = new Label(font);
+        this.fxVolume.write("Fx Volume");
+        this.fxVolumeValue = new Label(font);
+        this.fxVolumeValue.write(fxStrings[(int) (game.config.fxVolume * 10)]);
+        this.graphics = new Label(font);
+        this.graphics.write("Graphics");
+        this.graphicsValue = new Label(font);
+        this.graphicsValue.write(game.config.graphics.s);
+        this.gameMode = new Label(font);
+        this.gameMode.write("Game mode");
+        this.gameModeValue = new Label(font);
+        this.gameModeValue.write(game.config.gameMode.s);
+        this.checkValues = new boolean[checkStrings.length];
+        this.checkLabels = new Label[checkStrings.length];
+        for (int i = 0; i < checkLabels.length; i++) {
+            Label l = new Label(font, 5f);
+            l.write(checkStrings[i]);
+            this.checkLabels[i] = l;
+        }
+        getValues();
+        GlyphLayout layout = new GlyphLayout();
+        layout.setText(font, CHECK);
+        checkDy = layout.height + 5;
+
+        this.visible = false;
+    }
+
+    private void getValues()
+    {
+        checkValues[6] = game.config.showMoves;
+        checkValues[5] = game.config.showTargets;
+        checkValues[4] = game.config.showMoveAssists;
+        checkValues[3] = game.config.showEnemyPossibilities;
+        checkValues[2] = game.config.canCancel;
+        checkValues[1] = game.config.mustValidate;
+        checkValues[0] = game.config.debug;
+    }
+
+    private boolean apply()
+    {
+        game.config.showMoves = checkValues[6];
+        game.config.showTargets = checkValues[5];
+        game.config.showMoveAssists = checkValues[4];
+        game.config.showEnemyPossibilities = checkValues[3];
+        game.config.canCancel = checkValues[2];
+        game.config.mustValidate = checkValues[1];
+        game.config.debug = checkValues[0];
+        if (!game.config.gameModeImplemented()) {
+            this.visible = false;
+            okCancel.show(String.format("'%s' Game Mode not implemented yet.", game.config.gameMode.s));
+            okCancel.noCancel();
+            return false;
+        }
+        return true;
+    }
+
+    private void cycleFxVolume()
+    {
+        int i = (int) (game.config.fxVolume * 10) + 1;
+        if (i > 10) i = 0;
+        float fx = fxVolumeValue.getX();
+        float fy = fxVolumeValue.getY();
+        fxVolumeValue.write(fxStrings[i]);
+        fxVolumeValue.setPosition(fx, fy);
+        game.config.fxVolume = (i / 10f);
+    }
+
+    private void cycleGraphics()
+    {
+        game.config.graphics = game.config.graphics.next();
+        float fx = graphicsValue.getX();
+        float fy = graphicsValue.getY();
+        graphicsValue.write(game.config.graphics.s);
+        graphicsValue.setPosition(fx, fy);
+    }
+
+    private void cycleGameMode()
+    {
+        game.config.gameMode = game.config.gameMode.next();
+        float fx = gameModeValue.getX();
+        float fy = gameModeValue.getY();
+        gameModeValue.write(game.config.gameMode.s);
+        gameModeValue.setPosition(fx, fy);
+    }
+
+    public void setPosition()
+    {
+        float h = (title.getHeight() + TITLE_PADDING + ((checkLabels.length - 1) * VSPACING) + (2 * PADDING));
+        for (int i = 0; i < checkLabels.length; i++)
+            h += checkLabels[i].getHeight();
+        h += (graphics.getHeight() + VSPACING);
+        h += (gameMode.getHeight() + VSPACING);
+        h += (fxVolume.getHeight() + VSPACING);
+
+        float w = title.getWidth();
+        for (int i = 0; i < checkLabels.length; i++) {
+            float t = checkLabels[i].getWidth();
+            if (t > w)
+                w = t;
+        }
+        w += (2 * PADDING) + HSPACING;
+
+        float x = position.getX(w);
+        float y = position.getY(h);
+        setPosition(x, y, w, h);
+
+        okBtn.setPosition((x + w - okBtn.getWidth() + OK_PADDING), (y - OK_PADDING));
+
+        y += PADDING;
+        x += PADDING + HSPACING;
+        float dy = (VSPACING + checkLabels[0].getHeight());
+
+        graphics.setPosition(x, y);
+        graphicsValue.setPosition((x + graphics.getWidth() + 10), y);
+        y += dy;
+        gameMode.setPosition(x, y);
+        gameModeValue.setPosition((x + gameMode.getWidth() + 10), y);
+        y += dy;
+        fxVolume.setPosition(x, y);
+        fxVolumeValue.setPosition((x + fxVolume.getWidth() + 10), y);
+        y += dy;
+        for (int i = 0; i < checkLabels.length; i++) {
+            checkLabels[i].setPosition(x, y);
+            y += dy;
+        }
+        y += (TITLE_PADDING - VSPACING);
+        title.setPosition(x, y);
+    }
+
+    @Override
+    public boolean hit(float x, float y)
+    {
+        if (okCancel.hit(x, y)) {
+            this.visible = true;
+            okCancel.visible = false;
+            return false;
+        }
+
+        if (!visible) return false;
+
+        if (okBtn.hit(x, y)) {
+            return apply();
+        } else if (fxVolume.hit(x, y) || fxVolumeValue.hit(x, y)) {
+            cycleFxVolume();
+        } else if (graphics.hit(x, y) || graphicsValue.hit(x, y)) {
+            cycleGraphics();
+        } else if (gameMode.hit(x, y) || gameModeValue.hit(x, y)) {
+            cycleGameMode();
+        } else {
+            for (int i = 0; i < checkLabels.length; i++) {
+                if (checkLabels[i].hit(x, y))
+                    checkValues[i] =! checkValues[i];
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        title.dispose();
+        okBtn.dispose();
+        okCancel.dispose();
+        fxVolume.dispose();
+        fxVolumeValue.dispose();
+        graphics.dispose();
+        graphicsValue.dispose();
+        gameMode.dispose();
+        gameModeValue.dispose();
+        for (int i = 0; i < checkLabels.length; i++)
+            checkLabels[i].dispose();
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        okCancel.draw(batch);
+
+        if (!visible) return;
+        super.draw(batch);
+        title.draw(batch);
+        okBtn.draw(batch);
+        fxVolume.draw(batch);
+        fxVolumeValue.draw(batch);
+        graphics.draw(batch);
+        graphicsValue.draw(batch);
+        gameMode.draw(batch);
+        gameModeValue.draw(batch);
+        for (int i = 0; i < checkLabels.length; i++) {
+            Label l = checkLabels[i];
+            l.draw(batch);
+            if (checkValues[i])
+                font.draw(batch, CHECK, (l.getX() - HSPACING) , l.getY() + checkDy);
+        }
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/menu/ScenariosMenu.java b/core/src/ch/asynk/rustanddust/menu/ScenariosMenu.java
new file mode 100644
index 0000000..d5b99ed
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/menu/ScenariosMenu.java
@@ -0,0 +1,141 @@
+package ch.asynk.rustanddust.menu;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.GlyphLayout;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+
+import ch.asynk.rustanddust.ui.Label;
+import ch.asynk.rustanddust.ui.Bg;
+import ch.asynk.rustanddust.ui.Patch;
+import ch.asynk.rustanddust.RustAndDust;
+import ch.asynk.rustanddust.game.Battle;
+
+public class ScenariosMenu extends Patch
+{
+    public static int PADDING = 40;
+    public static int BTN_PADDING = 10;
+    public static int TITLE_PADDING = 30;
+    public static int VSPACING = 5;
+    public static int HSPACING = 30;
+    public static String CHECK = "#";
+
+    private final RustAndDust game;
+    private final BitmapFont font;
+
+    private float checkDy;
+    private Label title;
+    protected Bg okBtn;
+    protected Bg cancelBtn;
+    private Label [] battleLabels;
+
+    public boolean launch;
+
+    public ScenariosMenu(RustAndDust game, BitmapFont font, TextureAtlas atlas)
+    {
+        super(atlas.createPatch("typewriter"));
+        this.game = game;
+        this.font = font;
+        this.okBtn = new Bg(atlas.findRegion("ok"));
+        this.cancelBtn = new Bg(atlas.findRegion("cancel"));
+        this.title = new Label(font);
+        this.title.write("- Scenarios");
+        this.battleLabels = new Label[game.factory.battles.length];
+        for (int i = 0; i < battleLabels.length; i++) {
+            Label l = new Label(font, 8f);
+            l.write(game.factory.battles[i].getName());
+            battleLabels[i] = l;
+        }
+        GlyphLayout layout = new GlyphLayout();
+        layout.setText(font, CHECK);
+        checkDy = layout.height + 9;
+
+        this.visible = false;
+        this.launch = false;
+    }
+
+    public void setPosition()
+    {
+        float h = (title.getHeight() + TITLE_PADDING + ((battleLabels.length - 1) * VSPACING) + (2 * PADDING));
+        for (int i = 0; i < battleLabels.length; i++)
+            h += battleLabels[i].getHeight();
+
+        float w = title.getWidth();
+        for (int i = 0; i < battleLabels.length; i++) {
+            float t = battleLabels[i].getWidth();
+            if (t > w)
+                w = t;
+        }
+        w += (2 * PADDING) + HSPACING;
+
+        float x = position.getX(w);
+        float y = position.getY(h);
+        setPosition(x, y, w, h);
+
+        okBtn.setPosition((x + w - okBtn.getWidth() + BTN_PADDING), (y - BTN_PADDING));
+        cancelBtn.setPosition((x - BTN_PADDING), okBtn.getY());
+
+        y += PADDING;
+        x += PADDING + HSPACING;
+        float dy = (VSPACING + battleLabels[0].getHeight());
+
+        for (int i = (battleLabels.length - 1); i > -1; i--) {
+            battleLabels[i].setPosition(x, y);
+            y += dy;
+        }
+        y += (TITLE_PADDING - VSPACING);
+        title.setPosition(x, y);
+    }
+
+    @Override
+    public boolean hit(float x, float y)
+    {
+        if (!visible) return false;
+
+        if (okBtn.hit(x, y)) {
+            this.launch = (game.config.battle != null);
+            return true;
+        } else if (cancelBtn.hit(x, y)) {
+            this.launch = false;
+            return true;
+        } else {
+            for (int i = 0; i <battleLabels.length; i++) {
+                if (battleLabels[i].hit(x, y)) {
+                    if (game.config.battle == game.factory.battles[i])
+                        game.config.battle = null;
+                    else
+                        game.config.battle = game.factory.battles[i];
+                }
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        title.dispose();
+        okBtn.dispose();
+        cancelBtn.dispose();
+        for (int i = 0; i < battleLabels.length; i++)
+            battleLabels[i].dispose();
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        super.draw(batch);
+        title.draw(batch);
+        okBtn.draw(batch);
+        cancelBtn.draw(batch);
+        for (int i = 0; i < battleLabels.length; i++) {
+            Label l = battleLabels[i];
+            l.draw(batch);
+            if (game.config.battle == game.factory.battles[i])
+                font.draw(batch, CHECK, (l.getX() - HSPACING) , l.getY() + checkDy);
+        }
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/menu/TutorialsMenu.java b/core/src/ch/asynk/rustanddust/menu/TutorialsMenu.java
new file mode 100644
index 0000000..7f54aad
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/menu/TutorialsMenu.java
@@ -0,0 +1,94 @@
+package ch.asynk.rustanddust.menu;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+
+import ch.asynk.rustanddust.ui.Label;
+import ch.asynk.rustanddust.ui.Bg;
+import ch.asynk.rustanddust.ui.Patch;
+import ch.asynk.rustanddust.RustAndDust;
+
+public class TutorialsMenu extends Patch
+{
+    public static int PADDING = 40;
+    public static int OK_PADDING = 10;
+    public static int TITLE_PADDING = 30;
+    public static int VSPACING = 20;
+
+    private final RustAndDust game;
+    private final BitmapFont font;
+
+    private Label title;
+    private Label msg;
+    protected Bg okBtn;
+
+    public TutorialsMenu(RustAndDust game, BitmapFont font, TextureAtlas atlas)
+    {
+        super(atlas.createPatch("typewriter"));
+        this.game = game;
+        this.font = font;
+        this.okBtn = new Bg(atlas.findRegion("ok"));
+        this.title = new Label(font);
+        this.title.write("- Tutorials");
+        this.msg = new Label(font);
+        this.msg.write("Not implemented yet.");
+
+        this.visible = false;
+    }
+
+    public void setPosition()
+    {
+        float h = (title.getHeight() + TITLE_PADDING + (2 * PADDING));
+        h += msg.getHeight();
+
+        float w = title.getWidth();
+        if (msg.getWidth() > w)
+            w = msg.getWidth();
+        w += (2 * PADDING);
+
+        float x = position.getX(w);
+        float y = position.getY(h);
+        setPosition(x, y, w, h);
+
+        okBtn.setPosition((x + w - okBtn.getWidth() + OK_PADDING), (y - OK_PADDING));
+
+        y += PADDING;
+        x += PADDING;
+
+        msg.setPosition(x, y);
+
+        y += (msg.getHeight() + TITLE_PADDING);
+        title.setPosition(x, y);
+    }
+
+    @Override
+    public boolean hit(float x, float y)
+    {
+        if (!visible) return false;
+
+        if (okBtn.hit(x, y))
+            return true;
+
+        return false;
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        title.dispose();
+        msg.dispose();
+        okBtn.dispose();
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        super.draw(batch);
+        title.draw(batch);
+        msg.draw(batch);
+        okBtn.draw(batch);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/screens/GameCamera.java b/core/src/ch/asynk/rustanddust/screens/GameCamera.java
new file mode 100644
index 0000000..0dbcb50
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/screens/GameCamera.java
@@ -0,0 +1,212 @@
+package ch.asynk.rustanddust.screens;
+
+import com.badlogic.gdx.Gdx;
+
+import com.badlogic.gdx.graphics.OrthographicCamera;
+
+import com.badlogic.gdx.math.Rectangle;
+import com.badlogic.gdx.math.Matrix4;
+import com.badlogic.gdx.math.Vector3;
+import com.badlogic.gdx.math.MathUtils;
+
+public class GameCamera extends OrthographicCamera
+{
+    private static final float ZEROF = 0.01f;
+
+    private int screenWidth;
+    private int screenHeight;
+    private float zoomOut;
+    private float zoomIn;
+    private float viewportAspect;
+    private float widthFactor;
+    private float heightFactor;
+    private Rectangle virtual;
+    private Rectangle window;
+    private Rectangle hud;
+    private Matrix4 hudMatrix;
+    private Matrix4 hudInvProjMatrix;
+    private int hudCorrection;
+    private int hudLeft;
+    private int hudBottom;
+    private boolean fixedHud;
+
+    public GameCamera(float virtualWidth, float virtualHeight, float zoomOut, float zoomIn, int hudCorrection, boolean fixedHud)
+    {
+        super(virtualWidth, virtualHeight);
+        this.zoomOut = zoomOut;
+        this.zoomIn = zoomIn;
+        this.viewportAspect = (viewportWidth / viewportHeight);
+        this.virtual = new Rectangle();
+        this.virtual.set(0, 0, virtualWidth, virtualHeight);
+        this.window = new Rectangle();
+        this.hud = new Rectangle();
+        this.hudMatrix = new Matrix4();
+        this.hudInvProjMatrix = new Matrix4();
+        this.hudCorrection = hudCorrection;
+        this.fixedHud = fixedHud;
+    }
+
+    public void updateViewport(int screenWidth, int screenHeight)
+    {
+        this.screenWidth = screenWidth;
+        this.screenHeight = screenHeight;
+
+        float aspect = (screenWidth / (float) screenHeight);
+        float diff = (viewportAspect - aspect);
+
+        if (diff < -ZEROF) {
+            // wider than tall
+            window.width = java.lang.Math.min((screenHeight * viewportAspect / zoom), screenWidth);
+            window.height = screenHeight;
+            window.x = ((screenWidth - window.width) / 2f);
+            window.y = 0f;
+            viewportWidth = (viewportHeight * (window.width / window.height));
+            hud.y = hudCorrection;
+            hud.x = (hud.y * viewportWidth / viewportHeight);
+        } else if (diff > ZEROF) {
+            // taller than wide
+            // FIXME fix hud vertical position
+            window.width = screenWidth;
+            window.height = java.lang.Math.min((screenWidth * viewportAspect / zoom), screenHeight);
+            window.x = 0f;
+            window.y = ((screenHeight - window.height) / 2f);
+            viewportHeight = (viewportWidth * (window.height / window.width));
+            hud.x = hudCorrection;
+            hud.y = (hud.x * viewportHeight / viewportWidth);
+        }
+
+        if (fixedHud) {
+            hud.x = 0;
+            hud.y = 0;
+            hud.width = screenWidth;
+            hud.height = screenHeight;
+        } else {
+            hud.width = (window.width - (2 * hud.x));
+            hud.height = (window.height - (2 * hud.y));
+        }
+
+        widthFactor = (viewportWidth / screenWidth);
+        heightFactor = (viewportHeight / screenHeight);
+
+        clampPosition();
+        update(true);
+        hudMatrix.setToOrtho2D(hud.x, hud.y, hud.width, hud.height);
+        hudInvProjMatrix.set(hudMatrix);
+        Matrix4.inv(hudInvProjMatrix.val);
+    }
+
+    public void applyMapViewport()
+    {
+        Gdx.gl.glViewport((int)window.x, (int)window.y, (int)window.width, (int)window.height);
+    }
+
+    public void applyHudViewport()
+    {
+        if (fixedHud)
+            Gdx.gl.glViewport(0, 0, screenWidth, screenHeight);
+    }
+
+    public Matrix4 getHudMatrix()
+    {
+        return hudMatrix;
+    }
+
+    public int getScreenWidth()
+    {
+        return screenWidth;
+    }
+
+    public int getScreenHeight()
+    {
+        return screenHeight;
+    }
+
+    public int getHudLeft()
+    {
+        return (int) hud.x;
+    }
+
+    public int getHudBottom()
+    {
+        return (int) hud.y;
+    }
+
+    public int getHudWidth()
+    {
+        return (int) hud.width;
+    }
+
+    public int getHudHeight()
+    {
+        return (int) hud.height;
+    }
+
+    public void centerOnWorld()
+    {
+        position.set((viewportWidth / 2f), (viewportHeight / 2f), 0f);
+    }
+
+    public void zoom(float dz)
+    {
+        zoom += dz;
+        clampZoom();
+        updateViewport(screenWidth, screenHeight);
+    }
+
+    public void translate(float dx, float dy)
+    {
+        float deltaX = (dx * zoom * widthFactor);
+        float deltaY = (dy * zoom * heightFactor);
+        translate(deltaX, -deltaY, 0);
+        clampPosition();
+        update(true);
+    }
+
+    public void clampZoom()
+    {
+        zoom = MathUtils.clamp(zoom, zoomIn, zoomOut);
+    }
+
+    public void clampPosition()
+    {
+        float cx = (viewportWidth * zoom);
+        float cy = (viewportHeight * zoom);
+
+        if ((virtual.width - cx) > ZEROF) {
+            cx /= 2f;
+            position.x = MathUtils.clamp(position.x, cx, (virtual.width - cx));
+        } else
+            position.x = (virtual.width / 2f);
+
+        if ((virtual.height - cy) > ZEROF) {
+            cy /= 2f;
+            position.y = MathUtils.clamp(position.y, cy, (virtual.height - cy));
+        } else
+            position.y = (virtual.height / 2f);
+    }
+
+    public void debug()
+    {
+        System.err.println(String.format(" VIEWPORT: %dx%d * %.2f -> %dx%d", (int)viewportWidth, (int)viewportHeight,
+                zoom, (int)(viewportWidth * zoom), (int)(viewportHeight * zoom)));
+        System.err.println(String.format("   WINDOW: %d;%d %dx%d", (int)window.x, (int)window.y, (int)window.width, (int)window.height));
+        System.err.println("MATRIX:" + combined.toString());
+    }
+
+    public void unproject(int x, int y, Vector3 v)
+    {
+        unproject(v.set(x, y, 0), window.x, window.y, window.width, window.height);
+    }
+
+    public void unprojectHud(float x, float y, Vector3 v)
+    {
+        Rectangle r = (fixedHud ? hud : window);
+        x = x - r.x;
+        y = Gdx.graphics.getHeight() - y - 1;
+        y = y - r.y;
+        v.x = (2 * x) / r.width - 1;
+        v.y = (2 * y) / r.height - 1;
+        v.z = 2 * v.z - 1;
+        v.prj(hudInvProjMatrix);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/screens/GameScreen.java b/core/src/ch/asynk/rustanddust/screens/GameScreen.java
new file mode 100644
index 0000000..c369989
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/screens/GameScreen.java
@@ -0,0 +1,221 @@
+package ch.asynk.rustanddust.screens;
+
+import com.badlogic.gdx.Gdx;
+
+import com.badlogic.gdx.Screen;
+import com.badlogic.gdx.Input;
+import com.badlogic.gdx.InputAdapter;
+import com.badlogic.gdx.InputMultiplexer;
+import com.badlogic.gdx.input.GestureDetector;
+import com.badlogic.gdx.input.GestureDetector.GestureAdapter;
+
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import com.badlogic.gdx.math.Vector2;
+
+import ch.asynk.rustanddust.RustAndDust;
+
+import ch.asynk.rustanddust.game.Ctrl;
+
+public class GameScreen implements Screen
+{
+    private static boolean DEBUG = false;
+
+    private static final boolean FIXED_HUD = true;
+    private static final float INPUT_DELAY = 0.1f;
+    private static final float ZOOM_IN_MAX = 0.3f;
+    private static final float ZOOM_OUT_MAX = 1f;
+    private static final float ZOOM_GESTURE_FACTOR = .01f;
+    private static final float ZOOM_SCROLL_FACTOR = .1f;
+    private static final int DRAGGED_Z_INDEX = 10;
+    private static final int DRAG_THRESHOLD = 6;
+
+    private final GameCamera cam;
+
+    private final SpriteBatch batch;
+    private ShapeRenderer debugShapes = null;
+
+    private final RustAndDust game;
+    private Ctrl ctrl;
+
+    private int dragged;
+    private boolean blocked;
+    private float inputDelay = 0f;
+    private Vector2 dragPos = new Vector2();
+
+    public GameScreen(final RustAndDust game)
+    {
+        DEBUG = game.config.debug;
+
+        this.game = game;
+        this.dragged = 0;
+        this.blocked = false;
+
+        this.batch = new SpriteBatch();
+        this.ctrl = new Ctrl(game, game.config.battle);
+        this.cam = new GameCamera(ctrl.map.getWidth(),  ctrl.map.getHeight(), ZOOM_OUT_MAX, ZOOM_IN_MAX, game.hudCorrection, FIXED_HUD);
+
+        if (DEBUG) this.debugShapes = new ShapeRenderer();
+
+        Gdx.input.setInputProcessor(getMultiplexer());
+    }
+
+
+    private InputMultiplexer getMultiplexer()
+    {
+        final InputMultiplexer multiplexer = new InputMultiplexer();
+        multiplexer.addProcessor(new GestureDetector(new GestureAdapter() {
+            @Override
+            public boolean zoom(float initialDistance, float distance)
+            {
+                if (initialDistance > distance)
+                    cam.zoom(ZOOM_GESTURE_FACTOR);
+                else
+                    cam.zoom(-ZOOM_GESTURE_FACTOR);
+                ctrl.hud.resize(cam.getHudLeft(), cam.getHudBottom(), cam.getHudWidth(), cam.getHudHeight());
+                blocked = true;
+                inputDelay = INPUT_DELAY;
+                return true;
+            }
+        }));
+        multiplexer.addProcessor(new InputAdapter() {
+            @Override
+            public boolean touchDragged(int x, int y, int pointer)
+            {
+                dragged += 1;
+                cam.translate((dragPos.x - x), (dragPos.y - y));
+                dragPos.set(x, y);
+                return true;
+            }
+            @Override
+            public boolean touchDown(int x, int y, int pointer, int button)
+            {
+                if (blocked) return true;
+                if (button == Input.Buttons.LEFT) {
+                    dragPos.set(x, y);
+                    cam.unproject(x, y, ctrl.mapTouch);
+                    cam.unprojectHud(x, y, ctrl.hudTouch);
+                    ctrl.touchDown();
+                }
+                return true;
+            }
+            @Override
+            public boolean touchUp(int x, int y, int pointer, int button)
+            {
+                if (blocked) return true;
+                if (dragged > DRAG_THRESHOLD) {
+                    dragged = 0;
+                    return true;
+                }
+                dragged = 0;
+                if (button == Input.Buttons.LEFT) {
+                    cam.unproject(x, y, ctrl.mapTouch);
+                    cam.unprojectHud(x, y, ctrl.hudTouch);
+                    ctrl.touchUp();
+                }
+                return true;
+            }
+            @Override
+            public boolean scrolled(int amount)
+            {
+                cam.zoom(amount * ZOOM_SCROLL_FACTOR);
+                ctrl.hud.resize(cam.getHudLeft(), cam.getHudBottom(), cam.getHudWidth(), cam.getHudHeight());
+                return true;
+            }
+        });
+
+        return multiplexer;
+    }
+
+    @Override
+    public void render(float delta)
+    {
+        if (inputDelay > 0f) {
+            inputDelay -= delta;
+            if (inputDelay <= 0f)
+                blocked = false;
+        }
+
+        ctrl.hud.animate(delta);
+        ctrl.map.animate(delta);
+
+        Gdx.gl.glClearColor(0, 0, 0, 1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+
+        // cam.update();
+        cam.applyMapViewport();
+        batch.setProjectionMatrix(cam.combined);
+        batch.begin();
+        ctrl.map.draw(batch);
+        batch.end();
+
+
+        if (DEBUG) {
+            Gdx.gl.glEnable(GL20.GL_BLEND);
+            debugShapes.setAutoShapeType(true);
+            debugShapes.setProjectionMatrix(cam.combined);
+            debugShapes.begin();
+            ctrl.map.drawDebug(debugShapes);
+            debugShapes.end();
+        }
+
+        cam.applyHudViewport();
+        batch.setProjectionMatrix(cam.getHudMatrix());
+        batch.begin();
+        ctrl.hud.draw(batch, DEBUG);
+        batch.end();
+
+        if (DEBUG) {
+            Gdx.gl.glEnable(GL20.GL_BLEND);
+            debugShapes.setAutoShapeType(true);
+            debugShapes.setProjectionMatrix(cam.getHudMatrix());
+            debugShapes.begin();
+            debugShapes.rect(cam.getHudLeft(), cam.getHudBottom(), cam.getHudWidth(), cam.getHudHeight());
+            ctrl.hud.drawDebug(debugShapes);
+            debugShapes.end();
+        }
+    }
+
+    @Override
+    public void resize(int width, int height)
+    {
+        // RustAndDust.debug("GameScreen", "resize (" + width + "," + height + ")");
+        cam.updateViewport(width, height);
+        ctrl.hud.resize(cam.getHudLeft(), cam.getHudBottom(), cam.getHudWidth(), cam.getHudHeight());
+    }
+
+    @Override
+    public void dispose()
+    {
+        // RustAndDust.debug("GameScreen", "dispose()");
+        batch.dispose();
+        ctrl.dispose();
+        if (DEBUG) debugShapes.dispose();
+    }
+
+    @Override
+    public void show()
+    {
+        // RustAndDust.debug("GameScreen", "show()");
+    }
+
+    @Override
+    public void hide()
+    {
+        // RustAndDust.debug("GameScreen", "hide()");
+    }
+
+    @Override
+    public void pause()
+    {
+        // RustAndDust.debug("GameScreen", "pause()");
+    }
+
+    @Override
+    public void resume()
+    {
+        // RustAndDust.debug("GameScreen", "resume()");
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/screens/MenuCamera.java b/core/src/ch/asynk/rustanddust/screens/MenuCamera.java
new file mode 100644
index 0000000..be8341a
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/screens/MenuCamera.java
@@ -0,0 +1,112 @@
+package ch.asynk.rustanddust.screens;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.OrthographicCamera;
+import com.badlogic.gdx.math.Vector3;
+import com.badlogic.gdx.math.Matrix4;
+import com.badlogic.gdx.math.Rectangle;
+
+public class MenuCamera extends OrthographicCamera
+{
+    private static final float ZEROF = 0.01f;
+
+    private float virtualAspect;
+    private final Rectangle virtual;
+    private final Rectangle window;
+    private int hudLeft;
+    private int hudBottom;
+    private int hudCorrection;
+
+    private Matrix4 uiMatrix;
+    private Matrix4 uiInvProjMatrix;
+
+    public MenuCamera(int cx, int cy, int width, int height, int hudCorrection)
+    {
+        super(width, height);
+        this.virtual = new Rectangle();
+        this.virtual.set(cx, cy, width, height);
+        this.virtualAspect = (virtual.width / virtual.height);
+        this.window = new Rectangle();
+        this.window.set(0, 0, 0, 0);
+        this.position.set(virtual.x, virtual.y, 0f);
+        this.hudLeft = 0;
+        this.hudBottom = 0;
+        this.hudCorrection = hudCorrection;
+
+        this.uiMatrix = new Matrix4();
+        this.uiInvProjMatrix = new Matrix4();
+    }
+
+    public void updateViewport(int screenWidth, int screenHeight)
+    {
+        float aspect = (screenWidth / (float) screenHeight);
+        float diff = (virtualAspect - aspect);
+
+        if (diff < -ZEROF) {
+            viewportWidth = (virtual.height * aspect);
+            viewportHeight = virtual.height;
+        } else if (diff > ZEROF) {
+            viewportWidth = virtual.width;
+            viewportHeight = (virtual.width / aspect);
+        }
+
+        window.width = screenWidth;
+        window.height = screenHeight;
+        hudLeft = hudCorrection;
+        hudBottom = (int) (hudLeft / aspect);
+
+        Gdx.gl.glViewport((int)window.x, (int)window.y, (int)window.width, (int)window.height);
+
+        update(true);
+
+        uiMatrix.setToOrtho2D(getHudLeft(), getHudBottom(), getHudWidth(), getHudHeight());
+        uiInvProjMatrix.set(uiMatrix);
+        Matrix4.inv(uiInvProjMatrix.val);
+    }
+
+    public float getScreenWidth()
+    {
+        return window.width;
+    }
+
+    public float getScreenHeight()
+    {
+        return window.height;
+    }
+
+    public int getHudLeft()
+    {
+        return hudLeft;
+    }
+
+    public int getHudBottom()
+    {
+        return hudBottom;
+    }
+
+    public int getHudWidth()
+    {
+        return (int) window.width - (2 * getHudLeft());
+    }
+
+    public int getHudHeight()
+    {
+        return (int) window.height - (2 * getHudBottom());
+    }
+
+    public void uiUnproject(float x, float y, Vector3 v)
+    {
+        x = x - window.x;
+        y = Gdx.graphics.getHeight() - y - 1;
+        y = y - window.y;
+        v.x = (2 * x) / window.width - 1;
+        v.y = (2 * y) / window.height - 1;
+        v.z = 2 * v.z - 1;
+        v.prj(uiInvProjMatrix);
+    }
+
+    public Matrix4 uiCombined()
+    {
+        return uiMatrix;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/screens/MenuScreen.java b/core/src/ch/asynk/rustanddust/screens/MenuScreen.java
new file mode 100644
index 0000000..0ca8a63
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/screens/MenuScreen.java
@@ -0,0 +1,258 @@
+package ch.asynk.rustanddust.screens;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Screen;
+import com.badlogic.gdx.InputAdapter;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.math.Vector3;
+import com.badlogic.gdx.math.Interpolation;
+
+import ch.asynk.rustanddust.RustAndDust;
+import ch.asynk.rustanddust.ui.Position;
+import ch.asynk.rustanddust.menu.MainMenu;
+import ch.asynk.rustanddust.menu.OptionsMenu;
+import ch.asynk.rustanddust.menu.ScenariosMenu;
+import ch.asynk.rustanddust.menu.TutorialsMenu;
+
+public class MenuScreen implements Screen
+{
+    private final RustAndDust game;
+
+    private final int OFFSET = 20;
+    private final int V_WIDTH = 1600;
+    private final int V_HEIGHT = 1125;
+    private final int V_CENTER_X = 1000;
+    private final int V_CENTER_Y = 890;
+
+    private float percent;
+    private float delay = 0.0f;
+    private float dx;
+    private float dy;
+    private int[] xPath = { 369, 558, 747, 936, 1125, 1030, 936, 1125, 1314, 1408, 1597};
+    private int[] yPath = { 565, 565, 565, 565,  565,  729, 892,  892,  892, 1056, 1056};
+    private int n = xPath.length;
+
+    private boolean ready;
+    private boolean gameAssetsLoading;
+    private Texture bg;
+
+    private Sprite unit;
+    private Sprite move;
+    private Sprite from;
+    private Sprite to;
+    private Sprite geFlag;
+    private Sprite usFlag;
+
+    private MainMenu mainMenu;
+    private OptionsMenu optionsMenu;
+    private ScenariosMenu scenariosMenu;
+    private TutorialsMenu tutorialsMenu;
+
+    private final MenuCamera camera;
+    private final SpriteBatch batch;
+    private Vector3 touch = new Vector3();
+
+    public MenuScreen(final RustAndDust game)
+    {
+        this.game = game;
+        this.batch = new SpriteBatch();
+
+        float width = Gdx.graphics.getWidth();
+        float height = Gdx.graphics.getHeight();
+
+        this.camera = new MenuCamera(V_CENTER_X, V_CENTER_Y, V_WIDTH, V_HEIGHT, game.hudCorrection);
+
+        this.gameAssetsLoading = false;
+
+        this.bg = game.manager.get("data/map_a.png", Texture.class);
+
+        this.unit = new Sprite(game.menuAtlas.findRegion("unit"));
+        this.move = new Sprite(game.menuAtlas.findRegion("move"));
+        this.from = new Sprite(game.menuAtlas.findRegion("from"));
+        this.to = new Sprite(game.menuAtlas.findRegion("to"));
+        this.usFlag = new Sprite(game.menuAtlas.findRegion("us-flag"));
+        this.geFlag = new Sprite(game.menuAtlas.findRegion("ge-flag"));
+
+        this.mainMenu = new MainMenu(game.fontB, game.uiAtlas);
+        this.optionsMenu = new OptionsMenu(game, game.fontB, game.uiAtlas);
+        this.scenariosMenu = new ScenariosMenu(game, game.fontB, game.uiAtlas);
+        this.tutorialsMenu = new TutorialsMenu(game, game.fontB, game.uiAtlas);
+
+        this.game.config.battle = null;
+
+        Gdx.input.setInputProcessor(new InputAdapter() {
+            @Override
+            public boolean touchDown(int x, int y, int pointer, int button)
+            {
+                camera.uiUnproject(x, y, touch);
+                return hit(touch.x, touch.y);
+            }
+        });
+    }
+
+    private boolean hit(float x, float y)
+    {
+        if (mainMenu.hit(x, y)) {
+            mainMenu.visible = false;
+            showNextMenu();
+            return true;
+        } else if (optionsMenu.hit(x, y)) {
+            mainMenu.visible = true;
+            optionsMenu.visible = false;
+            return true;
+        } else if (scenariosMenu.hit(x, y)) {
+            mainMenu.visible = true;
+            scenariosMenu.visible = false;
+            if (scenariosMenu.launch)
+                startLoading();
+            return true;
+        } else if (tutorialsMenu.hit(x, y)) {
+            mainMenu.visible = true;
+            tutorialsMenu.visible = false;
+            return true;
+        }
+
+        return false;
+    }
+
+    private void showNextMenu()
+    {
+        MainMenu.Items item = mainMenu.getMenu();
+
+        if (item == MainMenu.Items.OPTIONS)
+            optionsMenu.visible = true;
+        else if (item == MainMenu.Items.SCENARIOS)
+            scenariosMenu.visible = true;
+        else if (item == MainMenu.Items.TUTORIALS)
+            tutorialsMenu.visible = true;
+    }
+
+    private void startLoading()
+    {
+        mainMenu.visible = false;
+        game.loadGameAssets();
+        gameAssetsLoading = true;
+    }
+
+    private void gameAssetsLoadingCompleted()
+    {
+        RustAndDust.debug("LoadScreen", "assets ready : " + (Gdx.app.getJavaHeap()/1024.0f) + "KB");
+        game.switchToGame();
+        dispose();
+    }
+
+    @Override
+    public void render(float delta)
+    {
+        float x = xPath[0];
+        float y = yPath[0];
+        if (gameAssetsLoading) {
+            if (game.manager.update()) {
+                delay += delta;
+                if (delay >= 0.6f)
+                    gameAssetsLoadingCompleted();
+            }
+
+            percent = Interpolation.linear.apply(percent, game.manager.getProgress(), 0.1f);
+            int idx = (int) (percent * 10);
+            float fraction = ((percent * 100 ) % 10 / 10);
+            x = (xPath[idx] + ((xPath[idx + 1] - xPath[idx]) * fraction));
+            y = (yPath[idx] + ((yPath[idx + 1] - yPath[idx]) * fraction));
+        }
+
+        Gdx.gl.glClearColor(0, 0, 0, 1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+
+        batch.setProjectionMatrix(camera.combined);
+        batch.begin();
+        batch.draw(bg, 0, 0);
+        from.draw(batch);
+        to.draw(batch);
+        usFlag.draw(batch);
+        geFlag.draw(batch);
+        for (int i = 1; i < (n - 1); i++)
+            drawCentered(batch, move, xPath[i], yPath[i]);
+        drawCentered(batch, unit, (int) (x + dx), (int) (y + dy));
+        batch.end();
+
+        batch.setProjectionMatrix(camera.uiCombined());
+        batch.begin();
+        mainMenu.draw(batch);
+        optionsMenu.draw(batch);
+        scenariosMenu.draw(batch);
+        tutorialsMenu.draw(batch);
+        batch.end();
+    }
+
+    private void drawCentered(SpriteBatch batch, TextureRegion region, int x, int y)
+    {
+        batch.draw(region, (x - (region.getRegionWidth() / 2f)), (y - (region.getRegionHeight() / 2f)));
+    }
+
+    private void setCenteredPosition(Sprite sprite, int x, int y)
+    {
+        sprite.setPosition((x - (sprite.getWidth() / 2f)), (y - (sprite.getHeight() / 2f)));
+    }
+
+    private void update(int width, int height)
+    {
+        camera.updateViewport(width, height);
+        Position.update(camera.getHudLeft(), camera.getHudBottom(), camera.getHudWidth(), camera.getHudHeight());
+
+        setCenteredPosition(from, xPath[0], yPath[0]);
+        setCenteredPosition(to, xPath[n - 1], yPath[n - 1]);
+        setCenteredPosition(usFlag, xPath[0], yPath[0]);
+        setCenteredPosition(geFlag, xPath[n - 1], yPath[n - 1]);
+
+        mainMenu.setPosition();
+        optionsMenu.setPosition();
+        scenariosMenu.setPosition();
+        tutorialsMenu.setPosition();
+    }
+
+    @Override
+    public void resize(int width, int height)
+    {
+        update(width, height);
+    }
+
+    @Override
+    public void dispose()
+    {
+        mainMenu.dispose();
+        optionsMenu.dispose();
+        scenariosMenu.dispose();
+        tutorialsMenu.dispose();
+    }
+
+    @Override
+    public void show()
+    {
+        int width = (int) Gdx.graphics.getWidth();
+        int height = (int) Gdx.graphics.getHeight();
+        update(width, height);
+    }
+
+    @Override
+    public void hide()
+    {
+        // RustAndDust.debug("MenuScreen", "hide()");
+    }
+
+    @Override
+    public void pause()
+    {
+        // RustAndDust.debug("MenuScreen", "pause()");
+    }
+
+    @Override
+    public void resume()
+    {
+        // RustAndDust.debug("MenuScreen", "resume()");
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/Bg.java b/core/src/ch/asynk/rustanddust/ui/Bg.java
new file mode 100644
index 0000000..cac3ddc
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/Bg.java
@@ -0,0 +1,28 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+
+public class Bg extends Widget
+{
+    private TextureRegion region;
+
+    public Bg(TextureRegion region)
+    {
+        super();
+        this.region = region;
+        setPosition(0, 0, region.getRegionWidth(), region.getRegionHeight());
+    }
+
+    @Override
+    public void dispose()
+    {
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        batch.draw(region, rect.x, rect.y, rect.width, rect.height);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/Label.java b/core/src/ch/asynk/rustanddust/ui/Label.java
new file mode 100644
index 0000000..6a6d809
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/Label.java
@@ -0,0 +1,72 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.GlyphLayout;
+
+public class Label extends Widget
+{
+    private BitmapFont font;
+    private GlyphLayout layout;
+    private float dx;
+    private float dy;
+    protected String text;
+
+    public Label(BitmapFont font)
+    {
+        this(font, 0f);
+    }
+
+    public Label(BitmapFont font, float padding)
+    {
+        this(font, padding, Position.MIDDLE_CENTER);
+    }
+
+    public Label(BitmapFont font, float padding, Position position)
+    {
+        super();
+        this.font = font;
+        this.padding = padding;
+        this.position = position;
+        this.layout = new GlyphLayout();
+    }
+
+    @Override
+    public void dispose()
+    {
+    }
+
+    @Override
+    public void translate(float dx, float dy)
+    {
+        setPosition((rect.x + dx), (rect.y + dy));
+    }
+
+    @Override
+    public void setPosition(float x, float y)
+    {
+        this.layout.setText(font, (text == null) ? "" : text);
+        setPosition(x, y, (layout.width + (2 * padding)), (layout.height + (2 * padding)));
+        this.dx = (x + padding);
+        this.dy = (y + padding + layout.height);
+    }
+
+    public void write(String text)
+    {
+        this.text = text;
+        setPosition(position);
+    }
+
+    public void write(String text, float x, float y)
+    {
+        this.text = text;
+        setPosition(x, y);
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        font.draw(batch, layout, dx, dy);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/LabelImage.java b/core/src/ch/asynk/rustanddust/ui/LabelImage.java
new file mode 100644
index 0000000..0fb6ecb
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/LabelImage.java
@@ -0,0 +1,72 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+public class LabelImage extends Bg
+{
+    private Label label;
+
+    public LabelImage(TextureRegion region, BitmapFont font)
+    {
+        this(region, font, 0f);
+    }
+
+    public LabelImage(TextureRegion region, BitmapFont font, float padding)
+    {
+        this(region, font, padding, Position.MIDDLE_CENTER);
+    }
+
+    public LabelImage(TextureRegion region, BitmapFont font, float padding, Position position)
+    {
+        super(region);
+        this.label = new Label(font, padding, position);
+    }
+
+    @Override
+    public void dispose()
+    {
+        label.dispose();
+    }
+
+    @Override
+    public void translate(float dx, float dy)
+    {
+        super.translate(dx, dy);
+        label.translate(dx, dy);
+    }
+
+    public void setPosition(float x, float y)
+    {
+        super.setPosition(x, y);
+        label.setPosition(x, y);
+    }
+
+    public void setLabelPosition(Position position)
+    {
+        label.setPosition(position, this);
+    }
+
+    public void write(String text)
+    {
+        this.label.write(text);
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        super.draw(batch);
+        label.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        if (!visible) return;
+        super.drawDebug(shapes);
+        label.drawDebug(shapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/LabelStack.java b/core/src/ch/asynk/rustanddust/ui/LabelStack.java
new file mode 100644
index 0000000..92933e3
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/LabelStack.java
@@ -0,0 +1,72 @@
+package ch.asynk.rustanddust.ui;
+
+import java.util.ArrayDeque;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+
+import ch.asynk.rustanddust.engine.gfx.Animation;
+
+public class LabelStack extends Label implements Animation
+{
+    class MsgInfo
+    {
+        String text;
+        float duration;
+        Position position;
+        MsgInfo(String text, float duration, Position position)
+        {
+            this.text = text;
+            this.duration = duration;
+            this.position = position;
+        }
+    }
+
+    private float duration;
+    private float elapsed;
+    private ArrayDeque<MsgInfo> stack;
+
+    public LabelStack(BitmapFont font, float padding)
+    {
+        super(font, padding);
+        this.visible = false;
+        this.stack = new ArrayDeque<MsgInfo>();
+    }
+
+    public void pushWrite(String text, float duration, Position position)
+    {
+        if (visible)
+            stack.push(new MsgInfo(text, duration, position));
+        else
+            write(text, duration, position);
+    }
+
+    public void write(String text, float duration, Position position)
+    {
+        this.position = position;
+        write(text, duration);
+    }
+
+    public void write(String text, float duration)
+    {
+        this.duration = duration;
+        this.visible = true;
+        this.elapsed = 0f;
+        write(text);
+    }
+
+    @Override
+    public boolean animate(float delta)
+    {
+        if (!visible) return true;
+        elapsed += delta;
+        if (elapsed >= duration) {
+           visible = false;
+           if (stack.size() > 0) {
+               MsgInfo info = stack.pop();
+               write(info.text, info.duration, info.position);
+           }
+        }
+        return false;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/Menu.java b/core/src/ch/asynk/rustanddust/ui/Menu.java
new file mode 100644
index 0000000..2fe93a7
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/Menu.java
@@ -0,0 +1,93 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.NinePatch;
+
+public class Menu extends Patch
+{
+    public static int PADDING = 40;
+    public static int VSPACING = 8;
+
+    protected Label []labels;
+
+    public interface MenuItem
+    {
+        public int last();
+        public int i();
+    };
+
+    protected MenuItem menuItem;
+
+    public Menu(MenuItem menuItem, BitmapFont font, NinePatch ninePatch)
+    {
+        super(ninePatch);
+        this.menuItem = menuItem;
+        this.labels = new Label[menuItem.last()];
+        for (int i = 0; i< menuItem.last(); i ++)
+            labels[i] = new Label(font, 10);
+    }
+
+    protected Label label(MenuItem m)
+    {
+        return labels[m.i()];
+    }
+
+    protected float widestLabel()
+    {
+        float w = 0f;
+        for (int i = 0; i< menuItem.last(); i ++) {
+            float t = labels[i].getWidth();
+            if (t> w)
+                w = t;
+        }
+        return w;
+    }
+
+    protected float highestLabel()
+    {
+        float h = 0f;
+        for (int i = 0; i< menuItem.last(); i ++) {
+            float t = labels[i].getHeight();
+            if (t> h)
+                h = t;
+        }
+        return h;
+    }
+
+    public void setPosition()
+    {
+        float lh = highestLabel();
+        float h = ((menuItem.last() * lh) + (2 * PADDING) + ((menuItem.last() - 1) * VSPACING));
+        float w = (widestLabel() + (2 * PADDING));
+        float x = position.getX(w);
+        float y = position.getY(h);
+        setPosition(x, y, w, h);
+
+        y += PADDING;
+        x += PADDING;
+        float dy = (VSPACING + lh);
+
+        for (int i = 0; i< menuItem.last(); i ++) {
+            labels[i].setPosition(x, y);
+            y += dy;
+        }
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        for (int i = 0; i < menuItem.last(); i ++)
+            labels[i].dispose();
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        super.draw(batch);
+        for (int i = 0; i < menuItem.last(); i ++)
+            labels[i].draw(batch);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/Msg.java b/core/src/ch/asynk/rustanddust/ui/Msg.java
new file mode 100644
index 0000000..e1e7c13
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/Msg.java
@@ -0,0 +1,79 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+public class Msg extends Patch
+{
+    private LabelStack label;
+
+    public Msg(BitmapFont font, TextureAtlas atlas)
+    {
+        super(atlas.createPatch("typewriter"));
+        label = new LabelStack(font, 20f);
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        label.dispose();
+    }
+
+    public void updatePosition()
+    {
+        if (!visible) return;
+        float dx = (position.getX(rect.width) - rect.x);
+        float dy = (position.getY(rect.height) - rect.y);
+        translate(dx, dy);
+        label.translate(dx, dy);
+    }
+
+    public void write(String text, float duration)
+    {
+        label.write(text, duration);
+        resize();
+    }
+
+    public void write(String text, float duration, Position position)
+    {
+        this.position = position;
+        label.write(text, duration, position);
+        resize();
+    }
+
+    public void pushWrite(String text, float duration, Position position)
+    {
+        this.position = position;
+        label.pushWrite(text, duration, position);
+        resize();
+    }
+
+    private void resize()
+    {
+        setPosition(label.getX(), label.getY(), label.getWidth(), label.getHeight());
+    }
+
+    public boolean animate(float delta)
+    {
+        return label.animate(delta);
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!label.visible) return;
+        super.draw(batch);
+        label.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        if (!label.visible) return;
+        super.drawDebug(shapes);
+        label.drawDebug(shapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/OkCancel.java b/core/src/ch/asynk/rustanddust/ui/OkCancel.java
new file mode 100644
index 0000000..f30a65b
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/OkCancel.java
@@ -0,0 +1,115 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+public class OkCancel extends Patch
+{
+    public static int PADDING = 20;
+    public static int VSPACING = 10;
+    public static int HSPACING = 10;
+
+    public boolean ok;
+    protected Label label;
+    protected Bg okBtn;
+    protected Bg cancelBtn;
+
+    public OkCancel(BitmapFont font, TextureAtlas atlas)
+    {
+        super(atlas.createPatch("typewriter"));
+        this.label = new Label(font);
+        this.okBtn = new Bg(atlas.findRegion("ok"));
+        this.cancelBtn = new Bg(atlas.findRegion("cancel"));
+        this.visible = false;
+    }
+
+    public void updatePosition()
+    {
+        if (!visible) return;
+        float dx = (position.getX(rect.width) - rect.x);
+        float dy = (position.getY(rect.height) - rect.y);
+        translate(dx, dy);
+        label.translate(dx, dy);
+        okBtn.translate(dx, dy);
+        cancelBtn.translate(dx, dy);
+    }
+
+    public void show(String msg)
+    {
+        show(msg, Position.MIDDLE_CENTER);
+    }
+
+    public void show(String msg, Position position)
+    {
+        label.write(msg);
+
+        float height = (label.getHeight() + okBtn.getHeight() + (2 * PADDING) + (2 * VSPACING));
+        float width = (label.getWidth() + (2 * PADDING));
+        float w2 = (okBtn.getWidth() + cancelBtn.getWidth() + (2 * PADDING) + (1 * HSPACING));
+        if (w2 > width)
+            width = w2;
+        float x = position.getX(width);
+        float y = position.getY(height);
+        setPosition(x, y, width, height);
+
+        okBtn.setPosition((x + width - okBtn.getWidth() - PADDING), (y + PADDING));
+        cancelBtn.setPosition((x + PADDING), okBtn.getY());
+        label.setPosition((x + PADDING), (y + PADDING + okBtn.getHeight() + VSPACING));
+        cancelBtn.visible = true;
+        visible = true;
+        ok = false;
+    }
+
+    public void noCancel()
+    {
+        cancelBtn.visible = false;
+    }
+
+    @Override
+    public boolean hit(float x, float y)
+    {
+        if (!cancelBtn.visible && super.hit(x, y)) {
+            ok = true;
+            return true;
+        }
+        if (okBtn.hit(x, y)) {
+            ok = true;
+            return true;
+        } else if (cancelBtn.hit(x, y)) {
+            ok = false;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void dispose()
+    {
+        super.dispose();
+        label.dispose();
+        okBtn.dispose();
+        cancelBtn.dispose();
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        super.draw(batch);
+        label.draw(batch);
+        okBtn.draw(batch);
+        cancelBtn.draw(batch);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        if (!visible) return;
+        super.drawDebug(shapes);
+        label.drawDebug(shapes);
+        okBtn.drawDebug(shapes);
+        cancelBtn.drawDebug(shapes);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/Patch.java b/core/src/ch/asynk/rustanddust/ui/Patch.java
new file mode 100644
index 0000000..acff791
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/Patch.java
@@ -0,0 +1,28 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.NinePatch;
+
+public class Patch extends Widget
+{
+    private NinePatch patch;
+
+    public Patch(NinePatch patch)
+    {
+        super();
+        this.patch = patch;
+        setPosition(0, 0, patch.getTotalWidth(), patch.getTotalHeight());
+    }
+
+    @Override
+    public void dispose()
+    {
+    }
+
+    @Override
+    public void draw(Batch batch)
+    {
+        if (!visible) return;
+        patch.draw(batch, rect.x, rect.y, rect.width, rect.height);
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/Position.java b/core/src/ch/asynk/rustanddust/ui/Position.java
new file mode 100644
index 0000000..d8c6096
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/Position.java
@@ -0,0 +1,239 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.Gdx;
+import ch.asynk.rustanddust.game.Hud;
+
+public enum Position
+{
+    TOP_LEFT,
+    TOP_RIGHT,
+    TOP_CENTER,
+    MIDDLE_LEFT,
+    MIDDLE_RIGHT,
+    MIDDLE_CENTER,
+    BOTTOM_LEFT,
+    BOTTOM_RIGHT,
+    BOTTOM_CENTER;
+
+    public Position verticalMirror()
+    {
+        Position p = this;
+        switch(this) {
+            case TOP_LEFT:
+                p = TOP_RIGHT;
+                break;
+            case MIDDLE_LEFT:
+                p = MIDDLE_RIGHT;
+                break;
+            case BOTTOM_LEFT:
+                p = BOTTOM_RIGHT;
+                break;
+            case TOP_RIGHT:
+                p = TOP_LEFT;
+                break;
+            case MIDDLE_RIGHT:
+                p = MIDDLE_LEFT;
+                break;
+            case BOTTOM_RIGHT:
+                p = BOTTOM_LEFT;
+                break;
+        }
+        return p;
+    }
+
+    public Position horizontalMirror()
+    {
+        Position p = this;
+        switch(this) {
+            case TOP_LEFT:
+                p = BOTTOM_LEFT;
+                break;
+            case TOP_CENTER:
+                p = BOTTOM_CENTER;
+                break;
+            case TOP_RIGHT:
+                p = BOTTOM_RIGHT;
+                break;
+            case BOTTOM_LEFT:
+                p = TOP_LEFT;
+                break;
+            case BOTTOM_CENTER:
+                p = TOP_CENTER;
+                break;
+            case BOTTOM_RIGHT:
+                p = TOP_RIGHT;
+                break;
+        }
+        return p;
+    }
+
+    public boolean isLeft()
+    {
+        boolean r = false;
+        switch(this) {
+            case TOP_LEFT:
+            case MIDDLE_LEFT:
+            case BOTTOM_LEFT:
+                r = true;
+                break;
+            default:
+                r = false;
+                break;
+        }
+        return r;
+    }
+
+    public boolean isRight()
+    {
+        boolean r = false;
+        switch(this) {
+            case TOP_RIGHT:
+            case MIDDLE_RIGHT:
+            case BOTTOM_RIGHT:
+                r = true;
+                break;
+            default:
+                r = false;
+                break;
+        }
+        return r;
+    }
+
+    public boolean isCenter()
+    {
+        boolean r = false;
+        switch(this) {
+            case TOP_CENTER:
+            case MIDDLE_CENTER:
+            case BOTTOM_CENTER:
+                r = true;
+                break;
+            default:
+                r = false;
+                break;
+        }
+        return r;
+    }
+
+    private static int hudLeft = 0;
+    private static int hudBottom = 0;
+    private static int hudWidth = Gdx.graphics.getWidth();
+    private static int hudHeight = Gdx.graphics.getHeight();
+
+    public static void update(int width, int height)
+    {
+        update(0, 0, width, height);
+    }
+
+    public static void update(int left, int bottom, int width, int height)
+    {
+        hudLeft = left;
+        hudBottom = bottom;
+        hudWidth = width;
+        hudHeight = height;
+    }
+
+    public float getX(float width)
+    {
+        float x = hudLeft;
+        switch(this) {
+            case TOP_LEFT:
+            case MIDDLE_LEFT:
+            case BOTTOM_LEFT:
+                x += Hud.OFFSET;
+                break;
+            case TOP_CENTER:
+            case MIDDLE_CENTER:
+            case BOTTOM_CENTER:
+                x += ((hudWidth - width) / 2);
+                break;
+            case TOP_RIGHT:
+            case MIDDLE_RIGHT:
+            case BOTTOM_RIGHT:
+                x += (hudWidth - width - Hud.OFFSET);
+                break;
+            default:
+                x += ((hudWidth - width) / 2);
+                break;
+        }
+        return x;
+    }
+
+    public float getY(float height)
+    {
+        float y = hudBottom;
+        switch(this) {
+            case TOP_LEFT:
+            case TOP_CENTER:
+            case TOP_RIGHT:
+                y += (hudHeight - height - Hud.OFFSET);
+                break;
+            case MIDDLE_LEFT:
+            case MIDDLE_CENTER:
+            case MIDDLE_RIGHT:
+                y += ((hudHeight - height) / 2);
+                break;
+            case BOTTOM_LEFT:
+            case BOTTOM_CENTER:
+            case BOTTOM_RIGHT:
+                y += Hud.OFFSET;
+                break;
+            default:
+                y += ((hudHeight - height) / 2);
+                break;
+        }
+        return y;
+    }
+
+    public float getX(Widget widget, float width)
+    {
+        float x = 0;
+        switch(this) {
+            case TOP_LEFT:
+            case MIDDLE_LEFT:
+            case BOTTOM_LEFT:
+                x = widget.getX();
+                break;
+            case TOP_CENTER:
+            case MIDDLE_CENTER:
+            case BOTTOM_CENTER:
+                x = (widget.getX() + ((widget.getWidth() - width) / 2));
+                break;
+            case TOP_RIGHT:
+            case MIDDLE_RIGHT:
+            case BOTTOM_RIGHT:
+                x = (widget.getX() + widget.getWidth() - width);
+                break;
+            default:
+                x = (widget.getX() + ((widget.getWidth() - width) / 2));
+                break;
+        }
+        return x;
+    }
+
+    public float getY(Widget widget, float height)
+    {
+        float y = 0;
+        switch(this) {
+            case TOP_LEFT:
+            case TOP_CENTER:
+            case TOP_RIGHT:
+                y = (widget.getY() + widget.getHeight() - height);
+                break;
+            case MIDDLE_LEFT:
+            case MIDDLE_CENTER:
+            case MIDDLE_RIGHT:
+                y = (widget.getY() + ((widget.getHeight() - height) / 2));
+                break;
+            case BOTTOM_LEFT:
+            case BOTTOM_CENTER:
+            case BOTTOM_RIGHT:
+                y = widget.getY();
+                break;
+            default:
+                y = (widget.getY() + ((widget.getHeight() - height) / 2));
+                break;
+        }
+        return y;
+    }
+}
diff --git a/core/src/ch/asynk/rustanddust/ui/Widget.java b/core/src/ch/asynk/rustanddust/ui/Widget.java
new file mode 100644
index 0000000..4ae8afd
--- /dev/null
+++ b/core/src/ch/asynk/rustanddust/ui/Widget.java
@@ -0,0 +1,93 @@
+package ch.asynk.rustanddust.ui;
+
+import com.badlogic.gdx.utils.Disposable;
+import com.badlogic.gdx.math.Rectangle;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
+import ch.asynk.rustanddust.engine.gfx.Drawable;
+
+public abstract class Widget implements Disposable, Drawable
+{
+    public boolean blocked;
+    public boolean visible;
+    protected float padding;
+    protected Rectangle rect;
+    protected Position position;
+    protected Widget parent;
+
+    protected Widget()
+    {
+        this.parent = null;
+        this.blocked = false;
+        this.visible = true;
+        this.padding = 0f;
+        this.rect = new Rectangle(0, 0, 0, 0);
+        this.position = Position.MIDDLE_CENTER;
+    }
+
+    public float getX() { return rect.x; }
+    public float getY() { return rect.y; }
+    public float getWidth() { return rect.width; }
+    public float getHeight() { return rect.height; }
+
+    public void translate(float dx, float dy)
+    {
+        rect.x += dx;
+        rect.y += dy;
+    }
+
+    public void setPosition(Rectangle r)
+    {
+        rect.set(r);
+    }
+
+    public void setPosition(float x, float y)
+    {
+        rect.x = x;
+        rect.y = y;
+    }
+
+    public void setPosition(float x, float y, float w, float h)
+    {
+        rect.set(x, y, w, h);
+    }
+
+    public void setPosition(Position position)
+    {
+        this.position = position;
+        setParent(this.parent);
+    }
+
+    public void setPosition(Position position, Widget parent)
+    {
+        this.position = position;
+        setParent(parent);
+    }
+
+    public void setParent(Widget parent)
+    {
+        this.parent = parent;
+        if (parent == null) {
+            rect.x = position.getX(rect.width);
+            rect.y = position.getY(rect.height);
+        } else {
+            rect.x = position.getX(parent, rect.width);
+            rect.y = position.getY(parent, rect.height);
+        }
+        // might trigger something if overriden
+        setPosition(rect.x, rect.y);
+    }
+
+    public boolean hit(float x, float y)
+    {
+        if (blocked || !visible) return false;
+        return rect.contains(x, y);
+    }
+
+    @Override
+    public void drawDebug(ShapeRenderer shapes)
+    {
+        if (!visible) return;
+        shapes.rect(rect.x, rect.y, rect.width, rect.height);
+    }
+}