Android斗地主棋牌游戏牌桌实现源码下载

本次给大家分享下Android斗地主棋牌游戏牌桌实现源码下载如下：

为了节约内存资源，每张扑克牌都是剪切形成的，当然这也是当前编程的主流方法。

1、主Activity

package com.bison;  
      
    import android.app.Activity;  
    import android.content.pm.ActivityInfo;  
    import android.os.Bundle;  
    import android.view.Window;  
    import android.view.WindowManager;  
      
    /**
     *
     *  
     * @author Bison
     *  
     */  
    public class PukeActivity extends Activity {  
        /** Called when the activity is first created. */  
        @Override  
        public void onCreate(Bundle savedInstanceState) {  
            super.onCreate(savedInstanceState);  
            // 这个事隐藏标题栏，不解释   
            requestWindowFeature(Window.FEATURE_NO_TITLE);  
            // 隐藏状态栏，你懂的   
            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,  
                    WindowManager.LayoutParams.FLAG_FULLSCREEN);  
            /*
             * 开始有考虑使屏幕上扑克的排列随屏幕的分辨率变动 结果貌似不好做，注释掉了 Display display =
             * getWindowManager().getDefaultDisplay(); int screenWidth =
             * display.getWidth(); int screenHeight = display.getHeight();
             */  
      
            // 使用代码锁定横屏   
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);  
            // setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);这个是竖屏   
            setContentView(new GameView(this));  
        }  
    }

2、牌桌页面

