Offsetting X/Y

[Bryce Heath]

Hi again guys
I have been hard at work reading about tile map based games. I have managed to make a program that runs a movable sprite, around a tilemap created from a text file. This map is also set with collision detection on all tiles and the players sprite. My new project is to make this program have an RPG overhead view with X/Y scrolling as the player moves around. After many days of reading, I have found this is done by making a "camera" class that is used as a location reference for what tiles need to be drawn on screen. Now my problem is that I have not found a tutorial that has been able to explain this is a way I understand. I now this is a lot to ask on a forum, but if anyone has the time, I could really use a dumbed down version of this, or even if it is possible with my current code.
Hope someone can help Thanks.
//The Tile maker class that reads the text file map and eventually places the Chars in an array list.

public class TileMaker 
{
	private static char[][] mapArray;
	private static int mapWidth, mapPxWidth;
	private static int mapHeight, mapPxHeight;
	private static int tileWidth;
	private static int tileHeight;
	private File map;
	private File SelectBG;
	private ArrayList<ImageIcon> tileArray;
	public ArrayList<TileParent> tileLayout;
	private Image background;
	int Count = 0;
	
	
	public TileMaker(String mapName)
	{
		
		BrownTile brownT = new BrownTile(0,0);
		tileWidth = brownT.getTileWidth();
		tileHeight = brownT.getTileHeight();
		String mapLoc = "src/misc/textFiles/" + mapName + ".txt";
		
	 map = new File(mapLoc);
	 makeMap();
	 loadTiles();
	
	}
	
	
	//recieves background image name and makes an image object with the image
	public Image  getBG(String loc) 
	{
		String locBG = "/misc/images/" + loc + "1024_768px.png";
			
		ImageIcon background1 = new ImageIcon (this.getClass().getResource(locBG));
		background = background1.getImage();
		return background;
		
		 
	}
	
	
	
	
	/* makeMap is called by constructor it searches for the text map
         * by name the constructer recived then makes a 2d char array
         * representing the tiles on the map
         */
	public void makeMap()
	{
		
		try
		{
			
		
			Scanner  scan = new Scanner(map);
	        scan.useDelimiter(System.getProperty("line.separator"));

	       ArrayList<String> list = new ArrayList<String>();

	        while (scan.hasNext()) 
	        {
	            list.add(scan.next());
	        }
	        System.out.println(" list length" + list.get(0).length());
	        scan.close();

	        // finally convert the arraylist to a char[][]
	        mapArray = new char[list.size ()][];
	        for (int i = 0; i < list.size(); i++) 
	        {
	            mapArray[i] = list.get(i).toCharArray();
	        }
		}
		catch (IOException e)
		{
			System.out.println("You have run in to an error: " + e.getMessage());
		}
		
		
		
		
		
	} 
	
	public ArrayList getArray()
	{
		return tileLayout;
	}
	
	
	
	
	private void loadTiles()
	{
		
		tileLayout = new ArrayList<TileParent>();
		int locX = 0;
		int locY = 0;
		int count = 0;
		
		try
		{
			
			for(int y = 0; y < mapHeight  ; y++)
			{
				
				for(int x = 0; x < mapWidth  ; x++)
				{
					
						if(mapArray[y][x] == 'A')
						{	
/* if the 2d map array has an A it makes a brown tile
 * and checks to see if can place in an empty spot on the board
 */
							tileLayout.add( new BrownTile(locX, locY));
							
							if(x < mapWidth)
							{
								locX += tileWidth ;
								
								if(x == mapWidth - 1)
								{
									locY += tileHeight;
									locX = 0;
									
								}
								
							}
							
						}
					
						else if(mapArray[y][x] == ' ')
						{
							locX += tileWidth ;
						}
						//if block B in text file
						
						else if(mapArray[y][x] == 'B')
							{	
/*
 * if the 2d map array has an A it makes a brown tile and
 * checks to see if can place in an empty spot on the board
 */
								tileLayout.add( new BlueTile(locX, locY));
								
								if(x < mapWidth)
								{
									locX += tileWidth ;
										
									if(x == mapWidth - 1)
									{
										locY += tileHeight;
										locX = 0;
									}
										
										
								}
							
							}
				}			
			}	
		}		
				
				catch (ArrayIndexOutOfBoundsException e)
				{
					System.out.println("You have run in to an error: " + e.getMessage());
					System.out.println("fillIn " + e.fillInStackTrace());
					System.out.println("getCause " + e.getCause());
					System.out.println("local Message " + e.getLocalizedMessage());
					System.out.println("stackTrace " + e.getStackTrace());
					System.out.println("Print stackTrace ");   e.printStackTrace();
					
				}
					
	}
	
