MenuGameState.java

package uk.co.flyingsquirrels.gamestates;

import java.util.ArrayList;
import java.util.List;

import org.newdawn.slick.Color;
import org.newdawn.slick.Font;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.state.BasicGameState;
import org.newdawn.slick.state.StateBasedGame;

import uk.co.flyingsquirrels.menuoptions.MenuOption;
import uk.co.flyingsquirrels.utils.FontFactory;

public class MenuGameState extends BasicGameState {

	private static final int START_Y = 250;
	private static final int SPACING_Y = 50;

	private final int id;
	private final String title;
	private final Font font;

	private final List<MenuOption> menuOptions = new ArrayList<MenuOption>();
	private int optionIndex;

	private int maxTextWidth;

	public MenuGameState(int id) {
		this(id, null);
	}
	
	public MenuGameState(int id, String title) {
		this.id = id;
		this.title = title;
		font = FontFactory.loadFont("demo2");
	}

	public void addMenuOption(MenuOption menuOption) {
		menuOptions.add(menuOption);
	}

	public int getID() {
		return id;
	}

	public final void init(GameContainer container, StateBasedGame game)
			throws SlickException {
		initInternal(container, game);
		calculateMaxOptionWidth();
	}

	private void calculateMaxOptionWidth() {
		for (MenuOption menuOption : menuOptions) {
			int optionWidth = font.getWidth(menuOption.getText());
			if (optionWidth > maxTextWidth) {
				maxTextWidth = optionWidth;
			}
		}
	}

	public final void render(GameContainer container, StateBasedGame game,
			Graphics g) throws SlickException {
		if (renderInternal(container, game, g)) {
			return;
		}
		
		if (title != null) {
			drawCentredString(container, font, title, 50);
		}

		for (int i = 0; i < menuOptions.size(); i++) {
			drawString(container, font, menuOptions.get(i).getText(), START_Y
					+ (i * SPACING_Y));
			if (i == optionIndex) {
				g.setColor(Color.white);
				g.drawRect(container.getWidth() / 2 - maxTextWidth / 2 - 20,
						START_Y - 10 + (i * SPACING_Y), maxTextWidth + 40, 50);
			}
		}
	}

	private void drawString(GameContainer container, Font font, String text,
			int y) {
		font.drawString(calculateFontXOffset(container, font, text), y, text);
	}

	protected void drawCentredString(GameContainer container, Font font,
			String text, int y) {
		font.drawString(calculateFontXOffset(container, font, text), y, text);
	}

	private int calculateFontXOffset(GameContainer container, Font font,
			String text) {
		return (container.getWidth() / 2 - font.getWidth(text) / 2);
	}

	public void update(GameContainer container, StateBasedGame game, int delta)
			throws SlickException {
	}

	public final void keyReleased(int key, char c) {
		if (keyReleasedInternal(key, c)) {
			return;
		}
		if (key == Input.KEY_DOWN) {
			optionIndex++;
			if (optionIndex >= menuOptions.size()) {
				optionIndex = 0;
			}
		}
		if (key == Input.KEY_UP) {
			optionIndex--;
			if (optionIndex < 0) {
				optionIndex = menuOptions.size() - 1;
			}
		}

		if (key == Input.KEY_ENTER) {
			menuOptions.get(optionIndex).select();
		}
	}

	public void initInternal(GameContainer container, StateBasedGame game)
			throws SlickException {
	}

	/**
	 * @return true in your subclass to skip further rendering
	 */
	protected boolean renderInternal(GameContainer container,
			StateBasedGame game, Graphics g) throws SlickException {
		return false;
	}

	/**
	 * @return true in your subclass to skip further key processing
	 */
	protected boolean keyReleasedInternal(int key, char c) {
		return false;
	}

}