package com.bison;  
      
    import android.content.Context;  
    import android.graphics.Bitmap;  
    import android.graphics.BitmapFactory;  
    import android.graphics.Canvas;  
    import android.graphics.Rect;  
    import android.view.MotionEvent;  
    import android.view.SurfaceHolder;  
    import android.view.SurfaceView;  
      
    import com.bison.utils.Person;  
      
    /**
     *
     *  
     * 扑克图片来源,和牌桌背景在文章的下面。 扑克背面图等我没上传，玩家自行百度
     *  
     * @author Bison
     *  
     */  
    public class GameView extends SurfaceView implements SurfaceHolder.Callback {  
        private FlushThread thread = null;// 刷帧线程   
        private Bitmap sourceBitmap = null;// 扑克图片来源   
        private Bitmap backgroundDesk = null;// 牌桌背景   
        private Bitmap backgroundPuke = null;// 扑克背面   
      
        private final Person person;  
        private int pukeWidth = 0;// 扑克的宽   
        private int pukeHeight = 0;// 扑克的高   
        private int deskWidth = 0;// 牌桌的宽   
        private int deskHeight = 0;// 牌桌的高   
        private int left = 0;// 我自己首张牌左距离   
      
        public GameView(Context context) {  
            super(context);  
            getHolder().addCallback(this);  
            this.thread = new FlushThread(getHolder(), this);// 实例化线程   
            initBitmap();// 实例化图片   
            this.person = new Person();// 实例化Person类   
            this.left = deskWidth / 2 - (16 * 25 + pukeWidth) / 2;// 左距开始时赋值   
        }  
      
        private void initBitmap() {// 初始化图片   
            sourceBitmap = BitmapFactory.decodeResource(getResources(),  
                    R.drawable.smallcard);  
            pukeWidth = sourceBitmap.getWidth() / 14;// 每张扑克的宽高   
            pukeHeight = sourceBitmap.getHeight() / 4;  
      
            backgroundDesk = BitmapFactory.decodeResource(getResources(),  
                    R.drawable.gameback2);  
      
            deskWidth = backgroundDesk.getWidth();// 牌桌的宽高   
            deskHeight = backgroundDesk.getHeight();  
      
            backgroundPuke = BitmapFactory.decodeResource(getResources(),  
                    R.drawable.cardback);  
        }  
      
        @Override  
        protected void onDraw(Canvas canvas) {  
            // 绘制牌桌   
            canvas.drawBitmap(backgroundDesk, 0, 0, null);  
            personPaint(canvas, pukeWidth, pukeHeight);  
            deskthreePukes(canvas, pukeWidth, pukeHeight);  
        }  
      
        /** 绘制每个玩家手里的牌 */  
        public void personPaint(Canvas c, int pukeWidth, int pukeHeight) {  
            Rect src = new Rect();  
            Rect dst = new Rect();  
      
            // 遍历数组   
            for (int i = 0; i < 3; i++) {  
                for (int j = 0; j < 17; j++) {  
                    if (i == 0) {// 左手边玩家，不用绘出正面   
                        // src = person.cardRect(person.person1[j], pukeWidth,   
                        // pukeHeight);   
                        // dst.set(10, j * 20, 10 + pukeWidth, j * 20 + pukeHeight);   
                        c.drawBitmap(backgroundPuke, 35, 85, null);  
                    }  
                    if (i == 1) {// 自己   
                        src = person.cardRect(person.person2[j], pukeWidth,  
                                pukeHeight);  
                        dst.set(left + j * 25, this.deskHeight - 20 - pukeHeight,  
                                left + j * 25 + pukeWidth, deskHeight - 20);  
                        c.drawBitmap(sourceBitmap, src, dst, null);  
                    }  
                    if (i == 2) {// 右手边玩家，同样不用绘出正面   
                        // src = person.cardRect(person.person3[j], pukeWidth,   
                        // pukeHeight);   
                        // dst.set(this.screenWidth - 10 - pukeWidth, j * 20,   
                        // this.screenWidth - 10, j * 20 + pukeHeight);   
                        c.drawBitmap(backgroundPuke, deskWidth - 35 - pukeWidth,  
                                85, null);  
                    }  
                }  
            }  
        }  
      
        /** 绘制三张底牌 */  
        private void deskthreePukes(Canvas c, int pukeWidth, int pukeHeight) {  
            Rect src = new Rect();  
            Rect dst = new Rect();  
            for (int i = 0; i < 3; i++) {  
                src = person.cardRect(person.threePukes[i], pukeWidth, pukeHeight);  
                dst.set(280 + i * pukeWidth, 12, 280 + (i + 1) * pukeWidth,  
                        12 + pukeHeight);  
                c.drawBitmap(sourceBitmap, src, dst, null);  
            }  
        }  
      
        @Override  
        public boolean onTouchEvent(MotionEvent event) {  
            // 正在研究点击弹出相应的扑克   
            return super.onTouchEvent(event);  
        }  
      
        @Override  
        public void surfaceChanged(SurfaceHolder holder, int format, int width,  
                int height) {  
        }  
      
        @Override  
        public void surfaceCreated(SurfaceHolder holder) {  
            this.thread.setFlag(true);  
            this.thread.start();  
        }  
      
        @Override  
        public void surfaceDestroyed(SurfaceHolder holder) {  
            boolean retry = true;  
            this.thread.setFlag(false);  
            while (retry) {  
                try {  
                    thread.join();  
                    retry = false;  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
      
        }  
      
        // 刷帧线程，这个不解释，实在看不懂，M我：289302487@qq.com   
        class FlushThread extends Thread {  
            private boolean flag = false;  
            private final int span = 500;  
            private final GameView gameView;  
            private final SurfaceHolder holder;  
      
            public FlushThread(SurfaceHolder holder, GameView gameView) {  
                this.gameView = gameView;  
                this.holder = holder;  
            }  
      
            @Override  
            public void run() {  
                Canvas canvas;  
                while (this.flag) {  
                    canvas = null;  
                    try {  
                        canvas = this.holder.lockCanvas(null);  
                        synchronized (this.holder) {  
                            this.gameView.onDraw(canvas);  
                        }  
                    } finally {  
                        if (canvas != null) {  
                            this.holder.unlockCanvasAndPost(canvas);  
                        }  
                    }  
      
                    try {  
                        Thread.sleep(span);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
      
            public boolean isFlag() {  
                return flag;  
            }  
      
            public void setFlag(boolean flag) {  
                this.flag = flag;  
            }  
      
        }  
      
    }

3、相关实体类

扑克牌类：

package com.bison.utils;  
      
    import java.util.Random;  
      
    /**
     *
     *  
     * @author Bison
     *  
     */  
    public class Cards {  
        // 声明一副扑克牌   
        public int[] pukes = new int[54];  
      
        private static Cards cardsInstance = null;  
      
        private Cards() {  
            setPuke();  
            shuffle();  
        }  
      
        public static Cards getInstance() {  
            if (cardsInstance == null) {  
                cardsInstance = new Cards();  
            }  
            return cardsInstance;  
        }  
      
        /** 给54张扑克牌赋值 ：1~54 */  
        private void setPuke() {  
            for (int i = 0; i < 54; i++) {  
                pukes[i] = i + 1;  
            }  
        }  
      
        /** 洗牌 */  
        private void shuffle() {  
            Random rdm = new Random();  
            for (int i = 0; i < 54; i++) {  
                // random.nextInt();是个前闭后开的方法：0~53   
                int rdmNo = rdm.nextInt(54);  
                int temp = pukes[i];  
                pukes[i] = pukes[rdmNo];  
                pukes[rdmNo] = temp;  
            }  
        }  
    }

玩家类：

package com.bison.utils;  
      
    import android.graphics.Rect;  
      
    /**
     * 这个是玩家的实体类
     *  
     * @author Bison
     *  
     */  
    public class Person {  
        private final Cards mCards = Cards.getInstance();  
      
        public int[] person1 = new int[17];  
        public int[] person2 = new int[17];  
        public int[] person3 = new int[17];  
      
        // 余下三张属于地主的   
        public int[] threePukes = new int[3];  
      
        public Person() {  
            personHold(mCards.pukes);  
        }  
      
        /** 分牌 */  
        private void personHold(int[] pukes) {  
            int k = 0;  
            for (int i = 0; i < 3; i++) {  
                if (i == 0) {  
                    for (int j = 0; j < 17; j++) {  
                        person1[j] = pukes[k++];  
                    }  
                    // 将其排序   
                    sort(person1);  
                }  
                if (i == 1) {  
                    for (int j = 0; j < 17; j++) {  
                        person2[j] = pukes[k++];  
                    }  
                    // 将其排序   
                    sort(person2);  
                }  
                if (i == 2) {  
                    for (int j = 0; j < 17; j++) {  
                        person3[j] = pukes[k++];  
                    }  
                    // 将其排序   
                    sort(person3);  
                }  
            }  
      
            threePukes[0] = pukes[51];  
            threePukes[1] = pukes[52];  
            threePukes[2] = pukes[53];  
        }  
      
        /** 对每个玩家手里的牌排序:使用冒泡排序 */  
        private void sort(int[] ary) {  
            for (int i = 0; i < ary.length; i++) {  
                for (int j = 0; j < ary.length - i - 1; j++) {  
                    if (ary[j] > ary[j + 1]) {  
                        int temp = ary[j];  
                        ary[j] = ary[j + 1];  
                        ary[j + 1] = temp;  
                    }  
                }  
            }  
        }  
      
        /**
         * 对应扑克所在图片上的位置  
         * 1 5 9 ………… 53  
         * 2 6 10 ………… 54  
         * 3 7 11  
         * 4 8 12
         */  
        public Rect cardRect(int cardValue, int width, int height) {  
            int x = 0, y = 0;  
            if (cardValue % 4 == 0) {  
                x = cardValue / 4 - 1;  
                y = 4;  
            } else {  
                x = cardValue / 4;  
                y = cardValue % 4;  
            }  
      
            int left = x * width;  
            int top = (y - 1) * height;  
            int right = (x + 1) * width;  
            int bottom = (y) * height;  
            return new Rect(left, top, right, bottom);  
        }  
    }

PS：斗地主还是可以做的很复杂的。更多内容还请继续关注我，或者前往我组办的棋牌社区查看。