tabletop -> boardgame

8 files changed, 960 insertions, 0 deletions

diff --git a/test/src/ch/asynk/gdx/boardgame/test/AbstractScreen.java b/test/src/ch/asynk/gdx/boardgame/test/AbstractScreen.java
new file mode 100644
index 0000000..e564790
--- /dev/null
+++ b/test/src/ch/asynk/gdx/boardgame/test/AbstractScreen.java
@@ -0,0 +1,168 @@
+package ch.asynk.gdx.boardgame.test;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Screen;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.Camera;
+import com.badlogic.gdx.graphics.Texture;
+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.math.Vector2;
+import com.badlogic.gdx.math.Vector3;
+
+import ch.asynk.gdx.boardgame.ui.Root;
+
+public abstract class AbstractScreen implements Screen
+{
+    protected final float WORLD_RATIO = 0.5f;
+    private static final float INPUT_DELAY = 0.1f;              // filter out touches after gesture
+    private static final float ZOOM_SCROLL_FACTOR = .1f;
+    private static final float ZOOM_GESTURE_FACTOR = .01f;
+
+    protected final Vector2 dragPos = new Vector2();
+    protected final Vector3 boardTouch = new Vector3();
+    protected final Vector3 hudTouch = new Vector3();
+
+    protected final String dom;
+    protected final GdxBoardTest app;
+    protected final SpriteBatch batch;
+    protected final Texture bg;
+    protected final Root root;
+    protected Camera camera;
+    protected boolean inputBlocked;
+    protected float inputDelay;
+    protected boolean paused;
+
+    protected abstract void feed();
+    public AbstractScreen(final GdxBoardTest app, final String dom)
+    {
+        this.app = app;
+        this.dom = dom;
+        this.batch = new SpriteBatch();
+        this.bg = app.assets.getTexture(app.assets.MAP_00);
+        this.root = new Root(1);
+        this.root.setPadding(15);
+        feed();
+        Gdx.input.setInputProcessor(getMultiplexer());
+        this.inputBlocked = false;
+        this.inputDelay = 0f;
+        this.paused = false;
+    }
+
+    protected abstract void draw(SpriteBatch batch);
+    @Override public void render(float delta)
+    {
+        if (paused) return;
+
+        Gdx.gl.glClearColor(1, 1, 1, 1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+
+        camera.update();
+        batch.setProjectionMatrix(camera.combined);
+        batch.begin();
+        draw(batch);
+        batch.end();
+    }
+
+    @Override public void resize(int width, int height)
+    {
+        GdxBoardTest.debug(dom, String.format("resize (%d,%d)",width, height));
+        if (width >= height) {
+            camera.viewportWidth = bg.getWidth();
+            camera.viewportHeight = bg.getHeight() / (float)width * (float)height;
+        } else {
+            camera.viewportHeight = bg.getHeight();
+            camera.viewportWidth = bg.getWidth() / (float)height * (float)width;
+        }
+        camera.viewportWidth *= WORLD_RATIO;
+        camera.viewportHeight *= WORLD_RATIO;
+        camera.update();
+        root.resize(
+                camera.position.x - (camera.viewportWidth / 2f),
+                camera.position.y - (camera.viewportHeight / 2f),
+                camera.viewportWidth,
+                camera.viewportHeight
+                );
+    }
+
+    @Override public void dispose()
+    {
+        GdxBoardTest.debug(dom, "dispose()");
+        batch.dispose();
+    }
+
+    @Override public void show()
+    {
+        GdxBoardTest.debug(dom, "show()");
+        paused = false;
+    }
+
+    @Override public void hide()
+    {
+        GdxBoardTest.debug(dom, "hide()");
+        paused = true;
+    }
+
+    @Override public void pause()
+    {
+        GdxBoardTest.debug(dom, "pause() ");
+        paused = true;
+    }
+
+    @Override public void resume()
+    {
+        GdxBoardTest.debug(dom, "resume() ");
+        resize(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+        paused = false;
+    }
+
+    protected abstract void onTouch(int x, int y);
+    protected abstract void onZoom(float dz);
+    protected abstract void onDragged(int dx, int dy);
+    private InputMultiplexer getMultiplexer()
+    {
+        final InputMultiplexer multiplexer = new InputMultiplexer();
+        multiplexer.addProcessor(new InputAdapter() {
+            @Override public boolean scrolled(int amount)
+            {
+                onZoom(amount * ZOOM_SCROLL_FACTOR);
+                return true;
+            }
+            @Override public boolean touchDown(int x, int y, int pointer, int button)
+            {
+                if (inputBlocked) return true;
+                if (button == Input.Buttons.LEFT) {
+                    dragPos.set(x, y);
+                    onTouch(x, y);
+                }
+                return true;
+            }
+            @Override public boolean touchDragged(int x, int y, int pointer)
+            {
+                int dx = (int) (dragPos.x - x);
+                int dy = (int) (dragPos.y - y);
+                dragPos.set(x, y);
+                onDragged(dx, dy);
+                return true;
+            }
+        });
+        multiplexer.addProcessor(new GestureDetector(new GestureAdapter() {
+            @Override public boolean zoom(float initialDistance, float distance)
+            {
+                if (initialDistance > distance)
+                    onZoom(ZOOM_GESTURE_FACTOR);
+                else
+                    onZoom(-ZOOM_GESTURE_FACTOR);
+                inputBlocked = true;
+                inputDelay = INPUT_DELAY;
+                return true;
+            }
+        }));
+
+        return multiplexer;
+    }
+}
diff --git a/test/src/ch/asynk/gdx/boardgame/test/Assets.java b/test/src/ch/asynk/gdx/boardgame/test/Assets.java
new file mode 100644
index 0000000..0c8ba5c
--- /dev/null
+++ b/test/src/ch/asynk/gdx/boardgame/test/Assets.java
@@ -0,0 +1,84 @@
+package ch.asynk.gdx.boardgame.test;
+
+import com.badlogic.gdx.assets.loaders.FileHandleResolver;
+import com.badlogic.gdx.assets.loaders.resolvers.InternalFileHandleResolver;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGenerator;
+import com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGeneratorLoader;
+import com.badlogic.gdx.graphics.g2d.freetype.FreetypeFontLoader;
+import com.badlogic.gdx.graphics.g2d.freetype.FreetypeFontLoader.FreeTypeFontLoaderParameter;
+
+public class Assets extends ch.asynk.gdx.boardgame.Assets
+{
+    public static final String LOADING = "loading.atlas";
+
+    public static final String CORNER = "corner.png";
+    public static final String MAP_00 = "map_00.png";
+    public static final String CHESS = "chess.jpg";
+    public static final String TRI = "triangle.png";
+    public static final String FONT = "veteran-typewriter.ttf";
+    public static final String FONT_20 = "size20.ttf";
+    public static final String FONT_25 = "size25.ttf";
+    public static final String PATCH = "ui-patch.png";
+    public static final String SHERMAN = "sherman.png";
+
+    private final FreeTypeFontLoaderParameter params20;
+    private final FreeTypeFontLoaderParameter params25;
+
+    public Assets()
+    {
+        super();
+        final FileHandleResolver resolver = new InternalFileHandleResolver();
+        setLoader(FreeTypeFontGenerator.class, new FreeTypeFontGeneratorLoader(resolver));
+        setLoader(BitmapFont.class, ".ttf", new FreetypeFontLoader(resolver));
+        params20 = new FreeTypeFontLoaderParameter();
+        params20.fontFileName = FONT;
+        params20.fontParameters.size = 20;
+        params25 = new FreeTypeFontLoaderParameter();
+        params25.fontFileName = FONT;
+        params25.fontParameters.size = 25;
+    }
+
+    @Override public void dispose()
+    {
+        GdxBoardTest.debug("diagnostics:\n" + getDiagnostics() );
+        clear();
+        super.dispose();
+    }
+
+    public void loadLoading()
+    {
+        load(LOADING, TextureAtlas.class);
+    }
+
+    public void unloadLoading()
+    {
+        unload(LOADING);
+    }
+
+    public void loadApp()
+    {
+        load(MAP_00, Texture.class);
+        load(CHESS, Texture.class);
+        load(TRI, Texture.class);
+        load(CORNER, Texture.class);
+        load(PATCH, Texture.class);
+        load(SHERMAN, Texture.class);
+        load(FONT_20, BitmapFont.class, params20);
+        load(FONT_25, BitmapFont.class, params25);
+    }
+
+    public void unloadApp()
+    {
+        unload(MAP_00);
+        unload(CHESS);
+        unload(TRI);
+        unload(CORNER);
+        unload(PATCH);
+        unload(SHERMAN);
+        unload(FONT_20);
+        unload(FONT_25);
+    }
+}
diff --git a/test/src/ch/asynk/gdx/boardgame/test/BoardScreen.java b/test/src/ch/asynk/gdx/boardgame/test/BoardScreen.java
new file mode 100644
index 0000000..876c2e8
--- /dev/null
+++ b/test/src/ch/asynk/gdx/boardgame/test/BoardScreen.java
@@ -0,0 +1,240 @@
+package ch.asynk.gdx.boardgame.test;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.math.Vector2;
+
+import ch.asynk.gdx.boardgame.Camera;
+import ch.asynk.gdx.boardgame.Board;
+import ch.asynk.gdx.boardgame.board.BoardFactory;
+import ch.asynk.gdx.boardgame.ui.Alignment;
+import ch.asynk.gdx.boardgame.ui.Button;
+import ch.asynk.gdx.boardgame.ui.Root;
+
+public class BoardScreen extends AbstractScreen
+{
+
+    private static final boolean DEBUG = true;
+
+    private class MyBoard
+    {
+        private final Assets assets;
+        private final Texture sherman;
+        private final Vector2 v;
+        public Texture map;
+        public Board board;
+        public int dx;
+        public int dy;
+        public int w;
+        public int h;
+        public float r;
+
+        public MyBoard(final Assets assets)
+        {
+            this.assets = assets;
+            this.sherman = assets.getTexture(assets.SHERMAN);
+            this.v = new Vector2();
+        }
+
+        public void draw(SpriteBatch batch)
+        {
+            batch.draw(map, dx, dy, map.getWidth()/2, map.getHeight()/2, map.getWidth(), map.getHeight(), 1, 1, r, 0, 0, map.getWidth(), map.getHeight(), false, false);
+            batch.draw(sherman, v.x - (sherman.getWidth() / 2), v.y - (sherman.getHeight() / 2));
+        }
+
+        public void reset()
+        {
+            board.centerOf(0, 0, v);
+        }
+
+        public boolean touch(float x, float y)
+        {
+            board.toBoard(x, y, v);
+            GdxBoardTest.debug("BoardScreen", String.format("touchDown [%d;%d] => [%d;%d]", (int)x, (int)y, (int)v.x, (int)v.y));
+            board.centerOf((int)v.x, (int)v.y, v);
+            GdxBoardTest.debug("BoardScreen", String.format("                  => [%d;%d]", (int)v.x, (int)v.y));
+            return true;
+        }
+
+        public void setHEX_V()
+        {
+            map = assets.getTexture(assets.MAP_00);
+            r = 0;
+            dx = 0;
+            dy = 0;
+            w = map.getWidth();
+            h = map.getHeight();
+            board = BoardFactory.getBoard(BoardFactory.BoardType.HEX, 110, 50, 103, BoardFactory.BoardOrientation.VERTICAL);
+        }
+
+        public void setHEX_H()
+        {
+            map = assets.getTexture(assets.MAP_00);
+            r = 90;
+            dx = - ( map.getWidth() - map.getHeight() ) / 2;
+            dy = - dx;
+            w = map.getHeight();
+            h = map.getWidth();
+            board = BoardFactory.getBoard(BoardFactory.BoardType.HEX, 110, 103, 50, BoardFactory.BoardOrientation.HORIZONTAL);
+        }
+
+        public void setSQUARE()
+        {
+            map = assets.getTexture(assets.CHESS);
+            r = 0;
+            dx = 0;
+            dy = 0;
+            w = map.getWidth();
+            h = map.getHeight();
+            board = BoardFactory.getBoard(BoardFactory.BoardType.SQUARE, 83, 5, 5);
+        }
+
+        public void setTRI_H()
+        {
+            map = assets.getTexture(assets.TRI);
+            r = 0;
+            dx = 0;
+            dy = 0;
+            w = map.getWidth();
+            h = map.getHeight();
+            board = BoardFactory.getBoard(BoardFactory.BoardType.TRIANGLE, 150, 109, 53, BoardFactory.BoardOrientation.HORIZONTAL);
+        }
+
+        public void setTRI_V()
+        {
+            map = assets.getTexture(assets.TRI);
+            r = 90;
+            dx = - ( map.getWidth() - map.getHeight() ) / 2;
+            dy = - dx;
+            w = map.getHeight();
+            h = map.getWidth();
+            board = BoardFactory.getBoard(BoardFactory.BoardType.TRIANGLE, 150, 16, 110, BoardFactory.BoardOrientation.VERTICAL);
+        }
+    }
+
+    public enum State
+    {
+        HEX_V, HEX_H, SQUARE, TRI_H, TRI_V, DONE;
+        public State next()
+        {
+            switch(this) {
+                case HEX_V:
+                    return HEX_H;
+                case HEX_H:
+                    return SQUARE;
+                case SQUARE:
+                    return TRI_H;
+                case TRI_H:
+                    return TRI_V;
+                case TRI_V:
+                    return DONE;
+                default:
+                    return HEX_V;
+            }
+        }
+    }
+    private State state;
+
+    private Camera cam;
+    private MyBoard board;
+    private Button btn;
+    private Root root;
+
+    public BoardScreen(final GdxBoardTest app)
+    {
+        super(app, "");
+    }
+
+    @Override protected void feed()
+    {
+        this.board = new MyBoard(app.assets);
+        this.camera = this.cam = new Camera(10, board.w, board.h, 1.0f, 0.3f, false);
+        this.btn = new Button(
+                app.assets.getFont(app.assets.FONT_25),
+                app.assets.getNinePatch(app.assets.PATCH, 23, 23, 23 ,23),
+                15);
+        this.btn.setAlignment(Alignment.BOTTOM_RIGHT);
+        this.btn.write("next");
+        this.root = new Root(1);
+        this.root.add(btn);
+        this.root.setPadding(5);
+        setState(State.HEX_V);
+    }
+
+    @Override public void draw(SpriteBatch batch) { }
+    @Override public void render(float delta)
+    {
+        if (paused) return;
+
+        if (inputBlocked) {
+            inputDelay -= delta;
+            if (inputDelay <= 0f)
+                inputBlocked = false;
+        }
+
+        Gdx.gl.glClearColor(0, 0, 0, 1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+
+        cam.applyBoardViewport();
+        batch.setProjectionMatrix(cam.combined);
+        batch.begin();
+        board.draw(batch);
+        batch.end();
+
+        cam.applyHudViewport();
+        batch.setProjectionMatrix(cam.getHudMatrix());
+        batch.begin();
+        root.draw(batch);
+        batch.end();
+    }
+
+    @Override public void resize(int width, int height)
+    {
+        GdxBoardTest.debug("BoardScrean", String.format("resize (%d,%d)",width, height));
+        cam.updateViewport(width, height);
+        root.resize(cam.getHud());
+    }
+
+    @Override protected void onDragged(int dx, int dy)
+    {
+        cam.translate(dx, dy);
+    }
+
+    @Override protected void onTouch(int x, int y)
+    {
+        cam.unproject(x, y, boardTouch);
+        cam.unprojectHud(x, y, hudTouch);
+        if (btn.touch(hudTouch.x, hudTouch.y)) {
+            setState(state.next());
+        } else {
+            board.touch(boardTouch.x, boardTouch.y);
+        }
+    }
+
+    @Override protected void onZoom(float dz)
+    {
+        cam.zoom(dz);
+        resize(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+    }
+
+    private void setState(State state)
+    {
+        switch (state) {
+            case HEX_V: board.setHEX_V(); break;
+            case HEX_H: board.setHEX_H(); break;
+            case SQUARE: board.setSQUARE(); break;
+            case TRI_H: board.setTRI_H(); break;
+            case TRI_V: board.setTRI_V(); break;
+            case DONE:
+                cam.applyScreenViewport();
+                this.app.switchToMenu();
+                return;
+        }
+        board.reset();
+        cam.setDimension(board.w, board.h);
+        onZoom(1);
+        this.state = state;
+    }
+}
diff --git a/test/src/ch/asynk/gdx/boardgame/test/DesktopLauncher.java b/test/src/ch/asynk/gdx/boardgame/test/DesktopLauncher.java
new file mode 100644
index 0000000..2c9066f
--- /dev/null
+++ b/test/src/ch/asynk/gdx/boardgame/test/DesktopLauncher.java
@@ -0,0 +1,14 @@
+package ch.asynk.gdx.boardgame.test;
+
+import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
+import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
+
+public class DesktopLauncher {
+	public static void main (String[] arg) {
+		LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
+		new LwjglApplication(new GdxBoardTest(), config);
+        config.title = "gdx-boardgame Demo";
+        config.width=800;
+        config.height=600;
+	}
+}
diff --git a/test/src/ch/asynk/gdx/boardgame/test/GdxBoardTest.java b/test/src/ch/asynk/gdx/boardgame/test/GdxBoardTest.java
new file mode 100644
index 0000000..307f961
--- /dev/null
+++ b/test/src/ch/asynk/gdx/boardgame/test/GdxBoardTest.java
@@ -0,0 +1,97 @@
+package ch.asynk.gdx.boardgame.test;
+
+import com.badlogic.gdx.Game;
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Screen;
+
+public class GdxBoardTest extends Game
+{
+    private static final String DOM = "GdxBoardTest";
+
+    private enum State
+    {
+        NONE,
+        LOADING,
+        MENU,
+        UI,
+        BOARD,
+        EXIT
+    }
+    private State state;
+
+    public final Assets assets = new Assets();
+
+    @Override public void create()
+    {
+        this.state = State.NONE;
+        Gdx.app.setLogLevel(Gdx.app.LOG_DEBUG);
+        debug(String.format("create() [%d;%d] %f", Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), Gdx.graphics.getDensity()));
+        switchToLoading();
+    }
+
+    @Override public void dispose()
+    {
+        debug("dispose()");
+        assets.clear();
+        assets.dispose();
+    }
+
+    public static void error(String msg)
+    {
+        Gdx.app.error(DOM, msg);
+    }
+
+    public static void debug(String msg)
+    {
+        Gdx.app.debug(DOM, msg);
+    }
+
+    public static void debug(String from, String msg)
+    {
+        Gdx.app.debug(DOM, String.format("%s : %s", from, msg));
+    }
+
+    private void switchTo(Screen nextScreen, State nextState)
+    {
+        if (state == nextState) {
+            error("switch from and to " + state);
+            return;
+        }
+        if (state == State.LOADING) {
+            assets.unloadLoading();
+        }
+        if (state != State.NONE) {
+            getScreen().dispose();
+        }
+        setScreen(nextScreen);
+        this.state = nextState;
+    }
+
+    public void switchToLoading()
+    {
+        assets.loadLoading();
+        assets.finishLoading();
+        switchTo(new LoadingScreen(this, () -> assets.loadApp(), () -> switchToMenu()), State.LOADING);
+    }
+
+    public void switchToMenu()
+    {
+        switchTo(new MenuScreen(this), State.MENU);
+    }
+
+    public void switchToUi()
+    {
+        switchTo(new UiScreen(this), State.UI);
+    }
+
+    public void switchToBoard()
+    {
+        switchTo(new BoardScreen(this), State.BOARD);
+    }
+
+    public void switchToExit()
+    {
+        Gdx.app.exit();
+        switchTo(null, State.EXIT);
+    }
+}
diff --git a/test/src/ch/asynk/gdx/boardgame/test/LoadingScreen.java b/test/src/ch/asynk/gdx/boardgame/test/LoadingScreen.java
new file mode 100644
index 0000000..69c7e11
--- /dev/null
+++ b/test/src/ch/asynk/gdx/boardgame/test/LoadingScreen.java
@@ -0,0 +1,168 @@
+package ch.asynk.gdx.boardgame.test;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Screen;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.OrthographicCamera;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.TextureAtlas.AtlasRegion;
+
+public class LoadingScreen implements Screen
+{
+    private static final String DOM = "LoadingScreen";
+
+    private final GdxBoardTest app;
+    private final SpriteBatch batch;
+    private final Color c;
+    private final OrthographicCamera camera;
+
+    private final float BLINK_AFTER = 1f;
+    private final float ALPHA_FACTOR = 1.5f;
+
+    private boolean paused;
+    private  TextureAtlas atlas;
+    private  AtlasRegion bar;
+    private  AtlasRegion border;
+    private  AtlasRegion loading;
+    private  AtlasRegion loaded;
+
+    private int x, y;
+    private int count;
+    private float percent;
+    private float alpha;
+    private boolean incr;
+    private boolean isLoaded;
+
+    public interface LoadAction {
+        void call();
+    }
+    private LoadAction onLoaded;
+
+    public LoadingScreen(final GdxBoardTest app, LoadAction startLoading, LoadAction onLoaded)
+    {
+        this.app = app;
+        this.onLoaded = onLoaded;
+        this.batch = new SpriteBatch();
+        this.c = batch.getColor();
+        this.camera = new OrthographicCamera();
+        int w = Gdx.graphics.getWidth();
+        int h = Gdx.graphics.getHeight();
+        this.camera.setToOrtho(false, w, h);
+        this.camera.update();
+        this.paused = false;
+        atlas = app.assets.getAtlas(app.assets.LOADING);
+        bar = atlas.findRegion("bar");
+        border = atlas.findRegion("border");
+        loading = atlas.findRegion("loading");
+        loaded = atlas.findRegion("loaded");
+        computeCoords(w, h);
+        percent = 0f;
+        alpha = 1f;
+        incr = false;
+        isLoaded = false;
+        startLoading.call();
+    }
+
+    private void computeCoords(int width, int height)
+    {
+        x = (width - border.getRegionWidth()) / 2;
+        y = (height - border.getRegionHeight()) / 2;
+    }
+
+    @Override public void render(float delta)
+    {
+        if (paused) return;
+
+        if (!isLoaded) {
+            if (app.assets.update()) {
+                GdxBoardTest.debug(DOM, "assets loaded");
+                isLoaded = true;
+                percent = 1f;
+            } else {
+                percent = app.assets.getProgress();
+            }
+        }
+
+        if (!isLoaded && percent >= 1f) {
+            count = 0;
+            alpha = 1f;
+            incr = false;
+        }
+
+        delta *= ALPHA_FACTOR;
+        if (incr) {
+            alpha += delta;
+            if (alpha >= 1f ) {
+                alpha = 1f;
+                incr = false;
+                if (isLoaded) count += 1;
+                if (count >= BLINK_AFTER) {
+                    onLoaded.call();
+                    return;
+                }
+            }
+        } else {
+            alpha -= delta;
+            if (alpha <= 0f ) {
+                alpha = 0f;
+                incr = true;
+            }
+        }
+
+        Gdx.gl.glClearColor(0, 0, 0, 1);
+        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
+
+        batch.setProjectionMatrix(camera.combined);
+        batch.begin();
+        batch.setColor(c.r, c.g, c.b, 1f);
+        batch.draw(border, x, y);
+        batch.draw(bar, x + 4, y + 4, percent * bar.getRegionWidth(), bar.getRegionHeight());
+        batch.setColor(c.r, c.g, c.b, alpha);
+        if (!isLoaded) {
+            batch.draw(loading, x, y + border.getRegionHeight() + 3);
+        } else {
+            batch.draw(loaded, x + border.getRegionWidth() - loaded.getRegionWidth(), y - loaded.getRegionHeight() - 3);
+        }
+        batch.end();
+    }
+
+    @Override public void resize(int width, int height)
+    {
+        if (paused) return;
+        GdxBoardTest.debug("LoadingScreen", String.format("resize (%d,%d)",width, height));
+        this.camera.setToOrtho(false, width, height);
+        this.camera.update();
+        computeCoords(width, height);
+    }
+
+    @Override public void dispose()
+    {
+        GdxBoardTest.debug("LoadingScreen", "dispose()");
+        batch.dispose();
+    }
+
+    @Override public void show()
+    {
+        GdxBoardTest.debug("LoadingScreen", "show()");
+    }
+
+    @Override public void hide()
+    {
+        GdxBoardTest.debug("LoadingScreen", "hide()");
+    }
+
+    @Override public void pause()
+    {
+        paused = true;
+        GdxBoardTest.debug("LoadingScreen", "pause() ");
+    }
+
+    @Override public void resume()
+    {
+        GdxBoardTest.debug("LoadingScreen", "resume() ");
+        resize(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+        paused = false;
+    }
+}
diff --git a/test/src/ch/asynk/gdx/boardgame/test/MenuScreen.java b/test/src/ch/asynk/gdx/boardgame/test/MenuScreen.java
new file mode 100644
index 0000000..be9ec72
--- /dev/null
+++ b/test/src/ch/asynk/gdx/boardgame/test/MenuScreen.java
@@ -0,0 +1,86 @@
+package ch.asynk.gdx.boardgame.test;
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.Sprite;
+import com.badlogic.gdx.graphics.OrthographicCamera;
+
+import ch.asynk.gdx.boardgame.ui.Alignment;
+import ch.asynk.gdx.boardgame.ui.Menu;
+
+public class MenuScreen extends AbstractScreen
+{
+    private Sprite corner;
+    private Menu menu;
+
+    public MenuScreen(final GdxBoardTest app)
+    {
+        super(app, "MenuScreen");
+    }
+
+    @Override protected void feed()
+    {
+        final Assets assets = app.assets;
+        this.corner = new Sprite(assets.getTexture(assets.CORNER));
+
+        this.menu = new Menu(
+                assets.getFont(assets.FONT_25),
+                assets.getNinePatch(assets.PATCH, 23, 23, 23 ,23),
+                "Menu", new String[]{"UI","Board","Exit"});
+        this.menu.setAlignment(Alignment.MIDDLE_CENTER);
+        this.menu.setPaddings(5, 5);
+        this.menu.setSpacings(10, 5);
+        this.menu.setPadding(20);
+        this.menu.setLabelsOffset(10);
+        this.root.add(this.menu);
+
+        this.camera = new OrthographicCamera(bg.getWidth() * WORLD_RATIO, bg.getHeight() * WORLD_RATIO);
+        this.camera.position.set(bg.getWidth() / 2f, bg.getHeight() / 2f, 0);
+        this.camera.update();
+    }
+
+    @Override protected void draw(SpriteBatch batch)
+    {
+        batch.draw(bg, 0, 0);
+        drawCorners(batch);
+        root.draw(batch);
+    }
+
+    private void drawCorners(SpriteBatch batch)
+    {
+        float right = root.getInnerX() + root.getInnerWidth() - corner.getWidth();
+        float top = root.getInnerY() + root.getInnerHeight() - corner.getHeight();
+        corner.setRotation(0);
+        corner.setPosition(root.getInnerX(), top);
+        corner.draw(batch);
+        corner.setRotation(90);
+        corner.setPosition(root.getInnerX(), root.getInnerY());
+        corner.draw(batch);
+        corner.setRotation(180);
+        corner.setPosition(right, root.getInnerY());
+        corner.draw(batch);
+        corner.setPosition(right, top);
+        corner.setRotation(270);
+        corner.draw(batch);
+    }
+
+    @Override protected void onZoom(float dz) { }
+    @Override protected void onDragged(int dx, int dy) { }
+    @Override protected void onTouch(int x, int y)
+    {
+        hudTouch.set(x, y, 0);
+        camera.unproject(hudTouch);
+        if (root.touch(hudTouch.x, hudTouch.y)) {
+            switch(menu.touched()) {
+                case 0:
+                    app.switchToUi();
+                    break;
+                case 1:
+                    app.switchToBoard();
+                    break;
+                case 2:
+                    app.switchToExit();
+                    break;
+            }
+        }
+    }
+}
diff --git a/test/src/ch/asynk/gdx/boardgame/test/UiScreen.java b/test/src/ch/asynk/gdx/boardgame/test/UiScreen.java
new file mode 100644
index 0000000..5292af8
--- /dev/null
+++ b/test/src/ch/asynk/gdx/boardgame/test/UiScreen.java
@@ -0,0 +1,103 @@
+package ch.asynk.gdx.boardgame.test;
+
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.NinePatch;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.OrthographicCamera;
+
+import ch.asynk.gdx.boardgame.ui.Alignment;
+import ch.asynk.gdx.boardgame.ui.Button;
+
+public class UiScreen extends AbstractScreen
+{
+    private Button hello;
+
+    public UiScreen(final GdxBoardTest app)
+    {
+        super(app, "UiScreen");
+    }
+
+    public enum State
+    {
+        POSITIONS, DONE;
+        public State next()
+        {
+            switch(this) {
+                case POSITIONS:
+                    return DONE;
+                default:
+                    return POSITIONS;
+            }
+        }
+    }
+    private State state;
+
+    @Override protected void feed()
+    {
+        final NinePatch patch = app.assets.getNinePatch(app.assets.PATCH, 23, 23, 23 ,23);
+        final BitmapFont font = app.assets.getFont(app.assets.FONT_25);
+
+        this.hello = new Button(font, patch, 10, 15);
+        this.hello.write("Hello");
+        this.root.add(this.hello);
+
+        this.camera = new OrthographicCamera(bg.getWidth() * WORLD_RATIO, bg.getHeight() * WORLD_RATIO);
+        this.camera.position.set(bg.getWidth() / 2f, bg.getHeight() / 2f, 0);
+        this.camera.update();
+        setState(State.POSITIONS);
+    }
+
+    private void setState(State state)
+    {
+        switch (state) {
+            case DONE:
+                app.switchToMenu();
+        }
+        this.state = state;
+    }
+
+    @Override protected void draw(SpriteBatch batch)
+    {
+        batch.draw(bg, 0, 0);
+        switch (state) {
+            case POSITIONS:
+                drawButtons(batch);
+                break;
+        }
+    }
+
+    private void drawButtons(SpriteBatch batch)
+    {
+        hello.write("hello");
+        hello.setAlignment(Alignment.TOP_LEFT);
+        hello.setLabelAlignment(Alignment.BOTTOM_RIGHT);
+        root.draw(batch);
+        drawHello(batch, Alignment.TOP_CENTER, Alignment.BOTTOM_CENTER);
+        drawHello(batch, Alignment.TOP_RIGHT, Alignment.BOTTOM_LEFT);
+        drawHello(batch, Alignment.MIDDLE_LEFT, Alignment.MIDDLE_RIGHT);
+        drawHello(batch, Alignment.MIDDLE_RIGHT, Alignment.MIDDLE_LEFT);
+        drawHello(batch, Alignment.BOTTOM_LEFT, Alignment.TOP_RIGHT);
+        drawHello(batch, Alignment.BOTTOM_CENTER, Alignment.TOP_CENTER);
+        drawHello(batch, Alignment.BOTTOM_RIGHT, Alignment.TOP_LEFT);
+        hello.write("next");
+        drawHello(batch, Alignment.MIDDLE_CENTER, Alignment.MIDDLE_CENTER);
+    }
+
+    private void drawHello(SpriteBatch batch, Alignment alignment1, Alignment alignment2)
+    {
+        hello.setAlignment(alignment1);
+        hello.setLabelAlignment(alignment2);
+        hello.draw(batch);
+    }
+
+    @Override protected void onZoom(float dz) { }
+    @Override protected void onDragged(int dx, int dy) { }
+    @Override protected void onTouch(int x, int y)
+    {
+        hudTouch.set(x, y, 0);
+        camera.unproject(hudTouch);
+        if (root.touch(hudTouch.x, hudTouch.y)) {
+            setState(state.next());
+        }
+    }
+}