/* This file was created by Carbide.j */

package gamenokia;

import javax.microedition.lcdui.game.*;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

public class ShowCanvas extends GameCanvas implements Runnable
{
	//private gameLayerMger lm = new gameLayerMger();
	private static final int X = 0;
	private static final int Y = 1;
	private static final int WIDTH = 2;
	private static final int HEIGHT = 3;
	private static final int STEP = 3;
	
	//private MySpriteLoader loader=null;
	private Sprite bob;
	private Thread engine;
	
	//private TiledLayer layer;
	private gameLayerMger gLM;
	private int lastState = -1;
	
	private int WORLD_WIDTH;
	private int WORLD_HEIGHT;
	private int[] view = new int[4];
	
	private boolean initialized = false;
	
	private boolean paused = false;
	private Object executionLock = new Object();
	
	
	public ShowCanvas()
	{
		super(true);
		setFullScreenMode(true);
	}
	
	public void showNotify()
	{
		if(initialized)
		{
			synchronized (executionLock)
			{
				if (paused)
				{
					paused = false;
					executionLock.notify();
				}
			}
		}
	}
	
	public void hideNotify()
	{
		synchronized(executionLock)
		{
			paused = true;
		}
	}
	
	public Sprite getSprite()
	{
		Image img=null, tmp=null;
		
		try
		{
			img = Image.createImage("/images/example_sprite.png");
			tmp = Image.createImage(img, 0, 0, 72, 128, Sprite.TRANS_NONE);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		
		Sprite bob=new Sprite(tmp, 24, 32);
		return bob;
	}
	
	public void initialize()
	{
		view[X] = 0;
		view[Y] = 0;
		view[WIDTH] = getWidth();
		view[HEIGHT] = getHeight();
		
		//loader = new MySpriteLoader();
		//loader.load();
		
		//bob = loader.getSprite();
		bob = getSprite();
		bob.defineCollisionRectangle(0, 0, bob.getWidth(), bob.getHeight());
		
		gLM = new gameLayerMger();
		gLM.insert(bob, 0);
		gLM.setViewWindow(0, 0, getWidth(), getHeight());
		
		int[] size = getWorldSize();
		WORLD_WIDTH = size[0];
		WORLD_HEIGHT = size[1];
		
		initialized = true;		
	}
	
	private int[] getWorldSize()
	{
		int width = 0;
		int height = 0;
		for(int i=0; i<gLM.getSize(); i++)
		{
			Layer layer = gLM.getLayerAt(i);
			if(layer.getWidth() > width)
			{
				width = layer.getWidth();
			}
			if(layer.getHeight() > height)
			{
				height = layer.getHeight();
			}
		}
		return new int[]{width, height};
	}
	
	public void startEngine()
	{
		engine = new Thread(this);
		engine.start();
	}
	
	public void stopEngine()
	{
		initialized = false;
		engine = null;
	}
	
	/* （非 Javadoc）
	 * @see java.lang.Runnable#run()
	 */
	public void run()
	{
		
		Graphics g = getGraphics();
		
		while(initialized)
		{
			synchronized(executionLock)
			{
				if(paused)
				{
					try
					{
						wait();
					}
					catch(Exception e)
					{
						//e.printStackTrace();
					}
				}
			}
			
			int keyState=getKeyStates();
			
			if ((keyState & LEFT_PRESSED) != 0)
			{
				if(lastState != LEFT_PRESSED)
				{
					lastState = LEFT_PRESSED;
					bob.setFrameSequence(new int[] {9, 10, 11});					
				}
				else
				{
					bob.nextFrame();
				}
				
				if(bob.getX() - STEP >= 0)
					bob.move(-STEP, 0);
				else
					bob.setPosition(0, bob.getY());
			}
			else if ((keyState & RIGHT_PRESSED) != 0)
			{
				if(lastState != RIGHT_PRESSED)
				{
					lastState = RIGHT_PRESSED;
					bob.setFrameSequence(new int[] {3,4,5});
				}
				else
					bob.nextFrame();
				
				if (bob.getX()+bob.getWidth() < WORLD_WIDTH)
					bob.move(STEP, 0);
				else
					bob.setPosition(WORLD_WIDTH-bob.getWidth(), bob.getY());
			}
			else if ((keyState & UP_PRESSED) != 0)
			{
				if (lastState != UP_PRESSED)
				{
					lastState = UP_PRESSED;
					bob.setFrameSequence(new int[] {0,1,2});					
				}
				else
					bob.nextFrame();
				if (bob.getY()-STEP >= 0)
					bob.move(0, -STEP);
				else
					bob.setPosition(bob.getX(), 0);
			}
			else if ((keyState & DOWN_PRESSED) != 0)
			{
				if (lastState != DOWN_PRESSED)
				{
					lastState = DOWN_PRESSED;
					bob.setFrameSequence(new int[] {6,7,8});
				}
				else
					bob.nextFrame();
				
				if(bob.getY() + bob.getHeight() < WORLD_HEIGHT)
					bob.move(0, STEP);
				else
					bob.setPosition(bob.getX(), WORLD_HEIGHT-bob.getHeight());
			}
			
			checkCollision(lastState);
			
			if (bob.getX() < view[X] + bob.getWidth())
			{
				int dx = (view[X] - bob.getX() + bob.getWidth());
				if (view[X] - dx >= 0)
				{
					view[X] -= dx;
				}
			}
			else if( (bob.getX() + bob.getWidth()) > (view[X] + view[WIDTH]) - bob.getWidth() )
			{
				int dx = (bob.getX() + bob.getWidth()) - (view[X] + view[WIDTH] - bob.getWidth());
				if(view[X] + view[WIDTH] <= WORLD_WIDTH)
					view[X] += dx;
			}
			
			if (bob.getY() < view[Y] + bob.getHeight())
			{
				int dy = (view[Y] - bob.getY() + bob.getHeight());
				if(view[Y] - dy >= 0)
					view[Y] -= dy;				
			}
			
			else if (bob.getY() + bob.getHeight() > (view[Y] + view[HEIGHT]) - bob.getHeight())
			{
				int dy = (bob.getY() + bob.getHeight()) - (view[Y] + view[HEIGHT] - bob.getHeight());
				if(view[Y] + view[HEIGHT] <= WORLD_HEIGHT)
					view[Y] += dy;
			}
			
			gLM.setViewWindow(view[X], view[Y], view[WIDTH], view[HEIGHT]);
			
			gLM.paint(g, 0, 0);
			
			flushGraphics();
			
			try
			{
				Thread.sleep(100);
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
		}
	}
	
	private void checkCollision(int key)
	{
		if (bob.collidesWith((TiledLayer)gLM.getLayerAt(1), true))
		{
			if (key == LEFT_PRESSED)
				bob.move(STEP, 0);
			else if (key == RIGHT_PRESSED)
				bob.move(-STEP, 0);
			else if (key == UP_PRESSED)
				bob.move(0, STEP);
			else
				bob.move(0, -STEP);
		}

	}	
	public void paint( Graphics g )
	{
		if(!initialized)
		{
			initialize();
			
			if (engine == null)
			{
				startEngine();
			}
		}
		super.paint(g);
	}

}