public void transform() {
      at.setToIdentity();
      //translate to center of component
      at.translate(this.getX() +  getImageWidth() / 2, 
            this.getY() + getImageHeight() / 2);
      //do rotation
      at.rotate(Math.toRadians(getFaceAngle()));
      //translate so the rotation occurs around the center of the object
      at.translate(-getImageWidth() / 2, -getImageHeight() / 2); //is something going wrong here?
   }

import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.geom.Shape;
import org.newdawn.slick.tiled.TiledMap;

public class SimpleGame extends BasicGame {
   Image land = null;
   Image player = null;

   float playerX = 400f;
   float playerY = 300f;
   float scale = 1.0f;
   private TiledMap map;
   private Camera cam;
   private String blockedStr = "free";

   int currentBullet = 0;
   /**
    * The collision map indicating which tiles block movement - generated based
    * on tile properties
    */
   private boolean[][] blocked;
   private static final int SIZE = 32;

   public SimpleGame() {
      super("Window");
   }

   // overriden methods are the 3 methods that we will add code later to, they
   // make up our game loop
   @Override
   public void init(GameContainer gc) throws SlickException {

      map = new TiledMap("res/jungle.tmx");
      player = new Image("res/player.png"); // Note that this is Slick2D's
                                    // Image class not AWT's Image
                                    // class.

      cam = new Camera(gc, map);
      // build a collision map based on tile properties in the TileD map
      blocked = new boolean[map.getWidth()][map.getHeight()];

      for (int xAxis = 0; xAxis < map.getWidth(); xAxis++) {
         for (int yAxis = 0; yAxis < map.getHeight(); yAxis++) {
            int tileID = map.getTileId(xAxis, yAxis, 0);
            String value = map.getTileProperty(tileID, "blocked", "false");
            if (value.equals("true")) {
               blocked[xAxis][yAxis] = true;
            }
         }
      }
   }

   @Override
   public void update(GameContainer container, int delta)
         throws SlickException {
      boolean collision = false;
      Input input = container.getInput();
      float rotation = player.getRotation();
      float speed = 0.1f * delta;
      float newX = 0;
      float newY = 0;

      newX += speed * Math.sin(Math.toRadians(rotation));

      newY -= speed * Math.cos(Math.toRadians(rotation));

      if (input.isKeyDown(Input.KEY_UP)) {
         // Check all directions
         if (!(isBlocked(playerX, playerY - newY)
               || isBlocked(playerX + SIZE - 1, playerY - newY) //1 is a buffer space
               || isBlocked(playerX, playerY + SIZE + newY)
               || isBlocked(playerX + SIZE - 1, playerY + SIZE + newY)
               || isBlocked(playerX - newX, playerY)
               || isBlocked(playerX - newX, playerY + SIZE - 1)
               || isBlocked(playerX + SIZE + newX, playerY) || isBlocked(
                  playerX + SIZE + newX, playerY + SIZE - 1))) {

            // The lower the delta the slowest the sprite will animate.

            blockedStr = "Free";

            playerX += newX;
            playerY += newY;

         } else {
            collision = true;
         
         }
      }
if (collision == false) {
      if (input.isKeyDown(Input.KEY_LEFT)) {

         player.rotate(-0.2f * delta);

      }
      if (input.isKeyDown(Input.KEY_RIGHT)) {

         player.rotate(0.2f * delta);
      }
}
if (collision == true) {
   //reverse the player
   newX = 0;
   newX -= speed * Math.sin(Math.toRadians(rotation));

   newY = 0;
   newY += speed * Math.cos(Math.toRadians(rotation));
   playerY += newY;
   playerX += newX;   
}
   }

   private boolean isBlocked(float x, float y) {
      int xBlock = (int) x / SIZE;
      int yBlock = (int) y / SIZE;
      return blocked[xBlock][yBlock];
   }

   @Override
   public void render(GameContainer gc, Graphics g) throws SlickException {

      // after calculating the positions of all entities
      cam.centerOn(playerX, playerY);

      // in the render()-method
      cam.drawMap();
      cam.translateGraphics();

      // no depth in slick, images are rendered as the code executes so if we
      // render the player before the land, it will be underneath (no
      // transparency)
      player.draw(playerX, playerY);
      g.drawString("blocked:" + blockedStr, playerX - 10, playerY - 10);
   }

