Dream.In.Code -> Object-Oriented Java Tile Engine

Subscribe to Six's Game Programming Adventures

1 Votes

Object-Oriented Java Tile Engine

11 January 2012

1 Comments

Posted by SixOfEleven

I’ve been continuing work on my Java tile engine. It is continuing to evolve as is my Java knowledge. I’ve been moving to an object-oriented tile engine. There is now a map class that represents a tile map and a layer class that represents a layer of the map since I’m making a layered tile engine. At the moment there are two layers: the base layer that defines the ground and a second layer which is a decoration layer. In the future I will be moving to an unlimited, in theory, number of layers but one step at a time though. I also created a class that represents a tile set and a class for a camera that controls scrolling the map. I also created a couple utility classes. The first is used in drawing the tiles, a rectangle type class. The other represents a two dimensional vector. The vector class will continue to evolve as my game programming adventures continue.

Moving to use object-oriented programming in games is something I encourage others to do. Games can grow to be quiet complex and using objects makes them more manageable. There are times where you may want to break OOP though because following it strictly can hinder your development. In a strict OOP sense other objects shouldn’t know about the internal workings of other object. You interact with other objects using a well defined public interface. When I say interface I’m not talking Java interfaces, I’m talking a well defined set of methods for interacting with the object. You could use a Java interface to define these methods that way others who look at your code, or even yourself months down the line, will understand the object better.

With the tile engine shaping up it is time to consider what I want to do with it. I might look at creating a simple RPG with it, my favorite genre of course. First though I need to work out some more mechanics when it comes to programming games with Java. I’m taking the first steps on my adventure and truly enjoying it. Thanks for reading and as always the code for this adventure.

JavaTileEngine.java

Spoiler

import javax.swing.*;

public class JavaTileEngine extends JFrame {

    public static final int WINDOW_WIDTH = 800;
    public static final int WINDOW_HEIGHT = 600;
    
    private GamePanel gamePanel;
    
    public JavaTileEngine() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        setTitle("Tile Engine");
        setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
        setResizable(false);
        
        gamePanel = new GamePanel();
        add(gamePanel);
        
        setVisible(true);
    }
    
    public static void main(String[] args) {
        new JavaTileEngine();
    }
}

GamePanel.java

Spoiler

import javax.swing.*;

import java.awt.*;
import java.awt.event.*;

public class GamePanel extends JPanel implements ActionListener, KeyListener {
	private TileSet tileSet;
    private static Image buffer;
    private static Graphics bufferGraphics;
    
    private TileMap map;
    private Camera camera;
    
    private boolean isLeftDown = false;
    private boolean isRightDown = false;
    private boolean isUpDown = false;
    private boolean isDownDown = false;
    
    public GamePanel() {
    	// set the size of the panel using constants from the JFrame
        setSize(JavaTileEngine.WINDOW_WIDTH, JavaTileEngine.WINDOW_HEIGHT);
                
        setFocusable(true);
        requestFocus();
        
        Image tileSetImage = Toolkit.getDefaultToolkit().createImage("tileset1.png");
        prepareImage(tileSetImage, this);
        
        tileSet = new TileSet(tileSetImage, 512, 512, 32, 32);

        camera = new Camera();

        map = new TileMap(100, 100, 32, 32, tileSet);
                
        this.addKeyListener(this);
        
        Timer timer = new Timer(16, this);
        timer.start();
    }
    
    public void actionPerformed(ActionEvent e) {
        gameUpdate();
        gameRender();
        repaint();                
    }
    
    public void paintComponent(Graphics g) {
        super.paintChildren(g);
        g.drawImage(buffer, 0, 0, null);
        Toolkit.getDefaultToolkit().sync();
    }
    
    public void gameUpdate() {
    	
    	Vector2 motion = Vector2.zeroVector();
    	
    	if (isLeftDown)
    		motion.X -= 1;
    	else if (isRightDown)
    		motion.X += 1;
    	if (isUpDown)
    		motion.Y -= 1;
    	else if (isDownDown)
    		motion.Y += 1;
    	    	
    	motion.multiply(camera.getSpeed());
    	camera.getPosition().add(motion);
    	
    	camera.lockCamera(JavaTileEngine.WINDOW_WIDTH, JavaTileEngine.WINDOW_HEIGHT, TileMap.getMapWidthInPixels(), TileMap.getMapHeightInPixels());
    }
    
