Example usage for com.badlogic.gdx.scenes.scene2d.ui Dialog Dialog

List of usage examples for com.badlogic.gdx.scenes.scene2d.ui Dialog Dialog

Introduction

In this page you can find the example usage for com.badlogic.gdx.scenes.scene2d.ui Dialog Dialog.

Prototype

public Dialog(String title, WindowStyle windowStyle) 

Source Link

Usage

From source file:ateamproject.kezuino.com.github.network.rmi.Client.java

@Override
public void registerPackets() {
    packets.registerFunc(PacketKick.class, packet -> {
        if (packet.getSender() == null) {
            new Dialog("Kicked", ((BaseScreen) game.getScreen()).getSkin()) {
                {// w w  w .  j ava2  s. co  m
                    text(packet.getReason());
                    button("Oke");

                    addListener(new ClickListener(0) {
                        @Override
                        public void clicked(InputEvent event, float x, float y) {
                            game.setScreen(new MainScreen(game));
                        }
                    });
                }
            }.show(((BaseScreen) game.getScreen()).getStage());
            return true;
        } else {
            try {
                if (packet.getReceivers().length > 0) {
                    for (UUID receiver : packet.getReceivers()) {
                        this.rmi.getServer().kickClient(packet.getSender(), receiver, packet.getReasonType(),
                                packet.getReason());
                    }
                } else {
                    this.rmi.getServer().kickClient(packet.getSender(), null, packet.getReasonType(),
                            packet.getReason());
                }
            } catch (RemoteException ex) {
                Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
            }
            return true;
        }
    });

    packets.registerFunc(PacketLoginAuthenticate.class, packet -> {
        PacketLoginAuthenticate.ReturnData data = null;
        try {
            data = getRmi().getServer().login(packet.getEmailAddress(), packet.getPassword(), getRmi());
        } catch (Exception e) {
            data = new PacketLoginAuthenticate.ReturnData(null, null, null, null, "Server is niet online.",
                    false);
        }

        if (data != null) {
            if (data.getPrivateId() == null) {
                this.setEmailaddress(null);
                this.setUsername(null);
                this.setId(null);
                this.setPublicId(null);
            } else {
                this.setEmailaddress(data.getEmailadress());
                this.setUsername(data.getUsername());
                this.setId(data.getPrivateId());
                this.setPublicId(data.getPublicId());
                System.out.printf("Logged in as: (Username: %s), (Email: %s), (Private: %s), (Public: %s)%n",
                        data.getUsername(), data.getEmailadress(), data.getPrivateId(), data.getPublicId());
            }
        }

        return data;
    });

    packets.registerAction(PacketLogout.class, packet -> {

        try {
            getRmi().getServer().logout(getId());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    });

    packets.registerFunc(PacketHighScore.class, (packet) -> {
        try {
            return getRmi().getServer().setScore(packet.getSender(), packet.getScore());
        } catch (RemoteException ex) {
            Logger.getLogger(MainScreen.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    });

    packets.registerFunc(PacketCreateLobby.class, (p) -> {

        try {
            return getRmi().getServer().createLobby(p.getSender(), p.getLobbyname(), p.getClanname());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }
        return null;
    });

    packets.registerFunc(PacketGetLobbies.class, (p) -> {
        try {
            return getRmi().getServer().getLobbies(p.getSender(), p.isClanGame());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }
        return null;
    });

    packets.registerAction(PacketScreenUpdate.class, packet -> {
        if (game.getScreen().getClass().equals(packet.getScreenClass())) {
            RefreshableScreen screen = (RefreshableScreen) game.getScreen();
            screen.refresh();
        }
    });

    packets.registerFunc(PacketGetClans.class, (p) -> {
        try {
            return getRmi().getServer().getClans(p.getSender());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return null;
    });

    packets.registerAction(PacketReloadClans.class, (p) -> {
        // run methode op de serverbase .getclans
        try {
            getRmi().getServer().setClans(p.getSender());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }
    });

    packets.registerFunc(PacketJoinLobby.class, (p) -> {
        try {
            return getRmi().getServer().joinLobby(p.getLobbyId(), p.getSender());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }
        return null;
    });

    packets.registerFunc(PacketLoginCreateNewUser.class, (p) -> {
        try {
            return getRmi().getServer().loginCreateUser(p.getSender(), p.getUsername(), p.getEmail());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketLoginUserExists.class, (p) -> {
        try {
            return getRmi().getServer().doesUserExists(p.getEmail());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketGetKickInformation.class, (p) -> {
        try {
            return getRmi().getServer().getKickInformation(p.getSender());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketCreateClan.class, (p) -> {
        try {
            return getRmi().getServer().createClan(p.getSender(), p.getClanName());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketFillTable.class, (p) -> {
        try {
            return getRmi().getServer().clanFillTable(p.getEmailadres());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketGetEmail.class, (p) -> {
        try {
            return getRmi().getServer().getEmail(p.getSender());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketGetInvitation.class, (p) -> {
        try {
            return getRmi().getServer().clanGetInvitation(p.getSender(), p.getClanName());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketGetManagement.class, (p) -> {
        try {
            return getRmi().getServer().getManagement(p.getSender(), p.getClanName());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketGetPeople.class, (p) -> {
        try {
            return getRmi().getServer().getPeople(p.getClanName());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketGetUsername.class, (p) -> {
        try {
            return getRmi().getServer().getUsername(p.getEmailadres());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketHandleInvitation.class, (p) -> {
        try {
            return getRmi().getServer().handleInvitation(p.getInvite(), p.getClanName(), p.getEmailadres(),
                    p.getNameOfInvitee());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketHandleManagement.class, (p) -> {
        try {
            return getRmi().getServer().handleManagement(p.getManage(), p.getClanName(), p.getEmailadres());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerFunc(PacketSetUsername.class, (p) -> {
        try {
            return getRmi().getServer().setUsername(p.getName(), p.getEmailaddress(), p.getSender());
        } catch (RemoteException ex) {
            Logger.getLogger(ateamproject.kezuino.com.github.network.rmi.Client.class.getName())
                    .log(Level.SEVERE, null, ex);
        }

        return false;
    });

    packets.registerAction(PacketSetKickInformation.class, packet -> {
        try {
            getRmi().getServer().setKickInformation(packet.getSender(), packet.getPersonToVoteFor());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    });

    packets.registerAction(PacketClientJoined.class, p -> {
        if (game.getScreen() instanceof LobbyScreen) {
            LobbyScreen t = (LobbyScreen) game.getScreen();
            t.addMember(p.getJoinenId(), p.getUsername());
        }
    });

    packets.registerFunc(PacketLobbyMembers.class, packet -> {
        try {
            // return all current members in the lobby
            return getRmi().getServer().getLobbyMembers(packet.getLobbyId());

        } catch (RemoteException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    });

    packets.registerAction(PacketLaunchGame.class, p -> {
        if (p.getSender() != null) {
            // Request came from client..
            try {
                rmi.getServer().launchGame(p.getSender(), p.getLevel(), p.getScore());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        } else {
            // Request came from server..
            if (p.isPaused()) {
                Gdx.app.postRunnable(() -> {
                    // Sync data of pactales already send to connected clients with host.
                    try {
                        List<PacketGetGameClients.Data> data = getRmi().getServer()
                                .getGameClients(Client.getInstance().getId());

                        for (PacketGetGameClients.Data d : data) {
                            Pactale player = BaseScreen.getSession().getPlayer(d.getIndex());

                            player.setId(d.getPublicId());
                            player.setColor(
                                    ateamproject.kezuino.com.github.network.Game.SELECTABLE_COLORS[player
                                            .getPlayerIndex()]);
                        }
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }

                    game.setScreen(new GameScreen(game));
                    ((GameScreen) game.getScreen()).start();
                });
            } else {
                // Request came from server.. resume game.
                Gdx.app.postRunnable(() -> BaseScreen.getSession().resume());
            }
        }
    });

    packets.registerAction(PacketCreateGameObject.class, p -> {
        GameSession session = BaseScreen.getSession();
        if (session == null) {
            System.out.printf("Tried to create object: '%s' but no GameSession was set.%n", p.getTypeName());
            return;
        }

        GameObject object = null;
        try {
            String className = GameObject.class.getName();
            className = className.substring(0, className.lastIndexOf('.'));
            object = (GameObject) Class.forName(className + '.' + p.getTypeName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }

        if (object == null) {
            throw new IllegalStateException(
                    String.format("Cannot create GameObject of type: '%s'", p.getTypeName()));
        }
        object.setId(p.getId());
        object.setStartingPosition(p.getPosition());
        object.setDirection(p.getDirection());
        object.setExactPosition(p.getPosition());
        object.setMap(session.getMap());
        object.setMovementSpeed(p.getSpeed());

        Color color = Color.WHITE.cpy();
        Color.rgba8888ToColor(color, p.getColor());
        object.setColor(color);

        if (object instanceof Pactale) {
            Pactale pactale = (Pactale) object;
            pactale.setPlayerIndex(p.getIndex());
            final GameObject finalObject = object;
            Gdx.app.postRunnable(() -> finalObject.setAnimation(new Animation(true,
                    Assets.getTexture(finalObject.getClass().getSimpleName().toLowerCase() + ".png"))));
        } else if (object instanceof Enemy) {
            final Enemy enemy = (Enemy) object;

            // Only host should generate enemy paths. Clients will receive them from the host.
            enemy.setDisablePathfinding(!Client.getInstance().isHost());
            Gdx.app.postRunnable(() -> enemy.setAnimation(
                    new Animation(Assets.getTexture(enemy.getClass().getSimpleName().toLowerCase() + ".png"))));
        }

        session.getMap().addGameObject(object);
        session.setObjectsLoaded(session.getObjectsLoaded() + 1);

        System.out.printf("Loaded (%s): %d/%d%n", object.getClass().getSimpleName(), session.getObjectsLoaded(),
                session.getObjectsToLoad());

        if (session.getObjectsToLoad() == session.getObjectsLoaded()) {
            send(new PacketSetLoadStatus(PacketSetLoadStatus.LoadStatus.ObjectsLoaded, null));
        }
    });

    packets.registerAction(PacketCreateItem.class, packet -> {
        GameSession session = BaseScreen.getSession();
        if (session == null) {
            System.out.printf("Tried to create object: '%s' but no GameSession was set.%n", "item");
            return;
        }

        // Create item.
        Item item = new Item(packet.getType().toString(), packet.getPosition(), packet.getType());
        item.setId(packet.getObjId());
        item.setMap(session.getMap());

        Gdx.app.postRunnable(() -> item.setTexture(
                new TextureRegion(Assets.getTexture(item.getItemType().name().toLowerCase() + ".png"))));
        session.getMap().getNode(item.getExactPosition()).setItem(item);

        // Update load status.
        session.setObjectsLoaded(session.getObjectsLoaded() + 1);
        System.out.printf("Loaded (%s): %d/%d%n", item.getClass().getSimpleName(), session.getObjectsLoaded(),
                session.getObjectsToLoad());

        if (session.getObjectsToLoad() == session.getObjectsLoaded()) {
            send(new PacketSetLoadStatus(PacketSetLoadStatus.LoadStatus.ObjectsLoaded, null));
        }
    });

    packets.registerAction(PacketLobbySetDetails.class, p -> {
        try {
            rmi.getServer().setLobbyDetails(p.getSender(), p.getData());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    });

    packets.registerFunc(PacketLobbyGetDetails.class, p -> {
        PacketLobbySetDetails.Data data = p.getResult();

        // TODO: Update lobby screen with new information.
        if (data.getName() != null) {
            System.out.println("New lobby name: " + data.getName());
        }
        if (data.getMap() != null) {
            System.out.println("New lobby map: " + data.getMap());
        }

        return data;
    });

    packets.registerAction(PacketLoadGame.class, p -> {
        // Set this session as the new main session.
        GameSession session = new GameSession(p.getLevel(), p.getScore());
        BaseScreen.setSession(session);
        MapLoader loader = Map.getLoader(session, p.getMap(), p.getLevel());

        EnumSet<MapLoader.MapObjectTypes> excluded = null;
        if (p.isMaster()) {
            // Load everything and synchronize with server.
            excluded = EnumSet.noneOf(MapLoader.MapObjectTypes.class);
            loader.addConsumer(Enemy.class, obj -> {
                try {
                    getRmi().getServer().createObject(p.getSender(), Enemy.class.getSimpleName(),
                            obj.getExactPosition(), obj.getDirection(), obj.getMovementSpeed(), obj.getId(),
                            Color.argb8888(obj.getColor()), 0);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            });
            loader.addConsumer(Pactale.class, obj -> {
                if (obj.getPlayerIndex() == 0) {
                    obj.setId(getPublicId());
                }

                try {
                    getRmi().getServer().createObject(p.getSender(), Pactale.class.getSimpleName(),
                            obj.getExactPosition(), obj.getDirection(), obj.getMovementSpeed(), obj.getId(),
                            Color.argb8888(obj.getColor()), obj.getPlayerIndex());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            });
            loader.addConsumer(Item.class, obj -> {
                try {
                    getRmi().getServer().createItem(p.getSender(), obj.getId(), obj.getItemType(),
                            obj.getExactPosition());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            });
        } else {
            // Exclude everything that's network dependant.
            excluded = EnumSet.of(MapLoader.MapObjectTypes.ENEMY, MapLoader.MapObjectTypes.PACTALE,
                    MapLoader.MapObjectTypes.ITEM);
        }

        // Load map (on OpenGL thread).
        final EnumSet<MapLoader.MapObjectTypes> finalExcluded = excluded;
        Gdx.app.postRunnable(() -> {
            loader.getTypesToLoad().removeAll(finalExcluded);
            loader.setPlayerLimit(p.getPlayerLimit());
            loader.load();
            session.setMap(loader.getMap());

            // Tell the game that we are done loading.
            if (p.isMaster()) {
                send(new PacketSetLoadStatus(PacketSetLoadStatus.LoadStatus.ObjectsLoaded, null));
            } else {
                send(new PacketSetLoadStatus(PacketSetLoadStatus.LoadStatus.MapLoaded, null));
            }
        });
    });

    packets.registerAction(PacketSetLoadStatus.class, packet -> {
        try {
            getRmi().getServer().setLoadStatus(packet.getSender(), packet.getStatus());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    });

    packets.registerAction(PacketUpdateProgress.class, packet -> {
        switch (packet.getId()) {
        case "game_load_objects":
            if (BaseScreen.getSession() == null) {
                System.out.println(
                        "Warning: PacketUpdateProgress received but was not expected. GameSession is null.");
                return;
            }
            BaseScreen.getSession().setObjectsToLoad(packet.getProgress());
            break;
        }
    });

    packets.registerAction(PacketShootProjectile.class, packet -> {
        // If client sended it..send this private id to server.
        if (packet.getSender() != null && packet.getSender().equals(getId())) {
            try {
                getRmi().getServer().shootProjectile(packet.getExactPosition(), packet.getDirection(),
                        packet.getSender());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        } else {
            if (BaseScreen.getSession().getPlayer(packet.getSender()) != null) {
                Gdx.app.postRunnable(() -> {
                    // Server sended this.
                    BaseScreen.getSession().getPlayer(packet.getSender())
                            .shootProjectile(packet.getExactPosition(), packet.getDirection());
                });
            }
        }
    });

    packets.registerAction(PacketObjectMove.class, packet -> {
        if (packet.getSender() != null && packet.getSender().equals(getId())) {
            try {
                getRmi().getServer().objectSetDirection(packet.getSender(), packet.getObject(),
                        packet.getFrom(), packet.getTo());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        } else {
            // Server sent this.
            GameObject object = BaseScreen.getSession().findObject(packet.getObject());
            if (object != null) {
                object.setExactPosition(packet.getFrom());
                object.setDirection(Direction.getDirection((int) packet.getFrom().x, (int) packet.getFrom().y,
                        (int) packet.getTo().x, (int) packet.getTo().y));
            }
        }
    });

    packets.registerAction(PacketPlayerDied.class, packet -> {
        if (packet.getSender() != null && packet.getSender().equals(getId())) {
            try {
                getRmi().getServer().playerDied(packet.getSender());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        } else {
            BaseScreen.getSession().getPlayer(packet.getSender()).setInactive();
        }
    });

    packets.registerAction(PacketBalloonMessage.class, packet -> {
        if (packet.getSender() != null && packet.getSender().equals(getId())) {
            try {
                getRmi().getServer().balloonMessage(packet.getSender(), packet.getTypeName(),
                        packet.getPosition(), packet.getFollowTarget());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        } else {
            // Create balloon on OpenGL thread.
            Gdx.app.postRunnable(() -> {
                try {
                    BalloonMessage message = ((BalloonMessage) Class
                            .forName(BalloonMessage.class.getPackage().getName() + ".messages.Balloon"
                                    + packet.getTypeName())
                            .newInstance());
                    if (packet.getFollowTarget() != null) {
                        message.setFollowObject(BaseScreen.getSession().findObject(packet.getFollowTarget()));
                    } else {
                        message.setPosition(packet.getPosition());
                    }
                    message.addBalloonMessage();
                } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
                    e.printStackTrace();
                }
            });
        }
    });

    packets.registerAction(PacketRemoveItem.class, packet -> {
        if (packet.getSender() != null && packet.getSender().equals(getId())) {
            try {
                getRmi().getServer().removeItem(packet.getSender(), packet.getPlayer(), packet.getItemId(),
                        packet.getItemType());
            } catch (RemoteException ex) {
                ex.printStackTrace();
            }
        } else {
            Item foundItem;

            if ((foundItem = BaseScreen.getSession().findItem(packet.getItemId())) != null) {
                foundItem.activate(BaseScreen.getSession().getPlayer(packet.getPlayer()));
                foundItem.getNode().removeItem();
            }
        }
    });

    packets.registerAction(PacketScoreChanged.class, packet -> {
        if (packet.getSender() != null && packet.getSender().equals(getId())) {
            try {
                getRmi().getServer().changeScore(packet.getSender(), packet.getManipulationType(),
                        packet.getChange());
            } catch (RemoteException ex) {
                ex.printStackTrace();
            }
        } else {
            Score currentScore = BaseScreen.getSession().getScore();

            switch (packet.getManipulationType()) {
            case DECREASE:
                currentScore.decrease(packet.getChange());
                break;
            case INCREASE:
                currentScore.increase(packet.getChange());
                break;
            }
        }
    });

    packets.registerFunc(PacketGetHighscores.class, packet -> {
        java.util.Map<String, Integer> returnMap = new HashMap<>();
        try {
            returnMap = getRmi().getServer().getHighscores(packet.getSender());
        } catch (RemoteException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        }
        return returnMap;
    });
}

From source file:ateamproject.kezuino.com.github.render.screens.BaseScreen.java

public BaseScreen(Game game) {
    skin = Assets.getSkin("uiskin.json");

    // Bootstrap screen.
    renderers = new ArrayList<>();
    inputs = new InputMultiplexer();
    stage = new Stage();
    clearOnRender = true;/*from  w  w  w . j  a v a2 s .  co m*/
    clearOnRenderColor = Color.valueOf("ffffcc");

    // Bootstrap game objects.
    this.game = game;

    // Bootstrap input.
    inputs.addProcessor(stage);
    inputs.addProcessor(new InputAdapter() {
        @Override
        public boolean keyDown(int keycode) {
            switch (keycode) {
            case Input.Keys.F2:
                Gdx.graphics.setDisplayMode(Gdx.graphics.getDesktopDisplayMode().width,
                        Gdx.graphics.getDesktopDisplayMode().height, !Gdx.graphics.isFullscreen());
                break;
            case Input.Keys.F12:
                // Reset the screen.
                try {
                    Constructor<? extends BaseScreen> constructor = BaseScreen.this.getClass()
                            .getConstructor(Game.class);

                    final BaseScreen[] screen = { null };
                    // Reload content.
                    Assets.reloadSkin(false, () -> {
                        try {
                            screen[0] = constructor.newInstance(game);
                            game.setScreen(screen[0]);
                        } catch (InstantiationException | IllegalAccessException
                                | InvocationTargetException ignored) {
                        }

                        if (screen[0] != null) {
                            // Show dialog.
                            new Dialog("Reload", screen[0].skin) {
                                {
                                    text("Skin was reloaded.");
                                    button("Oke");
                                }
                            }.show(screen[0].stage);
                        }
                    });
                } catch (NoSuchMethodException e) {
                    // Show dialog.
                    new Dialog("Error", skin) {
                        {
                            text("Couldn't reload the skin.");
                            button("Oke");
                        }
                    }.show(stage);
                }
                return true;
            }
            return super.keyDown(keycode);
        }
    });
    Gdx.input.setInputProcessor(inputs);

    // Bootstrap view.
    camera = stage.getCamera();
    viewport = new FitViewport(stage.getWidth(), stage.getHeight(), camera);
    stage.setViewport(viewport);
}

From source file:ateamproject.kezuino.com.github.render.screens.GameScreen.java

private void createGui() {
    // Create pause menu.
    pauseMenu = new Dialog("Menu", skin);
    pauseMenu.setKeepWithinStage(false);

    TextButton bContinue = new TextButton("Doorgaan", skin);
    bContinue.addListener(new ClickListener() {
        @Override/*from ww  w . ja  v a  2s .  c  o m*/
        public void clicked(InputEvent event, float x, float y) {
            MoveToAction action = Actions.action(MoveToAction.class);
            action.setPosition(stage.getWidth() / 2 - pauseMenu.getWidth() / 2,
                    stage.getHeight() + pauseMenu.getHeight());
            action.setDuration(0.1f);
            getSession().setPauseMenuShowing(false);

            pauseMenu.hide(action);
        }
    });
    pauseMenu.add(bContinue);

    TextButton bExit = new TextButton("Verlaten", skin);
    bExit.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            PacketKick packet = new PacketKick(PacketKick.KickReasonType.GAME, "Client afgesloten.", null);
            Client.getInstance().send(packet);

            game.setScreen(new MainScreen(game));
        }
    });

    pauseMenu.add(bExit);

    //Create player menu.
    this.playerMenu = new Dialog("Menu", skin) {
    };
}

From source file:ateamproject.kezuino.com.github.render.screens.LoginScreen.java

public LoginScreen(Game game) {
    super(game);//from   ww w . j  a  v a2s.c o  m

    TextField txtUsername = new TextField("pactales1@gmail.com", skin);

    TextField txtPassword = new TextField("pactales!", skin);
    txtPassword.setPasswordCharacter('*');
    txtPassword.setPasswordMode(true);

    TextButton btnLogin = new TextButton("Inloggen", skin);

    btnLogin.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            btnLogin.setTouchable(Touchable.disabled);
            btnLogin.setText("Laden");
            Thread loginThread = new Thread(() -> {
                PacketLoginAuthenticate packet = new PacketLoginAuthenticate(txtUsername.getText(),
                        txtPassword.getText(), null);
                Client.getInstance().send(packet);

                Gdx.app.postRunnable(() -> {
                    // Login was successful..
                    if (Client.getInstance().getId() != null) {
                        PacketLoginUserExists packetUserExists = new PacketLoginUserExists(
                                txtUsername.getText(), null);
                        Client.getInstance().send(packetUserExists);

                        // Handle user doesn't exist.
                        if (!packetUserExists.getResult()) {
                            Dialog d = new Dialog("Geen gebruiker gevonden", skin);
                            d.add("Gebruikersnaam:");
                            TextField f = new TextField("", skin);
                            d.add(f);
                            bExit = new TextButton("Oke", skin);
                            bExit.addListener(new ClickListener() {
                                @Override
                                public void clicked(InputEvent event, float x, float y) {
                                    if (!f.getText().isEmpty()) {
                                        PacketLoginCreateNewUser packet1;
                                        packet1 = new PacketLoginCreateNewUser(f.getText(),
                                                txtUsername.getText());
                                        Client.getInstance().send(packet1);
                                        if (!packet1.getResult()) {
                                            new Dialog("Error", skin) {
                                                {
                                                    text("De naam bestaat al.");
                                                    button("Oke");
                                                }
                                            }.show(stage);
                                        } else {
                                            d.hide();
                                            Client.getInstance().setUsername(f.getText());
                                            game.setScreen(new MainScreen(game));
                                        }
                                    }
                                }
                            });
                            d.add(bExit);
                            d.show(stage);
                        } else {
                            game.setScreen(new MainScreen(game));
                        }
                    } else {
                        new Dialog("Error", skin) {
                            {
                                text(packet.getResult().getMessage());
                                button("Oke");
                            }
                        }.show(stage);
                    }
                    btnLogin.setText("Inloggen");
                    btnLogin.setTouchable(Touchable.enabled);//enable button touch
                });
            });
            loginThread.start();
        }
    });

    txtUsername.setSize(300, 40);
    txtPassword.setSize(300, 40);
    txtPassword.setPasswordMode(true);
    btnLogin.setSize(300, 40);

    btnLogin.setPosition(stage.getWidth() / 2 - btnLogin.getWidth() / 2, 150);
    txtUsername.setPosition(stage.getWidth() / 2 - txtUsername.getWidth() / 2, 300);
    txtPassword.setPosition(stage.getWidth() / 2 - txtPassword.getWidth() / 2, 250);

    stage.addActor(btnLogin);
    stage.addActor(txtUsername);
    stage.addActor(txtPassword);

    backgroundMusic = Assets.getMusicStream("menu.mp3");
}

From source file:ateamproject.kezuino.com.github.render.screens.MainScreen.java

public MainScreen(Game game) {
    super(game);//from  ww  w .j  a v a2  s .  c  o  m

    TextButton tbSearchGame = new TextButton("Spel zoeken", skin);
    tbSearchGame.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            game.setScreen(new LobbyListScreen(game, false));
        }
    });

    TextButton tbClanGame = new TextButton("Clan spel", skin);
    tbClanGame.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            Client client = Client.getInstance();
            PacketGetClans packet = new PacketGetClans();

            client.send(packet);
            ArrayList<String> listclans = packet.getResult();

            if (listclans.isEmpty()) {
                Dialog d = new Dialog("error", skin);
                d.add("Gebruiker zit niet in een clan.");
                TextButton bExit = new TextButton("Oke", skin);
                bExit.addListener(new ClickListener() {
                    @Override
                    public void clicked(InputEvent event, float x, float y) {
                        d.hide();
                    }
                });
                d.add(bExit);
                d.show(stage);
            } else {
                game.setScreen(new LobbyListScreen(game, true));
            }
        }
    });

    TextButton tbHighscores = new TextButton("Highscores", skin);
    tbHighscores.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            game.setScreen(new HighscoreScreen(game, false));
        }
    });

    TextButton tbChangeLook = new TextButton("Uiterlijk aanpassen", skin);
    tbChangeLook.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            game.setScreen(new SkinSelectScreen(game));

        }
    });

    TextButton tbLogout = new TextButton("Uitloggen", skin);
    tbLogout.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            PacketKick packet = new PacketKick(PacketKick.KickReasonType.QUIT, "Logging out.", null);
            Client.getInstance().send(packet);
            game.setScreen(new LoginScreen(game));
        }
    });

    TextButton tbClanManagement = new TextButton("Clan management", skin);
    tbClanManagement.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            game.setScreen(new ClanManagementScreen(game));
        }
    });

    tbChangeLook.setSize(300, 40);
    tbClanGame.setSize(300, 40);
    tbHighscores.setSize(300, 40);
    tbLogout.setSize(300, 40);
    tbSearchGame.setSize(300, 40);
    tbClanManagement.setSize(300, 40);

    float xOfSearchGameButton = stage.getWidth() / 2 - tbSearchGame.getWidth() / 2;
    float yOfSearchGameButton = stage.getHeight() - 50;

    tbSearchGame.setPosition(xOfSearchGameButton, yOfSearchGameButton);
    tbClanGame.setPosition(xOfSearchGameButton, yOfSearchGameButton - 50);
    tbHighscores.setPosition(xOfSearchGameButton, yOfSearchGameButton - 100);
    tbChangeLook.setPosition(xOfSearchGameButton, yOfSearchGameButton - 150);
    tbClanManagement.setPosition(xOfSearchGameButton, yOfSearchGameButton - 200);
    tbLogout.setPosition(xOfSearchGameButton, yOfSearchGameButton - 250);

    stage.addActor(tbSearchGame);
    stage.addActor(tbClanGame);
    stage.addActor(tbHighscores);
    stage.addActor(tbChangeLook);
    stage.addActor(tbClanManagement);
    stage.addActor(tbLogout);

    backgroundMusic = Assets.getMusicStream("menu.mp3");
}

From source file:ca.hiphiparray.amazingmaze.ContinueScreen.java

License:Open Source License

/**
 * Displays the high score dialog.// w ww  .  j a va  2 s  . co  m
 */
public void highScoreDialog() {
    Label.LabelStyle labelStyle = new Label.LabelStyle(
            game.assets.getFont(Assets.MONO_REGULAR, Assets.SMALL_FONT_SIZE), Color.WHITE);
    final Dialog dialog = new Dialog("High Score", game.assets.skin);
    final TextButton okButton = new TextButton("OK", game.assets.skin);
    dialog.getButtonTable().bottom();
    Label label = new Label("Enter your name:", labelStyle);
    label.setScale(.5f);
    label.setWrap(true);
    label.setAlignment(Align.center);
    final TextField nameField = new TextField("", game.assets.skin);
    dialog.add(label).width(500).pad(50);
    dialog.add(nameField);
    dialog.add(okButton).bottom();
    nameField.setTextFieldListener(new TextFieldListener() {
        @Override
        public void keyTyped(TextField textField, char key) {
            name = formatString(nameField.getText());
            if (!name.equals("")) {
                if (key == (char) 13) {
                    displayHighScores(name);
                }
            }
        }
    });
    okButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            name = formatString(nameField.getText());
            if (!name.equals("")) {
                if (okButton.isPressed()) {
                    dialog.hide();
                    displayHighScores(name);
                }
            }
        }
    });
    dialog.addListener(new InputListener() {
        @Override
        public boolean keyDown(InputEvent event, int keycode) {
            name = formatString(nameField.getText());
            if (!name.equals("")) {
                if (keycode == Keys.ENTER) {
                    displayHighScores(name);
                    return true;
                }
            }
            return false;
        }
    });
    dialog.show(stage);
}

From source file:ca.hiphiparray.amazingmaze.FishMiniGame.java

License:Open Source License

/**
 * Constructor for FishMiniGame./*from  ww w. j  a va 2  s. com*/
 *
 * @param game the {@link AmazingMazeGame} instance that is managing this screen.
 * @param player the {@link Player} instance that completed the last level.
 */
public FishMiniGame(final AmazingMazeGame game, Player player) {
    this.game = game;
    this.player = player;
    fishNumber = new int[5];

    fishNumber[0] = this.player.blueCollected;
    fishNumber[1] = this.player.purpleCollected;
    fishNumber[2] = this.player.greenCollected;
    fishNumber[3] = this.player.redCollected;
    fishNumber[4] = this.player.orangeCollected;

    answer = 0;
    for (int i = 0; i < fishNumber.length; i++) {
        answer += fishNumber[i] * fishValue[i];
    }

    stage = new Stage(new ScreenViewport(), this.game.batch);

    menuTable = new Table();
    fishTable = new Table();

    canvas = new Canvas(
            new Pixmap(Gdx.graphics.getWidth(), Gdx.graphics.getHeight() + shift, Pixmap.Format.RGB565));

    menuTable.setFillParent(true);
    menuTable.top();
    fishTable.bottom();
    fishTable.setFillParent(true);

    fishImage = new Image[5];

    TextureAtlas atlas = this.game.assets.manager.get(Assets.GAME_ATLAS_LOCATION, TextureAtlas.class);
    fishImage[0] = new Image(atlas.findRegion(Assets.FISH + Assets.BLUE_MODIFIER));
    fishImage[0].setScale(4f);
    fishImage[1] = new Image(atlas.findRegion(Assets.FISH + Assets.PURPLE_MODIFIER));
    fishImage[1].setScale(4f);
    fishImage[2] = new Image(atlas.findRegion(Assets.FISH + Assets.GREEN_MODIFIER));
    fishImage[2].setScale(4f);
    fishImage[3] = new Image(atlas.findRegion(Assets.FISH + Assets.RED_MODIFIER));
    fishImage[3].setScale(4f);
    fishImage[4] = new Image(atlas.findRegion(Assets.FISH + Assets.ORANGE_MODIFIER));
    fishImage[4].setScale(4f);

    pencilButton = new Button(new TextureRegionDrawable(
            new TextureRegion(this.game.assets.manager.get(Assets.PENCIL_BUTTON, Texture.class))));
    pencilButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (pencilButton.isPressed()) {
                canvas.setColor(drawColor);
            }
        }
    });

    eraserButton = new Button(new TextureRegionDrawable(
            new TextureRegion(this.game.assets.manager.get(Assets.ERASER_BUTTON, Texture.class))));
    eraserButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (eraserButton.isPressed()) {
                canvas.setColor(clearColor);
            }
        }
    });

    helpButton = new Button(new TextureRegionDrawable(
            new TextureRegion(this.game.assets.manager.get(Assets.HELP_BUTTON, Texture.class))));
    helpButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (helpButton.isPressed()) {
                Label.LabelStyle labelStyle = new Label.LabelStyle(
                        game.assets.getFont(Assets.MONO_REGULAR, Assets.SMALL_FONT_SIZE), Color.WHITE);
                final Dialog dialog = new Dialog("Help", game.assets.skin);
                final TextButton okButton = new TextButton("OK", game.assets.skin);
                dialog.getButtonTable().bottom();
                Label label = new Label("Find the total value of fish that you retrieved!\n"
                        + "Each colour corresponds to the colour of Canadian money.\n"
                        + "The numbers correspond to each number of fish you got.\n\n"
                        + "In case you forgot: blue is 5, purple is 10, green is 20, red is 50, and orange is 100.",
                        labelStyle);
                label.setScale(.5f);
                label.setWrap(true);
                label.setAlignment(Align.center);
                dialog.add(label).width(500).pad(50);
                dialog.add(okButton).bottom();
                okButton.addListener(new ChangeListener() {
                    @Override
                    public void changed(ChangeEvent event, Actor actor) {
                        if (okButton.isPressed()) {
                            dialog.hide();
                            canvas.setColor(drawColor);
                        }
                    }
                });
                dialog.key(Keys.ENTER, true);
                dialog.show(stage);
            }
        }
    });

    checkButton = new Button(new TextureRegionDrawable(
            new TextureRegion(this.game.assets.manager.get(Assets.CHECK_BUTTON, Texture.class))));
    checkButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            dialog();
        }
    });

    clearButton = new Button(new TextureRegionDrawable(
            new TextureRegion(this.game.assets.manager.get(Assets.CLEAR_BUTTON, Texture.class))));
    clearButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (clearButton.isPressed()) {
                canvas.clear();
                canvas.setColor(drawColor);
            }
        }
    });

    answerField = new TextField("", game.assets.skin);
    answerField.setTextFieldListener(new TextFieldListener() {
        @Override
        public void keyTyped(TextField textField, char key) {
            if (key == (char) 13) {
                stage.unfocus(answerField);
                dialog();
            }
        }
    });
    stage.addActor(menuTable);
    stage.addActor(canvas);
    stage.addActor(fishTable);

    menuTable.clear();
    fishTable.clear();
    helpButton.right();
    menuTable.background(new TextureRegionDrawable(
            new TextureRegion(this.game.assets.manager.get(Assets.MINI_BACKGROUND, Texture.class))));
    menuTable.add(pencilButton).pad(10).size(64);
    menuTable.add(eraserButton).pad(10).size(64);
    menuTable.add(clearButton).pad(10).size(64);
    menuTable.add(helpButton).pad(10).size(64);

    menuTable.row();

    Label.LabelStyle labelStyle = new Label.LabelStyle(
            game.assets.getFont(Assets.SANS_REGULAR, Assets.REGULAR_FONT_SIZE), Color.WHITE);

    for (int i = 0; i < 5; i++) {
        fishTable.add(fishImage[i]).bottom().left().padLeft(10);
    }
    fishTable.add(answerField).minWidth(150).padLeft(150);
    fishTable.add(checkButton).pad(10).size(64);
    fishTable.row();

    for (int i = 0; i < 5; i++) {
        fishTable.add(new Label(fishNumber[i] + "", labelStyle)).pad(30).center();
    }
    fishTable.row();

    setupPauseMenu();
    input = new InputMultiplexer(stage, this);
    input.addProcessor(pauseMenu);
}