	//gets width in tiles
	public static int getMapWidth() 
	{
		mapWidth =  mapArray[0].length;
		return mapWidth;
	}
	//gets height in tiles
	public static int getMapHeight() 
	{
		mapHeight = mapArray.length;
		return mapHeight;
	}
	public static int getMapPxWidth()
	{
		mapPxWidth = tileWidth * mapArray[0].length;
	}
	public static int getMapPxHeight()
	{
		mapPxHeight = tileHeight * mapArray.length;
	}
	// toString returns a text layout of the map
	public String toString()
	{
		String layout = "Current map layout \n\n";
		
		for (int i = 0; i < mapArray.length; i++) 
        {
            for (int j = 0; j < mapArray[i].length; j++) 
            {
                layout += mapArray[i][j];
            }
            layout += ("\n");
        }
		
		return layout;
	}
	
	
	
}

//This is the game class

public class Board extends JPanel implements ActionListener
{
	//private Timer timer;
	private TileMaker gameMap;
	private ArrayList<TileParent> tileLayout;
	private ChampSprite hero;
	private Timer timer;
	public Board()
	{
		Camera cam = new Camera();
		hero = new ChampSprite();
		gameMap = new TileMaker("map");
		setFocusable(true);
	    setBackground(Color.WHITE);
	    setDoubleBuffered(true);
	    getTileArray();
	    addKeyListener(new TAdapter());
	    initGame();
	}

	public void initGame() 
	{
		
		 timer = new Timer(0, this);
	    timer.start();
	}

	public void addNotify() 
	{
        super.addNotify();
	}
	
	public void getTileArray()
	{
		tileLayout = new ArrayList();
		tileLayout = gameMap.getArray();
		
	}
	
	
	public void paintComponent(Graphics g)
	{
		super.paintComponents(g);
		
		Graphics2D g2d = (Graphics2D)g;
		
		g2d.drawImage(gameMap.getBG("grassBG") , 0, 0, this);
		 
		for (int i = 0; i < tileLayout.size(); i++) 
		{
			g2d.drawImage(
               tileLayout.get(i).
               getImage(), tileLayout.get(i).getX(), tileLayout.get(i).getY() , this);
        }
        
		
		
		if (hero.isVisible())
		{
			g2d.drawImage(hero.getImage(), hero.getX() - cam., heroSpriteY - cameraY);
			//g2d.drawImage(hero.getImage(), hero.getX(), hero.getY(), this);
		}
	
		repaint();
			
		Toolkit.getDefaultToolkit().sync();
	    g.dispose();
	}
	
	public  void checkCollisions() 
	{
		Rectangle r1 = hero.getBounds();
/* checks to see if the heros rectangle has entered a
 * blocks if so it moves the hero back to where he was before the collision
 */
		for (int x = 0; x < tileLayout.size(); x++) 
        {
            TileParent block =  tileLayout.get(x);
            Rectangle r2 = block.getBounds();
           
            if (r1.intersects(r2)) 
            {
            	
            	hero.collision();
            }
        }
	}

	

	
	
	 
	private class TAdapter extends KeyAdapter 
	{
		 public void keyReleased(KeyEvent e) 
		 {
	       hero.keyReleased(e);
	    }
	
	    public void keyPressed(KeyEvent e)
	    {
	        hero.keyPressed(e);
	    }
	}
	
		
	@Override
	public void actionPerformed(ActionEvent arg0) 
	{
		
		checkCollisions();
		
		hero.move();
		
	}

}

//This is the hero sprite class

public class ChampSprite 
{
	private static int x;
	private static int y;
	private int dx;
	private int dy;
	private int testX;
	private int testY;
	private int width;
    private int height;
	private Image image;
	private boolean visible;
	private String location;
	
	public ChampSprite()
	{
		ImageIcon icon = new ImageIcon (
             this.getClass().getResource("/misc/images/hero30_30px.png"));
		image = icon.getImage();
		x = 32;
		y = 32;
		width = image.getWidth(null);
        height = image.getHeight(null);
       testX = 0;
       testY = 0;
        visible = true;
    }
	// moves the hero sprite
    public void move()
    {
    	
    	testX = dx;
    	testY = dy;
    	if(dy == 0)
    		x += dx;
    	if(dx == 0)
    		y += dy;
    	
    }
/* checks if the hero has touched a block that can not
 * be passed and moves them back to the location before they touched the block
 */
    public void collision()
    {
    	
    	if(testX == 1)
    		x  += - 1;
    	else if(testX == -1)
    		x  +=  1;
    	else if(testY == 1)
    		y  +=  - 1;
    	else if(testY == -1)
    		y  +=  1;
    	
    }
  