    public void gameRender() {
        if (buffer == null || bufferGraphics == null) {
            buffer = this.createImage(JavaTileEngine.WINDOW_WIDTH, JavaTileEngine.WINDOW_HEIGHT);
            bufferGraphics = buffer.getGraphics();        
        }
        
        bufferGraphics.setColor(Color.lightGray);
        bufferGraphics.fillRect(0, 0, getWidth(), getHeight());
        
        map.Draw(bufferGraphics, camera);
    }

	@Override
	public void keyPressed(KeyEvent arg0) {
		// TODO Auto-generated method stub
		if (arg0.getKeyCode() == KeyEvent.VK_DOWN || arg0.getKeyCode() == KeyEvent.VK_KP_DOWN)
			isDownDown = true;
		if (arg0.getKeyCode() == KeyEvent.VK_UP || arg0.getKeyCode() == KeyEvent.VK_KP_UP)
			isUpDown = true;
		if (arg0.getKeyCode() == KeyEvent.VK_LEFT || arg0.getKeyCode() == KeyEvent.VK_KP_LEFT)
			isLeftDown = true;
		if (arg0.getKeyCode() == KeyEvent.VK_RIGHT || arg0.getKeyCode() == KeyEvent.VK_KP_RIGHT)
			isRightDown = true;
	}

	@Override
	public void keyReleased(KeyEvent arg0) {
		// TODO Auto-generated method stub
		if (arg0.getKeyCode() == KeyEvent.VK_DOWN || arg0.getKeyCode() == KeyEvent.VK_KP_DOWN)
			isDownDown = false;
		if (arg0.getKeyCode() == KeyEvent.VK_UP || arg0.getKeyCode() == KeyEvent.VK_KP_UP)
			isUpDown = false;
		if (arg0.getKeyCode() == KeyEvent.VK_LEFT || arg0.getKeyCode() == KeyEvent.VK_KP_LEFT)
			isLeftDown = false;
		if (arg0.getKeyCode() == KeyEvent.VK_RIGHT || arg0.getKeyCode() == KeyEvent.VK_KP_RIGHT)
			isRightDown = false;		
	}

	@Override
	public void keyTyped(KeyEvent arg0) {
		// TODO Auto-generated method stub
		
	}
}

TileMap.java

Spoiler

import java.awt.Graphics;
import java.util.Random;

public class TileMap {
	private TileSet tileSet;
	private TileLayer[] layers;
	private static int mapWidth;
	private static int mapHeight;
	private static int tileWidth;
	private static int tileHeight;
	
	public TileMap(int mapWidth, int mapHeight, int tileWidth, int tileHeight, TileSet tileSet) {
		this.tileSet = tileSet;
		TileMap.mapWidth = mapWidth;
		TileMap.mapHeight = mapHeight;
		TileMap.tileWidth = tileWidth;
		TileMap.tileHeight = tileHeight;
		
		layers = new TileLayer[2];
		
		layers[0] = new TileLayer(mapWidth, mapHeight);
		layers[1] = new TileLayer(mapWidth, mapHeight);
		
		for (int x = 0; x < mapWidth; x++) {
			for (int y = 0; y < mapHeight; y++) {
				layers[0].setTile(x, y, 0);
				layers[1].setTile(x, y, -1);
			}
		}
		
		Random rand = new Random();
		
		for (int i = 0; i < 200; i++) {
			int x = rand.nextInt(mapWidth);
			int y = rand.nextInt(mapHeight);
			int tile = rand.nextInt(5) + 2;
			
			layers[1].setTile(x, y, tile);
		}
	}
	
	public static int getMapWidth() {
		return mapWidth;
	}
	
	public static int getMapHeight() {
		return mapHeight;
	}
	
	public static int getMapWidthInPixels() {
		return mapWidth * tileWidth;
	}
	
	public static int getMapHeightInPixels() {
		return mapHeight * tileHeight;
	}
	
	public void Draw(Graphics g, Camera camera) {
        int dx1 = 0;
        int dx2 = 0;
        int dy1 = 0;
        int dy2 = 0;
        int sx1 = 0;
        int sx2 = 0;
        int sy1 = 0;
        int sy2 = 0;
        
        for (int i = 0; i < layers.length; i++) {
        	for (int x = 0; x < 100; x++) {
        		for (int y = 0; y < 100; y++) {
        			int tile = layers[i].getTile(x, y);
        		
        			if (tile != -1) {
        				dx1 = x * tileWidth - (int)camera.getPosition().X;
        				dy1 = y * tileHeight - (int)camera.getPosition().Y;
        				dx2 = dx1 + tileWidth;
        				dy2 = dy1 + tileHeight;
        				sx1 = tileSet.getRectagnles()[tile].getsx1();
        				sy1 = tileSet.getRectagnles()[tile].getsy1();
        				sx2 = tileSet.getRectagnles()[tile].getsx2();
        				sy2 = tileSet.getRectagnles()[tile].getsy2();
        		
        				g.drawImage(tileSet.getImage(), dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null);
            		}
            	}
            }
        }
	}
}

