Android --- 斗地主 [牌桌实现源码]

1、主Activity

1. <span style="font-size:18px;color:#3333ff;">package com.bison;
2. import android.app.Activity;
3. import android.content.pm.ActivityInfo;
4. import android.os.Bundle;
5. import android.view.Window;
6. import android.view.WindowManager;
7. /**
8. * </span>

1. <span style="font-size:18px;color:#3333ff;"> * @author Bison
2. *
3. */
4. public class PukeActivity extends Activity {
5. /** Called when the activity is first created. */
6. @Override
7. public void onCreate(Bundle savedInstanceState) {
8. super.onCreate(savedInstanceState);
9. // 这个事隐藏标题栏，不解释
10. requestWindowFeature(Window.FEATURE_NO_TITLE);
11. // 隐藏状态栏，你懂的
12. getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
13. WindowManager.LayoutParams.FLAG_FULLSCREEN);
14. /*
15. * 开始有考虑使屏幕上扑克的排列随屏幕的分辨率变动 结果貌似不好做，注释掉了 Display display =
16. * getWindowManager().getDefaultDisplay(); int screenWidth =
17. * display.getWidth(); int screenHeight = display.getHeight();
18. */
19. // 使用代码锁定横屏
20. setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
21. // setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);这个是竖屏
22. setContentView(new GameView(this));
23. }
24. }</span>

2、牌桌页面