   public static void main(String[] args) throws SlickException {
      AppGameContainer app = new AppGameContainer(new SimpleGame());

      app.setDisplayMode(800, 600, false);
      app.start();

   }

}

import org.newdawn.slick.GameContainer;
import org.newdawn.slick.geom.Shape;
import org.newdawn.slick.tiled.TiledMap;
//Example Camera Class
public class Camera {

   protected TiledMap map;
   protected int numTilesX;
   protected int numTilesY;
   protected int mapHeight;
   protected int mapWidth;
   protected int tileWidth;
   protected int tileHeight;
   protected GameContainer gc;
   protected float cameraX;
   protected float cameraY;
   
   public Camera(GameContainer gc, TiledMap map) {
      this.map = map;
      
      this.numTilesX = map.getWidth();
      this.numTilesY = map.getHeight();
      
      this.tileWidth = map.getTileWidth();
      this.tileHeight = map.getTileHeight();
      
      this.mapHeight = this.numTilesX * this.tileWidth;
      this.mapWidth = this.numTilesY * this.tileHeight;
      
      this.gc = gc;
   }
   
   public void centerOn(float x, float y) {
      //try to set the given position as center of the camera by default
      cameraX = x - gc.getWidth()  / 2;
      cameraY = y - gc.getHeight() / 2;
      
      //if the camera is at the right or left edge lock it to prevent a black bar
      if(cameraX < 0) cameraX = 0;
      if(cameraX + gc.getWidth() > mapWidth) cameraX = mapWidth - gc.getWidth();
      
      //if the camera is at the top or bottom edge lock it to prevent a black bar
      if(cameraY < 0) cameraY = 0;
      if(cameraY + gc.getHeight() > mapHeight) cameraY = mapHeight - gc.getHeight();
   }

   public void centerOn(float x, float y, float height, float width) {
      this.centerOn(x + width / 2, y + height / 2);
   }


   public void centerOn(Shape shape) {
      this.centerOn(shape.getCenterX(), shape.getCenterY());
   }
   
  
   public void drawMap() {
      this.drawMap(0, 0);
   }
   
 
   
   public void drawMap(int offsetX, int offsetY) {
       //calculate the offset to the next tile (needed by TiledMap.render())
       int tileOffsetX = (int) - (cameraX % tileWidth);
       int tileOffsetY = (int) - (cameraY % tileHeight);
       
       //calculate the index of the leftmost tile that is being displayed
       int tileIndexX = (int) (cameraX / tileWidth);
       int tileIndexY = (int) (cameraY / tileHeight);
       
       //finally draw the section of the map on the screen
       map.render(   
             tileOffsetX + offsetX, 
             tileOffsetY + offsetY, 
             tileIndexX,  
             tileIndexY,
                (gc.getWidth()  - tileOffsetX) / tileWidth  + 1,
                (gc.getHeight() - tileOffsetY) / tileHeight + 1);
   }
   
   /**
    * Translates the Graphics-context to the coordinates of the map - now everything
    * can be drawn with it's NATURAL coordinates.
    */
   public void translateGraphics() {
      gc.getGraphics().translate(-cameraX, -cameraY);
   }
   /**
    * Reverses the Graphics-translation of Camera.translatesGraphics().
    * Call this before drawing HUD-elements or the like
    */
   public void untranslateGraphics() {
      gc.getGraphics().translate(cameraX, cameraY);
   }
   
}

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.FileNotFoundException;

import javax.swing.ImageIcon;

public class ArrayToImage {
   Image image;

   private Image wall = null;
   private Image stone = null;
   private Image Water = null;
   int x, y, temp = 0;
   private boolean imagesLoaded = false;

   public void loadImages() {
      wall = loadImage("Wall.png");
      stone = loadImage("Stone.png");
      Water = loadImage("Water.png");

      imagesLoaded = true;
   }

   private Image loadImage(String fileName) {
      return new ImageIcon(fileName).getImage();
   }

   public void drawImage(Graphics g, Image image, int x, int y) {
      g.drawImage(image, x, y, null);
   }

   public ArrayToImage() {
   }

