cvs.zerfleddert.de Git - FreeShisen/blame_incremental - src/de/cwde/freeshisen/ShisenShoView.java

package de.cwde.freeshisen;

import java.lang.ref.WeakReference;
import java.util.List;
import java.util.Locale;
import java.util.Timer;
import java.util.TimerTask;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Paint.Align;
import android.graphics.Paint.Cap;
import android.graphics.Paint.Join;
import android.graphics.Paint.Style;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.os.Handler;
import android.os.Message;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

class ShisenShoView extends SurfaceView implements SurfaceHolder.Callback {

	private static final String INVALID_TIME = "9:99:99";
	private static final String COLOR_TEXT = "#FFFFFF";
	private static final String COLOR_TEXT_SHADOW = "#000000";
	private static final String COLOR_HINT = "#F0C000";
	private static final String COLOR_SELECTED = "#FF0000";

	private enum StatePlay { UNINITIALIZED, IDLE, SELECTED1, SELECTED2, GAMEOVER };
	private enum StatePaint { BOARD, SELECTED1, SELECTED2, MATCHED, WIN, LOSE, HINT, TIME };

	private int screenWidth;
	private int screenHeight;
	private int tilesetRows;
	private int tilesetCols;
	private int tileHeight;
	private int tileWidth;
	private Bitmap bg;
	private Bitmap tile[];
	private Point selection1 = new Point(0, 0);
	private Point selection2 = new Point(0, 0);
	private List<Point> path = null;
	private List<Line> pairs = null;
	private long startTime;
	private long playTime;
	private long baseTime;
	private Timer timer;

	static class hHandler extends Handler {
		private final WeakReference<ShisenShoView> mTarget;

		hHandler(ShisenShoView target) {
			mTarget = new WeakReference<ShisenShoView>(target);
		}

		@Override
		public void handleMessage(Message msg) {
			ShisenShoView target = mTarget.get();
			if (target != null)
				target.onUpdateTime();
		}
	}

	private Handler timerHandler = new hHandler(this);

	private boolean timerRegistered = false;
	private ShisenSho app;
	private StatePlay cstate;
	private StatePaint pstate;
	private Canvas canvas = null;
	private SurfaceHolder surfaceHolder = null;
	private String time = INVALID_TIME;

	public ShisenShoView(ShisenSho shishenSho) {
		super((Context) shishenSho);
		this.app = shishenSho;
		cstate = StatePlay.UNINITIALIZED;
		surfaceHolder = getHolder();
		surfaceHolder.addCallback(this);
	}

	public ShisenShoView(Context ctx) {
		super((Context) ctx);
		// silence lint?
	}

	private void paint(StatePaint pstate) {
		this.pstate=pstate;
		repaint();
	}

	private void control(StatePlay cstate) {
		this.cstate=cstate;
	}

	private void loadTileset() {
		BitmapFactory.Options ops = new BitmapFactory.Options();
		ops.inScaled = false;
		Bitmap tileset = BitmapFactory.decodeResource(getResources(), R.drawable.tileset, ops);
		tileset.setDensity(Bitmap.DENSITY_NONE);

		// The tile set has 4 rows x 9 columns
		tilesetRows = 4;
		tilesetCols = 9;
		int loadedtileWidth = tileset.getWidth()/tilesetCols;
		int loadedtileHeight = tileset.getHeight()/tilesetRows;
		tile = new Bitmap[tilesetRows*tilesetCols];

		// align to screen:
		// "large" is 16x6, and we want to have a nice border, so we use 17x7 and
		// choose the lowest scale so everything fits
		float scalex = ((float) screenWidth/17) / loadedtileWidth;
		float scaley = ((float) screenHeight/7) / loadedtileHeight;
		if (scaley < scalex) {
			scalex = scaley;
		} else {
			scaley = scalex;
		}
		Matrix matrix = new Matrix();
		matrix.setScale(scalex, scaley);

		int k=0;
		for (int i=0; i<tilesetRows; i++) {
			for (int j=0; j<tilesetCols; j++) {
				tile[k] = Bitmap.createBitmap(tileset, j*loadedtileWidth, i*loadedtileHeight,
						loadedtileWidth, loadedtileHeight, matrix, false);
				tile[k].setDensity(Bitmap.DENSITY_NONE);
				k++;
			}
		}
		tileWidth = tile[0].getWidth();
		tileHeight = tile[0].getHeight();
	}

	private void loadBackground() {
		BitmapFactory.Options ops = new BitmapFactory.Options();
		ops.inScaled = false;
		bg = BitmapFactory.decodeResource(getResources(), R.drawable.kshisen_bgnd, ops);
		bg.setDensity(Bitmap.DENSITY_NONE);
	}