1. <span style="color:#3333ff;">package com.bison;
2. import android.content.Context;
3. import android.graphics.Bitmap;
4. import android.graphics.BitmapFactory;
5. import android.graphics.Canvas;
6. import android.graphics.Rect;
7. import android.view.MotionEvent;
8. import android.view.SurfaceHolder;
9. import android.view.SurfaceView;
10. import com.bison.utils.Person;
11. /**
12. *
13. * @author Bison
14. *
15. */
16. public class GameView extends SurfaceView implements SurfaceHolder.Callback {
17. private FlushThread thread = null;// 刷帧线程
18. private Bitmap sourceBitmap = null;// 扑克图片来源
19. private Bitmap backgroundDesk = null;// 牌桌背景
20. private Bitmap backgroundPuke = null;// 扑克背面
21. private final Person person;
22. private int pukeWidth = 0;// 扑克的宽
23. private int pukeHeight = 0;// 扑克的高
24. private int deskWidth = 0;// 牌桌的宽
25. private int deskHeight = 0;// 牌桌的高
26. private int left = 0;// 我自己首张牌左距离
27. public GameView(Context context) {
28. super(context);
29. getHolder().addCallback(this);
30. this.thread = new FlushThread(getHolder(), this);// 实例化线程
31. initBitmap();// 实例化图片
32. this.person = new Person();// 实例化Person类
33. this.left = deskWidth / 2 - (16 * 25 + pukeWidth) / 2;// 左距开始时赋值
34. }
35. private void initBitmap() {// 初始化图片
36. sourceBitmap = BitmapFactory.decodeResource(getResources(),
37. R.drawable.smallcard);
38. pukeWidth = sourceBitmap.getWidth() / 14;// 每张扑克的宽高
39. pukeHeight = sourceBitmap.getHeight() / 4;
40. backgroundDesk = BitmapFactory.decodeResource(getResources(),
41. R.drawable.gameback2);
42. deskWidth = backgroundDesk.getWidth();// 牌桌的宽高
43. deskHeight = backgroundDesk.getHeight();
44. backgroundPuke = BitmapFactory.decodeResource(getResources(),
45. R.drawable.cardback);
46. }
47. @Override
48. protected void onDraw(Canvas canvas) {
49. // 绘制牌桌
50. canvas.drawBitmap(backgroundDesk, 0, 0, null);
51. personPaint(canvas, pukeWidth, pukeHeight);
52. deskthreePukes(canvas, pukeWidth, pukeHeight);
53. }
54. /** 绘制每个玩家手里的牌 */
55. public void personPaint(Canvas c, int pukeWidth, int pukeHeight) {
56. Rect src = new Rect();
57. Rect dst = new Rect();
58. // 遍历数组
59. for (int i = 0; i < 3; i++) {
60. for (int j = 0; j < 17; j++) {
61. if (i == 0) {// 左手边玩家，不用绘出正面
62. // src = person.cardRect(person.person1[j], pukeWidth,
63. // pukeHeight);
64. // dst.set(10, j * 20, 10 + pukeWidth, j * 20 + pukeHeight);
65. c.drawBitmap(backgroundPuke, 35, 85, null);
66. }
67. if (i == 1) {// 自己
68. src = person.cardRect(person.person2[j], pukeWidth,
69. pukeHeight);
70. dst.set(left + j * 25, this.deskHeight - 20 - pukeHeight,
71. left + j * 25 + pukeWidth, deskHeight - 20);
72. c.drawBitmap(sourceBitmap, src, dst, null);
73. }
74. if (i == 2) {// 右手边玩家，同样不用绘出正面
75. // src = person.cardRect(person.person3[j], pukeWidth,
76. // pukeHeight);
77. // dst.set(this.screenWidth - 10 - pukeWidth, j * 20,
78. // this.screenWidth - 10, j * 20 + pukeHeight);
79. c.drawBitmap(backgroundPuke, deskWidth - 35 - pukeWidth,
80. 85, null);
81. }
82. }
83. }
84. }
85. /** 绘制三张底牌 */
86. private void deskthreePukes(Canvas c, int pukeWidth, int pukeHeight) {
87. Rect src = new Rect();
88. Rect dst = new Rect();
89. for (int i = 0; i < 3; i++) {
90. src = person.cardRect(person.threePukes[i], pukeWidth, pukeHeight);
91. dst.set(280 + i * pukeWidth, 12, 280 + (i + 1) * pukeWidth,
92. 12 + pukeHeight);
93. c.drawBitmap(sourceBitmap, src, dst, null);
94. }
95. }
96. @Override
97. public boolean onTouchEvent(MotionEvent event) {
98. // 正在研究点击弹出相应的扑克
99. return super.onTouchEvent(event);
100. }
101. @Override
102. public void surfaceChanged(SurfaceHolder holder, int format, int width,
103. int height) {
104. }
105. @Override
106. public void surfaceCreated(SurfaceHolder holder) {
107. this.thread.setFlag(true);
108. this.thread.start();
109. }
110. @Override
111. public void surfaceDestroyed(SurfaceHolder holder) {
112. boolean retry = true;
113. this.thread.setFlag(false);
114. while (retry) {
115. try {
116. thread.join();
117. retry = false;
118. } catch (InterruptedException e) {
119. e.printStackTrace();
120. }
121. }
122. }
123. // 刷帧线程</span>

1. <span style="color:#3333ff;">   class FlushThread extends Thread {
2. private boolean flag = false;
3. private final int span = 500;
4. private final GameView gameView;
5. private final SurfaceHolder holder;
6. public FlushThread(SurfaceHolder holder, GameView gameView) {
7. this.gameView = gameView;
8. this.holder = holder;
9. }
10. @Override
11. public void run() {
12. Canvas canvas;
13. while (this.flag) {
14. canvas = null;
15. try {
16. canvas = this.holder.lockCanvas(null);
17. synchronized (this.holder) {
18. this.gameView.onDraw(canvas);
19. }
20. } finally {
21. if (canvas != null) {
22. this.holder.unlockCanvasAndPost(canvas);
23. }
24. }
25. try {
26. Thread.sleep(span);
27. } catch (InterruptedException e) {
28. e.printStackTrace();
29. }
30. }
31. }
32. public boolean isFlag() {
33. return flag;
34. }
35. public void setFlag(boolean flag) {
36. this.flag = flag;
37. }
38. }
39. }
40. </span>

