程序员css五子棋

⑴ 简单五子棋棋盘怎么画

五子棋棋盘以及下子 怎么画
都是正方形方格，越多越好
五子棋棋盘怎么画
横线竖线垂直相交，就是画方格，数量多多宜善。
五子棋的棋盘怎么画
都是正方形方格，越多越好
五子棋棋盘以及下子 怎么画
如果是用画的方式下子，那么建议16横16竖，围成225个格子，并且标识上横座标ABCD纵座标1234，类似第一象限

五子棋的棋盘怎么绘制
五子棋的樱升棋盘就是方格，用笔后和尺子绘制，如果是在绘图软件里用直线工具，借助标尺就可以绘制了。格子的大小，略大于棋子的大小即可。一般横竖都有20来格就可以了，适当多点更好。

希望采纳。
请问如何用mfc画一个五子棋的棋盘啊？
1、打开VC++ 6.0

2、新建一个MFC AppWizard(exe)的工程，工程名为wuzi

3、点击确定

4、选择单个文档，去掉"文档/查看体系结构支持"复选框

5、点击完成

6、切换到CLassView

7、找到CChildView类下的OnPaint()函数，双击该函数

8、OnPaint()函数代码如下：

void CChildView::OnPaint()

{

CPaintDC dc(this);

CPen bi,*jbi;

bi.CreatePen(PS_DASH,2,RGB(0,255,0)); 创建绿色画笔

jbi=dc.SelectObject(&bi); 选择画笔

for(int i=0;i<15;i++) 画水平线

{

dc.MoveTo(40,40+i*40);

dc.LineTo(15*40,40+i*40);

}

for(i=0;i<15;i++) 画垂直线

{

dc.MoveTo(40+i*40,40);

dc.LineTo(40+i*40,15*40);

}

dc.SelectObject(jbi);

}

9、编译，运行

画五子棋的子，可用以下的画圆的函数，

BOOL Ellipse( int x1, int y1, int x2, int y2 );

或

BOOL Ellipse( LPCRECT lpRect );

补充：

CChildView类没找到,可能因为你没有去掉"文档/查看体系结构支持"复选框。（第4步）

如果不去掉该复选框，选择单个文档，点击完成 ，那么你将看到CWuziView类,切换到CLassView ,找到CWuziView类,右击该类，选择Add Windows Message Handler,弹出一对话框，在左边选择WM_PAINT,双击它或点击右边的Add Handler,再点击Edit Existing,进入到CWuziView::OnPaint()函数，函数代码同上面的第8步。

最脊租老后，编译，运行 。
html5五子棋游戏的棋盘怎么画
棋盘用1个 div 作为容器，用 css 一些内边距{padding: 60px;}，里面的网格也是用 div 标签，可以用脚本生成，一共输出20*20=400个格子就可以了，型枣方便多了，格子设置样式为{width: 40px; height: 40px; float: left;}
怎样用C画五子棋棋盘
画图的函数：line（a,a,b,b）可以画线。

楼主就知道这一个函数。。。

这个得查函数，定义图形中点的问题我也不会

这个好像有点用：

getpixel

原型：extern int getpixel(int x, int y);

用法：#include

功能：返回屏幕上指定点的状态

说明：(x,y)为屏幕上点的座标，如果点为清除状态返回零，否则返回非零值。

举例：

pixel.c

#include

main()

{

int i,j;

clrscr();

printf("V");

gotoxy(10,10); Hide cursor

for(i=0;i<8;i++)

for(j=0;j<16;j++)

{

if(getpixel(i,j))

putpixel(10+i,10+j,1);

else

putpixel(10+i,10+j,0);

}

getchar();

return 0;

}

还有配套的：

putpixel

原型：extern void putpixel(int x, int y, int mode);

用法：#include

功能：在屏幕的指定位置上画点

说明：(x,y)为屏幕上点的座标，mode值含义如下：

mode=0：清除（x，y）处的点

1：在（x，y）处画点

2：将（x，y）处的点的状态取反

举例：

pixel.c

#include

main()

{

int i,j;

clrscr();

printf("V");

gotoxy(10,10); Hide cursor

for(i=0;i<8;i++)

for(j=0;j<16;j++)

{

if(getpixel(i,j))

putpixel(10+i,10+j,1);

else

putpixel(10+i,10+j,0);

}

getchar();

return 0;

}

这些都在 库里，引用的时候必须在开头注明。

再给lz一个示范吧：贪吃蛇。我现在手头就这一个了。

#define N 200

#include

#include

#include

#define LEFT 0x4b00

#define RIGHT 0x4d00

#define DOWN 0x5000

#define UP 0x4800

#define ESC 0x011b

int i,key;

int score=0;/*得分*/

int gamespeed=500000;/*游戏速度自己调整*/

struct Food

{

int x;/*食物的横座标*/

int y;/*食物的纵座标*/

int yes;/*判断是否要出现食物的变量*/

}food;/*食物的结构体*/

struct Sna......
用VISUAL STUDIO 怎么样画出一个五子棋的棋盘？就是放张图片然后把棋子放到格子里面。
gdi+

using System.Drawing;

using System.Drawing.Drawing2D;

可以选择放一个背景图片,bitmap

也可以自己画
怎样用c语言画出五子棋棋盘
************************************************************** C++语言五子棋源程序 ************************************************************* #include

#include

#include

#include

#define backcolor CYAN

#define defaultcolor BLACK

#define linecolor MAGENTA

#define player1_color RED

#define player2_color WHITE

#define error_color RED

#define winner_color RED

const int left=40;

const int top=390;

const int d=30;

const int line_num=9;

const int turn=0;

const int r=d/3;

const int j=10;

int x,y,k=1,step=(line_num+1)*(line_num+1);

union REGS regs1,regs2;

class player1;

class player2;

class qipan{

public:

qipan();

~qipan(){};

void init_qipan();

friend void fall(player1 &num1,player2 &num2,qipan &num);

friend void input(player1 &num1,player2 &num2,qipan &num);

private:

int point[line_num+1][line_num+1];

};

class player1{

public:

player1();

~player1(){};

friend void fall(player1 &num1,player2 &num2,qipan &num);

friend void input(player1 &num1,player2 &num2);

friend int judge_winner(player1 &num1,player2 &num2);

private:

int point1[line_num+1][line_num+1];

};

class player2{

public:

player2();

~player2(){};

friend void fall(player1 &num1,player2 &num2,qipan &num);

friend void input(player1 &num1,player2 &num2,qipan &num);

friend int judge_winner(player1 &num1,player2 &num2);

private:

int point2[line_num+1][line_num+1];

};

void input(player1 &num1,player2 &num2);

void fal......

⑵ 五子棋中的冲型活型，双三双四，禁手，冲四，活三等都是什么意思啊

一．游戏介绍

五子棋是起源于中国古代的传统黑白棋种之一。现代五子棋日文称顷山之为 “ 连珠 ” ，英译为 “Renju” ，英文称之为 “Gobang” 或 “FIR”(Five in a Row 的缩写 ) ，亦有 “ 连五子 ” 、 “ 五子连 ” 、 “ 串珠 ” 、 “ 五目 ” 、 “ 五目碰 ” 、 “ 五格 ” 等多种称谓。

