public void MapInit() throws SlickException {
   map = new TiledMap("assets/maps/testmap.tmx");
   System.out.println(map.getHeight() + "" + map.getWidth());
      
   //puts tiles with blocked set true in the collision array
        blocked = new boolean[map.getWidth()][map.getHeight()];
        for (int x=0;x<map.getWidth();x++) {
        for (int y=0;y<map.getHeight();y++) {
            System.out.println(x + " " + y);
            int id = map.getTileId(x, y, 0);
            String value = map.getTileProperty(id, "blocked", "true");
            if (value.equalsIgnoreCase("true")) {
               System.out.println(value);
               blocked[x][y] = true;
            }
          }
        }
        
}

private boolean tryToMove(float x, float y) {
         float newx = playerX + x;
         float newy = playerY + y;
         // checks the blocked array for collision
         if (isBlocked((newx/map.getWidth()), (newy/map.getHeight()))) {
             //can't move if blocked is true at the given location
             return false;
         }else{
            //allows the move
              return true;
         }       
   }

Input input = container.getInput();
      
      float fdelta=delta*0.1f;

      if (input.isKeyDown(Input.KEY_UP))
      {
         if(tryToMove(playerX, playerY - fdelta)){
            playerY -= fdelta;
            System.out.println(playerX/map.getTileWidth() + " " + playerY/map.getTileHeight());
         }
      }   
      
      else if (input.isKeyDown(Input.KEY_DOWN))
      {
         if(tryToMove(playerX, playerY + fdelta)){
            playerY += fdelta;
            System.out.println(playerX/map.getTileWidth() + " " + playerY/map.getTileHeight());

         }
      }
      else if (input.isKeyDown(Input.KEY_LEFT))
      {
         if(tryToMove(playerX - fdelta, playerY)){
            playerX -= fdelta;
            System.out.println(playerX/map.getTileWidth() + " " + playerY/map.getTileHeight());

         }
      }
      else if (input.isKeyDown(Input.KEY_RIGHT))
      {
         if(tryToMove(playerX + fdelta, playerY)){
            playerX += fdelta;
            System.out.println(playerX/map.getTileWidth() + " " + playerY/map.getTileHeight());

         }
      }

public class Camera {
   private int x, y;
    

   Camera(){
      
   }
   
   public void setPosition(){
      x = Instances.player.getX()-Settings.width/2;
      y = Instances.player.getY()-Settings.heigth/2;
   }
   
   public void setX(int x){
      this.x = x;
   }
   
   public void setY(int y){
      this.y = y;
   }
   
   public int getX(){
      return x;
   }
   
   public int getY(){
      return y;
   }
}