3、相关实体类

扑克牌类：

1. <span style="font-size:18px;color:#3333ff;">package com.bison.utils;
2. import java.util.Random;
3. /**
4. * 生成一副洗好的牌，并且 设计为单例模式
5. *
6. * @author Bison
7. *
8. */
9. public class Cards {
10. // 声明一副扑克牌
11. public int[] pukes = new int[54];
12. private static Cards cardsInstance = null;
13. private Cards() {
14. setPuke();
15. shuffle();
16. }
17. public static Cards getInstance() {
18. if (cardsInstance == null) {
19. cardsInstance = new Cards();
20. }
21. return cardsInstance;
22. }
23. /** 给54张扑克牌赋值 ：1~54 */
24. private void setPuke() {
25. for (int i = 0; i < 54; i++) {
26. pukes[i] = i + 1;
27. }
28. }
29. /** 洗牌 */
30. private void shuffle() {
31. Random rdm = new Random();
32. for (int i = 0; i < 54; i++) {
33. // random.nextInt();是个前闭后开的方法：0~53
34. int rdmNo = rdm.nextInt(54);
35. int temp = pukes[i];
36. pukes[i] = pukes[rdmNo];
37. pukes[rdmNo] = temp;
38. }
39. }
40. }
41. </span>

玩家类：

1. <span style="font-size:18px;color:#3333ff;">package com.bison.utils;
2. import android.graphics.Rect;
3. /**
4. * 这个是玩家的实体类
5. *
6. * @author Bison
7. *
8. */
9. public class Person {
10. private final Cards mCards = Cards.getInstance();
11. public int[] person1 = new int[17];
12. public int[] person2 = new int[17];
13. public int[] person3 = new int[17];
14. // 余下三张属于地主的
15. public int[] threePukes = new int[3];
16. public Person() {
17. personHold(mCards.pukes);
18. }
19. /** 分牌 */
20. private void personHold(int[] pukes) {
21. int k = 0;
22. for (int i = 0; i < 3; i++) {
23. if (i == 0) {
24. for (int j = 0; j < 17; j++) {
25. person1[j] = pukes[k++];
26. }
27. // 将其排序
28. sort(person1);
29. }
30. if (i == 1) {
31. for (int j = 0; j < 17; j++) {
32. person2[j] = pukes[k++];
33. }
34. // 将其排序
35. sort(person2);
36. }
37. if (i == 2) {
38. for (int j = 0; j < 17; j++) {
39. person3[j] = pukes[k++];
40. }
41. // 将其排序
42. sort(person3);
43. }
44. }
45. threePukes[0] = pukes[51];
46. threePukes[1] = pukes[52];
47. threePukes[2] = pukes[53];
48. }
49. /** 对每个玩家手里的牌排序:使用冒泡排序 */
50. private void sort(int[] ary) {
51. for (int i = 0; i < ary.length; i++) {
52. for (int j = 0; j < ary.length - i - 1; j++) {
53. if (ary[j] > ary[j + 1]) {
54. int temp = ary[j];
55. ary[j] = ary[j + 1];
56. ary[j + 1] = temp;
57. }
58. }
59. }
60. }
61. /**
62. * 对应扑克所在图片上的位置
63. * 1 5 9 ………… 53
64. * 2 6 10 ………… 54
65. * 3 7 11
66. * 4 8 12
67. */
68. public Rect cardRect(int cardValue, int width, int height) {
69. int x = 0, y = 0;
70. if (cardValue % 4 == 0) {
71. x = cardValue / 4 - 1;
72. y = 4;
73. } else {
74. x = cardValue / 4;
75. y = cardValue % 4;
76. }
77. int left = x * width;
78. int top = (y - 1) * height;
79. int right = (x + 1) * width;
80. int bottom = (y) * height;
81. return new Rect(left, top, right, bottom);
82. }
83. }
84. </span>

PS：斗地主还是可以做成很复杂的。相关图片