android开发 自定义view实现黑白棋子游戏

最新推荐文章于 2021-08-27 20:51:11 发布
最新推荐文章于 2021-08-27 20:51:11 发布
阅读量644 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25188705/article/details/53159201
版权

1.最近写了个棋盘游戏，大致实现如下功能：棋盘设定（n子棋，m*m棋盘）、重玩、后退（悔棋）、前进、保存、加载保存的棋盘状态。

2.先上最终效果图：

 

3.思路：第一步先画棋盘

int width = getWidth();
int height = getHeight();
mChildWidth = width / Max;
mChildHeight = height / Max;

//竖
for (int i = 1; i < Max; i++) {
   canvas.drawLine(mChildWidth * i, 0, mChildWidth * i, height, mLinePaint);
}
//横
for (int i = 1; i < Max; i++) {
   canvas.drawLine(0, mChildHeight * i, width, mChildHeight * i, mLinePaint);
}
第二步，画黑白棋子，此时必须监听onTouch事件，将棋手所点的坐标转化为二维数组（比如第一行第一列即为0,0位置。。。以此类推） 

/**
 * 获取下棋子的位置(数组下标)
 *
 * @param event
 */
private Point getPoint(MotionEvent event) {
   float fx = event.getX();
   float fy = event.getY();
   int x = 0, y = 0;
   for (int i = 0; i < Max; i++) {
      if (fx < mChildWidth * (i + 1)) {
         x = i;
         break;
      }
   }
   for (int i = 0; i < Max; i++) {
      if (fy < mChildHeight * (i + 1)) {
         y = i;
         break;
      }
   }

   Point point = new Point(x, y);
   return point;
}


/**
 * 获取下棋子的位置(坐标)
 *
 * @param point
 */
private Position getPosition(Point point) {
   float x = 0, y = 0;

   for (int i = 0; i < Max; i++) {
      if (point.getX() == i) {
         x = i * mChildWidth + mChildWidth / 2;
      }
   }

   for (int i = 0; i < Max; i++) {
      if (point.getY() == i) {
         y = i * mChildHeight + mChildHeight / 2;
      }
   }
   Position position = null;
   if (mChessPieces == -1) {
      position = new Position(x, y, Color.BLACK, mChessPieces, point);
   } else {
      position = new Position(x, y, Color.WHITE, mChessPieces, point);
   }

   return position;
}


public class Point implements Serializable {
   public int x;
   public int y;

   public Point(int x, int y) {
      this.x = x;
      this.y = y;
   }

   public int getX() {
      return x;
   }

   public Point setX(int x) {
      this.x = x;
      return this;
   }

   public int getY() {
      return y;
   }

   public Point setY(int y) {
      this.y = y;
      return this;
   }

   // @Override
   // public int hashCode() {
   //    return x + y;
   // }

   @Override
   public boolean equals(Object obj) {
      if (this == obj)
         return true;
      Point other = (Point) obj;
      if (x != other.x)
         return false;
      if (y != other.y)
         return false;
      return true;
   }

}

@Override
public boolean onTouchEvent(MotionEvent event) {
   if (canTouch && event.getAction() == MotionEvent.ACTION_DOWN) {
      mPositionUndoList.clear();//一旦重新下棋子，不能redo
      Point point = getPoint(event);
      if (mScore[point.getY()][point.getX()].getScore() == 0) {
         Position position = getPosition(point);
         mPositionList.add(position);
         mScore[point.getY()][point.getX()] = position;
         if (mChessPieces == -1) {
            mBlackPositionList.add(position);
            calculator(mBlackPositionList, "黑子");
         } else if (mChessPieces == 1) {
            mWhitePositionList.add(position);
            calculator(mWhitePositionList, "白子");
         }
         postInvalidate();
         exchangeChess();
         event.setAction(MotionEvent.ACTION_CANCEL);
      } else {
         //有棋子
         onResultListener.onError("当前位置有棋子，换个位置！");
      }
   }


   return super.onTouchEvent(event);
}

/**
 * 换棋手
 */
private void exchangeChess() {
   if (mChessPieces == -1) {
      mChessPieces = 1;
      mCirclePaint.setColor(Color.WHITE);
      if (onCurrentColorListener != null)
         onCurrentColorListener.onCurrentColor("白子");
   } else {
      mChessPieces = -1;
      mCirclePaint.setColor(Color.BLACK);
      if (onCurrentColorListener != null)
         onCurrentColorListener.onCurrentColor("黑子");
   }
}

