android 五子棋开发

新人开发五子棋,两天完成基本功能,本小白的思路。

思路:

1.用canvas绘制棋盘:得到手机的分辨率。棋盘大小为19*19。将手机宽屏分为21份,取中间19份为棋盘。上下空白位置为按钮功能。

如下:画出棋盘。

 1 protected void onDraw(Canvas canvas,Paint paint) {
 2
 3         canvas.drawColor(Color.rgb(128,64,0));
 4         //canvas.drawColor(Color.WHITE);
 5         w = chess_W/20;//平均分为21块 横坐标
 6         h =scrren_h/2-chess_W/2;
 7         for(int i =1; i<=19; i++ ){  //21分,画其中的地1份和第19份,0和20不画
 8             canvas.drawLine(i*w,h+w,i*w,h+19*w, paint);
 9         }//绘制直线
10         for(int i =1; i<=19;i++)
11         {
12
13             canvas.drawLine(w,h+i*w,19*w,h+i*w, paint);
14         }
15         paint.setStrokeWidth(3);
16         canvas.drawLine(w/2,h+w/2,w/2, h+19*w+w/2, paint);
17         canvas.drawLine(19*w+w/2,h+w/2,19*w+w/2,h+19*w+w/2, paint);
18         canvas.drawLine(w/2,h+w/2,19*w+w/2, h+w-w/2, paint);
19         canvas.drawLine(w/2,h+19*w+w/2,19*w+w/2, h+19*w+w/2, paint);
20
21         /*
22          * (w,h+w)            (19*w,h+w)
23          *
24          *
25          * (w,h+19*w)        (19*w,h+19*w)
26          * */
27
28         //绘制四角
29         // 绘制这个三角形,你可以绘制任意多边形
30         paint.setColor(Color.rgb(227,207,0));
31         Path path = new Path();
32         path.moveTo(w/2,h+18*w);// 此点为多边形的起点
33         path.lineTo(w/2,h+19*w+w/2);
34         path.lineTo(2*w,h+19*w+w/2);
35         path.close(); // 使这些点构成封闭的多边形
36         canvas.drawPath(path, paint);
37
38         Path path1 = new Path();
39         path1.moveTo(w/2,h+w/2);// 此点为多边形的起点
40         path1.lineTo(w/2,h+w+w);
41         path1.lineTo(2*w,h+w/2);
42         path1.close(); // 使这些点构成封闭的多边形
43         canvas.drawPath(path1, paint);
44         Path path2= new Path();
45         path2.moveTo(19*w+w/2,h+w/2);// 此点为多边形的起点
46         path2.lineTo(19*w+w/2,h+2*w);
47         path2.lineTo(18*w,h+w/2);
48         path2.close(); // 使这些点构成封闭的多边形
49         canvas.drawPath(path2, paint);
50         Path path3 = new Path();
51         path3.moveTo(19*w+w/2,h+19*w+w/2);// 此点为多边形的起点
52         path3.lineTo(18*w,h+19*w+w/2);
53         path3.lineTo(19*w+w/2,h+18*w);
54         path3.close(); // 使这些点构成封闭的多边形
55         canvas.drawPath(path3, paint);
56     }

2.在棋盘上落子:用canvas.bitmap。

需要注意的是:1.落子的地方以前没有被落子

2.落子的要保证落在棋盘的线上

3.落子要保证随心,不能与下棋者按下的棋点有偏差。

4.持黑先行,用步数控制应该下黑白棋。

5.采用一个二维数组存储数据,未落子为0,黑子为1,白子为2.

6.貌似canvas画图需要每次落子都要重新绘图,要从数组的提取数据依次绘图。可以自己设计算法,提高速度,比如根据步数,当发现棋子数量等于步数 后面就不用遍历了。最好不要全部遍历数组。

7.采用数组要注意数组越界问题。

8.边界问题!!!这个很重要。

落子落在棋线上和存储落子数据:

