手机五子棋游戏的设计与实现
专业：
姓名：
班级：
学号：
指导教师：
摘 要
J2ME(Java 2 Micro Edition)是近年来随着各种不同设备，尤其是移动通信设备的飞速发展而诞生的一项开发技术。它因其“write once,run anywhere”的Java特性而提高了开发的效率。随着手机性能的不断提高，手机休闲娱乐应用将成为PC休闲娱乐应用之后又一重要业务增长点。棋类游戏规则单一，比较适合在手机等便携终端推广。
由于具有跨平台、易于移植、占用空间小的优势，J2ME成为移动应用开发平台的主流，并提供了很多用以支持移动应用软件的开发的API。现将该技术用于这次的手机游戏开发，可以实现游戏的快速开发，不但便于查看游戏运行过程中内存的占用量和程序的每一部分代码消耗了多少处理器时间，而且可以不断地优化代码，使代码具有高度的复用性、可扩展性、可维护性。
游戏的开发以J2ME为平台，利用Java技术，结合J2ME的MIDP技术，并对于程序设计思想，重要类、方法等展开讨论。在对弈部分，分析设计走棋算法，选择合适的方式组织成代码，实现基本的人工智能。过程中使用了J2ME中的CLDC/MIDP软件体系，主要运用了MID Profile的特定类的支持，来完成游戏的开发。
关键词：J2ME；CLDC；MIDP
Abstract
J2ME is a kind of fast developing technology implemented on various devices especially mobile communication equipments. It improves the efficiency of the development process because of its "write once, run anywhere" nature. The development trend of the entertainment market based on the cell phone is very obvious because the handset performance enhances unceasingly. The entertainment market based on the cell phone will to be the new important business growth point follow the PC entertainment market. As the rules of a single chess game, it is more suitable for mobile phones and other portable terminal extension.
J2ME has been the preferred platform for development because of its platform independent and compatibility, and provides a lot of APIs to support the development of mobile application software. The technology for mobile game development, can achieve the rapid development of the game. It is not only easy to observe the memory consumption and processor consumed time during the operation of the game, but also can optimize the code, so that the code has a high degree of reusability, scalability, maintainability.
The game has designed by J2ME, the Java technology and the MIDP technology. I studied the procedure thought, the important class and the method. In the playing chess part, I have analyzed the algorithm, choosed the appropriate way to organize the code and realized the basic artificial intelligence. On the other hand, I learned software system of CLDC/MIDP and the specific class of the MID Profile to complete the game development.
Key words: J2ME；CLDC；MIDP
目 录
1 概述... 5
1.1 课题研究背景... 5
1.2 课题研究意义... 5
2 开发技术背景... 6
2.1 JAVA语言概述... 6
2.2 J2ME简介... 6
2.3 移动信息设备简表... 6
3 系统分析及总体设计... 7
3.1 可行性分析... 7
3.2 需求分析... 8
3.3 系统概要设计... 8
4 系统详细设计... 9
4.1 界面设计... 9
4.1.1 图形的低级绘制... 10
4.1.2 用户按键设计... 10
4.2 走棋算法... 11
4.3 胜负判断... 11
5 系统测试... 11
5.1 测试方案... 11
5.2 测试结果... 12
6总 结... 13
基于J2ME的手机五子棋游戏的设计与实现
1 概述
1.1 课题研究背景
五子棋是当前非常流行的一种棋。五子棋不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。
手机游戏的实现方式主要包括嵌入式游戏、浏览器游戏、短消息服务游戏、J2ME和其它的解释语言。Java 2 Micro Edition是一种针对移动电话和PDA这样的小型设备的Java语言。J2ME与台式机中的Java相比还是有一定的限制，但是它已经极大的提高了移动电话支持游戏的能力。并且具备一定的优势：庞大的潜在用户群、便携性、开发门槛较低。
手机是现代生活方式的产物，如同因特网的普及导致网络游戏的高速发展一样，手机的普及，对满足不同功能的手机软件的需求也就越来越迫切，这就需要比较好的手机软件开发平台，此时具有平台无关性优点的J2ME开发平台也就应运而生。与传统的主流的PC游戏相比，手机游戏的价值在于打发一些无聊的时间，作为一个移动的娱乐终端，手机游戏施展身手的机会永远可能是在地铁站、公交车或者是洗手间这些地方，也许在庞大的游戏行业里，手机游戏将永远扮演着一个边缘者的角色，因为谁也不能指望一个人在家的时候用手机玩游戏或者看电影。但是手机游戏的市场是巨大的，即便是只有十分之一的用户来购买游戏，那也将是不可忽视的商业机遇。
手机游戏是手机的一种高附加值操作软件，游戏编程是手机软件编程的重要组成，同时也持续推动手机软件技术升级进步。手机游戏按手机平台分类，主要有J2ME、Brew、UniJa等。其中J2ME手机开发平台使用最为广泛。作为SUN公司针对微型嵌入式消费电子产品开发的编程系统，J2ME技术是当前手机软件开发的主流平台，各大手机生产厂商目前的主流产品绝大都使用J2ME技术。基于J2ME技术开发手机软件可以实现手机功能的多样化与专业化，极大的满足了人们对手机要求更高的需求。
1.2 课题研究意义
本设计基于J2ME技术，开发一款五子棋游戏软件，可以供人们闲暇时间随时随地娱乐，提高棋艺。五子棋不但容易上手，而且它区别于别的游戏，它不但使人娱乐，而且能使人的头脑变得更加聪明。
通过对该课题的研究，首先，进一步熟悉面向对象语言，加深对J2ME层次结构的了解。通过eclipse集成开发环境创建软件，最终形成一个具备基本功能的手机五子棋游戏，可应用于便携式设备，适合于棋类爱好者。其次，了解手机游戏开发的特点和现状。
2 开发技术背景
2.1 JAVA语言概述
Java的出现是源于对独立于平台语言的需要，希望这种编程语言能编写出嵌入各种家用电器等设备的芯片上、且易于维护的程序。人们发现当时的编程语言都有一个共同的缺点，就是针对CPU芯片进行编译。这样，一旦电器设备更换了芯片就不能保证程序正确运行。九零年Sun公司成立了开发小组，开始致力于开发一种可移植的、跨平台的编程语言，该语言能生成正确运行于各种操作系统、各种芯片上的代码。Java的出现标志着真正的分布式系统的到来。
Java是一种跨平台的、面向对象的、分布式的、解释的、安全的、结构的、可移植的、性能很优异的多线程的动态语言。
Java的特点：平台无关性；安全性；面向对象；分布式；健壮性。
2.2 J2ME简介
J2ME是SUN公司针对嵌入式、消费类电子产品推出的开发平台，与J2SE和J2EE共同组成Java技术的三个重要的分支。J2ME实际上是一系列规范的集合，由JCP组织制定相关的Java Specification Request（JSR）并发布，各个厂商会按照规范在自己的产品上进行实现，但是必须要通过TCK测试，这样确保兼容性。J2ME是JAVA的三大分支之一,专门用于开发基于消费性电子产品的应用。J2ME支持个人手持移动设备，如手机、PDA等。手机用户可以通过支持JAVA功能的终端,使用多种全新图形化、动态化和个性化的移动增值服务。
2.3 移动信息设备简表
移动信息设备简表(MIDP)为移动电话和入门级PDA设计，为移动应用程序提供了所需的全部核心功能，包括应用程序模型、用户界面、持久性数据存储、联网能力及应用程序管理功能，目前应用非常广泛的MIDlet就是在MIDP中定义的。
MIDP框架如图2-1所示。
图2-1 MIDP框架图
MIDP提供核心应用程序功能，包括用户界面、网络连接、本地数据存储和应用程序生命周期管理。MIDlet生命周期流程图如图2-2所示。
MIDP中含有下列API包:
A. javax.microedition.lcdui: 用户界面(UI)API，它为MIDP应用提供了一整套实现用户界面的功能特性。
B. javax.microediton.rms: 移动信息设备描述提供了一种让MIDlets持久性储存并在以后可以取回数据的机制。
C. javax.microedition.midlet: 这个MIDlet包明确定义了MIDP应用，也定义了和应用环境之间的交互。
D. javax.microedition.io: 移动信息设备还描述包括基于有限连接设备配置GenericConnection框架的网络支持。
图2-2 MIDlet生命周期流程图
3 系统分析及总体设计
3.1 可行性分析
3.1.1技术可行性
五子棋是传统的对弈游戏，历史悠久、规则单一。手机游戏的实现方式主要包括嵌入式游戏、浏览器游戏、短消息服务游戏、J2ME和其它的解释语言。Java 2 Micro Edition是一种针对移动电话和PDA这样的小型设备的Java语言，虽然它与台式机中的Java相比还是有一定的限制，但是已经极大的提高了移动电话支持游戏的能力。
在eclipse环境中编写并在模拟器中运行简单明了。
3.1.2操作可行性
本游戏开发后可导入手机操作，供个人平常娱乐所用，完全使用手机键盘操作，操作简单，所以在这方面是完全可行的。
3.2 需求分析
3.2.1系统的性能需求
首先，手机游戏最大的问题在于每一款手机拥有自己的屏幕大小和特定的API及性能。游戏开发过程中，要考虑到游戏程序的设计要能合乎大多数手机的应用。J2ME提出的一系列标准使得使用J2ME开发的游戏可以在配备J2ME的任何厂家的移动设备上运行。软件最好操作简单容易。受手机屏幕大小和显示的影响。手机键盘的不方便，游戏需要设计得容易操作。
其次，软件具有人工智能算法原理要简单，并且运行快速。对于人机游戏，不需要网络连接，游戏处理不会有太长的等待时间。游戏是需要快速反应的。手机处理器的频率直接要求我们需要使用简单实用的智能算法。
3.2.2系统的功能需求
A.游戏内容
此款游戏主题是五子棋对弈。无“禁手”的规则基本是人人皆知。相同颜色的棋子，五子一线为胜。
B.游戏方式
区别于一般的生活中的人与人的对弈，用在手机上为人机对弈，在手机屏幕上构造一个游戏棋盘，并且设计黑、白棋子。利用人工智能的相关知识实现对弈。
C.游戏对象
五子棋手机游戏是大众游戏，游戏者只要具备一般的操作知识就可以进入游戏。对玩游戏者并没有什么特殊要求。
D.游戏目标
此款手机游戏为棋类游戏，就是为了让人们闲暇时间休闲、锻炼棋艺。
a) 欢迎界面：玩家可点击“确定”进入规则说明界面。
b) 规则说明界面：玩家可点击“开始游戏”进入游戏。
c) 棋盘界面：对弈界面，使用上、下、左、右键来移动落子点位，使用确定按钮来落子，相应条件下可实现重新开始游戏功能。
d) 胜负判断：涉及人工智能，用以判断人与机器的输赢状况，游戏无“禁手”，五子首先连成一线者胜。
3.3 系统概要设计
该系统设计的主要模块分为：欢迎模块、规则说明模块、对弈与胜负判断模块。各主要模块的功能描述如下：
欢迎模块：这部分是游戏出现的第一个界面，主要是为了说明已经进入五子棋游戏系统。
规则说明模块：此模块说明了游戏规则。玩家可以选择开始游戏或返回欢迎界面。
对弈模块：该部分主要是进行人机对弈的棋盘界面。该模块有退出游戏和重新开始的功能。
胜负判断模块：这部分即是对每次棋局结果的判断，是人赢了或者是电脑获胜。
系统主要功能模块如图3-1所示。
图3-1 系统功能模块图
4 系统详细设计
4.1 界面设计
该部分主要说明手机游戏画面显示，包括画面的低级绘制以及如何进行游戏按键处理。
本程序的设计主要使用了MIDP所提供的javax.microedition.lcdui包中的类来实现手机的用户界面。
各个类如表4-1所示。
表4-1 javax.microedition.lcdui包
4.1.1 图形的低级绘制
若是要在MIDlet中使用低级用户界面设计，就必须定义一个从Canvas类派生出来的子类。
在Canvas类的子类中必须实现paint()方法。Graphics对象包含了所有的在屏幕上绘画的方法，例如drawArc()、drawLine()，drawRect ()，drawString()和fillArc()等。
本程序设计用到了Canvas类中的基本绘图方法：
绘制直线：
Public void drawLine(int x1,int y1,int x2,int y2)
绘制矩形：
Public void drawRect(int x,int y,int width,int height)。
绘制字符串：
Public void drawString(String str,int x,int y,int anchor)。
填充指定矩形内的圆：
Public void fillArc(int x,int y,int width,int height,int startAngel,in tint arcAngel)。
使用上述方法绘制棋盘界面：
绘制棋盘：
gg.drawLine(gridWidth,i*gridHeight,grifWidth*lineNumber+1,i*gridHeight)。
gg.drawLine(i*gridWidth,gridHeight,i*gridWidth,,lineNumber*gridHeight+1)。
绘制棋子：
gg.fillArc(x-gridwidth*2/5),y-gridHeight*2/5,gridWidth*4/5,gridHeight*4/5,0,360)。
绘制显示输赢的字符串：
gg.drawString(Show String,base x,base y,Graphics.TOP| Graphics.LEFT)。
4.1.2 用户按键设计
游戏是交互的，因此在游戏中一个重要的内容就是响应用户的按键操作。下
面介绍在游戏中用户按键响应的实现。
使用Canvas中的protected void keyPressed(int keycode)函数，当按下按键时调用该函数，实现上下左右的按键消息。
设计举例：
Protected void keyPressed(int keyCode){
if (keycode==getKeyCode(Canvas.LEFT)){
……}
}
手机键盘与平常设备键盘不同，命令的执行主要通过command类设计。该类构建在执行信息状态列中，功能是在对象中命令执行动作状况。动作定义在CommandListener，并且结合显示状态，主要提供接口与使用者交互模式。
设计举例：
private Command ok1 = new Command("确定", Command.OK, 1);
使用优先级作为希望的命令显示顺序的标识。一般数字越小，在列表中的级别就越高。
4.2 走棋算法
对于五子棋游戏，主要就是判断棋盘上是否存在五子连珠情况。判断五子连珠的原理是从横，竖，左斜线，右斜线4条线上是否存在5个相连的同类棋子。
对战一方落子后，在该处向8个方向检测连续的同类棋子，如果检测到直线方向上存在5个连续的同类棋子，则判断为“连五”并结束检测。基于检测结果，可以判断游戏是否结束，并根据获胜方的落子代码判断获胜方是谁。
4.3 胜负判断
为检测当前棋局是否已经有一方获胜，从横向、纵向、左斜、右斜四种情况考虑。首先，获取当前下棋点（x,y）和棋子的颜色,接着计算连续的相同颜色的棋子；有连续5个相同的棋子则return true；给出本次棋局结果。
对战一方落子后，在该处向8个方向检测连续的同类棋子，如果检测到直线方向上存在5个连续的同类棋子，则判断为“连五”并结束检测。基于检测结果，可以判断游戏是否结束，并根据获胜方的落子代码判断获胜方是谁。
5 系统测试
5.1 测试方案
程序测试是程序编码完成后必须的一步，通过测试，检查代码的正确性，了解功能的实现性，可以达到发现问题，改进功能，让程序更完善更健壮。没有经过测试的软件是无法大量投入使用的，因为它无法保证可以在用户端健壮地运行。测试通常分为两大类：白盒测试和黑盒测试。“白盒测试”指的是测试者清楚待测对象内部工作机制的测试；“黑盒测试”指的是测试者无需了解测试对象内部工作机制的测试。
因为并不是所有的用户都能知道系统的结构和处算法，所以，从用户的角度出发，采用黑盒测试法对系统进行功能测试。
5.2 测试结果
a)运行程序，出现欢迎界面，如图5-1所示：
5-1
b)点击“确定”进入游戏说明界面，可点击“返回”回到欢迎界面，如图5-2所示：
5-2
c)点击“开始游戏”进入棋盘界面，默认玩家先行，为黑子，如图5-3所示
5-3
d)对弈棋盘如图5-4所示，假设走棋结果人获胜。
5-4
e)假设走棋结果电脑获胜，结果如图5-5所示。
5-5
6总 结
整个设计基本完成，由于能力和时间的关系，总是有很多不尽人意的地方，譬如功能较少、外观较粗糙等。通过这个程序设计，我深刻体会到即使是对于一个并不大的程序，代码的组织都是非常重要的，因为这关系到日后的维护以及扩展。
刚开始决定编写五子棋游戏时，我觉得难度比较大。后来通过网络寻找相关的视频学习相关知识，并查找，一点点进行下去。同时，因为该程序的设计侧重于算法部分，对弈算法的设计，对于我而言很难，通过网络资源，我了解到，不少参考资料上已提供了各种精良可用的现成算法，我可以先学习这些已经设计好的算法，选择合适的方式组织代码。
整个设计过程中，我受益非浅，感受颇深，体会到软件开发并不是纯数学，更侧重于分析。虽然设计结果并不是很完善，有很多地方还有待进一步改进，但是我觉得最可贵的是过程中的收获。在以后的时间里，我仍将努力学习，深入实践，不断提升自我，努力实现更高的自我价值。
参考文献
[1] 赫玉龙，李向前.J2ME移动应用开发[M].北京:清华大学出版社,2006.9.
[2] 李振鹏,龚剑.J2ME手机游戏开发技术详解[M].北京:清华大学出版社,2006.3.
[3] 王森.Java手机/PDA程序设计入门[M].北京:电子工业出版社,2004.3.
[5] 欧阳泉,许向阳.J2ME平台结构及开发应用[J].计算机与数字工程,2006,(03):112-113.
[6] 刘洁,段晓勇.基于J2ME的Java手机应用程序的开发[J].科技广场,2007,(01):66-68.
[7] 李观华,范辉.J2ME在移动通信程序中的应用[J].计算机应用,2003,(03):124-126.
[8]http://www.j2medev.com/Index.asp
源代码：
Midlet1.java
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
public class Midlet1 extends MIDlet implements CommandListener
{
public Display display;
private Canvas1 lc = new Canvas1();
//欢迎界面
private Form W;//新建一个form对象
private Command ok1;
private Command exit;
private Image welcomeimg;
//说明界面
private Form E;
private Command ok2;
private Command back;
private Image helpimg;
public Midlet1()
{
lc.setParam(); //初始化数组
display = Display.getDisplay(this); //通过display的静态方法getdisplay()来获得当前设备的display对象
}
public void commandAction(Command c,Displayable s)
{
if (c ==exit)
{
this.notifyDestroyed();
}
if (c == ok1)
{
display.setCurrent(E);//调用setcurrent（）方法将display对象绑定到显示设备
}
if (c == back)
{
display.setCurrent(W);
}
if (c == ok2)
{
display.setCurrent(lc);
}
}
public void startApp()
{
//欢迎界面
W= new Form("欢迎您进入五子棋游戏^_^");
display.setCurrent(W);//调用setcurrent方法将display对象绑定到显示设备
ok1 = new Command("确定",Command.OK,1);
exit = new Command("退出",Command.EXIT,1);
W.addCommand(exit); //调用addCommand方法将Command对象添加到GUI显示组件
W.addCommand(ok1);
try{
welcomeimg = Image.createImage("/welcome.png");
W.append(welcomeimg);
}catch (Exception e){}
//游戏说明界面
E= new Form("五子棋游戏说明");
ok2= new Command("开始游戏",Command.OK,1);
back= new Command("返回",Command.BACK,1);
E.addCommand(ok2);
E.addCommand(back);
try{
helpimg = Image.createImage("/help.png");
E.append(helpimg); //添加图层
}catch (Exception e){}
//设置命令监听者
W.setCommandListener(this);
E.setCommandListener(this);
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
}
Canvas1.java
import javax.microedition.lcdui.*;
import java.util.*;
public class Canvas1 extends Canvas implements CommandListener {
Graphics gg;
Random rnd = new Random(); // 构造一个随机数生成器
int lineNumber=15;
int gridWidth=10; //格子的宽度
int gridHeight=10; //格子的高度
int lineColor = 0x006699; //棋盘格子线的颜色
int focusColor = 0x00ff00; //焦点的颜色
int intRunMode = 0; //0-等待初始态，1-下棋,2-等待用户响应
int intPlayer =0; //0-黑棋（先下者），1-白棋（后下者）
int gotoValue;
int[] qipan;
//使用一个二维数组记录棋盘棋子的分布//检查后，如果不存在五子，则全为0，如果存在，则依次是五个子的位置
int[] wuzi = new int[5];
int[][] q;
int[][] m;
//int[] g={1,16,15,17}; //这个
int[] g= new int[4];
int baseX=10; //棋盘左上角X
int baseY=10; //棋盘左上角Y
int currentX; //当前所在区域的左上角X
int currentY; //当前所在区域的左上角Y
int currentA; //当前是第几个竖线
int currentB; //当前是第几个横线
int LastA; //最后一个子位于第几根竖线
int LastB; //最后一个子位于第几根横线
boolean loadedMenu = false;
Command cmdRestart = new Command("重新开始", Command.SCREEN, 1);
//设置一些棋盘参数
public void setParam() {
qipan = new int[lineNumber * lineNumber];
q = new int[3][lineNumber * lineNumber];
m = new int[3][lineNumber * lineNumber];
g[0] = 1;
g[1] = lineNumber ;
g[2] = lineNumber - 1;
g[3] = lineNumber + 1;
}
public void paint(Graphics g) {
addCommand(cmdRestart);
setCommandListener(this);
gg=g;
if (intRunMode == 0) {
buildChessboard();
}
}
//事件处理函数
public void commandAction(Command c, Displayable d) {
if (c == cmdRestart)
{
intRunMode = 0;
repaint();
}
}
/**
* 开始游戏时所做的一些工作
* 比如画棋盘，初始化一些参数、数组，并设置最开始时的焦点位置
*/
public void buildChessboard() {
try {
//初始化数组
for (int i = 0; i < lineNumber * lineNumber; i++) {
qipan[i] = 0;
}
for (int i = 0; i < 5; i++)
wuzi[i] = 0;
gg.setColor(0x006699cc);
gg.fillRect(0, 0, getWidth(), getHeight());
for (int i = 1; i < lineNumber + 1; i++) {
gg.setColor(lineColor);
gg.drawLine(gridWidth, i * gridHeight, gridWidth * lineNumber + 1, i * gridHeight);
gg.drawLine(i * gridWidth, gridHeight, i * gridWidth,lineNumber * gridHeight + 1);
}
//初始时在中间
currentX = baseX + gridWidth * (lineNumber - 1) / 2 - gridWidth / 2;
currentY = baseY + gridHeight * (lineNumber - 1) / 2 - gridHeight / 2;
currentA = 8;
currentB = 8;
intRunMode = 1;
intPlayer = 0;
moveFoucs(currentX - gridWidth / 2, currentY - gridHeight / 2 - 1,gridWidth * 3, gridHeight * 2);
}
catch (Exception e) {
System.out.println("buildChessboard Error:" + e);
}
}
//移动焦点，需要对六个格子大的范围进行重画
//（可以优化为两个格子重画内容包括六个棋盘格子，十二个可能存在的棋子，以及一个焦点
public void moveFoucs(int x, int y, int width, int height) {
try {
gg.setColor(0x006699cc);
gg.fillRect(x, y, width, height);
//这六个格子可能是横着的，也可能是竖的，其中有四个格子的位置是不变的
mydrawRect(x, y, gridWidth, gridHeight);
mydrawRect(x, y + gridHeight, gridWidth, gridHeight);
mydrawRect(x + gridWidth, y, gridWidth, gridHeight);
mydrawRect(x + gridWidth, y + gridHeight, gridWidth, gridHeight);
if (width > height) {
mydrawRect(x + gridWidth * 2, y, gridWidth, gridHeight);
mydrawRect(x + gridWidth * 2, y + gridHeight, gridWidth, gridHeight);
//最右边的竖线
DrawChessman(x + gridWidth * 3, y);
DrawChessman(x + gridWidth * 3, y + gridHeight);
DrawChessman(x + gridWidth * 3, y + gridHeight * 2);
//最下面的横线
DrawChessman(x, y + gridHeight * 2);
DrawChessman(x + gridWidth, y + gridHeight * 2);
DrawChessman(x + gridWidth * 2, y + gridHeight * 2);
}
else {
mydrawRect(x, y + gridHeight * 2, gridWidth, gridHeight);
mydrawRect(x + gridWidth, y + gridHeight * 2, gridWidth, gridHeight);
//最右边的竖线
DrawChessman(x + gridWidth * 2, y);
DrawChessman(x + gridWidth * 2, y + gridHeight);
DrawChessman(x + gridWidth * 2, y + gridHeight * 2);
DrawChessman(x + gridWidth * 2, y + gridHeight * 3);
//最下面的横线
DrawChessman(x, y + gridHeight * 3);
DrawChessman(x + gridWidth, y + gridHeight * 3);
}
//画光标
gg.setColor(focusColor);
gg.drawLine(currentX, currentY,currentX + gridWidth /5, currentY);
gg.drawLine(currentX, currentY, currentX,currentY + gridHeight /5);
gg.drawLine(currentX +gridWidth*4/5,currentY,currentX + gridWidth, currentY);
gg.drawLine(currentX + gridWidth, currentY, currentX + gridWidth,currentY + gridHeight /5);
gg.drawLine(currentX,currentY + gridHeight * 4/ 5,currentX, currentY + gridHeight);
gg.drawLine(currentX,currentY + gridHeight,currentX + gridWidth / 5,currentY + gridHeight);
gg.drawLine(currentX +gridWidth*4/5,currentY + gridHeight, currentX + gridWidth,currentY + gridHeight);
gg.drawLine(currentX + gridWidth,currentY + gridHeight *4 / 5,currentX + gridWidth, currentY + gridHeight);
repaint();
}
catch (Exception e) {
System.out.println("moveFoucs Error:" + e);
}
}
/*
* 画格子，并画棋子。把这部分独立出来主要是要检查边界问题
* x 格子右上角x
* y 格子右上角y
* width 格子宽度
* height 格子高度
*/
private void mydrawRect(int x, int y, int width, int height) {
int a, b;
a = (x - baseX) / gridWidth + 1;
b = (y - baseY) / gridHeight + 1;
if (a != lineNumber && b != lineNumber) {
gg.setColor(lineColor);
gg.drawRect(x, y + 1, width, height);
}
DrawChessman(x, y);
}
//画棋子，x,y分别是圆的中心坐标，棋子的直径为格子边长（格子为正方形）的4/5
public void DrawChessman(int x, int y) {
try {
int a;
int b;
a = (x - baseX) / gridWidth + 1;
b = (y - baseY) / gridHeight + 1;
if (a > lineNumber || a < 1 || b > lineNumber || b < 1) {
return;
}
if (qipan[ (b - 1) * lineNumber + a - 1] == 1)
gg.setColor(0, 0, 0);
else if (qipan[ (b - 1) * lineNumber + a - 1] == 2)
gg.setColor(255, 255, 255);
else {
return;
}
gg.fillArc(x - gridWidth * 2 / 5, y - gridHeight * 2 / 5,
gridWidth * 4 / 5, gridHeight * 4 / 5, 0, 360);
if (LastA == a && LastB == b) {
gg.setColor(0xff0000);
gg.drawLine(x, y - gridHeight / 5, x, y + gridHeight / 5);
gg.drawLine(x - gridWidth / 5, y, x + gridWidth / 5, y);
}
repaint();
}
catch (Exception e) {
System.out.println("DrawChessman Error:" + e);
}
}
//键盘被按下。主要是移动焦点，以及落子的处理
protected void keyPressed(int keycode) {
if(keycode==getKeyCode(Canvas.LEFT)){
if (currentX < baseX)return;
currentX = currentX - gridWidth;
currentA--;
moveFoucs(currentX - gridWidth / 2, currentY - gridHeight / 2,
gridWidth * 3, gridHeight * 2);
}
if(keycode==getKeyCode(Canvas.RIGHT)){
if (currentX > baseX + gridWidth * (lineNumber - 2))return;
currentX = currentX + gridWidth;
currentA++;
moveFoucs(currentX - gridWidth * 3 / 2, currentY - gridHeight / 2,
gridWidth * 3, gridHeight * 2);
}
if(keycode==getKeyCode(Canvas.UP)){
if (currentY < baseY)return;
currentY = currentY - gridHeight;
currentB--;
moveFoucs(currentX - gridWidth / 2, currentY - gridHeight / 2,
gridWidth * 2, gridHeight * 3);
}
if(keycode==getKeyCode(Canvas.DOWN)){
if (currentY > baseY + gridHeight * (lineNumber - 2))return;
currentY = currentY + gridHeight;
currentB++;
moveFoucs(currentX - gridWidth / 2, currentY - gridHeight * 3 / 2,
gridWidth * 2, gridHeight * 3);
}
if(keycode==getKeyCode(Canvas.FIRE)){
if (intPlayer == 0) {
if (qipan[lineNumber * (currentB - 1) + currentA - 1] != 0) {
System.out.println("此处有子");
return;
}
}
qipan[lineNumber * (currentB - 1) + currentA - 1] = 1;
DrawChessman(currentX + gridWidth / 2, currentY + gridHeight / 2);
gotoValue = tk();
//检查人是否胜利
if (checkVictory())return;
//模拟电脑下一个
intPlayer = 1;
int a = currentA;
int b = currentB;
qipan[gotoValue] = 2;
a = LastA;
b = LastB;
LastA = (gotoValue + 1) % lineNumber;
LastB = (gotoValue + 1 - LastA) / lineNumber + 1;
DrawChessman( (a - 1) * gridWidth + baseX,
(b - 1) * gridHeight + baseY);
DrawChessman( (LastA - 1) * gridWidth + baseX,
(LastB - 1) * gridHeight + baseY);
tk();
checkVictory();
//准备人下
intPlayer = 0;
}
}
//分析当前是否有一方胜利。并找出下一步该走在何处
private int tk() {
try {
int[] e = {1, 2, 4, 12, 24};
int[] c = new int[3];
int g_b = 0; //此变量记录电脑应下于何处
int n = 0;
int p;
int a0;
int h;
int a;
int d = 0;
int z = 0;
for (p = 0; p < 3; p++) { //对两个大数组清零
for (a0 = 0; a0 < lineNumber * lineNumber; a0++) {
q[p][a0] = 0;
m[p][a0] = 0;
}
}
for (a0 = 0; a0 < lineNumber * lineNumber; a0++) {
for (d = 0; d < 4; d++) {
if ( (a0 / lineNumber < (lineNumber - 4) || d == 0) &&
(a0 % lineNumber < (lineNumber - 4) || d == 1 || d == 2) &&
(a0 % lineNumber > 3 || d != 2)) {
c[1] = 0;
c[2] = 0;
for (z = 0; z < 5; z++) {
c[qipan[a0 + z * g[d]]]++;
}
if (c[1] == 0)
p = 2;
else if (c[2] == 0)
p = 1;
else
p = 0;
if (p != 0) {
for (z = 0; z < 5; z++) {
if (c[p] == 5)
//记录五个子的坐标
wuzi[z] = a0 + z * g[d];
else if (qipan[a0 + z * g[d]] == 0) {
a = a0 + z * g[d];
q[0][a] += e[c[p]];
if (c[p] >= 2)
q[p][a] += e[c[p]];
if (c[p] > m[p][a])
m[p][a] = c[p];
}
}
}
}
}
for (p = 1; p < 3; p++)
if (q[p][a0] >= e[4]) {
h = 2 * m[p][a0];
if (p == 2)
h++;
if (q[0][a0] < lineNumber * lineNumber)
q[0][a0] += lineNumber * lineNumber * h;
else if (q[0][a0] < lineNumber * lineNumber * h)
q[0][a0] = lineNumber * lineNumber * h;
}
if (q[0][a0] > q[0][g_b])
n = 0;
if (q[0][a0] >= q[0][g_b]) {
n++;
if ( (rnd.nextInt() & 0x7FFFFFFF) % 1000 * n / 1000 < 1)
g_b = a0;
}
}
return g_b;
}
catch (Exception e) {
System.out.println("tk Error:" + e);
return 0;
}
}
//检查是否有一方胜出，并做出相应处理
private boolean checkVictory() {
if (wuzi[1] != 0) { //WuZi[1]!=0表示已经大到5个了，一方胜利
String ShowString;
if (intPlayer == 0)
ShowString = "你赢了！";
else
ShowString = "电脑赢了！";
gg.drawString(ShowString, baseX, baseY, Graphics.TOP | Graphics.LEFT);
return true;
}
else {
return false;
}
}
}