第三步，也就是本游戏的核心，计算输赢的算法。基本思想就是每次棋手下棋子后，就去计算横、竖、斜杠、反斜杠四个方向同一颜色的棋子的个数是否到达n子棋，若到达，即为相应的棋手方获胜，反之继续，直至棋子总数==棋盘m*m数时，平手。

/**
 * 计算输赢
 */
private void calculator(List<Position> myChessPosition, String color) {
   mSuccessPointList.clear();
   if (myChessPosition.size() < COUNT) {
      return;
   }
   if (color.equals("黑子")) {
      mColor = Color.BLACK;
   } else {
      mColor = Color.WHITE;
   }
   List<Point> myPointList = new ArrayList<>();
   Point temPoint = new Point(0, 0);
   for (int i = 0; i < myChessPosition.size(); i++) {
      myPointList.add(myChessPosition.get(i).getPoint());
   }
   int count = 0;
   Point point = myPointList.get(myPointList.size() - 1);//获取最后下的棋子的位置
   int x = point.getX();
   int y = point.getY();
   temPoint.setX(x).setY(y);
   //横
   while (myPointList.contains(temPoint)) {
      mSuccessPointList.add(new Point(temPoint.getX(), temPoint.getY()));
      count++;
      int tempX = temPoint.getX();
      if (!(tempX < Max) || count >= COUNT) {
         break;
      }
      temPoint.setX(tempX + 1);
   }
   if (count == COUNT) {
      resultMsg = "本局结束，" + color + "胜！！！";
      new Thread(new CircleThread()).start();
      return;
   }
   temPoint.setX(x).setY(y);
   mSuccessPointList.remove(0);
   count--;//重复算了x,y这点
   while (myPointList.contains(temPoint)) {
      mSuccessPointList.add(new Point(temPoint.getX(), temPoint.getY()));
      count++;
      int tempX = temPoint.getX();
      if (tempX < 1 || count >= COUNT) {
         break;
      }
      temPoint.setX(tempX - 1);
   }
   if (count == COUNT) {
      resultMsg = "本局结束，" + color + "胜！！！";
      new Thread(new CircleThread()).start();
      return;
   }
   //竖
   mSuccessPointList.clear();
   count = 0;
   temPoint.setX(x).setY(y);
   while (myPointList.contains(temPoint)) {
      mSuccessPointList.add(new Point(temPoint.getX(), temPoint.getY()));
      count++;
      int tempY = temPoint.getY();
      Log.d("横+", "count=" + count + ",tempY=" + tempY);
      if (!(tempY < Max) || count >= COUNT) {
         break;
      }
      temPoint.setY(tempY + 1);
   }
   if (count == COUNT) {
      resultMsg = "本局结束，" + color + "胜！！！";
      new Thread(new CircleThread()).start();
      return;
   }
   mSuccessPointList.remove(0);
   temPoint.setX(x).setY(y);
   count--;//重复算了x,y这点
   while (myPointList.contains(temPoint)) {
      mSuccessPointList.add(new Point(temPoint.getX(), temPoint.getY()));
      count++;
      int tempY = temPoint.getY();
      Log.d("横-", "count=" + count + ",tempY=" + tempY);
      if (tempY < 1 || count >= COUNT) {
         break;
      }
      temPoint.setY(tempY - 1);
   }
   if (count == COUNT) {
      resultMsg = "本局结束，" + color + "胜！！！";
      new Thread(new CircleThread()).start();
      return;
   }
   //正斜向 /
   mSuccessPointList.clear();
   count = 0;
   temPoint.setX(x).setY(y);
   while (myPointList.contains(temPoint)) {
      mSuccessPointList.add(new Point(temPoint.getX(), temPoint.getY()));
      count++;
      int tempX = temPoint.getX();
      int tempY = temPoint.getY();
      Log.d("横+", "count=" + count + ",tempY=" + tempY);
      if (tempY < 1 || !(tempX < Max) || count >= COUNT) {
         break;
      }
      temPoint.setX(tempX + 1).setY(tempY - 1);
   }
   if (count == COUNT) {
      resultMsg = "本局结束，" + color + "胜！！！";
      new Thread(new CircleThread()).start();
      return;
   }
   mSuccessPointList.remove(0);
   temPoint.setX(x).setY(y);
   count--;
   while (myPointList.contains(temPoint)) {
      mSuccessPointList.add(new Point(temPoint.getX(), temPoint.getY()));
      count++;
      int tempX = temPoint.getX();
      int tempY = temPoint.getY();
      Log.d("横+", "count=" + count + ",tempY=" + tempY);
      if (tempX < 1 || !(tempY < Max) || count >= COUNT) {
         break;
      }
      temPoint.setX(tempX - 1).setY(tempY + 1);
   }
   if (count == COUNT) {
      resultMsg = "本局结束，" + color + "胜！！！";
      new Thread(new CircleThread()).start();
      return;
   }
   //反斜向 \
   mSuccessPointList.clear();
   count = 0;
   temPoint.setX(x).setY(y);
   while (myPointList.contains(temPoint)) {
      mSuccessPointList.add(new Point(temPoint.getX(), temPoint.getY()));
      count++;
      int tempX = temPoint.getX();
      int tempY = temPoint.getY();
      Log.d("横+", "count=" + count + ",tempY=" + tempY);
      if (!(tempY < Max) || !(tempX < Max) || count >= COUNT) {
         break;
      }
      temPoint.setX(tempX + 1).setY(tempY + 1);
   }
   if (count == COUNT) {
      resultMsg = "本局结束，" + color + "胜！！！";
      new Thread(new CircleThread()).start();
      return;
   }
   mSuccessPointList.remove(0);
   temPoint.setX(x).setY(y);
   count--;
   while (myPointList.contains(temPoint)) {
      mSuccessPointList.add(new Point(temPoint.getX(), temPoint.getY()));
      count++;
      int tempX = temPoint.getX();
      int tempY = temPoint.getY();
      Log.d("横+", "count=" + count + ",tempY=" + tempY);
      if (tempX < 1 || tempY < 1 || count >= COUNT) {
         break;
      }
      temPoint.setX(tempX - 1).setY(tempY - 1);
   }
   if (count == COUNT) {
      resultMsg = "本局结束，" + color + "胜！！！";
      new Thread(new CircleThread()).start();
      return;
   }
   if (mPositionList.size() == Max * Max) {
      resultMsg = "本局结束，平局！！！";
      mSuccessPointList.clear();
      onResultListener.onComplete(resultMsg);
   }
}