/判断落子
    public float downx(float x,float y) {

        if (x > ChessDraw.w / 2 && x < ChessDraw.w * 19 + ChessDraw.w / 2) {
            if (y > ChessDraw.h + ChessDraw.w / 2 && y < ChessDraw.h + 19 * ChessDraw.w + ChessDraw.w / 2) {

                int kx = (int) (x / ChessDraw.w);
                int jx = (int) (x % ChessDraw.w);

                if (jx >= ChessDraw.w / 2) { //过了格子的一半
                    kx++;
                   x = kx * ChessDraw.w;
                    if(kx>20 || kx<=0) { //防止数组越界
                        x=-100;
                    }
                }
                else{   //未过格子的一半

                    x = kx * ChessDraw.w;
                    if(kx>20 || kx<=0) { //防止数组越界
                        x=-100;
                    }
                }

                //获取落子的地点x
                chess_x=kx;
            }
            else {
                MySurfaceView.downQ = false; //不在棋盘,不允许落子
            }

        }
        else {
            MySurfaceView.downQ = false; //不在棋盘,不允许落子
        }
        return x;
    }
        //判断落子

    public float downy(float x, float y) {

        if (x > ChessDraw.w / 2 && x < ChessDraw.w * 19 + ChessDraw.w / 2) {
            if (y > ChessDraw.h + ChessDraw.w / 2 && y < ChessDraw.h + 19 * ChessDraw.w + ChessDraw.w / 2) {

                //error
                int ky = (int) ((y - ChessDraw.w / 2 - ChessDraw.h) / ChessDraw.w);
                int jy = (int) ((y - ChessDraw.w / 2 - ChessDraw.h) % ChessDraw.w);
                if (jy >= ChessDraw.w / 2) { //如果过了格子的一般
                    ky++;
                    y = ky * ChessDraw.w + ChessDraw.h ;
                    if(ky>20 || ky<=0) { //防止数组越界
                      y=-100;
                    }

                }
                else{//如果没有过格子的一半

                    y=ky * ChessDraw.w + ChessDraw.h;
                    if(ky>20 || ky<=0) { //防止数组越界
                        y=-100;
                    }
                }
                //获取落子的地点x
                chess_y=ky;

            }
            else {
               MySurfaceView.downQ = false;
            }
        }
        else {
            MySurfaceView.downQ = false; //不在棋盘,不允许落子
        }
        return y;

    }
    public void downarr(int x, int y,int step){
        if(step % 2 != 0)
            chess_arr[x][y]=MySurfaceView.BLACK_CHESS;
        else
            chess_arr[x][y]=MySurfaceView.WRITE_CHESS;
    }

3.胜利的判断,一共四个方向。对落子位子四个方向进行判断,如果一个方向累计成功五次以上即可。要注意数组坐标越界,可使用try catch,可优化算法。比如,前9步无需判断等,此处尚未优化,很暴力。