	private void registerTimer() {
		if (timer != null)
			return; // Already registered
		timer = new Timer();
		timer.scheduleAtFixedRate(new TimerTask() {
			public void run() {
				timerHandler.sendEmptyMessage(Activity.RESULT_OK);
			}
		}, 0, 1000);
		timerRegistered = true;
	}

	private void unregisterTimer() {
		if (timer == null)
			return; // Already unregistered
		timer.cancel();
		timer = null;
		timerRegistered = false;
	}

	public void pauseTime() {
		updateTime();
		baseTime = playTime;
		startTime = System.currentTimeMillis();

	}

	public void resumeTime() {
		startTime = System.currentTimeMillis();
		updateTime();
	}

	private void updateTime() {
		if (cstate!=StatePlay.GAMEOVER) {
			playTime = (System.currentTimeMillis()-startTime)/1000+baseTime;
		}
	}

	private void initializeGame() {
		loadBackground();
		screenWidth=getWidth();
		screenHeight=getHeight();
		loadTileset();
		//undo.sensitive=false;
		pstate=StatePaint.BOARD;
		app.newPlay();
		control(StatePlay.IDLE);
		startTime=System.currentTimeMillis();
		playTime=0;
		baseTime=0;
		if (!timerRegistered) {
			registerTimer();
		}
		pairs=app.board.getPairs(1);
	}

	public boolean onOptionsItemSelected(MenuItem item) {
		// Handle item selection
		switch (item.getItemId()) {
		case R.id.hint:
			this.postDelayed(new Runnable() { public void run() { onHintActivate(); } }, 100);
			return true;
		case R.id.undo:
			this.postDelayed(new Runnable() { public void run() { onUndoActivate(); } }, 100);
			return true;
		case R.id.clean:
			this.postDelayed(new Runnable() { public void run() { reset(); } }, 100);
			return true;
		case R.id.options:
			return true;
		case R.id.about:
			return true;
		default:
			return false;
		}
	}

	public void reset() {
		control(StatePlay.UNINITIALIZED);
		paint(StatePaint.BOARD);
	}

	private void onHintActivate() {
		if (cstate!=StatePlay.GAMEOVER) {
			pairs=app.board.getPairs(1);
			paint(StatePaint.HINT);
			app.sleep(10);
			paint(StatePaint.BOARD);
			control(StatePlay.IDLE);
		}
	}

	private void onUndoActivate() {
		if (app.board.getCanUndo()) {
			if (cstate==StatePlay.GAMEOVER && !timerRegistered) {
				// Reprogram the time update that had been
				// deactivated with the game over status
				registerTimer();
			}
			app.board.undo();
			paint(StatePaint.BOARD);
			//undo.sensitive=app.board.getCanUndo();
			control(StatePlay.IDLE);
		}
	}

	public void onTimeCounterActivate() {
		if (cstate!=StatePlay.GAMEOVER && !timerRegistered) {
			// Reprogram the time update that had been
			// deactivated with the time_counter=false
			registerTimer();
		}
	}

	private void onUpdateTime() {
		paint(pstate);
		if (cstate==StatePlay.GAMEOVER) {
			unregisterTimer();
		}
	}

	@SuppressWarnings("deprecation")
	public static void drawMessage(Canvas canvas, int x, int y,
			boolean centered, String message, float textSize) {
		Paint paint = new Paint();
		paint.setLinearText(true);
		paint.setAntiAlias(true);
		paint.setTextAlign(centered ? Align.CENTER : Align.LEFT);
		paint.setTypeface(Typeface.SANS_SERIF);
		paint.setFakeBoldText(true);
		paint.setTextSize(textSize);
		paint.setColor(Color.parseColor(COLOR_TEXT_SHADOW));
		canvas.drawText(message, x + 1, y + 1, paint);
		paint.setColor(Color.parseColor(COLOR_TEXT));
		canvas.drawText(message, x, y, paint);
	}

	public void repaint() {
		if (surfaceHolder == null) return;
		try {
			if (canvas == null) canvas = surfaceHolder.lockCanvas(null);
			if (canvas == null) return;
			if (cstate==StatePlay.UNINITIALIZED) initializeGame();
			synchronized (surfaceHolder) {
				doDraw(canvas);
			}
		} finally {
			if (canvas != null) {
				surfaceHolder.unlockCanvasAndPost(canvas);
				canvas = null;
			}
		}
	}