五子棋不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。五子棋既有现代休闲的明显特征 “ 短、平、快 ” ，又有古典哲学的高深学问 “ 阴阳易理 ” ；它既有简单易学的特性，为人民群众所喜闻乐见，又有深奥的技巧和高水平的国际性比赛；它的棋文化源渊流长，具有东方的神秘和西方的直观；既有 “ 场 ” 的概念，亦有 “ 点 ” 的连接。它是中西文化的交流点，是古今哲理的结晶。

五子棋起源于古代中国，发展于日本，风靡于欧洲。对于它与围棋的关系有两种说法，一说早于围棋，早在 “ 尧造围棋 ” 之前，民间就已有五子棋游戏；一说源于围棋，是围棋发展的一个分支。在中国的文化里，倍受人们的青睐。古代的五子棋的棋具与围棋相同，纵横各十七道。五子棋大约随围棋一起在我国南北朝时先后传入朝鲜、日本等地。据日本史料文献介绍，中国古代的五子棋是经由高丽 ( 朝鲜 ) ，于 1688 年至 1704 年的日本元禄时代传到日本的。到日本明治 32 年 ( 公元 1899 年 ) ，经过公开征名， “ 连珠 ” 这一名称才被正式确定下来，取意于 “ 日月如合壁，五星如连珠 ” 。从此，连珠活动经过了不断的改良，主要是规则的变化 ( 即谈物对执黑棋一方的限制 ) ，例如， 1899 年规定，禁止黑白双方走 “ 双三 ” ； 1903 年规定，只禁止黑方走 “ 双三 ” ； 1912 年规定，黑方被迫走 “ 双三 ” 亦算输； 1916 年规定，黑方不许走 “ 长连 ” ； 1918 年规定，黑方不许走 “ 四、三、三 ” ； 1931 年规定，黑方不许走 “ 双四 ” ，并规定将 19×19 的围棋盘改为 15×15 的连珠专用棋盘。本世纪初五子棋传入欧洲并迅速风靡全欧。通过一系列的变化，使五子棋这一简单的游戏复杂化、规范化，而最终成为今天的职业连珠五子棋，同时也成为一种国际比赛棋。

二．简明职业连珠五子棋比赛规则的解释

1 、五子棋是两个人之间进行的竞技活动，由于对黑方白方规则不同，黑棋必须先行。
2 、五含乎液子棋专用盘为 15×15 ，五连子的方向为横、竖、斜。
3 、禁手是对局中被判为负的行棋手段。白棋无禁手。
请看图解
http://piano.ccjt.net/user/html/piclook.asp?id=5137
4 、在棋盘上以对局双方均不可能形成五连为和棋。
5 、在对局中，以在盘上落下的子又拿起来为拔子，判负。在对局中，一方自行终止比赛，判负。
6 、黑方在落下关键的第五子即形成五连的同时，又形成禁手。此时因黑方已成连五，故禁手失效，黑方胜。
7 、所谓黑方形成禁手，是指黑方一子落下同时形成两个或两个以上的活三、冲四及长连禁手。此时，白方应立即向黑方指出禁手，自然而胜。

三．特殊规定

职业连珠五子棋虽然对黑棋采取了种限制，但是黑棋先行的优势依然很大。因此，在高段位的职比赛中，又出现了三种特殊的规定。

