// -------------------------------------------------------------------------------------------
// Multi direction scrolling class
// -------------------------------------------------------------------------------------------

import javax.microedition.lcdui.*;

class BGLayer
//    extends TiledLayer
{
	private static final int MAX_SCROLL_SPEED = 16;
	public int MAP_TILE_WIDTH;
	public int MAP_TILE_HEIGHT;
	public int MAP_WIDTH;
	public int MAP_HEIGHT;
	public int BG_WIDTH_IN_TILES;		// Of background (not map)
	public int BG_HEIGHT_IN_TILES;	// Of background (not map)
	public int BG_WIDTH;
	public int BG_HEIGHT;
	private int	TILE_WIDTH;			// Of single tile
	private int	TILE_HEIGHT;		// Of single tile
	public 	int xScroll;
	public	int yScroll;
	public	Image blockImage;
	public	Image bgImage;
	private	Graphics bgG;

	BGLayer(Image img, int tw, int th, int mtw, int mth)
	{
        TILE_WIDTH = tw;
        TILE_HEIGHT = th;
        xScroll = 0;
        yScroll = 0;
        MAP_TILE_WIDTH = mtw;
        MAP_TILE_HEIGHT = mth;
        MAP_WIDTH = mtw * tw;
        MAP_HEIGHT = mth * th;
        blockImage = img;
        bgImage = Image.createImage(GMCanvas.DISPLAY_WIDTH+16,GMCanvas.DISPLAY_HEIGHT+16);
        bgG = bgImage.getGraphics();
        BG_WIDTH  = bgImage.getWidth();
        BG_HEIGHT = bgImage.getHeight();
        BG_WIDTH_IN_TILES = BG_WIDTH/TILE_WIDTH;
        BG_HEIGHT_IN_TILES = BG_HEIGHT/TILE_HEIGHT;
	}

	// -------------------------------------------------------------------------------------------
	// Fill the background layer with tiles
	// -------------------------------------------------------------------------------------------
    public void scrollTiles(int[] level)
    {
		for (int row = 0; row < MAP_TILE_HEIGHT; row++)
		{
			for (int column = 0; column < MAP_TILE_WIDTH; column++)
			{
				this.setCell(column, row, level[(row*MAP_TILE_WIDTH)+column]);
			}
		}
    }

	// -------------------------------------------------------------------------------------------
	// Set an individual tile on the background
	// -------------------------------------------------------------------------------------------
    public void setCell(int c, int r, int i)
    {
    	i--;
    	if (i < 0) return;
		if (c >= (xScroll>>4) && c < ((xScroll>>4)+BG_WIDTH_IN_TILES)
		&& r >= (yScroll>>4) && r < ((yScroll>>4)+BG_HEIGHT_IN_TILES))
		{
			while (c >= BG_WIDTH_IN_TILES)
			{
				c-=BG_WIDTH_IN_TILES;
			}
			while (r >= BG_HEIGHT_IN_TILES)
			{
				r-=BG_HEIGHT_IN_TILES;
			}
			bgG.setClip(c<<4,r<<4,16,16);
			bgG.drawImage(blockImage,(c<<4)-(i<<4),r<<4,Graphics.TOP | Graphics.LEFT);
		}
    }

	// -------------------------------------------------------------------------------------------
    // Show the background
	// -------------------------------------------------------------------------------------------
    public void show(Graphics g, int width)
    {
		int x = xScroll,
			y = yScroll,
			ys = ((GMCanvas.yDisplay+GMCanvas.DISPLAY_HEIGHT)>GMCanvas.VIS_HEIGHT) ? GMCanvas.VIS_HEIGHT-GMCanvas.yDisplay : GMCanvas.DISPLAY_HEIGHT;

		while (x>=BG_WIDTH)
		{
			x-=BG_WIDTH;
		}
		while (y>=BG_HEIGHT)
		{
			y-=BG_HEIGHT;
		}

		// Show part one
		g.setClip(GMCanvas.xDisplay, GMCanvas.yDisplay, width, ys);
		g.drawImage(bgImage,GMCanvas.xDisplay-x,GMCanvas.yDisplay-y,Graphics.TOP | Graphics.LEFT);

		// If there is an X scroll to cater for
		if (BG_WIDTH-x < GMCanvas.DISPLAY_WIDTH)
		{
			g.setClip(GMCanvas.xDisplay+(BG_WIDTH-x), GMCanvas.yDisplay, GMCanvas.DISPLAY_WIDTH-(BG_WIDTH-x), ys);
			g.drawImage(bgImage,GMCanvas.xDisplay+(BG_WIDTH-x),GMCanvas.yDisplay-y,Graphics.TOP | Graphics.LEFT);
		}

		// There is a Y scroll to cater for
		if (BG_HEIGHT-y < GMCanvas.DISPLAY_HEIGHT)
		{
			g.setClip(GMCanvas.xDisplay, (GMCanvas.yDisplay-y)+BG_HEIGHT, width, GMCanvas.DISPLAY_HEIGHT-(BG_HEIGHT-y));
			g.drawImage(bgImage,GMCanvas.xDisplay-x, (GMCanvas.yDisplay-y)+BG_HEIGHT,Graphics.TOP | Graphics.LEFT);

			// The last one. Is there an X & Y scroll to cater for?
			if (BG_WIDTH-x < GMCanvas.DISPLAY_WIDTH)
			{
				g.setClip(GMCanvas.xDisplay+(BG_WIDTH-x), (GMCanvas.yDisplay-y)+BG_HEIGHT, GMCanvas.DISPLAY_WIDTH-(BG_WIDTH-x), GMCanvas.DISPLAY_HEIGHT-(BG_HEIGHT-y));
				g.drawImage(bgImage,GMCanvas.xDisplay+(BG_WIDTH-x),(GMCanvas.yDisplay-y)+BG_HEIGHT,Graphics.TOP | Graphics.LEFT);
			}

		}
    }

	// -------------------------------------------------------------------------------------------
    // Lift background 16 pixels and repaint bottom row
	// -------------------------------------------------------------------------------------------
//#ifdef midp2
    public void lift(int[] level)
    {
        Graphics bgG = bgImage.getGraphics();
    	bgG.setClip(0,0,BG_WIDTH,BG_HEIGHT);
    	bgG.copyArea(0,16,BG_WIDTH,BG_HEIGHT-16,0,0,Graphics.TOP | Graphics.LEFT);
    	int row = BG_HEIGHT_IN_TILES-1;
		for (int column = 0; column < BG_WIDTH_IN_TILES; column++)
		{
			this.setCell(column, row, level[(row*MAP_TILE_WIDTH)+column]);
		}
    }
//#endif


	// -------------------------------------------------------------------------------------------
    // Get the desired scroll velocity and pass it to the move function
	// -------------------------------------------------------------------------------------------
	public void desiredScrollPos(int x, int y,int[] level)
	{
		x -= xScroll;
		y -= yScroll;
		int vx = x / 4,
			vy = y / 4;
		if (x < 0 && vx == 0) vx = -1;
		if (x > 0 && vx == 0) vx = 1;
		if (y < 0 && vy == 0) vy = -1;
		if (y > 0 && vy == 0) vy = 1;
		if (vx < -MAX_SCROLL_SPEED) vx = -MAX_SCROLL_SPEED;
		if (vx >  MAX_SCROLL_SPEED) vx =  MAX_SCROLL_SPEED;
		if (vy < -MAX_SCROLL_SPEED) vy = -MAX_SCROLL_SPEED;
		if (vy >  MAX_SCROLL_SPEED) vy =  MAX_SCROLL_SPEED;
		move(vx,vy,level);
	}


	// -------------------------------------------------------------------------------------------
    // Move the background based on the x & y velocities passed in
	// -------------------------------------------------------------------------------------------
    public void move(int x, int y, int[] level)
    {
		int tempXScroll = (xScroll & 0x000f) + x,
			tempYScroll = (yScroll & 0x000f) + y,
			oldX = xScroll,
			oldY = yScroll;
		boolean bUpdate = false;

		xScroll += x;
        yScroll += y;

        if ((tempXScroll & 0x00f0) != 0)
        {
			if (xScroll < 0)
				xScroll = 0;
			else bUpdate = true;
		}
        if ((tempYScroll & 0x00f0) != 0)
        {
			if (yScroll < 0)
				yScroll = 0;
			else bUpdate = true;
		}
		if (GMCanvas.DISPLAY_WIDTH >= MAP_WIDTH) xScroll = 0;
		else
		if (xScroll >= (MAP_WIDTH - GMCanvas.DISPLAY_WIDTH)) xScroll = (MAP_WIDTH - GMCanvas.DISPLAY_WIDTH) - 1;
		if (GMCanvas.DISPLAY_HEIGHT >= MAP_HEIGHT) yScroll = 0;
		else
		if (yScroll >= (MAP_HEIGHT - GMCanvas.DISPLAY_HEIGHT)) yScroll = (MAP_HEIGHT - GMCanvas.DISPLAY_HEIGHT) - 1;

		// Only
		if (bUpdate && (oldX != xScroll)) setScrollX(xScroll>oldX, level);
		if (bUpdate && (oldY != yScroll)) setScrollY(yScroll>oldY, level);
    }


	// -------------------------------------------------------------------------------------------
    // Deal with a x scroll update
	// -------------------------------------------------------------------------------------------
	public void setScrollX(boolean right, int[] level)
	{
		// boolean right means we have moved right and need to fill the right edge
		int x = (right) ? (xScroll&0xfff0)+BG_WIDTH-16 : (xScroll&0xfff0),
			r = (right) ? (xScroll>>4)+(BG_WIDTH_IN_TILES-1) : (xScroll>>4),
			y = (yScroll&0xfff0);

		x = x>>4;
		y = y>>4;
		r += (y * MAP_TILE_WIDTH);
		for (int i = y; i < y+BG_HEIGHT_IN_TILES; i++)
		{
			this.setCell(x, i, level[r]);
			r+=MAP_TILE_WIDTH;
		}

	}

	// -------------------------------------------------------------------------------------------
    // Deal with a y scroll update
	// -------------------------------------------------------------------------------------------
	public void setScrollY(boolean down, int[] level)
	{
		// boolean right means we have moved right and need to fill the right edge
		int y = (down) ? (yScroll&0xfff0)+BG_HEIGHT-16 : (yScroll&0xfff0),
			c = (down) ? ((yScroll>>4)+(BG_HEIGHT_IN_TILES-1))*MAP_TILE_WIDTH : (yScroll>>4)*MAP_TILE_WIDTH,
			x = (xScroll&0xfff0);

		x = x>>4;
		y = y>>4;
		c += x;

		for (int i = x; i < x+BG_WIDTH_IN_TILES; i++)
		{
			this.setCell(i, y, level[c]);
			c++;
		}

	}


}