   // This function will return an BufferedImage with all the tiles drawn on it
   public BufferedImage getMap(int[][] map) {
      loadImages();
      int largestRow = 0;
      for (int i = 0; i < map.length; i++) {
         if (map[i].length > largestRow)
            largestRow = map[i].length;
      }
      int tileSize = 128;

      BufferedImage bufferedImage = new BufferedImage(map.length * tileSize,
            largestRow * tileSize, BufferedImage.TYPE_INT_BGR);
      Graphics2D g2d = bufferedImage.createGraphics();
      g2d.setColor(Color.white);
      if (imagesLoaded) {
         for (int height = 0; height < map[0].length; height++) {
            for (int length = 0; length < map.length; length++) {
               switch (map[length][height]) {
               case 0: {
                  g2d.drawImage(Water, length * tileSize, height
                        * tileSize, null);
                  break;
               }
               case 1: {
                  g2d.drawImage(wall, length * tileSize , height
                        * tileSize, null);
                  // g2d.setColor(Color.red);
                  // g2d.fillRect(length*tileSize, height*tileSize, 32,
                  // 32);
                  break;
               }
               case 2: {
                  g2d.drawImage(stone, length * tileSize, height
                        * tileSize, null);
                  break;
               }
               }
            }
         }
         if (imagesLoaded == false) {
            System.out.println("Error Loading Images!");
         }
      }
      g2d.finalize();
      g2d.dispose();
      return bufferedImage;
   }

}

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.FileNotFoundException;

import javax.swing.ImageIcon;

public class ArrayToImage {
   Image image;

   private Image wall = null;
   private Image table = null;
   private Image floor = null;
   int x, y, temp = 0;
   private boolean imagesLoaded = false;

   public void loadImages() {
      wall = loadImage("wall.jpg");
      table = loadImage("Icicle.jpg");
      floor = loadImage("Floor.jpg");

      imagesLoaded = true;
   }

   private Image loadImage(String fileName) {
      return new ImageIcon(fileName).getImage();
   }

   public void drawImage(Graphics g, Image image, int x, int y) {
      g.drawImage(image, x, y, null);
   }

   public ArrayToImage() {
   }

   // This function will return an BufferedImage with all the tiles drawn on it
   public BufferedImage getMap(int[][] map) {
      loadImages();
      int largestRow = 0;
      for (int i = 0; i < map.length; i++) {
         if (map[i].length > largestRow)
            largestRow = map[i].length;
      }
      int tileSize = 32;

      BufferedImage bufferedImage = new BufferedImage(map.length * tileSize,
            largestRow * tileSize, BufferedImage.TYPE_INT_BGR);
      Graphics2D g2d = bufferedImage.createGraphics();
      g2d.setColor(Color.white);
      if (imagesLoaded) {
         for (int heigth = 0; heigth < map[0].length; heigth++) {
            for (int length = 0; length < map.length; length++) {
               switch (map[length][heigth]) {
               case 0: {
                  g2d.drawImage(floor, length * tileSize, heigth
                        * tileSize, null);
                  break;
               }
               case 1: {
                  g2d.drawImage(wall, length * tileSize, heigth
                        * tileSize, null);
                  // g2d.setColor(Color.red);
                  // g2d.fillRect(length*tileSize, heigth*tileSize, 32,
                  // 32);
                  break;
               }
               case 2: {
                  g2d.drawImage(table, length * tileSize, heigth
                        * tileSize, null);
                  break;
               }
               }
            }
         }
         if (imagesLoaded == false) {
            System.out.println("Error Loading Images!");
         }
      }
      g2d.finalize();
      g2d.dispose();
      return bufferedImage;
   }

}

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;


public class ArrayToImage {
   Image image;
      //ignore this part
   private Image wall = null;
    private Image table = null;
    private Image floor = null;
      int x,y,temp=0;
      //nothing here yet
      
