2D Game Engine Pacman Example

package com.sundttranb.game;

import java.awt.Color;
import java.awt.event.KeyEvent;

import com.sundttranb.engine.core.GameEngine;
import com.sundttranb.engine.core.GameObject;
import com.sundttranb.engine.core.game.entities.Entity;
import com.sundttranb.engine.core.game.entities.Mob;
import com.sundttranb.engine.core.game.entities.Player;
import com.sundttranb.engine.core.game.levels.Level;
import com.sundttranb.engine.core.game.levels.tiles.Tile;
import com.sundttranb.engine.core.input.InputHandler;
import com.sundttranb.engine.physics.PhysicsEngine;
import com.sundttranb.engine.physics.entities.BasicTopDownEntityPhysics;
import com.sundttranb.engine.physics.utils.Point;
import com.sundttranb.engine.rendering.RenderEngine;
import com.sundttranb.engine.rendering.Window;
import com.sundttranb.engine.rendering.graphics.AnimatedSprite;
import com.sundttranb.engine.rendering.graphics.Sprite;
import com.sundttranb.engine.rendering.graphics.sheets.Font;
import com.sundttranb.engine.rendering.graphics.sheets.SpriteSheet;
import com.sundttranb.engine.rendering.graphics.utils.ColorEntityMapper;
import com.sundttranb.engine.rendering.graphics.utils.ColorTileMapper;

public class Game extends GameObject
{

    private GameEngine gameEngine;

    private Level level;
    private Pacman player;

    private boolean won;
    private boolean lost;

    public Game(boolean scroll, boolean platformer)
    {
        Window.init(512, 536, "Pacman Demo");
        gameEngine = new GameEngine(this, scroll, platformer);
        RenderEngine.init();
        PhysicsEngine.init();
        Window.create(gameEngine);
    }

    public void init()
    {
        // RENDERING
        RenderEngine.addSpriteSheet(new SpriteSheet("res/textures/spritesheet.png"));
        RenderEngine.addFont(new Font("res/textures/fonts.png", "res/textures/fonts.txt", 7, 7));

        ColorTileMapper.addPair(new Color(63, 79, 156), new Tile("00010"));
        ColorTileMapper.addPair(new Color(255, 180, 119), new Tile("00100"));

        ColorEntityMapper.addPair(new Color(255, 255, 0), new Player("010111", null));
        ColorEntityMapper.addPair(new Color(255, 0, 0), new Ghost("02010", null));
        ColorEntityMapper.addPair(new Color(0, 255, 255), new Ghost("02110", null));
        ColorEntityMapper.addPair(new Color(255, 94, 217), new Ghost("02210", null));
        ColorEntityMapper.addPair(new Color(255, 106, 0), new Ghost("02310", null));

        // GAME
        level = new Level("res/levels/basic_level/basic_level_tiles.png", "res/levels/basic_level/basic_level_entities.png");
        Player p = level.getPlayer();
        player = new Pacman(p.getSpriteID(), p.getLevel());
        player.setPhysics(new BasicTopDownEntityPhysics(player, level));
        player.setX(p.getX());
        player.setY(p.getY());
        level.setPlayer(player);
    }

    public void update()
    {
        if (!lost && !won)
        {
            level.update();
            player.update();
            checkEntityCollision();

            int pellets = countPellets();
            if (pellets == 0)
                won = true;
        }
    }

    public boolean isPellet(Tile tile)
    {
        return tile.getSpriteID().substring(0, 3).equals("001");
    }

    public int countPellets()
    {
        int count = 0;

        for (int r = 0; r < level.getNRows(); r++)
            for (int c = 0; c < level.getNCols(); c++)
                if (level.getTile(r, c) != null && isPellet(level.getTile(r, c)))
                    count++;

        return count;
    }

    private void checkEntityCollision()
    {
        float px = player.getX();
        float py = player.getY();
        for (int i = 0; i < level.getNEntities(); i++)
        {
            Mob mob = (Mob) level.getEntity(i);
            float mx = mob.getX();
            float my = mob.getY();

            if (mx >= px && mx <= px + Player.WIDTH && my >= py && my <= py + Player.HEIGHT)
            {
                lost = true;
                break;
            }
        }
    }