    // gets the current location of the hero sprite
    public String location()
    {
    	
    	location = "X location " + getX() + " Y location " + getY();
    	
    	return location;
    }
    
    // sets hero sprite visablility
    public void setVisible(boolean visible) 
    {
        this.visible = visible;
    }
    //checks if hero is visable
    public boolean isVisible() 
    {
        return visible;
    }
    //returns a rectangle the size of the spirite for collision checking
    public Rectangle getBounds() 
    {
        return new Rectangle(x, y, width - 2, height - 2 );
    }
    // gets X axis location of the hero sprite
    public static int getX()
    {
    	return x;
    }
    // gets the Y axis location of the hero sprite
    public static int getY()
    {
    	return y;
    }
    
    
   
    //gets the testX int used for collision detection
    public int getTestX() 
    {
		return testX;
	}
    //sets the testX int used for collision detection
	public void setTestX(int testX) 
	{
		this.testX = testX;
	}
	// gets the testY int used for collision detection
	public int getTestY() 
	{
		return testY;
	}
	// sets the testY int used for collision detection
	public void setTestY(int testY) 
	{
		this.testY = testY;
	}
	// returns the image used for the hero sprite
	public Image getImage()
    {
    	return image;
    }
    // hero arrow key controls
    public void keyPressed(KeyEvent e) 
    {

        int key = e.getKeyCode();

        if (key == KeyEvent.VK_LEFT) 
        {
            dx = - 1;
        }

        else if (key == KeyEvent.VK_RIGHT) 
        {
            dx = 1;
        }

        else if (key == KeyEvent.VK_UP) 
        {
            dy = -1;
        }

        else if (key == KeyEvent.VK_DOWN) 
        {
            dy = 1;
        }
       
    }

    public void keyReleased(KeyEvent e) 
    {
        int key = e.getKeyCode();

        if (key == KeyEvent.VK_LEFT) 
        {
            dx = 0;
        }

        else if (key == KeyEvent.VK_RIGHT)
        {
            dx = 0;
        }

        else if (key == KeyEvent.VK_UP) 
        {
            dy = 0;
        }

        else if (key == KeyEvent.VK_DOWN) 
        {
            dy = 0;
        }
        
    }
}

//this is the class of one of the tiles

public class BrownTile extends TileParent
{
	private int x;
    private int y;
    public int tileWidth;
    public int tileHeight;
    private Image image;
	
    public BrownTile(int x, int y)
    {
    	 ImageIcon icon = new ImageIcon (
            this.getClass().getResource("/misc/images/brownBlock32_32px.png"));
    		image = icon.getImage();
    		
    		tileWidth = image.getWidth(null);
            tileHeight = image.getHeight(null);
            this.x = x;
            this.y = y;
    }
    public int getTileWidth()
    {
    	return tileWidth;
    }
    public int getTileHeight()
    {
    	return tileHeight;
    }
    public int getX() 
    {
        return x;
    }

    public int getY() 
    {
        return y;
    }
    
    public void setX(int x) 
    {
		this.x = x;
	}

	public void setY(int y) 
	{
		this.y = y;
	}

    public Image getImage() 
    {
        return image;
    }

	public String toString()
	{
		return "brownTile";
	}
	@Override
	public Rectangle getBounds() {
		 return new Rectangle(x, y, tileWidth -4, tileHeight - 4);
	}
	
}

Sorry for all the code, Im not sure what people might want to see to be able to help me. If any one has any ideas ect please let me know

[Campbell Ritchie]

I am afraid that code is far too long for anybody to read. You will have to shorten it.
Why are you catching an ArrayOutOfBoundsException? That makes me wonder whether you know how to iterate an array.
When you add the blocks, you are going up to width - 1. How do you know that is the correct figure? How you you know the sizes of the boxes will ever add up to 1 less than the width of the display? You need to check that arithmetic very carefully.

I shall move this discussion to our games forum because that is far too large for “beginning”.

[Bobby John]

Its really simple, create a class called Camera with an x and y coordinate.
Draw your tiles at whatever coordinate, plus the x and y from the Camera class.

Then, intstead of changing the coordinates of the player sprite, set them to the center of the screen, and change the Camera coordinates instead. This will keep the player in the center, and the tiles will move instead.