public void keyPressed(KeyEvent key) {
       
              switch (key.getKeyCode()) {
                        case KeyEvent.VK_UP:
                           Instances.player.setUp(true);
                             break;
                        case KeyEvent.VK_DOWN:
                           Instances.player.setDown(true);
                            break;
                        case KeyEvent.VK_LEFT:
                           Instances.player.setLeft(true);
                            break;
                        case KeyEvent.VK_RIGHT:
                           Instances.player.setRight(true);
                            break;
                        case KeyEvent.VK_ENTER:
                           if(Instances.GAMESTATE == GameState.INGAME){
                              Instances.GAMESTATE = GameState.BATTLE;
                              System.out.println(Instances.GAMESTATE);
                           }else if(Instances.GAMESTATE == GameState.MENU){
                              Instances.GAMESTATE = GameState.INGAME;
                              System.out.println(Instances.GAMESTATE);
                           }else if(Instances.GAMESTATE == GameState.BATTLE){
                              Instances.GAMESTATE = GameState.INGAME;
                              System.out.println(Instances.GAMESTATE);
                           }
                           break;
                        case KeyEvent.VK_SPACE:
                           System.out.println(Instances.GAMESTATE);
                           if(Instances.GAMESTATE == GameState.BATTLE){
                              Instances.battle.startFight();

private void tileMovement(){
      if(moveLeft){
         if(tempX>0){
            x--;
            //Instances.camera.setX(Instances.camera.getX()-1);
            tempX--;
            ready = false;
            System.out.println(getX() + getY());
         }else if(tempX<=0){
            moveLeft = false;
            ready = true;
            movementTimer = 1;
         }
      }else if(moveRight){
         if(tempX>0){
            x++;
            //Instances.camera.setX(Instances.camera.getX()+1);
            tempX--;
            ready = false;
         }else if(tempX<=0){
            moveRight = false;
            ready = true;
            movementTimer = 1;
         }
      }else if(moveUp){
         if(tempY>0){
            y--;
            //Instances.camera.setY(Instances.camera.getY()-1);
            tempY--;
            ready = false;
         }else if(tempY<=0){
            moveUp = false;
            ready = true;
            movementTimer = 1;
         }
      }else if(moveDown){
         if(tempY>0){
            y++;
            //Instances.camera.setY(Instances.camera.getY()+1);
            tempY--;
            ready = false;
         }else if(tempY<=0){
            moveDown = false;
            ready = true;
            movementTimer = 1;
         }
      }         
   }

private void movementUpdate(){

      if(ready){
         if(left){
            moveLeft = true;
            tempX = 15;
         }else if(right){
            moveRight = true;
            tempX = 15;
         }else if(up){
            moveUp = true;
            tempY = 15;
         }else if(down){
            moveDown = true;
            tempY = 15;
         }
      }
      movementTimer++;
      if(movementTimer>1){
         tileMovement();
      }

   }

import java.awt.*;
import java.util.*;
import java.net.*;
import java.io.*;

/**
 * this class was originally meant to simply hold a reference to a map
 * and a collection of sprites, which it delegated all the work to in the
 * logic and render methods of these objects...<p>
 *
 * so it is reasonably fitting that this class also manage the loading of the
 * maps and sprites it uses from files or URLs.<p>
 *
 * Each scene consists of a Map, and a collection of sprites, as intended, 
 * but may also be loaded or saved.
 */
public class Scene
{
   int offsetX = 0;
   int offsetY = 0;
   
   float effect_rScale = 1;
   float effect_gScale = 1;
   float effect_bScale = 1;
   float effect_hue = 0;
   float effect_sat = 1;
   
   Map map;
   ArrayList sprites;
   
   GraphicsBank tileset;
   
   /**
    * creates a scene using the given map and sprites.
    */
   public Scene(Map m, ArrayList s, GraphicsBank gfx)
   {
      this.map = m;
      sprites = s;
      this.tileset = gfx;
      
   }
   
   /* Create a new empty scene */
  public Scene() {
    map    = new Map(10, 10, 32, 32);
    tileset = new GraphicsBank();
  }
   
   
   public GraphicsBank getTileset()
   {
      return tileset;
      
   }
   
   public void setTileset(GraphicsBank gfx) {
      tileset = gfx;
      map.setTileset(gfx);
   }
   
   /**
    * loads a scene from the given URL. takes tiles from the given GraphicsBank.
    */
   static Scene loadScene(File f) throws IOException
   {
      boolean hasColourEffect = false;
      float r = 1;
      float g = 1;
      float b = 1;
      float h = 0;
      float s = 1;
   
      BufferedReader reader = new BufferedReader(new FileReader(f));
      
      String line = reader.readLine();
      
      StringTokenizer tokens = new StringTokenizer(line);
      int width = Integer.parseInt(tokens.nextToken());
      int height = Integer.parseInt(tokens.nextToken());
      
      String tileset = tokens.nextToken();
      
      GraphicsBank gfx = new GraphicsBank();
      
      System.out.println("Attempt to load tileset "+tileset);
      
      System.out.println("Working path is "+f.getParentFile());
      
      File ts = new File(f.getParentFile(), tileset);
      System.out.println("Attempt to load tileset "+ts.getAbsoluteFile());
      
      
      gfx.loadTileset(ts);
      
      Map map = new Map(width, height);
      
      line = reader.readLine();
      tokens = new StringTokenizer(line);
      
      if(tokens.nextToken().equalsIgnoreCase("colorization")) {
         hasColourEffect = true;
         r = Float.parseFloat(tokens.nextToken());
         g = Float.parseFloat(tokens.nextToken());
         b = Float.parseFloat(tokens.nextToken());
         h = Float.parseFloat(tokens.nextToken());
         s = Float.parseFloat(tokens.nextToken());
      }
      
      while(! line.equals("."))
      {
         line = reader.readLine();
      }
      
      
      for(int z=0; z<3; z++)
      {
         line = reader.readLine();
         tokens = new StringTokenizer(line);
         
         for(int y=0; y<height; y++)
         {
            for(int x=0; x<width; x++)
            {
               String code = tokens.nextToken();
               map.setTile(x, y, z, gfx.getTile(Integer.parseInt(code)));
            }
         }
      }
      reader.close();
      
      Scene scene = new Scene(map, new ArrayList(), gfx);
      scene.tileset = gfx;
      if(hasColourEffect) {
         System.out.println("Calling setEffect on scene recently loaded.");
         scene.setEffect(r, g, b, h, s, 1f);
      }
      return scene;
      
   }
   
   
    static Scene loadScene(String filename) throws IOException {
      Scene scene = loadScene(new File(filename));
      return scene;
    }
   /**
    * writes the map only (at the moment) to a file.
    */
  public void saveScene(File file)
  {
    if(tileset.isUnsaved()) {
      throw new RuntimeException("Tileset is unsaved. Cannot save the scene");
    }
      
      try
      {
         PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(file)));
         
         String line = "";
         
         int width = map.getWidth();
         int height = map.getHeight();
         
         
      
      File wd = new File(file.getParentFile().getCanonicalFile().toString());
         File ts = new File(tileset.getFile().getCanonicalFile().toString());
         
         String relativePath = RelativePath.getRelativePath(wd, ts);
         

         
      line = width + " " + height + " " + relativePath;
         writer.println(line);
         
         line = "colorization " + effect_rScale +
                            " " + effect_gScale +
                            " " + effect_bScale +
                            " " + effect_hue    +
                            " " + effect_sat;
         writer.println(line);

         System.out.println("Colorization red in save is "+effect_rScale);         
         writer.println(".");
         
         for(int z=0; z<3; z++)
         {
            for(int i=0; i<height; i++)
            {
               for(int j=0; j<width; j++)
               {
                  Tile t = map.getTile(j, i, z);
                  if(t != null)
                     writer.print(t.getNumber()+ " ");
                  else writer.print("0 ");
                  
                  
               }
               
            }
            writer.println();
         }
         
         writer.flush();
         writer.close();
         
         
      }
      catch(IOException e)
      {
         throw new RuntimeException("Could not save the level");
      }
      
      System.err.println("Saved");
   }
   
   /**
    * calls each sprites logic method.
    */
   void logic()
   {
      for(int i=0; i<sprites.size(); i++)
      {
         Sprite s = (Sprite)sprites.get(i);
         s.logic();
      }
   }
   
   /**
    * renders the scene to the graphics context.
    * at the moment, sprites appear above everything else.
    *
    * TODO: Fix this up.
    */
   void render(Graphics g)
   {
      //System.out.println("Render Scene");
      map.render(g, offsetX, offsetY);
      
      for(int i=0; i<sprites.size(); i++)
      {
         Sprite s = (Sprite)sprites.get(i);
         //s.render(g, offsetX, offsetY);
      }
      
   }
   public void render(Graphics g, int offX, int offY)
   {
      map.render(g, offX, offY);
   }
   public void render(Graphics g, Camera c)
   {
      map.render(g, c);
   }
   
   
   public void render(Graphics g, Point origin, Dimension size)
   {
      map.render(g, origin, size);
   }
   
   public void render(Graphics g, Point origin, Dimension size, int layer)
   {
      map.render(g, origin, size, layer);
   }
   
   /**
    * sets the visible area of the scene.
    * This will probably not be used once the game is finished.
    */
   void setViewSize(int width, int height)
   {
      map.setViewSize(width, height);
      
   }
   
   /**
    * sets the screen offset. Screen offset can be anywhere, not just
    * following a character around. This is good for cut scenes.
    */
   void setOffset(int x, int y)
   {
      offsetX = x;
      offsetY = y;
   }
   
   /**
    * Apply RGB scalars and hue/sat adjustments to the tiles and characters
    * in the scene. The hue and sat are always applied first
    **/
   public void setEffect(float r, float g, float b, float h, float s, float z) {
      System.out.println("Scene setEffect called. will call for the gfx bank...r" +r+" g"+g+" b"+b+" z"+z);
      effect_rScale = r;
      effect_gScale = g;
      effect_bScale = b;
      effect_hue = h;
      effect_sat = s;
      tileset.setEffect(r, g, b, h, s, z);
      map.setZoom(z);
   }
   
   /**
    * returns the map. not really any reason to want to do this except for the
    * level editor.
    */
   public Map getMap()
   {
      return map;
   }
}

void render() {
      Graphics2D g = (Graphics2D) bufferStrategy.getDrawGraphics();
      g.clearRect(0, 0, WIDTH, HEIGHT);
      //render(g);
      scene.render(g);
      g.dispose();
      bufferStrategy.show();
   }

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferStrategy;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class Draw extends JFrame{
   
   private static final long serialVersionUID = 1L;
   
   JFrame frame;
      Canvas canvas;
      BufferStrategy bufferStrategy;
      Image background;
      Image button;
      JPanel battlePane = (JPanel) getContentPane();
      Scene scene;
      Camera cam;
      
      
      
      final int WIDTH = Settings.width;
      final int HEIGHT = Settings.heigth;
      Draw(){
         frame = new JFrame("PlaceHolder");
            
            JPanel panel = (JPanel) frame.getContentPane();
            panel.setPreferredSize(new Dimension(WIDTH, HEIGHT));
            panel.setLayout(null);
           
           canvas = new Canvas();
            canvas.setBounds(0, 0, WIDTH, HEIGHT);
            canvas.setIgnoreRepaint(true);
            frame.setIgnoreRepaint(true);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.pack();
            frame.setResizable(true);
            frame.setVisible(true);
            panel.add(canvas);
            canvas.createBufferStrategy(2);
            bufferStrategy = canvas.getBufferStrategy();
            canvas.requestFocus();
            canvas.setBackground(Color.black);
            canvas.addKeyListener(new ButtonHandler());      
            
      }

   void render() throws IOException {
      Graphics2D g = (Graphics2D) bufferStrategy.getDrawGraphics();
      g.clearRect(0, 0, WIDTH, HEIGHT);
      scene = Scene.loadScene("scenes/datTestMap.dat");
      scene.render(g);
      g.dispose();
      bufferStrategy.show();
   }
   void renderMenu(){
      //int flicker = 0;
      Graphics2D g = (Graphics2D) bufferStrategy.getDrawGraphics();
      g.clearRect(0, 0, WIDTH, HEIGHT);
      g.drawString(" PRESS ENTER TO START ", WIDTH/2 - 70, HEIGHT/2 - 5);
      g.drawRect(WIDTH/4, HEIGHT/4, WIDTH/2, HEIGHT/2);
      g.dispose();
      bufferStrategy.show();
   }
   
   void renderBattle(){
      
      try{
              File pic = new File("bg.jpg");
              File b = new File("Button.jpg");
              background = ImageIO.read(pic);
              button = ImageIO.read(b);
              }catch (IOException e){
                 System.out.println("!");
              }
   
      //Image image = Toolkit.getDefaultToolkit().getImage("Button.jpg");       
      //image = new ImageIcon("Button.jpg").getImage();
      JButton testButton = new JButton("Fight!");
      Graphics2D g = (Graphics2D) bufferStrategy.getDrawGraphics();
      g.clearRect(0, 0, WIDTH, HEIGHT);
      //Draws background
      //g.drawImage(background, 0, 0, null);
      frame.getContentPane().add(testButton);
      testButton.setLocation(300, 300);
      g.drawString(" FIGHT BITCHES! ", HEIGHT-20, 20);
      //Draws Fight button
      g.drawRect(400, 400, Instances.button.getWidth(), Instances.button.getHeight());
      g.drawImage(button, 400, 400, null);
      g.drawString("FIGHT", 425, 415);
      //Draws Flee button
      g.drawRect(400, 425, Instances.button.getWidth(), Instances.button.getHeight());
      g.drawImage(button, 400, 425, null);
      g.drawString("FLEE", 425, 440);
      
      bufferStrategy.show();
      g.dispose();
      

   }
     
   protected void render(Graphics2D g){
      //g.drawImage(Instances.mapMan.getMap(), 0-Instances.camera.getX(), 0-Instances.camera.getY(), null);
   
      try {
         scene = Scene.loadScene("scenes/datTestMap");
      } catch (IOException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }

      //scene.render(g);
      
      g.setColor(Instances.player.getColor());
      g.fillRect(Instances.player.getX()-Instances.camera.getX(), Instances.player.getY()-Instances.camera.getY(), 15, 15);
   }

}

import java.io.IOException;

import javax.sound.sampled.Clip;
imporimport java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;


public class ButtonHandler extends KeyAdapter {

    public ButtonHandler() {
       System.out.println(" Button handler initialized! ");
               
    }

    public void keyPressed(KeyEvent key) {
       
              switch (key.getKeyCode()) {
                        case KeyEvent.VK_UP:
                           Instances.player.setUp(true);
                             break;
                        case KeyEvent.VK_DOWN:
                           Instances.player.setDown(true);
                            break;
                        case KeyEvent.VK_LEFT:
                           Instances.player.setLeft(true);
                            break;
                        case KeyEvent.VK_RIGHT:
                           Instances.player.setRight(true);
                            break;
                        case KeyEvent.VK_ENTER:
                           if(Instances.GAMESTATE == GameState.INGAME){
                              Instances.GAMESTATE = GameState.BATTLE;
                              System.out.println(Instances.GAMESTATE);
                           }else if(Instances.GAMESTATE == GameState.MENU){
                              Instances.GAMESTATE = GameState.INGAME;
                              System.out.println(Instances.GAMESTATE);
                           }else if(Instances.GAMESTATE == GameState.BATTLE){
                              Instances.GAMESTATE = GameState.INGAME;
                              System.out.println(Instances.GAMESTATE);
                           }
                           break;
                        case KeyEvent.VK_SPACE:
                           System.out.println(Instances.GAMESTATE);
                           if(Instances.GAMESTATE == GameState.BATTLE){
                              Instances.battle.startFight();


                              
                           }   
                           break;
                        case KeyEvent.VK_1:
                           Instances.mapMan.setMap("map1");
                           break;
                        case KeyEvent.VK_2:
                           Instances.mapMan.setMap("map2");
                           break;
                        case KeyEvent.VK_3:
                           Instances.mapMan.setMap("map3");
                           break;
              }
    }

    public void keyReleased(KeyEvent key) {
        switch (key.getKeyCode()) {
           case KeyEvent.VK_UP:
              Instances.player.setUp(false);
              System.out.println(" Released UP!");
                break;
           case KeyEvent.VK_DOWN:
              System.out.println(" Released DOWN!");
              Instances.player.setDown(false);
               break;
           case KeyEvent.VK_LEFT:
              System.out.println(" Released LEFT!");
              Instances.player.setLeft(false);
               break;
           case KeyEvent.VK_RIGHT:
              System.out.println(" Released RIGHT!");
              Instances.player.setRight(false);
               break;
        
        }
    }

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

 int key = evt.getKeyCode();  // keyboard code for the key that was pressed
     
     
     if (key == KeyEvent.VK_A) {
        if (leftHeld == true)
         playerX -= 5;
        testMessage = KeyEvent.getKeyText(key) + " is pressed";
         repaint();
         leftHeld = true;
         evt.consume();
      }
      else if (key == KeyEvent.VK_D) {
        if (rightHeld == true)
         playerX += 5;
        testMessage = KeyEvent.getKeyText(key) + " is pressed";
         repaint();
         rightHeld = true;
         evt.consume();
      }
      else if (key == KeyEvent.VK_W) {
        if (upHeld == true)
         playerY -= 5;
        testMessage = KeyEvent.getKeyText(key) + " is pressed";
         repaint();
         upHeld = true;
         evt.consume();
      }
      else if (key == KeyEvent.VK_S) {
         if (downHeld == true)
         playerY += 5;
         testMessage = KeyEvent.getKeyText(key) + " is pressed";
          repaint();
          downHeld = true;
          evt.consume();
      }
  

  }