From source file:ca.hiphiparray.amazingmaze.FishMiniGame.java

License:Open Source License

/**
 * Displays the results dialog./* w ww .  j a va2  s .c  om*/
 */
public void dialog() {
    message = formatString(answerField.getText());
    Label.LabelStyle labelStyle = new Label.LabelStyle(
            game.assets.getFont(Assets.MONO_REGULAR, Assets.SMALL_FONT_SIZE), Color.WHITE);
    final Dialog dialog = new Dialog("Results", game.assets.skin);
    final TextButton okButton = new TextButton("OK", game.assets.skin);
    dialog.getButtonTable().bottom();
    if (checkAnswer() == -1) {
        Label label = new Label("Invalid answer. Please try again.", labelStyle);
        label.setScale(.5f);
        label.setWrap(true);
        label.setAlignment(Align.center);
        dialog.add(label).width(500).pad(50);
        dialog.add(okButton).bottom();
        okButton.addListener(new ChangeListener() {
            @Override
            public void changed(ChangeEvent event, Actor actor) {
                if (okButton.isPressed()) {
                    dialog.hide();
                    canvas.setColor(drawColor);
                }
            }
        });
        dialog.addListener(new InputListener() {
            @Override
            public boolean keyDown(InputEvent event, int keycode) {
                if (keycode == Keys.ENTER) {
                    dialog.hide();
                    return true;
                }
                return false;
            }
        });
    } else {
        Label label = new Label("Your answer was: " + message + ". " + "The correct answer was: " + answer
                + ". " + "You get " + checkAnswer() + " back!", labelStyle);
        game.save.addScore(checkAnswer());
        game.save.setLives(player.getLives());
        label.setScale(.5f);
        label.setWrap(true);
        label.setAlignment(Align.center);
        dialog.add(label).width(500).pad(50);
        dialog.add(okButton).bottom();
        okButton.addListener(new ChangeListener() {
            @Override
            public void changed(ChangeEvent event, Actor actor) {
                if (okButton.isPressed()) {
                    dialog.cancel();
                    if ((game.save.getLevel() - 1) % 5 == 0) {
                        game.setScreen(new ContinueScreen(game, true));
                    } else {
                        game.setScreen(new MazeScreen(game, false));
                    }
                }
            }
        });
        dialog.addListener(new InputListener() {
            @Override
            public boolean keyDown(InputEvent event, int keycode) {
                if (keycode == Keys.ENTER) {
                    if ((game.save.getLevel() - 1) % 5 == 0) {
                        game.setScreen(new ContinueScreen(game, true));
                    } else {
                        game.setScreen(new MazeScreen(game, false));
                    }
                    return true;
                }
                return false;
            }
        });
    }
    dialog.show(stage);
}