      public void loadImages() {
       
       wall = Toolkit.getDefaultToolkit().getImage("Tree.bmp");
          table = Toolkit.getDefaultToolkit().getImage("Icicle.bmp");
         floor = Toolkit.getDefaultToolkit().getImage("floor.bmp");
         
      }
      public ArrayToImage(){
         loadImages();
      }
      //This function will return an BufferedImage with all the tiles drawn on it
      public BufferedImage getMap(int[][] map){
         loadImages();
         BufferedImage bufferedImage = new BufferedImage(map.length*4, (map[0].length)*15, BufferedImage.TYPE_INT_BGR);
         Graphics2D g2d = bufferedImage.createGraphics();
         g2d.setColor(Color.green);
         g2d.fillRect(0, 0, map.length*4, (map[0].length)*15);
         for(int height= 0; height<map[0].length; height++){
         for(int length = 0; length<map.length; length++) {
              switch(map[length][height]){
case 0:
g2d.drawImage(floor, length*15, height*15, null);
                                break;
case 1:
g2d.drawImage(wall, length*15, height*15, null);
break;
case 2:
g2d.drawImage(table, length*15, height*15, null);
break;
}
           }
         }

         g2d.finalize();
         g2d.dispose();
         return bufferedImage;
      }
   }

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.util.ArrayList;
public class MapToArray {

   private final String fileName;
   public int length;
   public int height;
   //simple constructor, Sets the map
   MapToArray(String fileName) {
      this.fileName = fileName;
   }
   
   //returns the 2D array of the map in INT[] []
   public int[] [] getArray() throws IOException {
      ArrayList<String> array = new ArrayList<String>();
       length = getLength();
       height = getHeight();
      
      LineNumberReader reader = new LineNumberReader (new FileReader(fileName));
      for (int i = 0; i < height; i++) {
      array.add(reader.readLine());
      }
      
      if (array.size() == 0) {
         System.out.println("Empty map");
   }
      int[][] numbers = new int [length][height]; //reserve space in memory
   int r= 0; 
   //now that we have the size of our array and the data, we fill it in
   for (String s : array) {
      toArray(s, r, numbers);
      r++;
   }
   return numbers; //return map
   }
      
   //returns the map's Length
   private int getLength() throws IOException {
      int countChar = 0;
      try {
         LineNumberReader reader = new LineNumberReader (new FileReader(fileName));
      String lineRead = reader.readLine();
      int length = 0;
      while (countChar < lineRead.length()) {
         if (!(lineRead.charAt(countChar) == ',')) {
            length++;
         }
         countChar++;
      }
      reader.close();
      return length;
      } catch (IOException e) {
         throw e;
      }
   }
   
   //returns height of map (number of lines)
   public int getHeight() throws IOException {
      int height = 0;
      try {
         LineNumberReader reader = new LineNumberReader(new FileReader(fileName));
         String lineRead;
         while ((lineRead = reader.readLine()) != null) {
         }
         //loops to last line of file}
            height = reader.getLineNumber();
            reader.close();
            return height;
         
      } catch (IOException e) {
         throw e;
      }
   

   }
   
   //This function will fill an entire row with the numbers from String s.
    private void toArray(String s, int row, int[][] numbers) {
        String match = ",";
        String[] veld = s.split(match);
        
        for(int i = 0; i<veld.length;i++)
           veld[i] = veld[i].replaceAll(" ","");
        
        for (int i = 0; i < veld.length; i++) {
            try {
                numbers[i][row] = Integer.parseInt(veld[i]);
            } catch (NumberFormatException e) {
                System.out.println("Not a valid map!");
            }
        }
    }

}

import javax.swing.*;

import java.awt.*;
import java.io.IOException;
public class MainFrame extends JFrame{
   int[][] array_map1;
   MapToArray map1;
   Image bckground_1;
   ArrayToImage draw = new ArrayToImage();

public void init() throws IOException {
   map1 = new MapToArray("level1.dat"); //sets the current map
   array_map1 = map1.getArray(); // grabs the map data and stores it in a 2D integer Array.
   bckground_1 = draw.getMap(array_map1); //draws the "Map" by creating a BufferedImage dependant on the 2D Array.
   }

   MainFrame() throws IOException {
      setSize(640,480);
      setTitle("MapLoad Demo");
   init();
   setVisible(true);
   
   }
   public void paint (Graphics g) {
      Graphics2D g2d = (Graphics2D) g;
   g2d.drawImage(bckground_1, 0, 0 ,null);
   }
   
   
   
}

public class Main {
   public static void main(String[] args) throws IOException {
      new MainFrame();
}
}