① “ 指定打法 ” ：是指比赛双方按照约定好的开局进行奔，由白棋先行。例如 “ 明星局 ” 、 “ 花月局 ” 等 ( 参看 “ 连珠五子棋的开局 ”) 。
② “ 三手可交换 ” ：是指黑棋下第 2 手棋 ( 盘面第 3 着棋之后，白方在应白 2 之前，如感觉黑方棋形不利于己方，可出交换，即执白棋一方变为执黑棋一方 ( 此方法不适用指定局打法，而用于随意开局 ) 。
③ “ 五手两打法 ” ：是指黑棋在下盘面上关键的第 5 手时，必须下两步棋，让白方在这两步棋中任选一步，然后再续下。

⑶ html5五子棋游戏的棋盘怎么画

棋蚂和盘用1个 div 作为容器，用基神 css 一些内边距{padding: 60px;}，里面的网格也是用 div 标签，可以用脚搏物亏本生成，一共输出20*20=400个格子就可以了，方便多了，格子设置样式为{width: 40px; height: 40px; float: left;}

⑷ 用C++编写的小游戏源代码

五子棋的代码：

#include<iostream>

#include<stdio.h>

#include<stdlib.h>

#include <time.h>

using namespace std;

const int N=15; //15*15的棋盘

const char ChessBoardflag = ' '; //棋盘标志

const char flag1='o'; //玩家1或电脑的棋子标志

const char flag2='X'; //玩家2的棋子标志

typedef struct Coordinate //坐标类

{

int x; //代表行

int y; //代表列

}Coordinate;

class GoBang //五子棋类

{

public:

GoBang() //初始化

{

InitChessBoard();

}

void Play() //下棋

{

Coordinate Pos1; // 玩家1或电脑

Coordinate Pos2; //玩家2

int n = 0;

while (1)

{

int mode = ChoiceMode();

while (1)

{

if (mode == 1) //电脑vs玩家

{

ComputerChess(Pos1,flag1); // 电脑下棋

if (GetVictory(Pos1, 0, flag1) == 1) //0表示电脑,真表示获胜

break;

PlayChess(Pos2, 2, flag2); //玩家2下棋

if (GetVictory(Pos2, 2, flag2)) //2表示玩家2

break;

}

else //玩家1vs玩家2

{

PlayChess(Pos1, 1, flag1); // 玩家1下棋

if (GetVictory(Pos1, 1, flag1)) //1表示玩家1

break;

PlayChess(Pos2, 2, flag2); //玩家2下棋

if (GetVictory(Pos2, 2, flag2)) //2表示玩家2

break;

}

}

cout << "***再来一局***" << endl;

cout << "y or n :";

char c = 'y';

cin >> c;

if (c == 'n')

break;

}

}

protected:

int ChoiceMode() //选择模式

{

int i = 0;

system("cls"); //系统调用，清屏

InitChessBoard(); //重新初始化棋盘

cout << "***0、退出 1、电脑vs玩家 2、玩家vs玩家***" << endl;

while (1)

{

cout << "请选择：";

cin >> i;

if (i == 0) //选择0退出

exit(1);

if (i == 1 || i == 2)

return i;

cout << "输入不合法" << endl;

}

}

void InitChessBoard() //初始化棋盘

{

for (int i = 0; i < N + 1; ++i)

{

for (int j = 0; j < N + 1; ++j)

{

_ChessBoard[i][j] = ChessBoardflag;

}

}

}

void PrintChessBoard() //打印棋盘，这个函数可以自己调整

{

system("cls"); //系统调用，清空屏幕

for (int i = 0; i < N+1; ++i)

{

for (int j = 0; j < N+1; ++j)

{

if (i == 0) //打印列数字

{

if (j!=0)

printf("%d ", j);

else

printf(" ");

}

else if (j == 0) //打印行数字

printf("%2d ", i);

else

{

if (i < N+1)

{

printf("%c |",_ChessBoard[i][j]);

}

}

}

cout << endl;

cout << " ";

for (int m = 0; m < N; m++)

{

printf("--|");

}

cout << endl;

}

}

void PlayChess(Coordinate& pos, int player, int flag) //玩家下棋

{

PrintChessBoard(); //打印棋盘

while (1)

{

printf("玩家%d输入坐标：", player);

cin >> pos.x >> pos.y;

if (JudgeValue(pos) == 1) //坐标合法

break;

cout << "坐标不合法，重新输入" << endl;

}

_ChessBoard[pos.x][pos.y] = flag;

}

void ComputerChess(Coordinate& pos, char flag) //电脑下棋

{

PrintChessBoard(); //打印棋盘

int x = 0;

int y = 0;

while (1)

{

x = (rand() % N) + 1; //产生1~N的随机数

srand((unsigned int) time(NULL));

y = (rand() % N) + 1; //产生1~N的随机数

srand((unsigned int) time(NULL));

if (_ChessBoard[x][y] == ChessBoardflag) //如果这个位置是空的，也就是没有棋子

break;

}

pos.x = x;

pos.y = y;

_ChessBoard[pos.x][pos.y] = flag;

}

int JudgeValue(const Coordinate& pos) //判断输入坐标是不是合法

{

if (pos.x > 0 && pos.x <= N&&pos.y > 0 && pos.y <= N)

{

if (_ChessBoard[pos.x][pos.y] == ChessBoardflag)

{

return 1; //合法

}

}

return 0; //非法

}

int JudgeVictory(Coordinate pos, char flag) //判断有没有人胜负(底层判断)

{

int begin = 0;

int end = 0;

int begin1 = 0;

int end1 = 0;

//判断行是否满足条件

(pos.y - 4) > 0 ? begin = (pos.y - 4) : begin = 1;

(pos.y + 4) >N ? end = N : end = (pos.y + 4);

for (int i = pos.x, j = begin; j + 4 <= end; j++)

{

if (_ChessBoard[i][j] == flag&&_ChessBoard[i][j + 1] == flag&&

_ChessBoard[i][j + 2] == flag&&_ChessBoard[i][j + 3] == flag&&

_ChessBoard[i][j + 4] == flag)

return 1;

}

//判断列是否满足条件

(pos.x - 4) > 0 ? begin = (pos.x - 4) : begin = 1;

(pos.x + 4) > N ? end = N : end = (pos.x + 4);

for (int j = pos.y, i = begin; i + 4 <= end; i++)

{

if (_ChessBoard[i][j] == flag&&_ChessBoard[i + 1][j] == flag&&

_ChessBoard[i + 2][j] == flag&&_ChessBoard[i + 3][j] == flag&&

_ChessBoard[i + 4][j] == flag)

return 1;

}

int len = 0;

//判断主对角线是否满足条件

pos.x > pos.y ? len = pos.y - 1 : len = pos.x - 1;

if (len > 4)

len = 4;

begin = pos.x - len; //横坐标的起始位置

begin1 = pos.y - len; //纵坐标的起始位置

pos.x > pos.y ? len = (N - pos.x) : len = (N - pos.y);

if (len>4)

len = 4;

end = pos.x + len; //横坐标的结束位置

end1 = pos.y + len; //纵坐标的结束位置

for (int i = begin, j = begin1; (i + 4 <= end) && (j + 4 <= end1); ++i, ++j)

{

if (_ChessBoard[i][j] == flag&&_ChessBoard[i + 1][j + 1] == flag&&

_ChessBoard[i + 2][j + 2] == flag&&_ChessBoard[i + 3][j + 3] == flag&&

_ChessBoard[i + 4][j + 4] == flag)

return 1;

}

//判断副对角线是否满足条件

(pos.x - 1) >(N - pos.y) ? len = (N - pos.y) : len = pos.x - 1;

if (len > 4)

len = 4;

begin = pos.x - len; //横坐标的起始位置

begin1 = pos.y + len; //纵坐标的起始位置

(N - pos.x) > (pos.y - 1) ? len = (pos.y - 1) : len = (N - pos.x);

if (len>4)

len = 4;

end = pos.x + len; //横坐标的结束位置

end1 = pos.y - len; //纵坐标的结束位置

for (int i = begin, j = begin1; (i + 4 <= end) && (j - 4 >= end1); ++i, --j)

{

if (_ChessBoard[i][j] == flag&&_ChessBoard[i + 1][j - 1] == flag&&

_ChessBoard[i + 2][j - 2] == flag&&_ChessBoard[i + 3][j - 3] == flag&&

_ChessBoard[i + 4][j - 4] == flag)

return 1;

}

for (int i = 1; i < N + 1; ++i) //棋盘有没有下满

{

for (int j =1; j < N + 1; ++j)

{

if (_ChessBoard[i][j] == ChessBoardflag)

return 0; //0表示棋盘没满

}

}

return -1; //和棋

}

bool GetVictory(Coordinate& pos, int player, int flag) //对JudgeVictory的一层封装，得到具体那个玩家获胜

{

int n = JudgeVictory(pos, flag); //判断有没有人获胜

if (n != 0) //有人获胜，0表示没有人获胜

{

PrintChessBoard();

if (n == 1) //有玩家赢棋

{

if (player == 0) //0表示电脑获胜，1表示玩家1,2表示玩家2

printf("***电脑获胜*** ");

else

printf("***恭喜玩家%d获胜*** ", player);

}

else

printf("***双方和棋*** ");

return true; //已经有人获胜

}

return false; //没有人获胜

}

private:

char _ChessBoard[N+1][N+1];

};

(4)程序员css五子棋扩展阅读：

设计思路

1、进行问题分析与设计，计划实现的功能为，开局选择人机或双人对战，确定之后比赛开始。

2、比赛结束后初始化棋盘，询问是否继续比赛或退出，后续可加入复盘、悔棋等功能。

3、整个过程中，涉及到了棋子和棋盘两种对象，同时要加上人机对弈时的AI对象，即涉及到三个对象。

⑸ 零基础，该怎么学习java

关于java怎么学？我的建议如下：

首先看一下java学习路线图，了解一下Java构成：

java学习步骤（方法）：

1、按阶段规划，时间留够，但一定要有互相催促的伙伴，否则会很孤独也难以坚持，伙伴得挑好了，别把你带歪了。

2、有了伙伴先学习HTML+CSS，做点网页出来，让自己心中对软件行业充满成就感，这样说培养自己的兴趣的一种，俗话说兴趣是最好的老师，没有兴趣走不远。

3、然后学习简单Java语法，写简单的流程控制语句，简单数据结构，当逻辑思维和数据结构达到一个3层循环都能搞清楚的水准的时候，马马虎虎可以进入下一步了

4、进入Java面向对象的学习，搞清楚类、对象，封装继承多态，内部类，对象的概念，然后进入常用集合和泛型以及集合的底层数据结构的学习

5、学习IO流，能够操作读取大文件，多线程，Socket编程，学完之后使用JavaSE的基础做一个五子棋游戏，或者QQ聊天，强化一下自己的知识。

6、进入数据库学习，先学习MySQL，较为简单常用，学完数据库，也可以看看Redis的使用

7、进入JavaWeb课程的学习，以Servlet+Jsp为主，还有tomcat和http基础，

8、学习JavaScritp+JQuery，结合JavaWeb做一个小的管理系统

9、进入JavaEE的学习，常用框架，主要是SpringMVC和Mybatis，学完之后试着去接触微服务架构

10、学习Linux操作，使用Linux部署tomcat进行环境搭建，跑一个简单的页面出来

11、SpringBoot可以进行了解学习，Oracle可以进行了解学习。

记得看视频看视频看视频啊！！！b站高淇讲得还不错，可以参考一下！

Java300集零基础适合初学者视频教程_Java300集零基础教程_Java初学入门视频

⑹ java游戏五子棋论文

<%@ page contentType="text/html;charset=utf-8"%>
<html>
<head>
<title>五子棋</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<style type="text/css">
body{ word-break:break-word;
}
#aboutstep{
position:absolute;
right:45px;
top:300px;
width:200px;
vertical-align:bottom;
}
</style>
<script language="javascript">
//五子棋棋子亦称“棋石”分黑、白两色，形状为扁圆形，有一面凸起或两面凸起等形状，厚度不超过0.8厘米，直径为2.0～2.3厘米；
//一副棋子总数为225枚，其中黑子113枚，白子112枚。
var presentperson=false; //true表示人先下,否则表示机器先下
//谁先只需要改为true或false就可以了,不需要改其它东西
var maxsize=15;
var personstep=0;
var machinestep=0;
var _stack=new Array();//needn't to allocate space
var chese=new Array(maxsize*maxsize);
var chesevalue=new Array(maxsize*maxsize);
for(var i=0;i<maxsize*maxsize;i++)//初始化棋盘
{ chese[i]=0;
}
</script>
</head>
<body onload="startup()">
<table id="chesetable" border="1px" width="auto" align="center" height="600px" style="background-color:#EED090;text-align:center;">
<%
for(int i=0;i<15;i++)
{out.print("<tr>");
for(int j=0;j<15;j++)
{out.print("<td onclick='putone(this,"+i+","+j+")' style='width:45px;height:45px;cursor:pointer;'></td>");
}
out.print("</tr>");
}
%>
</table>
<div id="aboutstep"><!-- 加计时器会降低速度，这里就不加了 -->
人<img src="images/white_.gif" alt="white" width="50px" height="50px" style="vertical-align:middle;"/><span id="aboutsteppeople" style="position:inline;">0</span>
<span style="display:inline;"><input type="text" id="peopleusedtime" size=4 maxlength="8" /></span>
<br />
机器<img src="images/black_.gif" alt="black" width="50px" height="50px" style="vertical-align:middle;"s/><span id="aboutstepmachine" style="position:inline;">0</span>
<span style="display:inline;"><input type="text" id="machineusedtime" size=4 maxlength="8" /></span>
</div>
<div align="center">
<input type="button" name="restart" value="重新开始" onclick="reload()"/><input type="button" name="turnout" value="交换顺序" />
<input type="button" name="undo" value="悔棋" onclick="popstack()"/>
</div>
<script language="JavaScript">
function startup()
{
if(!presentperson)//机器先下
{ var obj=document.getElementById("chesetable").rows[7].cells[7];
putone(obj,7,7);
}
}
function putone(obj,i,j)
{ //if(obj.firstChild.nodeValue=="◎"||obj.firstChild.nodeValue=="●")
if(obj.firstChild.nodeType==1) //表示放了棋子
{ return false;}

var node=null;
if(presentperson)
{ //node=document.createTextNode("◎"); //人的棋子颜色
if(document.uniqueID) //IE
node=document.createElement("<img src='images/white_.gif' alt='white' width='40px' height='40px' />");
else { //for Firefox,Opera
node=document.createElement("img");
node.setAttribute("src","images/white_.gif");
node.setAttribute("alt","white");
node.setAttribute("width","40px");
node.setAttribute("height","40px");
}
presentperson=!presentperson;
chese[maxsize*i+j]=1;
personstep++;
document.getElementById("aboutsteppeople").innerHTML=personstep;

}
else {//node=document.createTextNode("●"); //机器的棋子颜色
if(document.uniqueID) //IE
node=document.createElement("<img src='images/black_.gif' alt='black' width='40px' height='40px' />");
else { node=document.createElement("img");
node.setAttribute("src","images/black_.gif");
node.setAttribute("alt","black");
node.setAttribute("width","40px");
node.setAttribute("height","40px");
}presentperson=!presentperson;
chese[maxsize*i+j]=2;
machinestep++;
document.getElementById("aboutstepmachine").innerHTML=machinestep;
}
obj.replaceChild(node,obj.firstChild);
_stack.push(i);
_stack.push(j); //避免数据冗余，就不存储presentperson
var result=checkfinish(!presentperson,i,j);
if(result)
{ if(!presentperson) alert("Congratulation!You win.");
else alert("I am sorry that the machine wins,try your best to win next time.");
setTimeout(reload,4000); //刷新页面
}
if(!presentperson) {machinedecideposition();} //机器走。如果选择全部由人走就去掉这个
}
function checkfinish(presentperson,i,j)
{ //persentperson为true时表示刚才人下了一步
var checkword;
var result=false; //nobody wins
if(presentperson) checkword=1;
else checkword=2;
var total=1;
var tempj=j+1;
while(tempj<maxsize) //横
{ if(chese[maxsize*i+tempj]==checkword)
{total++; tempj++;}
else break;
}
tempj=j-1;
while(tempj>=0)
{ if(chese[maxsize*i+tempj]==checkword)
{total++; tempj--;}
else break;
}
if(total>4) { return true;}

total=1;
var tempi=i+1; //竖
while(tempi<maxsize)
{ if(chese[maxsize*tempi+j]==checkword)
{total++; tempi++;}
else break;
}
tempi=i-1;
while(tempi>=0)
{ if(chese[maxsize*tempi+j]==checkword)
{total++; tempi--;}
else break;
}
if(total>4) { return true;}

total=1;
tempi=i+1; //一三象限斜
tempj=j+1;
while(tempi<maxsize&&tempj<maxsize)
{ if(chese[maxsize*tempi+tempj]==checkword)
{total++; tempi++; tempj++;}
else break;
}

tempi=i-1;
tempj=j-1;
while(tempi>=0&&tempj>=0)
{ if(chese[maxsize*tempi+tempj]==checkword)
{total++; tempi--; tempj--;}
else break;
}
if(total>4) { return true;}

total=1;
tempi=i+1; //二四象限斜
tempj=j-1;
while(tempi<maxsize&&tempj>=0)
{ if(chese[maxsize*tempi+tempj]==checkword)
{total++; tempi++; tempj--;}
else break;
}
tempi=i-1;
tempj=j+1;
while(tempi>=0&&tempj<maxsize)
{ if(chese[maxsize*tempi+tempj]==checkword)
{total++; tempi--; tempj++;}
else break;
}
if(total>4) { return true;}
return false;
}
function pushstack()
{
}
function popstack() //悔棋
{
if(_stack.length/2<1) return;
//var ispresentperson=(_stack.length/2)%2?true:false;//这个跟谁先下有关
var ispresentperson=presentperson; //now it has not matter with the length of _stack
var j=_stack.pop();
var i=_stack.pop();
removeone(ispresentperson,i,j);

}
function removeone(ispresentperson,i,j)
{ var obj=document.getElementById("chesetable");
//text,tbody
var tbody=obj.firstChild.nextSibling;
tbody.rows[i].cells[j].innerHTML="";
chese[maxsize*i+j]=0; //也要初始化那个棋子所在的位置
presentperson=!presentperson;//也要回滚该谁走,who's turn now?
if(!ispresentperson) {personstep--;
document.getElementById("aboutsteppeople").innerHTML=personstep;
}
else {machinestep--;
document.getElementById("aboutstepmachine").innerHTML=machinestep;
}

}
function machinedecideposition() //机器决定下一步的位置
{ //在第一层节点选择的时候采用贪婪算法，直接找出相对分数比较高的几个形成第一层节点，目的是为了提高搜索速度和防止堆栈溢出。
if(machinestep==0) //机器走第一步
{ var obj=document.getElementById("chesetable").rows[7].cells[7];
if(putone(obj,7,7)==false)
{ obj=document.getElementById("chesetable").rows[6].cells[6];
putone(obj,6,6);
}
}
else if(machinestep==1) //机器走第二步
{ var obj=document.getElementById("chesetable").rows[7].cells[7];
if(putone(obj,7,7)==false) //7,7位置被占用
{ obj=document.getElementById("chesetable").rows[6].cells[6];
if(putone(obj,6,6)==false)//6,6位置被占用
{obj=document.getElementById("chesetable").rows[6].cells[7];
putone(obj,6,7);
}
}

}
else { var checkword=2; //先判断机器的，在设置为1判断这个位置对人的贡献
for(var tttt=0;tttt<maxsize*maxsize;tttt++)
chesevalue[tttt]=-10;//初始化
for(var i=0;i<maxsize;i++)
for(var j=0;j<maxsize;j++)
{ if(chese[maxsize*i+j]!=0) //the position is occupied
continue;

var total=1;
var tempj=j+1;
var spacenumber=0; //中间空多少个
var befive=0; //成5,包括五连和长连
var livefour=0; //活四，有两个点可以成5地四
var befour=0; //冲四，只有一个点可以成为5的四
var deadfour=0; //死四，不能成为5的四
var livethree=0; //活三，再走一步就可以成为活四的三
//活三包括 连活三和跳活三
var bethree=0;
var livetwo=0;
var betwo=0;
//三三，一子落下同时形成两个活三
//四四，一子落下同时形成两个冲四
//四三,一子落下同时形成一个冲四和 活三
for(var tt=0;;tt++)
{ if(tt==0)
checkword=2; //machine
else checkword=1; //people
while(tempj<maxsize) //横
{ if(chese[maxsize*i+tempj]==checkword&&checkword==2) //是机器的
{total++; tempj++;}
else if(chese[maxsize*i+tempj]==0&&checkword==2) //对于防守不考虑空格
{ //is empty
spacenumber++; break;
if((++tempj)<maxsize&&chese[maxsize*i+tempj]==checkword&&spacenumber<2)
total++;
else break;
}
else if(chese[maxsize*i+tempj]==checkword&&checkword==1) //防守
{ total++; tempj++;
}
else break;
}
var endj=tempj;
tempj=j-1;
while(tempj>=0)
{ if(chese[maxsize*i+tempj]==checkword&&checkword==2)
{total++; tempj--;}
else if(chese[maxsize*i+tempj]==0&&checkword==2)
{ //is empty
spacenumber++; break;
if((--tempj)>=0&&chese[maxsize*i+tempj]==checkword&&spacenumber<2)
total++;
else break;
}
else if(chese[maxsize*i+tempj]==checkword&&checkword==1) //防守
{ total++; tempj--;
}
else break;
}
var startj=tempj;
//由于checkword==2先运行，所以可以直接用befive=1,也可以用befive++;
if(total>4) { //能组成五个或以上的
if(checkword==2)
{befive+=2
} //堵住成五
else befive++;
}//进攻要大于防守
else if(total==4) { //能组成四个
if(checkword==2) //表示考虑进攻
{ if(startj>=0&&endj<maxsize&&chese[maxsize*i+startj]!=1&&chese[maxsize*i+endj]!=1) //两边为空格
livefour+=2; //放在这里可以形成一个活四
else if((startj>=0&&chese[maxsize*i+startj]!=1)||(endj<maxsize&&chese[maxsize*i+endj]!=1))
befour+=2; //形成一个冲四
else deadfour+=2;
}
else //考虑防守
{ if(startj>=0&&endj<maxsize&&chese[maxsize*i+startj]!=2&&chese[maxsize*i+endj]!=2)
livefour+=1; //放在这里可以形成一个活四
else if((startj>=0&&chese[maxsize*i+startj]!=2)||(endj<maxsize&&chese[maxsize*i+endj]!=2))
befour+=1; //形成一个冲四
else deadfour+=1;

}
}
else if(total==3){if(checkword==2) //表示考虑进攻
{ if(startj>=0&&endj<maxsize&&chese[maxsize*i+startj]!=1&&chese[maxsize*i+endj]!=1) //两边为空格
livethree+=2; //放在这里可以形成一个活三(算做连活三)
else if((startj>=0&&chese[maxsize*i+startj]!=1)||(endj<maxsize&&chese[maxsize*i+endj]!=1))
bethree+=2; //形成一个眠三，即可以冲四的三
// else deadfour+=2;
//跳三
}
else //考虑防守
{ if(startj>=0&&endj<maxsize&&chese[maxsize*i+startj]!=2&&chese[maxsize*i+endj]!=2) //两边为空格
livethree+=1; //放在这里可以形成一个活三(算做连活三)
else if((startj>=0&&chese[maxsize*i+startj]!=2)||(endj<maxsize&&chese[maxsize*i+endj]!=2))
bethree+=1; //形成一个眠三，即可以冲四的三
}
}
else if(total==2){ if(checkword==2) //表示考虑进攻
{ if(startj>=0&&endj<maxsize&&chese[maxsize*i+startj]!=1&&chese[maxsize*i+endj]!=1) //两边为空格
livetwo++; //放在这里可以形成一个活三(算做连活三)
}
else //考虑防守
{ if(startj>=0&&endj<maxsize&&chese[maxsize*i+startj]!=2&&chese[maxsize*i+endj]!=2) //两边为空格
livetwo++; //放在这里可以形成一个活三(算做连活三)

}
}

⑺ 什么样的编程水平可以编写五子棋、象棋程序

针对问题补充部分：

如果这个程序是人人对战的，那和人工智能完全没有关系。

但是如果你要编写一个带机器人可以人机对弈的程序，那这个机器人的设计就是人工智能了。这个难度会大出数倍的（五子棋可能好一些）。不过也有人因为编写了战胜世界冠军的战棋类机器人而出名过（当然他们用的硬件也很强），如果楼主能编出来这种程序，估计就可以商用往外卖了。

人工智能里面要学的东西很多，从理论框架到具体的机器学习算法（这个算法和ACM里面的简单算法完全是两回事）。如果楼主不是这个专业的， 而编写这种程序更多的是为了练习编程，那么还是建议不要涉猎人机对战的部分了。

如果真的感兴趣，建议等真的有很多时间可以开发个带机器人的2.0版本来（楼主要真能写出来，加我好友吧，我们可以互相交流一下，哈哈，主要是我向你学习一下）

=========================
我有个同学以前编过一个。自己曾经也试图编扫雷，写了一半最后还是放弃了。。。

编程水平的话，首先要有基本的语言知识，能够相对熟练地编写百行以上的程序吧。

当然上面的要求太基础了，要编这种棋类程序还需要两点技巧：

1. 可视化编程，比如c++的话就需要熟悉win32编程或者MFC编程。这样才能让程序可以看到，并且视窗交互。（我也见过一个cmd版本的五子棋，很惊叹，不过样子就不好看了）

2. 复杂逻辑的处理。无论是五子棋和象棋，都有自己的规则。这些规则人描述起来都比较麻烦，要正确的反应到程序中，就需要维护很多状态信息，加入很多判断函数（比如是否已经获胜、走法是否合法、等等）。如果你可视化编程已经没有问题，你会发现这部分逻辑设计难度是远远大于语言本身的。

如果以上两点都可以克服的话，这种程序是可以编出来的。楼主加油吧。

⑻ 五子棋-人人对战

五子棋是国内受到普遍欢迎的一款游戏，规则简单，趣味不俗。作为一名程序员，自然也希望将它移植到电脑上。

这篇我们要讲的主要就是实现简单的人人对战，AI算法放到以后单独说。

我指丛们先来整理一下脉络，看看实现五子棋需要哪些内容：

棋盘的绘制应该是十分简单，就不多说了，画成什么样就看自己的心情。当然，为了使用起来更加，我们可以加上开始游戏、悔棋、认输等按钮，按钮的监听我之前的文章也有讲过，不清楚的欢迎大家去看一下。其中，为了更合理一点，在开始游戏之前显然是不能悔棋和认输的，所以我们需要在开始游戏按钮按下之前将这两个按钮设置为无法使用，调用 setEnabled 方法就可以实现，需要一个参数，类型为布尔。

按钮的监听我们添加在 actionPerformed 方法（使用这个方法需要添加 ActionListener 接口）里，通过 e.getActionCommand 来获得按钮的名字来判断是哪个按钮，实现相应的功能。而落子的监听我们通过 mousePressed 、 mouseReleased 或 mouseClicked 来实现（需要继承 MouseAdapter 类或者添加 MouseListener 接口）。

其中 mouseClicked 不推荐使用，因为不好界定click的时间，本身似乎也有些问题，有些时候会监听不到，而前两个则没有上述问题。我则选择了 mousePressed 。

棋盘已经绘制完成，而五子棋的子下在棋盘线的交点处，为了棋盘的公整，应当将棋下在交点上，这只需要简单的数学计算就可以算出来，至于棋子长什么样，大家自己动手。

棋子已经能画出来了，但这显然是不够的，因为之后还有胜负判断，人可以一眼看到棋盘上子落在何处，计算机可不行，我们得用容器将棋子落下的位置保存下来，一个 二维数组 即可（0表示空，1表示黑子，2表示白子，当然其他方法也可以）。此外如果我们还要添加悔棋功能，那么仅保存棋子落下的位置是完全不够的，我们需要知道落子的先后顺序，所以我们应当选择使用有序容器。这里我选择了 Vector ，当然其他有序容器也都可以，自己选择。

为了储存和之后的操作方便，我们把棋子的位置（x和y）用一个类来保存，这个类十分简单，只需要两个 int 即可。这里，我储存的x和y并非是棋子在棋盘上的绝对位置，而是棋子的序号（0-14），这样的好处是在中间使用的时候十分清楚，并且如果要改变棋盘的大小等属性，只需要在绘画时更改公式即可唯档樱，中间过程一概不用动。

到这里，落子的监听基本就完成了，总结一下：

最后这一部分非常简单，只需要在每次落子之后判断一下是否达成五子即可。又因为五子棋规则简单，在落子之后棋子的位置不会再发生变化，所以只需要判断落子点是否会形成五子就可以，没必要每次都遍历全局。五子棋共有8个方向，但是形成连子其实只有四条直线，所以只需要判断四次。

先往上再往下，遇到异色子或者边界就停下，每个同色自给计数变量+1，加上自身含有5个即可达成胜利。这里基本不会遇到什么问题，只要细心判断边界，保证下标蠢伍不越界就不会有任何问题。

上述三个部分完成， 五子棋-人人对战 基本就完成了，但是重绘是每次绘图都会遇到的问题，在这里就提醒一下不要忘记重绘，不懂重绘的可以去搜索一下关于重绘的文章，本身并不是很难。

个人博客： https://wilfredshen.cn/

⑼ 求mac版中国象棋，五子棋下载地址

<%@ page contentType="text/html;charset=gb2312" language="java" %>
<html>
<head>
<title>中国象棋<桐穗/title>
<link rel="stylesheet" type="text/css" href="CSS/StyleChess.css"/>
<style type="text/css">
.chessstyle{
width:52px;
height:53px;
margin-left:4px;
margin-top:4px;
cursor:pointer;
display:inline;
text-align:center;
position:relative;
visibility:visible;
/*border:1px solid #00ff00;*/
}
.chessselected{
width:52px;
height:53px;
margin-left:4px;
margin-top:4px;
display:inline;
text-align:center;
position:relative;
background-image:url(image/select.png);
}
.button1 {
color:#003366;
font-size:14px;
font-weight:bold;
border-top:1px #CCC solid;
border-left:1px #CCC solid;
border-right:1px #CCC solid;
border-bottom:3px #CCC solid;
padding:2px 6px;
text-align:center;
background:#990000;
}
</style>
顷拦</head>
<body style="margin:0px;padding:0px;" onload="startup2()">
<div id="qipan1" style="width:509px;height:575px;border:0px solid;background:url(image/center.jpg);background-repeat:no-repeat;margin-left:350px;">
<% for(int i=0;i<10;i++)
for(int j=0;j<9;j++)
{ out.print("<div class='chessstyle' id='"+(i*9+j)+"' types='block' onclick='getchess(this)' onblur='backtonormal(this)'>");
// out.print(i*9+j);
out.print("</div>");
}
%>
</div>
<div style="text-align:center">
<input type="button" value="重新开始" class="button1" onclick="reload()"/>
<input type="button" value="悔棋" class="button1" onclick="undo()"/>
</div>
<script language="javascript">
var from=-1;
var to=-1;
var _stack=new Array();
var redturn=true;//now it is the red's turn ,也表示红方开始下
function $(s)
{ return document.getElementById(s);
}
function reload()
{ document.location.reload();
}
function undo()
{ if(_stack.length<4) return false;
var toid=_stack.pop();
var fromid=_stack.pop();
var topos=_stack.pop();
var frompos=_stack.pop();
//alert(toid+" "局乎卜+fromid+" "+topos+" "+frompos);
if(toid==-1)
{ /*alert($(topos).childNodes.length);
alert($(topos).removeChild($(topos).firstChild)); //innerHTML="";
var chessimg="image/"+fromid.substr(0,fromid.length-1)+".gif";
alert(chessimg);
draw(chessimg,true,frompos,fromid);
alrt("dd");
$(frompos).appendChild($(topos).firstChild);
*/
$(frompos).appendChild($(topos).firstChild);
}
else{ var chessimg="image/"+fromid.substr(0,fromid.length-1)+".gif";
draw(chessimg,true,frompos,fromid);
$(topos).innerHTML="";
chessimg="image/"+toid.substr(0,toid.length-1)+".gif";
draw(chessimg,true,topos,toid);
}
redturn=!redturn; //回滚由谁走
}
function draw(chessimg,booleanvalue,position,imageid)
{ //棋的图片，表示黑棋还是白棋，棋放的位置，棋的ID(用来唯一标识某个棋,通过前面的r/b来快速判断是红棋还是黑棋)
var obj=$(position);
var img=null;
if(document.uniqueID)
{ img=document.createElement("<img src='"+chessimg+"' width='45px' height='45px' alt='' id='"+imageid+"' style='vertical-align:bottom;'/>");
//vertical-align:bottom;很重要，删除了就更对不齐了
// align='center' valign='middle' style='vertical-align:middle;margin-top:0px;margin-left;0px;'
}
else { img=document.createElement("img");
img.setAttribute("src",chessimg);
img.setAttribute("width","45px");
img.setAttribute("height","45px");
img.setAttribute("alt"," ");
img.setAttribute("id",imageid);
img.setAttribute("align","center");
img.setAttribute("style","vertical-align:middle;");
//img.style.verticalAlign="middle";
//alert(position);
//alert(obj.childNodes.length);
}

obj.appendChild(img);

}
function startup2()
{
var qipan = document.getElementById("qipan1");
/* for(var t=0;t<qipan.attributes.length;t++)
alert(qipan.attributes[t].nodeName+" "+qipan.attributes[t].nodeValue);
*/
init();
}
function getchess(obj)
{ //alert(obj.childNodes.length);
if(obj.childNodes.length==1) //是标签img
{
if(redturn) //红方下的时候
{ if(obj.firstChild.id.charAt(0)=='r')//轮到红棋下的时候选择的是红棋
{obj.className="chessselected";
from=obj.id;
}
else if(obj.firstChild.id.charAt(0)=='b'&&from>=0)//轮到红棋下的时候选择的是黑棋
{
to=obj.id;
if(checkok(from,to))
{obj.className="chessselected";
_stack.push(from,to,$(from).firstChild.id,$(to).firstChild.id);
eatchess(from,to);
}
}
}
else { if(obj.firstChild.id.charAt(0)=='b')//轮到黑棋下的时候选择的是红黑棋
{ from=obj.id;
obj.className="chessselected";
}
else if(obj.firstChild.id.charAt(0)=='r'&&from>=0)//轮到黑棋下的时候选择的是红棋
{
to=obj.id;
if(checkok(from,to))
{ obj.className="chessselected";
// alert($(from).firstChild.id);
_stack.push(from,to,$(from).firstChild.id,$(to).firstChild.id);
eatchess(from,to);

}
}
}
}//end of 'img'
else {
if(from==-1) //还没有选择过棋子
return;
else { if(checkok(from,obj.id))
{ //alert(obj.firstChild);
_stack.push(from,obj.id,$(from).firstChild.id,-1);
movechess(from,obj.id);
obj.className="chessselected";

}
} //选择了空白位置就表示移动
}
}
function backtonormal(obj)
{ obj.className='chessstyle';
}
function eatchess(from1,to1)
{ //alert("eat");
var fromobj=$(from1);
var toobj= $(to1);
if(toobj.firstChild.id.indexOf("shuai")!=-1||toobj.firstChild.id.indexOf("jiang")!=-1)
{ if(redturn) alert("红方胜");
else alert("黑方胜");
setTimeout(reload,4000);
}
toobj.replaceChild(fromobj.firstChild,toobj.firstChild);
from=-1; //吃完了后初始化要移动的棋的位置
to=-1;
redturn=!redturn;
}
function checkok(from1,to1)
{ var toobj=$(to1);
var fromobj=$(from1);
var parentobj=$("")
var str=fromobj.firstChild.id; //检查是否符合该棋的 rule,不符合返回false;
if(-1!=str.indexOf("ju")) //走车
{ if(Math.floor(from1/9)==Math.floor(to1/9)) //同一行走车
{ var start=from1<to1?from1:to1;
var end=from1>to1?from1:to1;
for(var t=eval(start)+1;t<end;t++)
{ if($(t).childNodes.length>=1) return false; //中间有其它棋子，不能走
}
}
else if(from1%9==to1%9) //同一列走车
{ var start=Math.floor((from1<to1?from1:to1)/9);
var end=Math.floor((from1>to1?from1:to1)/9);

for(var t=start+1;t<end;t++)
{ if($((t*9+to1%9)).childNodes.length>=1) return false;
}
}
else return false;//其它情况就算不符合
}
else if(-1!=str.indexOf("ma")) //走马观花
{ var rowdec=Math.floor(from1/9)-Math.floor(to1/9);
var linedec=from1%9-to1%9;
//alert(rowdec+" "+linedec);
if(rowdec==2) //60,120 degree
{ if($((from1-9)).childNodes.length>=1) return false;
if(!(linedec==1||linedec==-1)) return false;
}
else if(rowdec==-2) //240,300 degree
{ if($((eval(from1)+9)).childNodes.length>=1){ return false;}
if(!(linedec==1||linedec==-1)) return false;
}
else if(rowdec==1)
{ if(linedec==-2) //30 degree
{ if($((eval(from1)+1)).childNodes.length>=1) return false;
}
else if(linedec==2)//150 degree
{ if($((from1-1)).childNodes.length>=1) return false;
}
else return false;
}
else if(rowdec==-1)
{ if(linedec==-2) //330 degree
{ if($((eval(from1)+1)).childNodes.length>=1) return false;
}
else if(linedec==2)//210 degree
{ if($((from1-1)).childNodes.length>=1) return false;
}
else return false;
}
else return false;
}
else if(-1!=str.indexOf("xiang")) //走象
{ var rowdec=Math.floor(from1/9)-Math.floor(to1/9);
var linedec=from1%9-to1%9;

if(Math.abs(rowdec)==2&&Math.abs(linedec)==2)
{ if(redturn&&(eval(to1)>45)) //红棋走的时候走过界了
return false;
else if((redturn==false)&&(eval(to1)<45)) //黑棋走的时候走过界了
return false;
}
else return false;

}
else if(-1!=str.indexOf("shi")) //走士
{ var rowdec=Math.floor(from1/9)-Math.floor(to1/9);
var linedec=from1%9-to1%9;
if((Math.abs(rowdec)==1)&&(Math.abs(linedec)==1))
{ if(redturn)
{ if((Math.floor(to1/9)>2)||(to1%9<3)||(to1%9>5)) return false; //红方过界
}
else {
if((Math.floor(to1/9)<7)||(to1%9<3)||(to1%9>5)) return false; //黑方过界
}
}
else return false;
}
else if(-1!=str.indexOf("pao")) //走炮
{ var middlechess=0; //中间的棋子的个数
var middlered=true; //标示中间的棋子是红色的
if(Math.floor(from1/9)==Math.floor(to1/9)) //同一行走炮
{ var start=from1<to1?from1:to1;
var end=from1>to1?from1:to1;
for(var t=eval(start)+1;t<end;t++)
{ if($(t).childNodes.length>=1){ middlechess++;
}
}
}
else if(from1%9==to1%9) //同一列走炮
{ var start=Math.floor((from1<to1?from1:to1)/9);
var end=Math.floor((from1>to1?from1:to1)/9);
// alert(start+" "+end);
for(var t=start+1;t<end;t++)
{ if($((t*9+to1%9)).childNodes.length>=1){ middlechess++;
/* if($((t*9+to1%9)).firstChild.id.charAt(0)=='r')
middlered=true;
else middlered=false; */
}
}
}
else return false;//其它情况就算不符合
// alert(middlechess+" "+redturn+" "+middlered);
if(middlechess==1)
{ if(toobj.childNodes.length==0) return false; //吃的时候不能是空白区
}
else if(middlechess==0) //移动到的地方要为空白区
{ if(toobj.childNodes.length>=1) return false;
}
else return false;
}
else if(-1!=str.indexOf("zu")) //走卒
{ if(redturn) //红棋走卒
{ if(Math.abs(to1-from1)==1&&(Math.floor(to1/9)==Math.floor(from1/9))&&(Math.floor(to1/9)>=5)) //走同一行
return true;
else if((to1-from1)==9) //走同一列
return true;
else return false;
}
else{ if(Math.abs(to1-from1)==1&&(Math.floor(to1/9)==Math.floor(from1/9))&&(Math.floor(to1/9)<5)) //走同一行
return true;
else if((to1-from1)==-9) //走同一列
return true;
else return false;
}
}
else if((-1!=str.indexOf("shuai"))||(-1!=str.indexOf("jiang"))) //走帅
{ var rowdec=Math.floor(from1/9)-Math.floor(to1/9);
var linedec=from1%9-to1%9;
if(rowdec==1||rowdec==-1)//走列
{ if(linedec!=0) return false;
if(redturn)
{ if(Math.floor(to1/9)>2||to1<0) return false;
}
else{ if(Math.floor(to1/9)<7) return false;
}
}
else if(linedec==1||linedec==-1)//走行
{ if(rowdec!=0) return false;
if((to1%9<3)||(to1%9>5)) return false;
}
else { var start=Math.floor((from1<to1?from1:to1)/9);
var end=Math.floor((from1>to1?from1:to1)/9);
if(($(to1).firstChild.id.indexOf("shuai")!=-1)||($(to1).firstChild.id.indexOf("jiang")!=-1))
{ for(var t=start+1;t<end;t++) //直接可以吃帅
{ if($((t*9+to1%9)).childNodes.length>=1) return false;
}
}
else return false;
}
}
else return false;
return true;
}
function movechess(from1,to1)
{
var toobj=$(to1);
var fromobj=$(from1);
//if(checkok==false) return false; //检查是否符合该棋的 rule,不符合返回false;
toobj.appendChild(fromobj.firstChild);
from=-1; //移动后初始化要移动的棋的位置
to=-1;
redturn=!redturn;
return true;
}
function init()
{ draw("image/rju.gif",true,0,"rju1"); //上面放红的
draw("image/rma.gif",true,1,"rma1");
draw("image/rxiang.gif",true,2,"rxiang1");
draw("image/rshi.gif",true,3,"rshi1");
draw("image/rshuai.gif",true,4,"rshuai");
draw("image/rshi.gif",true,5,"rshi2");
draw("image/rxiang.gif",true,6,"rxiang2");
draw("image/rma.gif",true,7,"rma2");
draw("image/rju.gif",true,8,"rju2");
draw("image/rpao.gif",true,19,"rpao1");
draw("image/rpao.gif",true,25,"rpao2");
draw("image/rzu.gif",true,27,"rzu1");
draw("image/rzu.gif",true,29,"rzu2");
draw("image/rzu.gif",true,31,"rzu3");
draw("image/rzu.gif",true,33,"rzu4");
draw("image/rzu.gif",true,35,"rzu5");

draw("image/bzu.gif",false,54,"bzu1"); //棋盘的下方放黑棋
draw("image/bzu.gif",false,56,"bzu2");
draw("image/bzu.gif",false,58,"bzu3");
draw("image/bzu.gif",false,60,"bzu4");
draw("image/bzu.gif",false,62,"bzu5");
draw("image/bpao.gif",false,64,"bpao1");
draw("image/bpao.gif",false,70,"bpao2");
draw("image/bju.gif",false,81,"bju1");
draw("image/bma.gif",false,82,"bma1");
draw("image/bxiang.gif",false,83,"bxiang1");
draw("image/bshi.gif",false,84,"bshi1");
draw("image/bjiang.gif",false,85,"bjiang");
draw("image/bshi.gif",false,86,"bshi2");
draw("image/bxiang.gif",false,87,"bxiang2");
draw("image/bma.gif",false,88,"bma2");
draw("image/bju.gif",false,89,"bju2");

}
</script>
</html>

⑽ 如何学习JAVA

如何学习java？

在这里我来为您提供一下Java学习的详细路线：

这是Java全套系列的学习思维导图：Java学习思维导图

高琪老师是我校着名的Java讲师，其课程也是受到广大初学者所喜爱；

如果有的小伙伴想要学Java编程，可以在下方评论领取视频！有最新的Java课程；

那么现在来说一下，Java编程初学者应该如何快速入门：

1、按阶段规划，时间留够，但一定要有互相催促的伙伴，否则会很孤独也难以坚持，伙伴得挑好了，别把你带歪了。

2、有了伙伴先学习HTML+CSS，做点网页出来，让自己心中对软件行业充满成就感，这样说培养自己的兴趣的一种，俗话说兴趣是最好的老师，没有兴趣走不远。

3、然后学习简单Java语法，写简单的流程控制语句，简单数据结构，当逻辑思维和数据结构达到一个3层循环都能搞清楚的水准的时候，马马虎虎可以进入下一步了

4、进入Java面向对象的学习，搞清楚类、对象，封装继承多态，内部类，对象的概念，然后进入常用集合和泛型以及集合的底层数据结构的学习

5、学习IO流，能够操作读取大文件，多线程，Socket编程，学完之后使用JavaSE的基础做一个五子棋游戏，或者QQ聊天，强化一下自己的知识。

6、进入数据库学习，先学习MySQL，较为简单常用，学完数据库，也可以看看Redis的使用

7、进入JavaWeb课程的学习，以Servlet+Jsp为主，还有tomcat和http基础，

8、学习JavaScritp+JQuery，结合JavaWeb做一个小的管理系统

9、进入JavaEE的学习，常用框架，主要是SpringMVC和Mybatis，学完之后试着去接触微服务架构

10、学习Linux操作，使用Linux部署tomcat进行环境搭建，跑一个简单的页面出来

11、SpringBoot可以进行了解学习，Oracle可以进行了解学习。

最后：最上方详细的学习线路图，对比话术更加详细，希望可以帮助到你们