From source file:ca.hiphiparray.amazingmaze.MainMenuScreen.java

License:Open Source License

/**
 * Creates the main menu.//  w  ww . ja  v a  2 s  . c  o m
 *
 * @param game The instance for the AmazingMazeGame used.
 */
public MainMenuScreen(final AmazingMazeGame game) {
    this.game = game;
    menu = new Stage(new ScreenViewport(), this.game.batch);

    table = new Table();

    table.setFillParent(true);
    table.bottom();
    menu.addActor(table);

    menuTitle = new Image(this.game.assets.manager.get(Assets.GAME_LOGO, Texture.class));

    // Play
    playButton = new TextButton("Play", game.assets.skin);
    playButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (playButton.isPressed()) {
                game.setScreen(game.storyScreen);
            }
        }
    });

    // Help
    helpButton = new TextButton("Help", game.assets.skin);
    helpButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (helpButton.isPressed()) {
                game.setScreen(new HelpScreen(game));
            }
        }
    });

    // Settings
    settingsButton = new TextButton("Settings", game.assets.skin);
    settingsButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (settingsButton.isPressed()) {
                game.setScreen(game.settingsScreen);
            }
        }
    });

    // Credits
    creditsButton = new TextButton("Credits", game.assets.skin);
    creditsButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (creditsButton.isPressed()) {
                game.setScreen(new CreditsScreen(game));
            }
        }
    });

    licenseDialog = new Dialog("License Information", game.assets.skin);
    licenseDialog.button("Okay");

    licenseDialog.text(
            "Amazing Maze is an educational game created in Java with the libGDX library.\n"
                    + "Copyright (C) 2017 Hip Hip Array\n" + "\n"
                    + "Amazing Maze is free software: you can redistribute it and/or modify\n"
                    + "it under the terms of the GNU General Public License as published by\n"
                    + "the Free Software Foundation, either version 3 of the License, or\n"
                    + "(at your option) any later version.\n" + "\n"
                    + "Amazing Maze is distributed in the hope that it will be useful,\n"
                    + "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
                    + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
                    + "GNU General Public License for more details.\n" + "\n"
                    + "You should have received a copy of the GNU General Public License\n"
                    + "along with Amazing Maze. If not, see <http://www.gnu.org/licenses/>.",
            game.assets.skin.get(Assets.WHITE_SANS_STYLE, LabelStyle.class));

    // License
    licenseButton = new TextButton("License", game.assets.skin);
    licenseButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (licenseButton.isPressed()) {
                licenseDialog.show(menu);
            }
        }
    });

    // High scores
    highScoresButton = new TextButton("High Scores", game.assets.skin);
    highScoresButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (highScoresButton.isPressed()) {
                game.setScreen(game.highScoresScreen);
            }
        }
    });

    // Quit
    quitButton = new TextButton("Quit", game.assets.skin);
    quitButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (quitButton.isPressed()) {
                game.save.writeScores();
                game.save.writeSettings();
                Gdx.app.exit();
            }
        }
    });
}

