Instead of me just giving you the classes and you not knowing what is happening in them, I will provide you with an explanation and run down of what is happening and then you can give it a go yourself.

I believe it's better to teach someone how to fish rather than catching the fish for them :)

Ok so lets get into it!

A camera is basically just an x and y offset. When we say "Move" the camera, we don't move the camera at all. We actually move everything else relative to the camera's position.

Please Note: There are a lot of different ways to implement a camera in a game and this is just one take of it. It is a very simplified version.

First thing to do is create a "Camera" class.

What are some things we need to do with this object?

• We need to place the camera in a designated position (x and y position)
• We want to move the camera around (x and y velocity)
• There are other things we could do with this class. However, these 2 needs will suffice for this example (eg. follow object, zoom out, zoom in etc)

As the above points give us an idea of the variables needed for this class lets add them to the camera class with their getters and setters.

Creating the Camera class

Camera Variables

int x; int y; int xVelocity; int yVelocity; 

Camera Constructor

public Camera(int x, int y) { this.x = x; this.y = y; this.xVelocity = 0; this.yVelocity = 0; } 

now that our camera class has variables we will need to add an update method which we will call from our map class later on.

This method will be called update() and will be adding the camera velocity to the position.

Camera update method

public void update() { x += xVelocity; y += yVelocity; } 

Woo! that is our very very simplified camera class!

Implementing our camera in the "Map" class

lets instantiate a Camera in the map class

public Camera camera = new Camera(0, 0); 

We just created the camera and placed it's x and y position at coordinates 0, 0

Now that we have instantiated our camera we would like to move the tiles or map in relation to the camera's x and y position. One way of doing this is like so:

lets presume you have a render method in your Map class that cycles through each of your tiles in your Tile[][] 2D array and renders each tile in it's designated position * tile size.

public void render(Graphics g) { for (int y = 0; y < mapHeight(); y++) { for (int x = 0; x < mapWidth(); x++) { Tile tile = getTile(x, y); // Custom method that gets the tile at xy coordinate tile.render(x * tile.getWidth(), y * tile.getHeight(), g); // renders tile at designated position } } } 

Now lets add the code to adjust for our camera's x and y position

NOTE This render method will render the WHOLE map. This can create lag if your map is really large, to overcome this issue I suggest only rendering the tiles inside the screen bounds.

public void render(Graphics g) { for (int y = 0; y < mapHeight(); y++) { for (int x = 0; x < mapWidth(); x++) { Tile tile = getTile(x, y); // Custom method that gets the tile at xy coordinate tile.render((x * tile.getWidth()) - camera.getX(), (y * tile.getHeight()) - camera.getY(), g); // renders tile at designated position } } } 

Now before our camera is ready to be moved we need to implement the "update()" method which is located in the camera class.

public void mapUpdate() { camera.update(); } 

Note: If you were to apply an x or y velocity to the camera right now you would soon figure out that it just keeps going and wont stop at the map boundaries. I am NOT going to show you how to prevent the camera's x and y position from moving outside of the map bounds as i believe you would be able to implement this feature yourself. You can either place it in the "Map" class update method or the "Camera" class update method, whichever seems more logical to you do that.

"Moving" the camera

We are now able to adjust the camera's x and y position which will adjust our maps position on screen due to the way we are rendering each tile with the camera offset.

NOTE Make sure you have map.update(); in a main update method.

Lets presume you have implemented a keyListener and have instantiated a Map map variable. A basic way to move the camera with keys is as follows:

@Override public void keyPressed(KeyEvent e) { int keyCode = e.getKeyCode(); switch (keyCode) { case KeyEvent.VK_A: case KeyEvent.VK_LEFT: map.camera.setxVelocity(-1); break; case KeyEvent.VK_W: case KeyEvent.VK_UP: map.camera.setyVelocity(-1); break; case KeyEvent.VK_S: case KeyEvent.VK_DOWN: map.camera.setyVelocity(1); break; case KeyEvent.VK_D: case KeyEvent.VK_RIGHT: map.camera.setxVelocity(1); break; } } @Override public void keyReleased(KeyEvent e) { int keyCode = e.getKeyCode(); switch (keyCode) { case KeyEvent.VK_A: case KeyEvent.VK_LEFT: map.camera.setxVelocity(0); break; case KeyEvent.VK_W: case KeyEvent.VK_UP: map.camera.setyVelocity(0); break; case KeyEvent.VK_S: case KeyEvent.VK_DOWN: map.camera.setyVelocity(0); break; case KeyEvent.VK_D: case KeyEvent.VK_RIGHT: map.camera.setxVelocity(0); break; } } 

Now if you run the program and use the arrow keys you will see your map moving around.

Below is a picture of what is happening with the map x and y coordinates and the camera x and y coordinates.

If you were to press the Right arrow key, the process below would happen. The camera would add to it's x position and the map would minus the camera's x position.

This implementation of a camera is very basic and has been simplified for ease of learning.

I hope you learnt something from this. It is basic and it is simplified. There are many ways to implement a camera and this is just one of them. It isn't the most effective nor is it the most efficient. It is merely an implementation for teaching purposes.

Good luck with everything!

EDIT: Download source code here

http://code.google.com/p/camerates/downloads/list