第四步，就是判断胜负出结果后，棋子闪动动画，这里用的是改变圆半径，通过线程控制重绘次数的方法。

private Handler circleHandler = new Handler() {

   public void handleMessage(Message msg) {
      super.handleMessage(msg);
      if (msg.what == 1) {
         canTouch = false;
         mCircleSize = (Integer) msg.obj;//圆半径
         invalidate();//重新绘制
      } else if (msg.what == 2) {
         onResultListener.onComplete(resultMsg);
      }
   }
};

    private class CircleThread implements Runnable {

      @Override
      public void run() {
         while (!Thread.currentThread().isInterrupted()) {
            try {
               Thread.sleep(200);
               m++;
               Message msg = new Message();
               if (m > 6) {
                  msg.what = 2;
                  circleHandler.sendMessage(msg);
                  return;
               }
               msg.what = 1;
               if (m % 2 == 0) {
                  msg.obj = 45;
               } else {
                  msg.obj = 40;
               }

               circleHandler.sendMessage(msg);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }

   }
}


第五步，如前进、后退（悔棋）、重玩功能，重点是通过List的增删等动作，思路清晰的话应该不难。 

private ArrayList<Position> mPositionList = new ArrayList<>();//棋盘共下的子
private ArrayList<Position> mBlackPositionList = new ArrayList<>();//棋盘下的黑子
private ArrayList<Position> mWhitePositionList = new ArrayList<>();//棋盘共下的白子
private ArrayList<Position> mPositionUndoList = new ArrayList<>();//存储悔棋的步骤
// private ArrayList<Position> mSuccessPositionList = new ArrayList<>();
private ArrayList<Point> mSuccessPointList = new ArrayList<>();

上面就是为了实现如上功能所设置的List，虽然有点多。。。


第六步，保存棋盘及加载棋盘状态，利用就是将序列化后的相关数据保存到外存，当需要时再由外存读入。重绘保存的数据信息，即可重现保存棋盘的模样。

/**
 * 保存棋盘
 */
public void save() {
   if (mPositionList.size() == 0) {
      return;
   }
   Map<String, Object> map = new HashMap<>();
   map.put("mScore", mScore);
   map.put("mPositionList", mPositionList);
   map.put("mBlackPositionList", mBlackPositionList);
   map.put("mWhitePositionList", mWhitePositionList);

   File filePath = new File(BaseApplication.instance.getCacheDir(), "gameTTT");
   FileSaveHandler.saveObject(filePath.getPath(), map);

   reset();
}

/**
 * 加载保存的棋盘
 */
public void load() {
   File filePath = new File(BaseApplication.instance.getCacheDir(), "gameTTT");
   Map<String, Object> map = (Map<String, Object>) FileSaveHandler.readObject(filePath.getPath());

   mScore = (Position[][]) map.get("mScore");
   mPositionList = (ArrayList<Position>) map.get("mPositionList");
   mBlackPositionList = (ArrayList<Position>) map.get("mBlackPositionList");
   mWhitePositionList = (ArrayList<Position>) map.get("mWhitePositionList");

   if (mPositionList.size() == 0) {
      return;
   }
   Position position = mPositionList.get(mPositionList.size() - 1);
   if (position.getColor() == Color.WHITE) {
      calculator(mWhitePositionList, "白子");
   } else {
      calculator(mBlackPositionList, "黑子");
   }
   postInvalidate();
}

最后，已上传代码至github。https://github.com/Selina592732122/GameTTT



qq_25188705
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
围棋 android 开源,开源围棋AI项目RN围棋
weixin_39601056的博客
06-02 762
更多：开源围棋…RN围棋https://github.com/zakki/Ray喜欢围棋编程的朋友，可以看看。C++源码。这也是能在个人电脑上跑的围棋AIhttps://github.com/zakki/Ray/releases编译好的RN引擎下载地址，加载参数是–thread 4 –playout 15000 –no-debug其中数–thread 4是线程，你电脑多少线程就设多少，–playo...
android黑白棋游戏
03-15
基于Android的SurfaceView控件的黑白块游戏，实现简单的黑白块游戏，可以设置白块的数量，是否加速，加速度是多少等 欢迎到https://github.com/zhyaoqi/Game-BlackWhiteBlock下载和点赞
实例源码--Android游戏开发基础实例--黑白棋
weixin_30616969的博客
10-13 189
下载源码 具体开发流程，详细参考源码! 部分效果： 转载于:https://www.cnblogs.com/love1025/archive/2011/10/13/2210502.html
Android自定义view之围棋动画
热门推荐
计蒙不吃鱼的博客
12-30 1万+
Android自定义view之围棋动画 好久不见，最近公众号内粉丝要求上新一篇有点难度的自定义view文章，它来了！！ 文章目录Android自定义view之围棋动画前言完成效果图一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 废话不多说直接开始 提示：以下是本篇文章正文内容，下面案例可供参考 完成效果图 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import
【Android】Android 黑白棋安卓小应用
ZLei
06-26 1489
安卓的黑白棋算法（只介绍软件的重点部分， 细节不介绍） 首先是界面问题， 这个比较简单， 只是自定义一个view对象， 首先将三种棋子的图片在自定义View对象中初始化为Bitmap对象， 其中有一个数组存储现在的棋局， for ( int i = 0; i < GameSize; i++) { for (int j = 0; j < GameSize; j++ ) {
android 黑白棋源码,黑白棋源代码
weixin_39771791的博客
05-29 566
【实例简介】黑白棋源代码， 自己写的，界面设计比较简单， 棋子也是自己找到的图片， 其中编码格式为utf-8, 亲测可以运行【实例截图】【核心代码】Chess└── Chess├── AndroidManifest.xml├── assets│ └── hite.wav├── bin│ ├── AndroidManifest.xml│ ├── Chess.apk│ ├── clas...
通过学习实现的一个简易五子棋小游戏，主要学习Android中自定义View相关知识
11-14
通过学习和实践这个五子棋小游戏，开发者不仅可以掌握自定义View的基本技巧，还能了解Android游戏开发的一些基础概念，这对于提升Android开发能力大有裨益。同时，这个项目也可以作为进一步扩展的基础，比如加入AI...
Android课设五子棋小游戏程序
最新发布
05-29
5. **自定义View**：为了实现五子棋棋盘，开发者可能需要创建一个自定义的View类，继承自View，并重写onDraw()方法来绘制棋盘和棋子。 6. **触摸事件处理**：Android通过MotionEvent类处理用户的触摸操作。在五子棋...
android 游戏 黑白棋
03-08
我们可以使用ImageView控件代表棋子，用GridLayout或自定义View实现棋盘。为了提高用户体验，棋盘应该能够响应触摸事件，当用户点击棋盘上的某个位置时，系统应判断是否可以在此处下棋并执行相应的动作。 接下来是...
Android游戏源码黑白棋（奥赛罗）完整APP源代码
07-29
3. **布局设计**：游戏界面通常需要自定义布局，包括棋盘和棋子的绘制，这涉及到XML布局文件的编写和`View`类的自定义。 4. **事件监听**：Android使用`OnClickListener`等接口处理用户触摸事件，实现棋子的点击和...
Android游戏源码黑白棋（奥赛罗） 完整APP源代码
05-30
注意：本项目使用android studio开发，eclipse可能无法直接导入。 黑白棋，又叫反棋（Reversi）、奥赛罗棋（Othello）、苹果棋或翻转棋。黑白棋在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。它的游戏规则简单，因此上手很容易，但是它的变化又非常复杂。有一种说法是：只需要几分钟学会它，却需要一生的时间去精通它。本资源系课程作业编写，包括完整的可编译的Android Studio 工程包，还包括可以直接在Android手机上安装的apk文件。
基于 Android 系统的手机游戏黑白棋的设计与实现
06-03
基于Android系统的手机游戏黑白棋的设计与实现_李林涛
黑白棋（奥赛罗）Android APP完整源代码工程包
01-09
黑白棋在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。它的游戏规则简单，因此上手很容易，但是它的变化又非常复杂。有一种说法是：只需要几分钟学会它，却需要一生的时间去精通它。 本资源系本人课程作业编写，包括完整的可编译的Android Studio 工程包，还包括可以直接在Android手机上安装的apk文件。该APP实现了所有黑白棋的功能和逻辑，还有背景音乐和翻转动画等效果。
Android游戏开发之黑白棋
01-20
黑白棋介绍 黑白棋，又叫苹果棋，最早流行于西方国家。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。黑白棋非常易于上手，但精通则需要考虑许多因素，比如角边这样的特殊位置、稳定度、行动力等。本游戏取名为黑白棋大师，提供了8种难度等级的选择，从菜鸟、新手、入门、棋手到棋士、大师、宗师、棋圣，助你不断提升棋力。 黑白棋游戏规则 游戏规则见黑白棋大师中的截图。 黑白棋大师游戏截图 游戏启动界面。 游戏过程中的一个截图。 开新局时的选项，选择先后手以及AI的水平。 几个关键的类 Rule Rule类实现游戏规则相关的方法，包括     1.判断某一步是否合法     2.获取所有
黑白棋（苹果棋）
05-28
好久之前用C++写的了，这是单机版的。
android系统黑白棋游戏源码
12-27
总结，Android系统上的黑白棋游戏开发涉及了Android应用的基础架构、游戏规则的编程实现、用户交互设计、图形界面渲染、数据持久化以及性能优化等多个方面，对于Android开发者来说，这是一个综合性的实践项目，有助...
android studio 黑白棋格
weixin_50748997的博客
08-27 495
具体如下： package com.example.testt; import android.content.Context; import android.graphics.Canvas; import android.graphics.Paint; import android.view.View; public class DrawlT extends View { public DrawlT(Context context) { super(context);
学习android, 自己编的一个黑白棋游戏 (提供源代码下载)
iteye_15499的博客
05-08 300
学习android, 自己编的一个黑白棋游戏. 支持人机对战, 可以选择难度. 还有很多bug,还在不断完善中. 规则: 黑白棋(Othello)是由黑方和白方两人进行的益智游戏。棋盘为8x8方格. 轮到一方下棋时，必须把棋下在与对方棋子相邻的空位上，要求所下的棋子和原有的已方棋子夹住对方的至少一个棋子(横竖斜夹均可)，然后把被夹住的子变成己方的颜色(也叫吃子)。 目标: 当双...
android 双人黑白棋开发博客,黑白棋 - 软件资讯 - 课堂党年级博客
weixin_32243075的博客
05-26 152
黑白棋叫反棋(Reversi)、奥赛罗棋(Othello)苹棋翻转棋黑白棋西本流行游戏通相互翻转棋棋盘谁棋判断胜负 黑白棋棋盘8*8格棋盘棋棋空格间像围棋交叉点始棋盘两白两黑四棋交叉放置黑棋总先 自颜色棋放棋盘空格自放棋横、竖、斜八向内自棋则夹间全部翻转自棋并且翻转棋才很可能有，黑白棋的规则和其它棋类比起来并不算复杂，就拿五子棋为例，从规则及棋盘的大小来看黑白棋都比五子棋要简单吧，但是五子棋的先...
Android自定义View实现推箱子游戏实战代码
本文主要介绍了如何在Android平台上通过自定义View来实现一个简单的推箱子（Tetris-like）游戏。作者使用`com.jisai.materialdesigndemo.tuixiangzhi`包下的`View_tuixiangzhi`类作为核心，这个自定义View继承自`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值