public ChessVictory(){
      chessRule = new ChessRule();
  }
    public void chessvictory(int x, int y) {
        int c =chessRule.chess_arr[x][y];
        for (int i = 0; i < 4; i++) { //四个方向
            linetrue2 = true;
            linetrue1 = true;
            victory_num=0;
            tx1=0;
            ty1=0;
            tx2=0;
            ty2=0;
            for (int k = 0; k < 5; k++) {
                try {
                    if (i == 0 && victory == false) {//对Y轴判断
                          ty1++;
                        int Ky1 = y+ty1;
                          ty2--;
                        int Ky2 = y+ty2;
                        if (linetrue1 && (chessRule.chess_arr[x][Ky1] == c)) {

                            victory_num++;
                        } else {
                            linetrue1 = false;
                        }
                        //y轴--判断,注意数组越界
                        if (linetrue2 && chessRule.chess_arr[x][Ky2] ==c) {

                            victory_num++;
                        } else {
                            linetrue2 = false;
                        }
                        if (victory_num >= 4) {
                            victory = true;
                        }

                    }
                    //对x轴判断

                    if (i == 1 && victory == false) {
                        tx1++;
                        int Kx1 = x+tx1;
                        tx2--;
                        int Kx2 = x+tx2;
                        if (linetrue1 && chessRule.chess_arr[Kx1][y] == c) {
                            victory_num++;
                        } else {
                            linetrue1 = false;
                        }
                        //y轴--判断,注意数组越界
                        if (linetrue2 && chessRule.chess_arr[Kx2][y] ==c) {
                            victory_num++;
                        } else {
                            linetrue2 = false;
                        }
                        if (victory_num >= 4) {
                            victory = true;

                        }

                    }
                    //斜对角判断
                    if (i == 2 && victory == false) {
                        tx1++;
                        int kx1 = x+tx1;
                        tx2--;
                        int kx2 = x+tx2;
                        ty1++;
                        int ky1 = y+ty1;
                        ty2--;
                        int ky2 = y+ty2;
                        if (linetrue1 && chessRule.chess_arr[kx2][ky1] == c) {
                            victory_num++;
                        } else {
                            linetrue1 = false;
                        }
                        //y轴--判断,注意数组越界
                        if (linetrue2 && chessRule.chess_arr[kx1][ky2] == c) {
                            victory_num++;
                        } else {
                            linetrue2 = false;
                        }
                        if (victory_num >= 4) {
                            victory = true;

                        }
                    }
                        //斜对角判断
                        if (i == 3 && victory == false) {
                            tx1++;
                            int kx1 = x+tx1;
                            tx2--;
                            int kx2 = x+tx2;
                            ty1++;
                            int ky1 = y+ty1;
                            ty2--;
                            int ky2 = y+ty2;
                            if (linetrue1 && chessRule.chess_arr[kx2][ky2] == c) {
                                victory_num++;
                            } else {
                                linetrue1 = false;
                            }
                            //y轴--判断,注意数组越界
                            if (linetrue2 && chessRule.chess_arr[kx1][ky1] ==c) {
                                victory_num++;
                            } else {
                                linetrue2 = false;
                            }
                            if (victory_num >= 4) {
                                victory = true;

                            }
                        }

                } catch (Exception e) {
                }
            }
        }

4.悔棋问题:

若只允许悔棋一次,可以直接对存储数据的数组操作。

若允许多次,可以在new一个数组进行每一步的存储(貌似数组存储不太好,具体实现的时候要考虑),悔棋时从此数组提取位子,在存储数据的数组上修改。

若要保存、载入等等。均可以在上次new的数组上进行保存。这样可以实现打谱。每次下一子,重现对局(未实现,只是思路)。

5.细节优化,比如从游戏进入后台,再从后台打开要保存原来的位置。本以为很难,其实在完成的时候只不过一笔带过。以及其余优化。

6.对战和AI设计。。。。继续完成。

时间: 2024-09-30 10:25:25

android 五子棋开发的相关文章

Android多媒体开发介绍(转)

Android多媒体开发介绍 转自:http://blog.csdn.net/reiliu/article/details/9060557 一.       多媒体架构 基于第三方PacketVideo公司的OpenCORE来实现,支持所有通用的音频/视频/静态图像格式,包括:MPEG4.H.264.MP3.AAC.AMR.JPG.PNG.GIF等.从功能上分为两部分,一是音/视频的回放(PlayBack),二是音视频的纪录(Recorder). CODEC(编解码器)使用OpenMAX 1L

IDEA搭建Android wear开发环境,Android wear,I&#39;m comming!

随着google发布了android wear这个东西,然后又有了三星的gear,LG的G watch以及moto 360,苹果由发布了apple watch,未来可能在智能手表行业又有一场战争.当然这只是笔者的个人观点,仅供参考. 作为开发者,当然关心的是只能手表的开发了,所以我们来搭建一下android wear的开发环境吧! 搭建android wear开发环境,我们需要以下的软件Intellij 13.1.3,android-sdk 23.0.02. 首先需要下载安装好android-s

Android应用开发-小巫CSDN博客客户端之显示博文详细内容

Android应用开发-小巫CSDN博客客户端之显示博文详细内容 上篇博文给大家介绍的是如何嵌入有米广告并且获取收益,本篇博客打算讲讲关于如何在一个ListView里显示博文的详细信息,这个可能是童鞋们比较困惑的,因为一篇博客可能有标题.摘要.图片.代码等等元素组成,我们要怎么在一个界面中显示这些内容并且按照自己的指定的方式显示呢,别急,下面会告诉大家. 重新整理一下一篇博文可能有以下元素: 标题 摘要 文本内容 图片 粗标题 代码块 在UI篇小巫已经介绍了,博文详细内容的主要控件就是一个Lis

Android游戏开发之主角的移动与地图的平滑滚动

人物移动地图的平滑滚动处理 玩过rpg游戏的朋友应该都知道RPG的游戏地图一般都比较大 今天我和大家分享一下在RPG游戏中如何来处理超出手机屏幕大小的游戏地图. 如图所示为程序效果动画图 地图滚动的原理 在本人之前博客的文章中介绍过人物在屏幕中的移动方式,因为之前拼的游戏地图是完全填充整个手机屏幕的,所以无需处理地图的平滑滚动.这篇文章我着重的向 大家介绍一下控制人物移动后地图滚动的处理方式.举个例子 如上图所示 比如人物向右移动,如果地图贴在屏幕左边边界 将先移动人物在地图的坐标,当人物在屏幕

windows平台下Android studio开发环境搭建教程

最近,Google 已宣布,为了简化 Android 的开发力度,以重点建设 Android Studio 工具,到今年年底将停止支持Eclipse等其他集成开发环境 .而随着Android studio正式版的推出和完善,Android开发者们转向Android studio开发平台也将是大势所趋! 小弟Vike原先学习Android也是一直用的eclipse,虽然时间不长,而且用起来慢点,卡点,但是毕竟熟悉起来了,猛地要转到一个新平台,还真是相当不习惯.且不说快捷键有变化,就连Android

配置Android应用开发环境

一.安装JDK 开发 Android应用程序的时候,仅有Java运行环境(Java Runtime Environment,JRE)是不够的,需要完整的JDK(JDK包含了JRE),且要求其版本在JDK 6以上,在开发Android 5及更高版本时,需要JDK 7及其以上版本. 如果JDK不可用或版本低于JDK 6,要下载Java SE开发工具包7 . 使用JDK 7及以上版本无需再对环境变量进行设置. 若安装JDK 6,需要在cmd下使用Java命令和编译.运行程序,可以配置环境变量(具体步骤

Android内核开发:理解和掌握repo工具

由于Android源码是用repo工具来管理的,因此,搞Android内核开发,首先要搞清楚repo是什么东西,它该怎么使用?作为<Android内核开发>系列文章的第二篇,我们首先谈谈对repo工具的理解和使用. 1. repo是什么? repo是一种代码版本管理工具,它是由一系列的Python脚本组成,封装了一系列的Git命令,用来统一管理多个Git仓库. 2. 为什么要用repo? 因为Android源码引用了很多开源项目,每一个子项目都是一个Git仓库,每个Git仓库都有很多分支版本,

android入门开发教程之网络性能的优化

我在麦子学院上android开发的时候,麦子学院android开发老师讲到Android开发过程中经常会涉及到性能优化的问题,应该从基础.网络.测试等各个层面进行整合优化.现在咱们聊聊Android开发之网络性能的优化. 1)避免频繁网络请求 访问server端时,建立连接本身比传输需要跟多的时间,如非必要,不要将一交互可以做的事情分成多次交互(这需要与Server端协调好).有效管理Service 后台服务就相当于一个持续运行的Acitivity,如果开发的程序后台都会一个service不停的

Android应用开发:网络工具——Volley(二)

引言 在Android应用开发:网络工具--Volley(一)中结合Cloudant服务介绍了Volley的一般使用方法.当中包括了两种请求类型StringRequest和JsonObjectRequest.一般的请求任务相信都能够通过他们完毕了,只是在千变万化的网络编程中,我们还是希望能够对请求类型.过程等步骤进行全然的把控.本文就从Volley源代码角度来分析一下.一个网络请求在Volley中是怎样运作的.也能够看作网络请求在Volley中的生命周期. 源头RequestQueue 在使用V