TileLayer.java

Spoiler

public class TileLayer {
	private int[][] tiles;
	private int width;
	private int height;
	
	public TileLayer(int width, int height) {
		this.width = width;
		this.height = height;
		
		tiles = new int[width][height];
	}
	
	public int getWidth() {
		return width;
	}
	
	public int getHeight() {
		return height;
	}
	
	public int getTile(int x, int y) {
		return tiles[x][y];
	}
	
	public void setTile(int x, int y, int value) {
		if (x > 0 && x < width && y > 0 && y < height)
		tiles[x][y] = value;
	}
}

TileSet.java

Spoiler

import java.awt.Image;

public class TileSet {
	Image image;
	TileRectangle[] rectangles;
	
	public TileSet(Image image, int imageWidth, int imageHeight, int tileWidth, int tileHeight) {
		this.image = image;
		
		int tilesWide = imageWidth / tileWidth;
		int tilesHigh = imageHeight / tileHeight;
		
		rectangles = new TileRectangle[tilesWide * tilesHigh];
		
		
		for (int y = 0; y < tilesHigh; y++) {
			for (int x = 0; x < tilesWide; x++) {
				int sx1 = x * tileWidth;
				int sx2 = sx1 + tileWidth;
				int sy1 = y * tileHeight;
				int sy2 = sy1 + tileHeight;
				
				rectangles[y * tilesWide + x] = new TileRectangle(sx1, sy1, sx2, sy2);
			}
		}
	}
	
	public TileRectangle[] getRectagnles() {
		return rectangles;
	}
	
	public Image getImage() {
		return image;
	}
}

TileRectangle.java

Spoiler

public class TileRectangle {
	private int sx1;
	private int sx2;
	private int sy1;
	private int sy2;
	
	public TileRectangle() {
		sx1 = 0;
		sx2 = 0;
		sy1 = 0;
		sy2 = 0;
	}
	
	public TileRectangle(int sx1, int sy1, int sx2, int sy2) {
		this.sx1 = sx1;
		this.sx2 = sx2;
		this.sy1 = sy1;
		this.sy2 = sy2;
	}
	
	public int getsx1() {
		return sx1;
	}
	
	public int getsx2() {
		return sx2;
	}
	
	public int getsy1() {
		return sy1;
	}
	
	public int getsy2() {
		return sy2;
	}
	
	public void setsx1(int value) {
		sx1 = value;
	}
	
	public void setsx2(int value) {
		sx2 = value;
	}
	
	public void setsy1(int value) {
		sy1 = value;
	}
	
	public void setsy2(int value) {
		sy2 = value;
	}
}

Camera.java

Spoiler

public class Camera {
	private Vector2 position;
	float speed;
	
	public Camera() {
		position = new Vector2();
		speed = 4f;
	}
	
	public Vector2 getPosition() {
		return position;
	}
	
	public float getSpeed() {
		return speed;
	}
	
	public void setPosition(Vector2 position) {
		this.position = position;
	}
	
	public void lockCamera(int screenWidth, int screenHeight, int mapWidthInPixels, int mapHeightInPixels) {
		if (position.X < 0)
			position.X = 0;
		if (position.Y < 0)
			position.Y = 0;
		if (position.X > mapWidthInPixels - screenWidth)
			position.X = mapWidthInPixels - screenWidth;
		if (position.Y > mapHeightInPixels - screenHeight)
			position.Y = mapHeightInPixels - screenHeight;
	}
}

Vector2.java

Spoiler

public class Vector2 {
	public float X;
	public float Y;
	
	public Vector2() {
		X = Y = 0;
	}
	
	public Vector2(float x, float y ) {
		X = x;
		Y = y;
	}
	
	public static Vector2 zeroVector() {
		return new Vector2();
	}
	
	public void multiply(float value) {
		X *= value;
		Y *= value;
	}

	public void divide(float value) {
		X /= value;
		Y /= value;
	}
	
	public void add(Vector2 vector) {
		X += vector.X;
		Y += vector.Y;
	}
}

Categories: Java

Share This Entry: