其实这篇学习总结应该早就要写的，但是对技术博客确实把握的不到位，总觉得语言不够生动，表达也略显牵强，除了贴几行代码，中间的技术点就透漏的不太多了，经过一个多月的沉沦之后，这篇本来要被毙掉的心得又被我拿出来炒一炒剩饭了。(源代码已在下面分享)
老师曾说过，学习还真的不是越学越进步的，现在回头想想，之前所熟练的知识现在还真的慢慢的生疏起来了，我们在公司学习了如何制作java五子棋，经过反反复复的锤磨打炼，我也算是好汉一条了，但是之前由于不够自信就一直在找借口不给自己寻找问题，就像老师说的，我们看到身边有越来越多的牛人，相反我们却变得更加懒惰了。
这个问题是我女朋友留给我的，我在去公司学习了不到一个月java的时间里，就大言不谗的答应她：“寒假我写个游戏给你玩。”新手都是这样的，我们在成长的过程中，最奇怪的事情就是，明明比以前要厉害了，胆子却越来越小了，只有小时候是什么都不怕的。作为一个新手，刚写了一个登陆界面就说自己要写一个QQ程序，路漫漫其修远兮，绝知此事要躬行（PS：这句话是出自两首诗哦）。
刚一开始也没有什么想法，看了下书上有一章介绍连连看的，心里想着，女生一般都比较喜欢玩连连看（我曾经就与她一起在网吧玩了两个多小时的连连看），心里不经的也乐了一下，不过在那天玩五子棋的时候，突然间想起了很小的时候在妈妈手机上玩的一款游戏，依稀的还记得名字好像是，没错，是黑白棋，在百度上面一搜索，还真的有,下面百科一下。
黑白棋，又叫Othello棋，反棋（Reversi）、苹果棋或翻转棋，借用莎士比亚名剧奥赛罗为其重命名。
下子的方法：
把自己颜色的棋子放在空格上，当上下左右或者斜方向上有一个自己的棋子时，夹在中间的棋子都会翻转变成自己的棋子，并且，只有可以翻转的地方才能下棋子。
棋盘如图所示：
起初觉得这游戏跟五子棋应该差不了多少，反正都是黑白色的，熟不知，同样的包装下，却是不一样的内核，就像你去商店买一个蛋黄派，包装上面明明说好了两个的，结果打开一看，却有四个。好的，闲话就不扯这么多了，下面分享一下人人对战的代码，由于是专门为女朋友准备的，所以界面也做了很大的改革哦，代码有点长，解释我尽量的添加详细了，中间被注释掉的内容是当初建模的时候用的，大家有兴趣的慢慢的看一下吧,如有错误，还请指点：
以下是界面类：
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
@SuppressWarnings("serial")
public class Chess extends JFrame {
public static void main(String args[]){
Chess ch=new Chess();
ch.showframe();
}
//显示游戏界面
public void showframe(){
//--------------------游戏界面----------------------
JPanel gamejp=new JPanel();
//--------------------组件界面----------------------
JPanel buttonjp=new JPanel();
//按钮图标
ImageIcon ali=new ImageIcon("image/阿狸.jpg");
ImageIcon taozi=new ImageIcon("image/桃子.jpg");
ImageIcon ali1=new ImageIcon("image/阿狸1.jpg");
ImageIcon taozi1=new ImageIcon("image/桃子1.jpg");
JButton alibu=new JButton(ali);
JButton taozibu=new JButton(taozi);
alibu.setRolloverIcon(ali1);
taozibu.setRolloverIcon(taozi1);
alibu.setPressedIcon(ali1);
taozibu.setPressedIcon(taozi1);
Dimension di=new Dimension(100,100);
alibu.setPreferredSize(di);
taozibu.setPreferredSize(di);
//-----------------------当前下棋的人---------------------
final JLabel jilu=new JLabel(" 阿狸下 ");
//设置字体
Font jilufont=new Font("黑体",Font.BOLD,30);
jilu.setFont(jilufont);
//用来记录阿狸与桃子的数目
final JLabel alila=new JLabel("2");
final JLabel taozila=new JLabel("2");
//设置Label的字体和大小
Font font=new Font("宋体",Font.BOLD,42);
alila.setFont(font);
taozila.setFont(font);
//-----------------重新开局的方法------------------
ImageIcon img=new ImageIcon("image/restart.jpg");
JButton bu=new JButton(img);
bu.setPreferredSize(new Dimension(100,40));
buttonjp.add(jilu);
buttonjp.add(alibu);
buttonjp.add(alila);
buttonjp.add(taozibu);
buttonjp.add(taozila);
buttonjp.add(bu);
this.setLayout(new GridLayout(1,2,600,0));
this.add(gamejp);
this.add(buttonjp);
this.setTitle("阿狸&桃子");
this.setSize(1000,650);
this.setResizable(false);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(3);
//显示窗口
this.setVisible(true);
//获取画布权限
Graphics g=this.getGraphics();
chess[3][3]=1;
chess[4][4]=1;
chess[3][4]=-1;
chess[4][3]=-1;
ChessListener lis=new ChessListener(g,this,jilu,alila,taozila);
this.addMouseListener(lis);
//按钮监听器----------------重新开始
ActionListener bulis=new ActionListener(){
public void actionPerformed(ActionEvent e){
clear();
//重绘的方法
repaint();
//绘制初始的四个图片
chess[3][3]=1;
chess[4][4]=1;
chess[3][4]=-1;
chess[4][3]=-1;
//将状态改为初始状态
ChessListener.stata=1;
jilu.setText(" 阿狸下 ");
alila.setText("2");
taozila.setText("2");
}
};
//如果点击阿狸则阿狸下
ActionListener alilis=new ActionListener(){
public void actionPerformed(ActionEvent e){
ChessListener.stata=1;
jilu.setText(" 阿狸下 ");
}
};
//如果点击桃子则桃子下
ActionListener taozilis=new ActionListener(){
public void actionPerformed(ActionEvent e){
ChessListener.stata=-1;
jilu.setText(" 桃子下 ");
}
};
alibu.addActionListener(alilis);
taozibu.addActionListener(taozilis);
bu.addActionListener(bulis);
}
/**
* 清空棋盘的方法
*/
public void clear(){
for(int i=0;i<chess.length;i++){
for(int j=0;j<chess[i].length;j++){
chess[i][j]=0;
}
}
}
/**
* 重写父类的paint方法
*/
public void paint(Graphics g){
super.paint(g);
Image back=new ImageIcon("image/棋盘.jpg").getImage();
g.drawImage(back, 10,30,800,600, null);
//重绘棋盘
//划横线
// for(int i=0;i<rows;i++){
// g.setColor(Color.BLUE);
// g.drawLine(x,y+i*size,x+size*(rows-1,y+i*size);
// }
// //划竖线
// for(int j=0;j<cols;j++){
// g.setColor(Color.BLUE);
// g.drawLine(x+j*size,y,x+j*size,y+size*(cols-1));
// }
//绘制棋子
for(int i=0;i<rows-1;i++){
for(int j=0;j<cols-1;j++){
int X=x+size/2+size*i;//棋子的横坐标
int Y=y+size/2+size*j;//棋子的纵坐标
if(chess[i][j]==1){
//画黑棋
Image b=new ImageIcon("image/ali.jpg").getImage();
g.drawImage(b, X-Chess_size/2, Y-Chess_size/2, Chess_size, Chess_size, null);
//g.fillOval(X-size/2,Y-size/2,Chess_size,Chess_size);
}
else if(chess[i][j]==-1){
//画白棋
Image w=new ImageIcon("image/taozi.jpg").getImage();
g.drawImage(w, X-Chess_size/2, Y-Chess_size/2, Chess_size, Chess_size, null);
//g.fillOval(X-size/2,Y-size/2,Chess_size,Chess_size);
}
}
}
}
public final static int x=79; //棋盘初始点横坐标
public final static int y=83; //棋盘初始点纵坐标
public final static int rows=9; //棋盘行数
public final static int cols=9; //棋盘列数
public final static int size=61;//棋盘格子大小
public final static int Chess_size=56;//棋子大小
public final static int chess[][]=new int[rows-1][cols-1];//定义一个8*8的数组，用来保存棋子
}
下面监听类，主要方法都在这里面：
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
public class ChessListener extends MouseAdapter{
private Graphics g; //将画布对象传过来
private int xiafa; //记录当前棋子的下法
public static int stata=1;//判断下黑棋还是白棋（黑棋阿狸，白棋桃子）
private int x1,y1; //记录点击处的横坐标和纵坐标
private JLabel jilu; //当前下棋子的人
private JLabel alila; //阿狸棋子数
private JLabel taozila; //桃子棋子数
private Chess ch; //用来刷新棋盘
private int te=0; //特殊情况
private int change; //记录改变的棋子数目
public ChessListener(Graphics g,Chess ch,JLabel jilu,JLabel alila,JLabel taozila){
this.g=g;
this.ch=ch;
this.jilu=jilu;
this.alila=alila;
this.taozila=taozila;
}
//点击下棋子
public void mouseClicked(MouseEvent e){
int a=1; //记录所下的子
String s = null;
x1=e.getX();
y1=e.getY();
for(int i=0;i<Chess.rows-1;i++){
for(int j=0;j<Chess.cols-1;j++){
int x2=Chess.x+Chess.size/2+Chess.size*i;//得到棋盘中棋子所在点的横坐标
int y2=Chess.y+Chess.size/2+Chess.size*j;//得到棋盘中棋子所在点的纵坐标
//将棋子下在棋盘格子的正中央
if(Math.abs(x1-x2)<Chess.size/3&&Math.abs(y1-y2)<Chess.size/3){
if(Chess.chess[i][j]==0){
if(stata==1){
//Image b=new ImageIcon("image/ali.jpg").getImage();
//g.drawImage(b, x2-Chess.Chess_size/2, y2-Chess.Chess_size/2, Chess.Chess_size, Chess.Chess_size, null);
//g.setColor(Color.BLACK);
stata=-1;
}
else if(stata==-1){
//Image w=new ImageIcon("image/ali.jpg").getImage();
//g.drawImage(w, x2-Chess.Chess_size/2, y2-Chess.Chess_size/2, Chess.Chess_size, Chess.Chess_size, null);
//g.setColor(Color.WHITE);
stata=1;
}
Chess.chess[i][j]=-stata;//将棋子存入棋盘
//g.fillOval(x2-Chess.size/2, y2-Chess.size/2, Chess.Chess_size, Chess.Chess_size);
//--------------如果8个方向都不能改变棋子则不改变棋盘状态--------------
if (hengYou(i, j) == null && hengZuo(i, j) == null
&& hengShang(i, j) == null
&& hengXia(i, j) == null
&& xieyouS(i, j) == null
&& xieyouX(i, j) == null
&& xiezuoS(i, j) == null
&& xiezuoX(i, j) == null){
Chess.chess[i][j]=0;
if(stata==1){
stata=-1;
}
else if(stata==-1){
stata=1;
}
//刷新棋盘
ch.update(g);
JOptionPane.showMessageDialog(null, "不能放子");
}
else{
// 改变中间子颜色
hengYou1(i, j);
hengZuo1(i, j);
hengShang1(i, j);
hengXia1(i, j);
xieyou1(i, j);
xieyou2(i, j);
xiezuo1(i, j);
xiezuo2(i, j);
// 以坐标为圆心画圆
//g.fillOval(x2-Chess.size/2, y2-Chess.size/2, Chess.Chess_size, Chess.Chess_size);
//g.setColor(Color.BLACK);
ch.update(g);
//改变棋子记录框里面的数字
alila.setText(judge()[0]+"");
taozila.setText(judge()[1]+"");
System.out.println("改变了"+change+"个子");
change=0;
//判断当前下棋的人
if(stata==1){
jilu.setText(" 阿狸下 ");
a=1;
s="阿狸";
}
else if(stata==-1){
jilu.setText(" 桃子下 ");
a=-1;
s="桃子";
}
xiafa=Check(a);
//输出当前下棋的人还有几种下法
System.out.println(s+"有"+xiafa+"种下法");
if(xiafa==0&&full()==false){//如果不能下子并且棋盘未满
te++;
JOptionPane.showMessageDialog(null, s+"不能下子，跳过!");
if(stata==1){//如果阿狸不能下子则跳过，桃子下
stata=-1;
jilu.setText(" 桃子下 ");
a=-1;
s="桃子";
}
else if(stata==-1){//如果桃子不能下子则跳过，阿狸下
stata=1;
jilu.setText(" 阿狸下 ");
a=1;
s="阿狸";
}
xiafa=Check(a);
System.out.println(s+"有"+xiafa+"种下法");
if(xiafa==0){
te++;//如果无子可下，则特殊情况记录加1
}else
te=0;
}
//----------------胜负判断----------------
if(judge()[0]==0){//如果阿狸没子了则桃子获胜
JOptionPane.showMessageDialog(null,"游戏结束，桃子获胜");
}
else if(judge()[1]==0){//如果桃子没子了则阿狸获胜
JOptionPane.showMessageDialog(null, "游戏结束，阿狸获胜");
}
if(full()){
if(judge()[0]>judge()[1]){//如果阿狸的子较多，则阿狸获胜
JOptionPane.showMessageDialog(null, "游戏结束，阿狸获胜");
}
else if(judge()[0]<judge()[1]){//如果桃子的子较多，则桃子获胜
JOptionPane.showMessageDialog(null, "游戏结束，桃子获胜");
}
else if(judge()[0]==judge()[1]){
JOptionPane.showMessageDialog(null, "平局");
}
}
}
return;
}
}
}
}
}
/**
* 判断输赢的方法，如果黑棋多则黑棋获胜，否则白棋获胜
* @return 黑棋和白棋的数目
*/
public int[] judge(){
int count[]=new int[2];
for(int i=0;i<Chess.rows-1;i++){
for(int j=0;j<Chess.cols-1;j++){
if(Chess.chess[i][j]==1){
count[0]++;
}
else if(Chess.chess[i][j]==-1){
count[1]++;
}
}
}
return count;
}
/**
* 判断棋盘是否已满的方法
*/
public boolean full(){
if(te==2){ //如果双方都不能下子，则游戏结束
return true;
}
else{
for(int i=0;i<Chess.rows-1;i++){
for(int j=0;j<Chess.cols-1;j++){
//如果有一个地方是空的则返回false
if(Chess.chess[i][j]==0){
return false;
}
}
}
}
return true;
}
/**
* 判断当前棋子的下法还有多少种
* @param return 返回下法的总数
*/
public int Check(int a){
int n=0;
for(int i=0;i<Chess.chess.length;i++){
for(int j=0;j<Chess.chess[i].length;j++){
if(Chess.chess[i][j]!=0){
continue;
}
else{
Chess.chess[i][j]=a;
if(hengYou(i, j) != null || hengZuo(i, j) != null
|| hengShang(i, j) != null || hengXia(i, j) != null
|| xieyouS(i, j) != null || xieyouX(i, j) != null
|| xiezuoS(i, j) != null || xiezuoX(i, j) != null)
{
Chess.chess[i][j]=0;
n++; //如果有一个地方可以下子，则n+1
}
else{
Chess.chess[i][j]=0;
}
}
}
}
return n;
}
/*********************************************** 检测相同颜色 *******************************/
/**
* 改变两棋子之间的棋子的颜色——直线
*/
public void paintChess(int r1, int c1, int r2, int c2) {
// 横向
if (c1 == c2) {
for (int k = Math.min(r1, r2) + 1; k < Math.max(r1, r2); k++) {
Chess.chess[k][c1] = Chess.chess[r1][c1];
change++;
}
}
// 纵向
if (r1 == r2) {
for (int k = Math.min(c1, c2) + 1; k < Math.max(c1, c2); k++) {
Chess.chess[r1][k] = Chess.chess[r1][c1];
change++;
}
}
}
/**
* 改变两棋子之间的棋子的颜色——斜线——右上
*/
public void paintChess1(int r1, int c1, int r2, int c2) {
for (int k = Math.min(r1, r2) + 1, v = Math.max(c1, c2) - 1; k < Math
.max(r1, r2); k++, v--) {
Chess.chess[k][v] = Chess.chess[r1][c1];
change++;
}
}
/**
* 改变两棋子之间的棋子的颜色——斜线——右下
*/
public void paintChess2(int r1, int c1, int r2, int c2) {
for (int k = Math.min(r1, r2) + 1, v = Math.min(c1, c2) + 1; k < Math
.max(r1, r2); k++, v++) {
Chess.chess[k][v] = Chess.chess[r1][c1];
change++;
}
}
/**
* 改变两棋子之间的棋子的颜色——斜线——左上
*/
public void paintChess3(int r1, int c1, int r2, int c2) {
for (int k = Math.max(r1, r2) - 1, v = Math.max(c1, c2) - 1; k > Math
.min(r1, r2); k--, v--) {
Chess.chess[k][v] = Chess.chess[r1][c1];
change++;
}
}
/**
* 改变两棋子之间的棋子的颜色——斜线——左下
*/
public void paintChess4(int r1, int c1, int r2, int c2) {
for (int k = Math.min(r1, r2) + 1, v = Math.max(c1, c2) - 1; k <= Math
.max(r1, r2); k++, v--) {
Chess.chess[k][v] = Chess.chess[r1][c1];
change++;
}
}
/**
* 向右检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL
* @param x
* @param y
* @return
*/
public int[] hengYou(int x, int y) {
int r = -2;
int i;
// 向右
for (i = x + 1; i < Chess.rows-1; i++) {
if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {
break;
}
if (Chess.chess[i][y] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x + 1][y] != Chess.chess[i][y]) {
return new int[] { r, y };
} else {
// System.out.println("向右不能");
return null;
}
}
/**
* 向左检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL
*/
public int[] hengZuo(int x, int y) {
int r = -2;
int i;
// 向左
for (i = x - 1; i >= 0; i--) {
if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {
break;
}
if (Chess.chess[i][y] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x - 1][y] != Chess.chess[i][y]) {
return new int[] { r, y };
} else {
// System.out.println("向左不能");
return null;
}
}
/**
* 向上检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL
*/
public int[] hengShang(int x, int y) {
int r = -2;
int i;
// 向上
for (i = y - 1; i >= 0; i--) {
if (Chess.chess[x][i] == 0) {
break;
}
if (Chess.chess[x][i] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x][y - 1] != Chess.chess[x][i]) {
return new int[] { x, r };
} else {
// System.out.println("向上不能");
return null;
}
}
/**
* 向上检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL
*/
public int[] hengShang1(int x, int y) {
int r = -2;
int i;
// 向上
for (i = y - 1; i >= 0; i--) {
if (Chess.chess[x][i] == 0) {
break;
}
if (Chess.chess[x][i] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x][y - 1] != Chess.chess[x][i]) {
// 改变中间的子
paintChess(x, y, x, r);
return new int[] { x, r };
} else {
return null;
}
}
/**
* 向下检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL
*/
public int[] hengXia(int x, int y) {
int r = -2;
int i;
// 向下
for (i = y + 1; i < Chess.rows-1; i++) {
if (Chess.chess[x][i] == 0) {
break;
}
if (Chess.chess[x][i] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x][y + 1] != Chess.chess[x][i]) {
return new int[] { x, r };
} else {
// System.out.println("向下不能");
return null;
}
}
/**
* 向下检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL
*/
public int[] hengXia1(int x, int y) {
int r = -2;
int i;
// 向下
for (i = y + 1; i < Chess.rows-1; i++) {
if (Chess.chess[x][i] == 0) {
break;
}
if (Chess.chess[x][i] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x][y + 1] != Chess.chess[x][i]) {
// 改变中间的子
paintChess(x, y, x, r);
return new int[] { x, r };
} else {
return null;
}
}
/**
* 斜右上方向
* @param x
* @param y
* @return
*/
public int[] xieyouS(int x, int y) {
// 向上
int r = -2, s = -2;
int i, j;
for (i = x + 1, j = y - 1; i < Chess.rows-1 && j >= 0; i++, j--) {
if (Chess.chess[i][j] == 0) {
break;
}
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x + 1][y - 1] != Chess.chess[i][j]) {
return new int[] { r, s };
} else {
// System.out.println("向右上不能");
return null;
}
}
/**
* 斜右下方向
*
* @param x
* @param y
* @return
*/
public int[] xieyouX(int x, int y) {
// 向下
int r = -2, s = -2;
int i, j;
for (i = x + 1, j = y + 1; i < Chess.rows-1 && j < Chess.cols-1; i++, j++) {
if (Chess.chess[i][j] == 0) {
break;
}
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x + 1][y + 1] != Chess.chess[i][j]) {
return new int[] { r, s };
} else {
// System.out.println("向右下不能");
return null;
}
}
/**
* 斜左上方向
*
* @param x
* @param y
* @return
*/
public int[] xiezuoS(int x, int y) {
// 向上
int r = -2, s = -2;
int i, j;
for (i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {
if (Chess.chess[i][j] == 0) {
break;
}
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x - 1][y - 1] != Chess.chess[i][j]) {
return new int[] { r, s };
} else {
return null;
}
}
/**
* 斜左下方向
* @param x
* @param y
* @return
*/
public int[] xiezuoX(int x, int y) {
// 向下
int r = -2, s = -2;
int i, j;
for (i = x - 1, j = y + 1; i >= 0 && j < Chess.cols-1; i--, j++) {
if (Chess.chess[i][j] == 0) {
break;
}
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x - 1][y + 1] != Chess.chess[i][j]) {
return new int[] { r, s };
} else {
return null;
}
}
/**
* 向右检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL
*/
public int[] hengYou1(int x, int y) {
int r = -2;
int i;
// 向右
for (i = x + 1; i < Chess.cols-1; i++) {
if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {
break;
}
if (Chess.chess[i][y] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x + 1][y] != Chess.chess[i][y]) {
// 改变中间的子
paintChess(x, y, r, y);
return new int[] { r, y };
} else {
return null;
}
}
/**
* 向左检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL
*/
public int[] hengZuo1(int x, int y) {
int r = -2;
int i;
// 向左
for (i = x - 1; i >= 0; i--) {
if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {
break;
}
if (Chess.chess[i][y] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x - 1][y] != Chess.chess[i][y]) {
// 改变中间的子
paintChess(x, y, r, y);
return new int[] { r, y };
} else {
return null;
}
}
/**
* 斜右上方向
* @param x
* @param y
* @return
*/
public int[] xieyou1(int x, int y) {
// 向上
int r = -2, s = -2;
int i, j;
for (i = x + 1, j = y - 1; i < Chess.rows-1 && j >= 0; i++, j--) {
if (Chess.chess[i][j] == 0) {
break;
}
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x + 1][y - 1] != Chess.chess[i][j]) {
// 改变中间的子
paintChess1(x, y, i, j);
return new int[] { r, s };
} else {
return null;
}
}
/**
* 斜右下方向
*
* @param x
* @param y
* @return
*/
public int[] xieyou2(int x, int y) {
// 向下
int r = -2, s = -2;
int i, j;
for (i = x + 1, j = y + 1; i < Chess.rows-1 && j < Chess.cols-1; i++, j++) {
if (Chess.chess[i][j] == 0) {
break;
}
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x + 1][y + 1] != Chess.chess[i][j]) {
// 改变中间的子
paintChess2(x, y, i, j);
return new int[] { r, s };
} else {
return null;
}
}
/**
* 斜左上方向
*
* @param x
* @param y
* @return
*/
public int[] xiezuo1(int x, int y) {
// 向上
int r = -2, s = -2;
int i, j;
for (i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {
if (Chess.chess[i][j] == 0) {
break;
}
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x - 1][y - 1] != Chess.chess[i][j]) {
// 改变中间的子
paintChess3(x, y, i, j);
return new int[] { r, s };
} else {
return null;
}
}
/**
* 斜左下方向
* @param x
* @param y
* @return
*/
public int[] xiezuo2(int x, int y) {
// 向下
int r = -2, s = -2;
int i, j;
for (i = x - 1, j = y + 1; i >= 0 && j < Chess.cols-1; i--, j++) {
if (Chess.chess[i][j] == 0) {
break;
}
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x - 1][y + 1] != Chess.chess[i][j]) {
// 改变中间的子
paintChess4(x, y, i, j);
return new int[] { r, s };
} else {
return null;
}
}
}
所使用到的图片素材都在附件中提供，喜欢黑白棋的朋友们不妨自己来做一做吧。
相关推荐
【JAVA Othello Game】是一款基于Java编程语言开发的桌面游戏，主要实现了经典的棋盘游戏——奥赛罗，也常被称为黑白棋或Reversi。这款游戏的规则简单但策略性极强，深受玩家喜爱。在Java中实现这个游戏，开发者不仅...
黑白棋，又叫翻转棋（Reversi）、奥赛罗棋（Othello）、苹果棋或反棋（Anti reversi），在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。常规的黑白棋及其配套AI算法多适用于8*...
8. **Othello.exe**：这是黑白棋的可执行程序，用户可以通过这个程序进行人机对战或者与其他玩家在线对战。 9. **AI_Othello.h**：头文件，包含了AI模块的接口定义，用于在其他源文件中引用和调用AI的功能。 通过...
标题中的“wbc.rar_othello_黑白棋_黑白棋 搜索”暗示这是一个关于Othello游戏（也称为黑白棋）的压缩包文件，其中可能包含实现这个游戏的源代码或相关资源。描述部分提到，作者在大学时期编写了这个黑白棋程序，...
本次课程设计主要围绕黑白棋（Reversi/Othello）游戏展开，通过使用C语言进行编程实现。黑白棋是一种策略型棋盘游戏，在一个8×8的棋盘上进行，双方玩家轮流下棋，目的是在棋盘上占据更多的位置。本项目不仅包含了...
首先，我们要理解黑白棋（Reversi或Othello）的基本规则。黑白棋是一种策略型棋类游戏，两名玩家各执一色棋子，通常是黑色和白色，目标是在棋盘上尽可能多地产生物质相反颜色的棋子。棋子的放置方式是：新下的棋子...
# Python使用Min-max算法和Alpha-Beta剪枝的黑白棋游戏AI代码 Pygame可视化 本项目是基于pygame实现的黑白棋（翻转棋）游戏，通过Min-max算法和Alpha-Beta剪枝实现人工智能对手。 使用方法： 1. 安装 pygame： $ pip...
【基于JAVA的黑白棋游戏】是一款使用Java编程语言开发的桌面游戏应用，它实现了经典的黑白棋（也称为翻转棋或反棋）的游戏规则。黑白棋游戏起源于19世纪的英国，是一种策略性极强的双人对弈游戏，深受玩家喜爱。此...
黑白棋，又称反棋、奥赛罗棋或苹果棋，是一种两人对弈的策略棋类游戏，具有简单易学但深度丰富的特点。本程序完全由自己编写，实现了完整的可视化界面，旨在提供一个让用户满意的游戏体验。 游戏规则： 1. **棋盘与...
黑白棋，又称翻转棋（Reversi）、奥赛罗棋（Othello），是一种双人对弈的策略棋类游戏。在这个项目中，我们看到它被实现为一个Python程序。Python是一种广泛使用的高级编程语言，以其简洁明了的语法和强大的功能而受...
【标题】"精选_基于easyx实现的黑白棋游戏_源码打包" 指的是一款使用EasyX库开发的黑白棋游戏。EasyX是一个针对Windows平台的小型C++图形库，它使得开发者能够轻松地进行图形界面编程，非常适合初学者和爱好者用于...
黑白棋，又称翻转棋（Reversi）或奥赛罗棋（Othello），是一种双人策略棋类游戏，其基本规则简单但变化多端，极具挑战性。在这个"黑白棋AI版"中，玩家可以与计算机进行对战，体验人工智能在棋盘游戏中的智能表现。 ...
在计算机游戏的海洋中，有一颗璀璨的明珠，它历经时间的洗礼，仍以其独特的魅力吸引着全世界的玩家，这就是被广泛认知的黑白棋。或许你对它的其他别称—翻转棋或反棋更为熟悉。无论在哪个时代，黑白棋都是一种令人...
黑白棋，又叫反棋(Reversi)、奥赛罗棋(Othello)、苹果棋或翻转棋。黑白棋在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。 它的游戏规则简单，因此上手很容易，但是它的变化又...
Java黑白棋，又称为翻转棋或者Othello，是一款深受玩家喜爱的双人策略游戏。在这个Java实现的黑白棋项目中，我们主要关注的是如何通过编程实现人机对弈的功能，并且实现一个相对简单的算法来让计算机具备一定的智能...
C语言黑白棋，简单易懂，轻松实现。 It has a fairly tweaked board evaluation heuristic, with an edge strategy and so on. It is possibly over-optimized by modern standards, but this thing plays a strong...
"Othello XControl.zip"可能包含了一个预封装的黑白棋逻辑控件，这样可以简化整体程序的开发。 在编写代码的过程中，我们还需要考虑用户交互的反馈，比如当用户尝试在非法位置下棋时，程序应给出提示。此外，为了...
黑白棋，又叫反棋（Reversi）、奥赛罗棋（Othello）、苹果棋或翻转棋。黑白棋在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。它的游戏规则简单，因此上手很容易，但是它的变化...
黑白棋，又称翻转棋（Reversi）或奥赛罗棋（Othello），是一种双人策略棋类游戏，其规则简单但策略性极强。在这个C语言编写的黑白棋游戏中，玩家需要掌握基本的编程概念以及黑白棋的游戏规则。 首先，我们需要了解...
黑白棋，又称翻转棋（Reversi）或奥赛罗棋（Othello），是一种双人对弈的策略型棋类游戏。这个游戏虽然规则简单，但蕴含着丰富的策略性，是初学者学习编程和算法设计的良好实践项目。在本文中，我们将深入探讨黑白棋...