From source file:com.bladecoder.engine.ui.MenuScreen.java

License:Apache License

@Override
public void show() {
    stage = new Stage(new ScreenViewport());

    final Skin skin = ui.getSkin();
    final World world = World.getInstance();

    final MenuScreenStyle style = skin.get(MenuScreenStyle.class);
    final BitmapFont f = skin.get(style.textButtonStyle, TextButtonStyle.class).font;
    float buttonWidth = f.getCapHeight() * 15f;

    // Image background = new Image(style.background);
    Drawable bg = style.background;//from w  ww . j a  v  a 2  s .co  m

    if (bg == null && style.bgFile != null) {
        bgTexFile = new Texture(EngineAssetManager.getInstance().getResAsset(style.bgFile));
        bgTexFile.setFilter(TextureFilter.Linear, TextureFilter.Linear);

        bg = new TextureRegionDrawable(new TextureRegion(bgTexFile));
    }

    final Table table = new Table();
    table.setFillParent(true);
    table.center();

    if (bg != null)
        table.setBackground(bg);

    table.addListener(new InputListener() {
        @Override
        public boolean keyUp(InputEvent event, int keycode) {
            if (keycode == Input.Keys.ESCAPE || keycode == Input.Keys.BACK)
                if (world.getCurrentScene() != null)
                    ui.setCurrentScreen(Screens.SCENE_SCREEN);

            return true;
        }
    });

    table.defaults().pad(BUTTON_PADDING).width(buttonWidth);

    stage.setKeyboardFocus(table);

    if (style.showTitle) {

        Label title = new Label(Config.getProperty(Config.TITLE_PROP, "Adventure Blade Engine"), skin,
                style.titleStyle);

        title.setAlignment(Align.center);

        table.add(title).padBottom(DPIUtils.getMarginSize() * 2);
        table.row();
    }

    if (world.savedGameExists() || world.getCurrentScene() != null) {
        TextButton continueGame = new TextButton(I18N.getString("ui.continue"), skin, style.textButtonStyle);

        continueGame.addListener(new ClickListener() {
            public void clicked(InputEvent event, float x, float y) {
                if (world.getCurrentScene() == null)
                    try {
                        world.load();
                    } catch (Exception e) {
                        Gdx.app.exit();
                    }

                ui.setCurrentScreen(Screens.SCENE_SCREEN);
            }
        });

        table.add(continueGame);
    }

    TextButton newGame = new TextButton(I18N.getString("ui.new"), skin, style.textButtonStyle);
    newGame.addListener(new ClickListener() {
        public void clicked(InputEvent event, float x, float y) {
            if (world.savedGameExists()) {
                Dialog d = new Dialog("", skin) {
                    protected void result(Object object) {
                        if (((Boolean) object).booleanValue()) {
                            try {
                                world.newGame();
                            } catch (Exception e) {
                                Gdx.app.exit();
                            }
                            ui.setCurrentScreen(Screens.SCENE_SCREEN);
                        }
                    }
                };

                d.pad(DPIUtils.getMarginSize());
                d.getButtonTable().padTop(DPIUtils.getMarginSize());
                d.getButtonTable().defaults().padLeft(DPIUtils.getMarginSize())
                        .padRight(DPIUtils.getMarginSize());

                Label l = new Label(I18N.getString("ui.override"), ui.getSkin(), "ui-dialog");
                l.setWrap(true);
                l.setAlignment(Align.center);

                d.getContentTable().add(l).prefWidth(Gdx.graphics.getWidth() * .7f);

                d.button(I18N.getString("ui.yes"), true, ui.getSkin().get("ui-dialog", TextButtonStyle.class));
                d.button(I18N.getString("ui.no"), false, ui.getSkin().get("ui-dialog", TextButtonStyle.class));
                d.key(Keys.ENTER, true).key(Keys.ESCAPE, false);

                d.show(stage);
            } else {

                try {
                    world.newGame();
                } catch (Exception e) {
                    Gdx.app.exit();
                }
                ui.setCurrentScreen(Screens.SCENE_SCREEN);
            }
        }
    });

    table.row();
    table.add(newGame);

    TextButton loadGame = new TextButton(I18N.getString("ui.load"), skin, style.textButtonStyle);
    loadGame.addListener(new ClickListener() {
        public void clicked(InputEvent event, float x, float y) {
            ui.setCurrentScreen(Screens.LOAD_GAME_SCREEN);
        }
    });

    table.row();
    table.add(loadGame);

    //      if (world.getCurrentScene() != null) {
    //         TextButton saveGame = new TextButton(I18N.getString("ui.save"), skin, style.textButtonStyle);
    //         saveGame.addListener(new ClickListener() {
    //            public void clicked(InputEvent event, float x, float y) {
    //               ui.setCurrentScreen(Screens.SAVE_GAME_SCREEN);
    //            }
    //         });
    //
    //         table.row();
    //         table.add(saveGame);
    //      }

    TextButton quit = new TextButton(I18N.getString("ui.quit"), skin, style.textButtonStyle);
    quit.addListener(new ClickListener() {
        public void clicked(InputEvent event, float x, float y) {
            Gdx.app.exit();
        }
    });

    table.row();
    table.add(quit);

    table.pack();

    stage.addActor(table);

    // BOTTOM-RIGHT BUTTON STACK
    credits = new Button(skin, "credits");
    credits.addListener(new ClickListener() {
        public void clicked(InputEvent event, float x, float y) {
            ui.setCurrentScreen(Screens.CREDIT_SCREEN);
        }
    });

    help = new Button(skin, "help");
    help.addListener(new ClickListener() {
        public void clicked(InputEvent event, float x, float y) {
            ui.setCurrentScreen(Screens.HELP_SCREEN);
        }
    });

    debug = new Button(skin, "debug");
    debug.addListener(new ClickListener() {
        public void clicked(InputEvent event, float x, float y) {
            DebugScreen debugScr = new DebugScreen();
            debugScr.setUI(ui);
            ui.setCurrentScreen(debugScr);
        }
    });

    Table buttonStack = new Table();
    buttonStack.defaults().pad(DPIUtils.getSpacing()).size(DPIUtils.getPrefButtonSize(),
            DPIUtils.getPrefButtonSize());
    buttonStack.pad(DPIUtils.getMarginSize() * 2);

    if (EngineLogger.debugMode() && world.getCurrentScene() != null) {
        buttonStack.add(debug);
        buttonStack.row();
    }

    buttonStack.add(help);
    buttonStack.row();
    buttonStack.add(credits);
    buttonStack.bottom().right();
    buttonStack.setFillParent(true);
    buttonStack.pack();
    stage.addActor(buttonStack);

    Label version = new Label("v" + Config.getProperty(Config.VERSION_PROP, " unspecified"), skin);
    version.setPosition(DPIUtils.getMarginSize(), DPIUtils.getMarginSize());
    stage.addActor(version);

    debug.addListener(new ClickListener() {
        public void clicked(InputEvent event, float x, float y) {
            DebugScreen debugScr = new DebugScreen();
            debugScr.setUI(ui);
            ui.setCurrentScreen(debugScr);
        }
    });

    pointer = new Pointer(skin);
    stage.addActor(pointer);

    Gdx.input.setInputProcessor(stage);
}