]> git.zerfleddert.de Git - FreeShisen/blob - src/de/cwde/freeshisen/ShisenShoView.java
projects / FreeShisen / blob
? search:


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