	protected void doDraw(Canvas canvas) {
		try {
			if (canvas == null) return;

			// Board upper left corner on screen
			int x0=0;
			int y0=0;

			if (app!=null && app.board!=null) {
				x0=(screenWidth-app.board.boardSize[1]*tileWidth)/2;
				y0=(screenHeight-app.board.boardSize[0]*tileHeight)/2;
			}

			int selectcolor = Color.parseColor(COLOR_SELECTED);
			int hintcolor = Color.parseColor(COLOR_HINT);

			// Background & board painting
			switch (pstate) {
			case BOARD:
			case SELECTED1:
			case SELECTED2:
			case MATCHED:
			case WIN:
			case LOSE:
			case HINT:
			case TIME:
				// Background painting
				int bgWidth = bg.getWidth();
				int bgHeight = bg.getHeight();
				for (int i=0; i<screenHeight/bgHeight+1; i++) {
					for (int j=0; j<screenWidth/bgWidth+1; j++) {
						canvas.drawBitmap(bg, j*bgWidth, i*bgHeight, null);
					}
				}

				// Board painting
				// Max visible size: 7x17
				if (app!=null && app.board!=null) {
					for (int i=0;i<app.board.boardSize[0];i++) {
						for (int j=0;j<app.board.boardSize[1];j++) {
							// Tiles are 56px height, 40px width each
							char piece=app.board.board[i][j];
							if (piece!=0) {
								canvas.drawBitmap(tile[piece], x0+j*tileWidth, y0+i*tileHeight, null);
							}
						}
					}
				}
				break;
			}

			// rectangle for selection 1
			switch (pstate) {
			case SELECTED1:
			case SELECTED2:
			case MATCHED:
				highlightTile(canvas, x0, y0, selection1, selectcolor);
				break;
			}

			// rectangle for selection 2
			switch (pstate) {
			case SELECTED2:
			case MATCHED:
				highlightTile(canvas, x0, y0, selection2, selectcolor);
				break;
			}

			// Matching path
			switch (pstate) {
			case MATCHED:
				if (path!=null) {
					Point p0=null;
					for (Point p1 : path) {
						if (p0!=null) {
							drawLine(canvas, x0, y0, p0, p1, selectcolor);
						}
						p0=p1;
					}
				}
				break;
			}

			// hint rectangles
			switch (pstate) {
			case HINT:
				if (pairs != null && pairs.size() > 0) {
					Line pair = pairs.get(0);
					Point a = pair.a;
					Point b = pair.b;
					path = app.board.getPath(a, b);

					highlightTile(canvas, x0, y0, a, hintcolor);

					if (path != null) {
						Point p0 = null;
						for (Point p1 : path) {
							if (p0 != null) {
								drawLine(canvas, x0, y0, p0, p1, hintcolor);
							}
							p0 = p1;
						}
						path = null;
					}

					highlightTile(canvas, x0, y0, b, hintcolor);
				}
				break;
			}

			// Win & loose notifications
			switch (pstate) {
			case WIN:
				drawMessage(canvas, screenWidth / 2, screenHeight / 2, true,
						"You Win!", 100);
				break;
			case LOSE:
				drawMessage(canvas, screenWidth / 2, screenHeight / 2, true,
						"Game Over", 100);
				break;
			}

			switch (pstate) {
			case BOARD:
			case SELECTED1:
			case SELECTED2:
			case MATCHED:
			case WIN:
			case LOSE:
			case HINT:
			case TIME:
				updateTime();
				int hours = (int) (playTime / (60 * 60));
				int minutes = (int) ((playTime / 60) % 60);
				int seconds = (int) (playTime % 60);
				if (hours < 10) {
					time = String.format(Locale.US, "%01d:%02d:%02d",
							hours, minutes, seconds);
				} else {
					time = INVALID_TIME;
				}

				int timePosX=screenWidth-120;
				int timePosY=screenHeight-10;

				if (app.timeCounter) {
					drawMessage(canvas, timePosX, timePosY, false, time, 30);
				}
				break;
			}

		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	private void drawLine(Canvas canvas, int x0, int y0, Point p0, Point p1, int color) {
		Paint paint = new Paint();
		paint.setFlags(Paint.ANTI_ALIAS_FLAG);
		paint.setColor(color);
		paint.setStyle(Style.STROKE);
		paint.setStrokeCap(Cap.ROUND);
		paint.setStrokeJoin(Join.ROUND);
		paint.setStrokeWidth(3);
		canvas.drawLine(
				x0 + p0.j * tileWidth - 2 + (tileWidth / 2),
				y0 + p0.i * tileHeight - 2 + (tileHeight / 2),
				x0 + p1.j * tileWidth - 2 + (tileWidth / 2),
				y0 + p1.i * tileHeight - 2 + (tileHeight / 2), paint);
	}

	private void highlightTile(Canvas canvas, int x0, int y0, Point p, int color) {
		Paint paint = new Paint();
		paint.setFlags(Paint.ANTI_ALIAS_FLAG);
		paint.setColor(color);
		paint.setStyle(Style.STROKE);
		paint.setStrokeCap(Cap.ROUND);
		paint.setStrokeJoin(Join.ROUND);
		paint.setStrokeWidth(3);
		Rect r = new Rect(
				x0 + p.j * tileWidth - 2,
				y0 + p.i * tileHeight - 2,
				x0 + p.j * tileWidth + tileWidth + 2,
				y0 + p.i * tileHeight + tileHeight + 2);
		canvas.drawRect(r, paint);
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		if (event.getAction()==MotionEvent.ACTION_DOWN) {
			onClick(Math.round(event.getX()),Math.round(event.getY()));
		}
		return super.onTouchEvent(event);
	}

	private void onClick(int x, int y) {
		try {
			int i=(y-(screenHeight-app.board.boardSize[0]*tileHeight)/2)/tileHeight;
			int j=(x-(screenWidth-app.board.boardSize[1]*tileWidth)/2)/tileWidth;

			switch (cstate) {
			case IDLE:
				if (i >= 0 && i < app.board.boardSize[0] && j >= 0
				&& j < app.board.boardSize[1]
						&& app.board.board[i][j] != 0) {
					selection1.set(i, j);
					paint(StatePaint.SELECTED1);
					control(StatePlay.SELECTED1);
				}
				break;
			case SELECTED1:
				if (i >= 0 && i < app.board.boardSize[0] && j >= 0
				&& j < app.board.boardSize[1]
						&& app.board.board[i][j] != 0) {
					if (selection1.equals(i, j)) {
						paint(StatePaint.BOARD);
						control(StatePlay.IDLE);
					} else {
						selection2.set(i, j);
						paint(StatePaint.SELECTED2);

						Point a = selection1.copy();
						Point b = selection2.copy();
						path = app.board.getPath(a, b);
						paint(StatePaint.MATCHED);
						app.sleep(2);
						paint(StatePaint.BOARD);
						if (path.size() > 0) {
							app.board.play(a, b);
						}
						path = null;
						paint(StatePaint.BOARD);

						pairs = app.board.getPairs(1);
						if (pairs.size() == 0) {
							if (app.board.getNumPieces() == 0) {
								paint(StatePaint.WIN);
							} else {
								paint(StatePaint.LOSE);
							}
							control(StatePlay.GAMEOVER);
						} else {
							control(StatePlay.IDLE);
						}
						//undo.sensitive=app.board.getCanUndo();
					}
				}
				break;
			case GAMEOVER:
				reset();
				paint(StatePaint.BOARD);
				break;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void surfaceChanged(SurfaceHolder holder, int format, int width,
			int height) {
		surfaceHolder = holder;
		if (cstate!=StatePlay.GAMEOVER && !timerRegistered) {
			registerTimer();
		}
		repaint();
	}

	public void surfaceCreated(SurfaceHolder holder) {
		surfaceHolder = holder;
		repaint();
	}

	public void surfaceDestroyed(SurfaceHolder holder) {
		surfaceHolder = null;
		if (timerRegistered) {
			unregisterTimer();
		}
	}
}
Commit	Line	Data
	1	package de.cwde.freeshisen;
	2
	3	import java.lang.ref.WeakReference;
	4	import java.util.List;
	5	import java.util.Locale;
	6	import java.util.Timer;
	7	import java.util.TimerTask;
	8
	9	import android.app.Activity;
	10	import android.content.Context;
	11	import android.graphics.Bitmap;
	12	import android.graphics.BitmapFactory;
	13	import android.graphics.Canvas;
	14	import android.graphics.Color;
	15	import android.graphics.Matrix;
	16	import android.graphics.Paint;
	17	import android.graphics.Paint.Align;
	18	import android.graphics.Paint.Cap;
	19	import android.graphics.Paint.Join;
	20	import android.graphics.Paint.Style;
	21	import android.graphics.Rect;
	22	import android.graphics.Typeface;
	23	import android.os.Handler;
	24	import android.os.Message;
	25	import android.view.MenuItem;
	26	import android.view.MotionEvent;
	27	import android.view.SurfaceHolder;
	28	import android.view.SurfaceView;
	29
	30	class ShisenShoView extends SurfaceView implements SurfaceHolder.Callback {
	31
	32	private static final String INVALID_TIME = "9:99:99";
	33	private static final String COLOR_TEXT = "#FFFFFF";
	34	private static final String COLOR_TEXT_SHADOW = "#000000";
	35	private static final String COLOR_HINT = "#F0C000";
	36	private static final String COLOR_SELECTED = "#FF0000";
	37
	38	private enum StatePlay { UNINITIALIZED, IDLE, SELECTED1, SELECTED2, GAMEOVER };
	39	private enum StatePaint { BOARD, SELECTED1, SELECTED2, MATCHED, WIN, LOSE, HINT, TIME };
	40
	41	private int screenWidth;
	42	private int screenHeight;
	43	private int tilesetRows;
	44	private int tilesetCols;
	45	private int tileHeight;
	46	private int tileWidth;
	47	private Bitmap bg;
	48	private Bitmap tile[];
	49	private Point selection1 = new Point(0, 0);
	50	private Point selection2 = new Point(0, 0);
	51	private List<Point> path = null;
	52	private List<Line> pairs = null;
	53	private long startTime;
	54	private long playTime;
	55	private long baseTime;
	56	private Timer timer;
	57
	58	static class hHandler extends Handler {
	59	private final WeakReference<ShisenShoView> mTarget;
	60
	61	hHandler(ShisenShoView target) {
	62	mTarget = new WeakReference<ShisenShoView>(target);
	63	}
	64
	65	@Override
	66	public void handleMessage(Message msg) {
	67	ShisenShoView target = mTarget.get();
	68	if (target != null)
	69	target.onUpdateTime();
	70	}
	71	}
	72
	73	private Handler timerHandler = new hHandler(this);
	74
	75	private boolean timerRegistered = false;
	76	private ShisenSho app;
	77	private StatePlay cstate;
	78	private StatePaint pstate;
	79	private Canvas canvas = null;
	80	private SurfaceHolder surfaceHolder = null;
	81	private String time = INVALID_TIME;
	82
	83	public ShisenShoView(ShisenSho shishenSho) {
	84	super((Context) shishenSho);
	85	this.app = shishenSho;
	86	cstate = StatePlay.UNINITIALIZED;
	87	surfaceHolder = getHolder();
	88	surfaceHolder.addCallback(this);
	89	}
	90
	91	public ShisenShoView(Context ctx) {
	92	super((Context) ctx);
	93	// silence lint?
	94	}
	95
	96	private void paint(StatePaint pstate) {
	97	this.pstate=pstate;
	98	repaint();
	99	}
	100
	101	private void control(StatePlay cstate) {
	102	this.cstate=cstate;
	103	}
	104
	105	private void loadTileset() {
	106	BitmapFactory.Options ops = new BitmapFactory.Options();
	107	ops.inScaled = false;
	108	Bitmap tileset = BitmapFactory.decodeResource(getResources(), R.drawable.tileset, ops);
	109	tileset.setDensity(Bitmap.DENSITY_NONE);
	110
	111	// The tile set has 4 rows x 9 columns
	112	tilesetRows = 4;
	113	tilesetCols = 9;
	114	int loadedtileWidth = tileset.getWidth()/tilesetCols;
	115	int loadedtileHeight = tileset.getHeight()/tilesetRows;
	116	tile = new Bitmap[tilesetRows*tilesetCols];
	117
	118	// align to screen:
	119	// "large" is 16x6, and we want to have a nice border, so we use 17x7 and
	120	// choose the lowest scale so everything fits
	121	float scalex = ((float) screenWidth/17) / loadedtileWidth;
	122	float scaley = ((float) screenHeight/7) / loadedtileHeight;
	123	if (scaley < scalex) {
	124	scalex = scaley;
	125	} else {
	126	scaley = scalex;
	127	}
	128	Matrix matrix = new Matrix();
	129	matrix.setScale(scalex, scaley);
	130
	131	int k=0;
	132	for (int i=0; i<tilesetRows; i++) {
	133	for (int j=0; j<tilesetCols; j++) {
	134	tile[k] = Bitmap.createBitmap(tileset, jloadedtileWidth, iloadedtileHeight,
	135	loadedtileWidth, loadedtileHeight, matrix, false);
	136	tile[k].setDensity(Bitmap.DENSITY_NONE);
	137	k++;
	138	}
	139	}
	140	tileWidth = tile[0].getWidth();
	141	tileHeight = tile[0].getHeight();
	142	}
	143
	144	private void loadBackground() {
	145	BitmapFactory.Options ops = new BitmapFactory.Options();
	146	ops.inScaled = false;
	147	bg = BitmapFactory.decodeResource(getResources(), R.drawable.kshisen_bgnd, ops);
	148	bg.setDensity(Bitmap.DENSITY_NONE);
	149	}
	150
	151	private void registerTimer() {
	152	if (timer != null)
	153	return; // Already registered
	154	timer = new Timer();
	155	timer.scheduleAtFixedRate(new TimerTask() {
	156	public void run() {
	157	timerHandler.sendEmptyMessage(Activity.RESULT_OK);
	158	}
	159	}, 0, 1000);
	160	timerRegistered = true;
	161	}
	162
	163	private void unregisterTimer() {
	164	if (timer == null)
	165	return; // Already unregistered
	166	timer.cancel();
	167	timer = null;
	168	timerRegistered = false;
	169	}
	170
	171	public void pauseTime() {
	172	updateTime();
	173	baseTime = playTime;
	174	startTime = System.currentTimeMillis();
	175
	176	}
	177
	178	public void resumeTime() {
	179	startTime = System.currentTimeMillis();
	180	updateTime();
	181	}
	182
	183	private void updateTime() {
	184	if (cstate!=StatePlay.GAMEOVER) {
	185	playTime = (System.currentTimeMillis()-startTime)/1000+baseTime;
	186	}
	187	}
	188
	189	private void initializeGame() {
	190	loadBackground();
	191	screenWidth=getWidth();
	192	screenHeight=getHeight();
	193	loadTileset();
	194	//undo.sensitive=false;
	195	pstate=StatePaint.BOARD;
	196	app.newPlay();
	197	control(StatePlay.IDLE);
	198	startTime=System.currentTimeMillis();
	199	playTime=0;
	200	baseTime=0;
	201	if (!timerRegistered) {
	202	registerTimer();
	203	}
	204	pairs=app.board.getPairs(1);
	205	}
	206
	207	public boolean onOptionsItemSelected(MenuItem item) {
	208	// Handle item selection
	209	switch (item.getItemId()) {
	210	case R.id.hint:
	211	this.postDelayed(new Runnable() { public void run() { onHintActivate(); } }, 100);
	212	return true;
	213	case R.id.undo:
	214	this.postDelayed(new Runnable() { public void run() { onUndoActivate(); } }, 100);
	215	return true;
	216	case R.id.clean:
	217	this.postDelayed(new Runnable() { public void run() { reset(); } }, 100);
	218	return true;
	219	case R.id.options:
	220	return true;
	221	case R.id.about:
	222	return true;
	223	default:
	224	return false;
	225	}
	226	}
	227
	228	public void reset() {
	229	control(StatePlay.UNINITIALIZED);
	230	paint(StatePaint.BOARD);
	231	}
	232
	233	private void onHintActivate() {
	234	if (cstate!=StatePlay.GAMEOVER) {
	235	pairs=app.board.getPairs(1);
	236	paint(StatePaint.HINT);
	237	app.sleep(10);
	238	paint(StatePaint.BOARD);
	239	control(StatePlay.IDLE);
	240	}
	241	}
	242
	243	private void onUndoActivate() {
	244	if (app.board.getCanUndo()) {
	245	if (cstate==StatePlay.GAMEOVER && !timerRegistered) {
	246	// Reprogram the time update that had been
	247	// deactivated with the game over status
	248	registerTimer();
	249	}
	250	app.board.undo();
	251	paint(StatePaint.BOARD);
	252	//undo.sensitive=app.board.getCanUndo();
	253	control(StatePlay.IDLE);
	254	}
	255	}
	256
	257	public void onTimeCounterActivate() {
	258	if (cstate!=StatePlay.GAMEOVER && !timerRegistered) {
	259	// Reprogram the time update that had been
	260	// deactivated with the time_counter=false
	261	registerTimer();
	262	}
	263	}
	264
	265	private void onUpdateTime() {
	266	paint(pstate);
	267	if (cstate==StatePlay.GAMEOVER) {
	268	unregisterTimer();
	269	}
	270	}
	271
	272	@SuppressWarnings("deprecation")
	273	public static void drawMessage(Canvas canvas, int x, int y,
	274	boolean centered, String message, float textSize) {
	275	Paint paint = new Paint();
	276	paint.setLinearText(true);
	277	paint.setAntiAlias(true);
	278	paint.setTextAlign(centered ? Align.CENTER : Align.LEFT);
	279	paint.setTypeface(Typeface.SANS_SERIF);
	280	paint.setFakeBoldText(true);
	281	paint.setTextSize(textSize);
	282	paint.setColor(Color.parseColor(COLOR_TEXT_SHADOW));
	283	canvas.drawText(message, x + 1, y + 1, paint);
	284	paint.setColor(Color.parseColor(COLOR_TEXT));
	285	canvas.drawText(message, x, y, paint);
	286	}
	287
	288	public void repaint() {
	289	if (surfaceHolder == null) return;
	290	try {
	291	if (canvas == null) canvas = surfaceHolder.lockCanvas(null);
	292	if (canvas == null) return;
	293	if (cstate==StatePlay.UNINITIALIZED) initializeGame();
	294	synchronized (surfaceHolder) {
	295	doDraw(canvas);
	296	}
	297	} finally {
	298	if (canvas != null) {
	299	surfaceHolder.unlockCanvasAndPost(canvas);
	300	canvas = null;
	301	}
	302	}
	303	}
	304
	305	protected void doDraw(Canvas canvas) {
	306	try {
	307	if (canvas == null) return;
	308
	309	// Board upper left corner on screen
	310	int x0=0;
	311	int y0=0;
	312
	313	if (app!=null && app.board!=null) {
	314	x0=(screenWidth-app.board.boardSize[1]*tileWidth)/2;
	315	y0=(screenHeight-app.board.boardSize[0]*tileHeight)/2;
	316	}
	317
	318	int selectcolor = Color.parseColor(COLOR_SELECTED);
	319	int hintcolor = Color.parseColor(COLOR_HINT);
	320
	321	// Background & board painting
	322	switch (pstate) {
	323	case BOARD:
	324	case SELECTED1:
	325	case SELECTED2:
	326	case MATCHED:
	327	case WIN:
	328	case LOSE:
	329	case HINT:
	330	case TIME:
	331	// Background painting
	332	int bgWidth = bg.getWidth();
	333	int bgHeight = bg.getHeight();
	334	for (int i=0; i<screenHeight/bgHeight+1; i++) {
	335	for (int j=0; j<screenWidth/bgWidth+1; j++) {
	336	canvas.drawBitmap(bg, jbgWidth, ibgHeight, null);
	337	}
	338	}
	339
	340	// Board painting
	341	// Max visible size: 7x17
	342	if (app!=null && app.board!=null) {
	343	for (int i=0;i<app.board.boardSize[0];i++) {
	344	for (int j=0;j<app.board.boardSize[1];j++) {
	345	// Tiles are 56px height, 40px width each
	346	char piece=app.board.board[i][j];
	347	if (piece!=0) {
	348	canvas.drawBitmap(tile[piece], x0+jtileWidth, y0+itileHeight, null);
	349	}
	350	}
	351	}
	352	}
	353	break;
	354	}
	355
	356	// rectangle for selection 1
	357	switch (pstate) {
	358	case SELECTED1:
	359	case SELECTED2:
	360	case MATCHED:
	361	highlightTile(canvas, x0, y0, selection1, selectcolor);
	362	break;
	363	}
	364
	365	// rectangle for selection 2
	366	switch (pstate) {
	367	case SELECTED2:
	368	case MATCHED:
	369	highlightTile(canvas, x0, y0, selection2, selectcolor);
	370	break;
	371	}
	372
	373	// Matching path
	374	switch (pstate) {
	375	case MATCHED:
	376	if (path!=null) {
	377	Point p0=null;
	378	for (Point p1 : path) {
	379	if (p0!=null) {
	380	drawLine(canvas, x0, y0, p0, p1, selectcolor);
	381	}
	382	p0=p1;
	383	}
	384	}
	385	break;
	386	}
	387
	388	// hint rectangles
	389	switch (pstate) {
	390	case HINT:
	391	if (pairs != null && pairs.size() > 0) {
	392	Line pair = pairs.get(0);
	393	Point a = pair.a;
	394	Point b = pair.b;
	395	path = app.board.getPath(a, b);
	396
	397	highlightTile(canvas, x0, y0, a, hintcolor);
	398
	399	if (path != null) {
	400	Point p0 = null;
	401	for (Point p1 : path) {
	402	if (p0 != null) {
	403	drawLine(canvas, x0, y0, p0, p1, hintcolor);
	404	}
	405	p0 = p1;
	406	}
	407	path = null;
	408	}
	409
	410	highlightTile(canvas, x0, y0, b, hintcolor);
	411	}
	412	break;
	413	}
	414
	415	// Win & loose notifications
	416	switch (pstate) {
	417	case WIN:
	418	drawMessage(canvas, screenWidth / 2, screenHeight / 2, true,
	419	"You Win!", 100);
	420	break;
	421	case LOSE:
	422	drawMessage(canvas, screenWidth / 2, screenHeight / 2, true,
	423	"Game Over", 100);
	424	break;
	425	}
	426
	427	switch (pstate) {
	428	case BOARD:
	429	case SELECTED1:
	430	case SELECTED2:
	431	case MATCHED:
	432	case WIN:
	433	case LOSE:
	434	case HINT:
	435	case TIME:
	436	updateTime();
	437	int hours = (int) (playTime / (60 * 60));
	438	int minutes = (int) ((playTime / 60) % 60);
	439	int seconds = (int) (playTime % 60);
	440	if (hours < 10) {
	441	time = String.format(Locale.US, "%01d:%02d:%02d",
	442	hours, minutes, seconds);
	443	} else {
	444	time = INVALID_TIME;
	445	}
	446
	447	int timePosX=screenWidth-120;
	448	int timePosY=screenHeight-10;
	449
	450	if (app.timeCounter) {
	451	drawMessage(canvas, timePosX, timePosY, false, time, 30);
	452	}
	453	break;
	454	}
	455
	456	} catch (Exception e) {
	457	e.printStackTrace();
	458	}
	459
	460	}
	461
	462	private void drawLine(Canvas canvas, int x0, int y0, Point p0, Point p1, int color) {
	463	Paint paint = new Paint();
	464	paint.setFlags(Paint.ANTI_ALIAS_FLAG);
	465	paint.setColor(color);
	466	paint.setStyle(Style.STROKE);
	467	paint.setStrokeCap(Cap.ROUND);
	468	paint.setStrokeJoin(Join.ROUND);
	469	paint.setStrokeWidth(3);
	470	canvas.drawLine(
	471	x0 + p0.j * tileWidth - 2 + (tileWidth / 2),
	472	y0 + p0.i * tileHeight - 2 + (tileHeight / 2),
	473	x0 + p1.j * tileWidth - 2 + (tileWidth / 2),
	474	y0 + p1.i * tileHeight - 2 + (tileHeight / 2), paint);
	475	}
	476
	477	private void highlightTile(Canvas canvas, int x0, int y0, Point p, int color) {
	478	Paint paint = new Paint();
	479	paint.setFlags(Paint.ANTI_ALIAS_FLAG);
	480	paint.setColor(color);
	481	paint.setStyle(Style.STROKE);
	482	paint.setStrokeCap(Cap.ROUND);
	483	paint.setStrokeJoin(Join.ROUND);
	484	paint.setStrokeWidth(3);
	485	Rect r = new Rect(
	486	x0 + p.j * tileWidth - 2,
	487	y0 + p.i * tileHeight - 2,
	488	x0 + p.j * tileWidth + tileWidth + 2,
	489	y0 + p.i * tileHeight + tileHeight + 2);
	490	canvas.drawRect(r, paint);
	491	}
	492
	493	@Override
	494	public boolean onTouchEvent(MotionEvent event) {
	495	if (event.getAction()==MotionEvent.ACTION_DOWN) {
	496	onClick(Math.round(event.getX()),Math.round(event.getY()));
	497	}
	498	return super.onTouchEvent(event);
	499	}
	500
	501	private void onClick(int x, int y) {
	502	try {
	503	int i=(y-(screenHeight-app.board.boardSize[0]*tileHeight)/2)/tileHeight;
	504	int j=(x-(screenWidth-app.board.boardSize[1]*tileWidth)/2)/tileWidth;
	505
	506	switch (cstate) {
	507	case IDLE:
	508	if (i >= 0 && i < app.board.boardSize[0] && j >= 0
	509	&& j < app.board.boardSize[1]
	510	&& app.board.board[i][j] != 0) {
	511	selection1.set(i, j);
	512	paint(StatePaint.SELECTED1);
	513	control(StatePlay.SELECTED1);
	514	}
	515	break;
	516	case SELECTED1:
	517	if (i >= 0 && i < app.board.boardSize[0] && j >= 0
	518	&& j < app.board.boardSize[1]
	519	&& app.board.board[i][j] != 0) {
	520	if (selection1.equals(i, j)) {
	521	paint(StatePaint.BOARD);
	522	control(StatePlay.IDLE);
	523	} else {
	524	selection2.set(i, j);
	525	paint(StatePaint.SELECTED2);
	526
	527	Point a = selection1.copy();
	528	Point b = selection2.copy();
	529	path = app.board.getPath(a, b);
	530	paint(StatePaint.MATCHED);
	531	app.sleep(2);
	532	paint(StatePaint.BOARD);
	533	if (path.size() > 0) {
	534	app.board.play(a, b);
	535	}
	536	path = null;
	537	paint(StatePaint.BOARD);
	538
	539	pairs = app.board.getPairs(1);
	540	if (pairs.size() == 0) {
	541	if (app.board.getNumPieces() == 0) {
	542	paint(StatePaint.WIN);
	543	} else {
	544	paint(StatePaint.LOSE);
	545	}
	546	control(StatePlay.GAMEOVER);
	547	} else {
	548	control(StatePlay.IDLE);
	549	}
	550	//undo.sensitive=app.board.getCanUndo();
	551	}
	552	}
	553	break;
	554	case GAMEOVER:
	555	reset();
	556	paint(StatePaint.BOARD);
	557	break;
	558	}
	559	} catch (Exception e) {
	560	e.printStackTrace();
	561	}
	562	}
	563
	564	public void surfaceChanged(SurfaceHolder holder, int format, int width,
	565	int height) {
	566	surfaceHolder = holder;
	567	if (cstate!=StatePlay.GAMEOVER && !timerRegistered) {
	568	registerTimer();
	569	}
	570	repaint();
	571	}
	572
	573	public void surfaceCreated(SurfaceHolder holder) {
	574	surfaceHolder = holder;
	575	repaint();
	576	}
	577
	578	public void surfaceDestroyed(SurfaceHolder holder) {
	579	surfaceHolder = null;
	580	if (timerRegistered) {
	581	unregisterTimer();
	582	}
	583	}
	584	}