    public void render()
    {
        level.draw();
        player.draw();

        RenderEngine.drawString("SCORE:" + player.getScore(), 0, 512, RenderEngine.getFont(0), 3, Color.ORANGE);

        if (won)
            RenderEngine.drawString("YOU WIN!", 256, 512, RenderEngine.getFont(0), 3, Color.GREEN);
        else if (lost)
            RenderEngine.drawString("YOU LOSE!", 256,512, RenderEngine.getFont(0), 3, Color.RED);
    }

    public static void main(String args[])
    {
        Game game = new Game(false, false);
    }

}

class Pacman extends Player implements Entity
{

    private int score;

    private AnimatedSprite sprite;

    private static final int UP = 0;
    private static final int DOWN = 1;
    private static final int LEFT = 2;
    private static final int RIGHT = 3;
    private int facing;

    private boolean moving;

    public Pacman(String spriteID, Level level)
    {
        super(spriteID, level);

        sprite = (AnimatedSprite) super.sprite;

        facing = -1;
    }

    @Override
    public void update()
    {
        pollInput();
        physics.update();
        if (moving)
            sprite.update();
        else
            sprite.reset();
        checkScore();

        if (facing == UP)
            sprite.rotateCurrentFrame(-90);
        else if (facing == DOWN)
            sprite.rotateCurrentFrame(90);
        else if (facing == LEFT)
            sprite.rotateCurrentFrame(180);
    }

    private void pollInput()
    {
        boolean w = InputHandler.isPressed(KeyEvent.VK_W);
        boolean s = InputHandler.isPressed(KeyEvent.VK_S);
        boolean a = InputHandler.isPressed(KeyEvent.VK_A);
        boolean d = InputHandler.isPressed(KeyEvent.VK_D);

        physics.setUp(w);
        physics.setDown(s);
        physics.setLeft(a);
        physics.setRight(d);

        checkFace(w, s, a, d);

        moving = w || s || a || d;
    }

    private void checkFace(boolean w, boolean s, boolean a, boolean d)
    {
        if (w)
            facing = UP;
        if (s)
            facing = DOWN;
        if (a)
            facing = LEFT;
        if (d)
            facing = RIGHT;
    }

    private void checkScore()
    {
        int r = Math.round(getY() / Tile.SIZE);
        int c = Math.round(getX() / Tile.SIZE);
        if (level.getTile(r, c) != null && isPellet(level.getTile(r, c)))
        {
            level.setTile(r, c, null);
            score += 5;
        }
    }

    public boolean isPellet(Tile tile)
    {
        return tile.getSpriteID().substring(0, 3).equals("001");
    }

    public AnimatedSprite getAnimatedSprite()
    {
        return (AnimatedSprite) sprite;
    }

    public int getScore()
    {
        return score;
    }

}

class Ghost extends Mob implements Entity
{

    private boolean attacking;

    public Ghost(String spriteID, Level level)
    {
        super(spriteID, level);

        maxMoves = 50;
    }

    @Override
    public void update()
    {
        move();
        physics.update();
    }

    private void move()
    {
        Point point = new Point((int)getX(), (int)getY());
        Point playerPoint = new Point((int)level.getPlayer().getX(), (int)level.getPlayer().getY());
        int dist = point.calcDistance(playerPoint);

        if (attacking)
        {
            physics.setUp(false);
            physics.setDown(false);
            physics.setLeft(false);
            physics.setRight(false);
        }
        if (dist >= Tile.SIZE * 3)
        {
            attacking = false;
            physics.setMoveSpeed(1.0f);

            if (moves == 0)
            {
                physics.setUp(false);
                physics.setDown(false);
                physics.setLeft(false);
                physics.setRight(false);

                int dir = (int)(Math.random() * 4);

                if (dir == 0)
                    physics.setUp(true);
                else if (dir == 1)
                    physics.setDown(true);
                else if (dir == 2)
                    physics.setLeft(true);
                else if (dir == 3)
                    physics.setRight(true);

                moves = maxMoves;
            }
            else
            {
                moves--;

                if (getX() == lastX && getY() == lastY)
                    moves = 0;

                lastX = getX();
                lastY = getY();
            }
        }
        else
        {
            attacking = true;
            physics.setMoveSpeed(1.5f);

            if (getY() >= level.getPlayer().getY())
                physics.setUp(true);
            if (getY() <= level.getPlayer().getY())
                physics.setDown(true);
            if (getX() >= level.getPlayer().getX())
                physics.setLeft(true);
            if (getX() <= level.getPlayer().getX())
                physics.setRight(true);
        }
    }

    @Override
    public Entity clone()
    {
        return new Ghost(spriteID, level);
    }

}