实现一个质量过硬五子棋

测试棋力在相同配置下，初级水平基本相当于五子棋大师的特级大师水平。
一楼上图：

主页面.png

五子棋的引擎和自定义控件我封装在lib中，可以通过
implementation 'win.regin:renju:1.0.0'来引用，而ndk的调用类Ai是用kotlin编写的，上传的时候传不上去，做为一个jar包引用了。

五子棋自定义控件代码，关键地方有注释:

package win.regin.renju;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;

import java.util.ArrayList;
import java.util.List;


/**
 * @author :Reginer in  2018/7/9 20:00.
 * 联系方式:QQ:282921012
 * 功能描述:
 */

public class RenjuView extends View {
    /**
     * 棋盘面板宽度
     */
    private int mPanelWidth;
    /**
     * 棋盘每格的行高
     */
    private float mLineHeight;
    /**
     * 棋盘尺寸
     */
    private static final int MAX_LINE = 15;
    /**
     * 棋子占行高比例
     */
    private float ratioPieceOfLineHeight = 0.9f;
    private float startPos;
    private float endPos;

    /**
     * 白棋数组
     */
    private ArrayList<Point> mWhiteArray = new ArrayList<>();
    /**
     * 黑棋数组
     */
    private ArrayList<Point> mBlackArray = new ArrayList<>();
    /**
     * 棋盘数组
     */
    private ArrayList<Point> chessArray = new ArrayList<>();
    private int[][] mBoard = new int[MAX_LINE][MAX_LINE];

    /**
     * 胜利玩家
     */
    private int mWinner;
    /**
     * 连成五个的棋子
     */
    private ArrayList<Point> fiveArray = new ArrayList<>();
    /**
     * 游戏是否结束
     */
    private boolean mIsGameOver = false;


    private int gameMode = RenjuConstant.HUMAN_COMPUTER;

    /**
     * 玩家以及AI得分纪录
     */
    private int userScore, aiScore;
    /**
     * 玩家执子
     */
    private int userChess;
    /**
     * 当前回合是否轮到玩家
     */
    private boolean isUserBout;
    /**
     * 显示棋子编号
     */
    private boolean isDrawChessNum = true;

    private RenjuCallback callBack;

    private Paint mPaint = new Paint();
    private Bitmap mWhitePiece;
    private Bitmap mBlackPiece;

    private Point suggestPoint;

    public RenjuView(Context context) {
        this(context, null);
    }

    public RenjuView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public RenjuView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mPaint.setColor(Color.BLACK);
        //抗锯齿
        mPaint.setAntiAlias(true);
        mPaint.setDither(true);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setTextSize(24);
        mPaint.setTextAlign(Paint.Align.CENTER);
        mWhitePiece = BitmapFactory.decodeResource(getResources(), R.drawable.ic_white_chess);
        mBlackPiece = BitmapFactory.decodeResource(getResources(), R.drawable.ic_black_chess);
        userScore = 0;
        aiScore = 0;
        start();
    }


    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        int measureSize = Math.min(widthSize, heightSize);
        if (widthMode == MeasureSpec.UNSPECIFIED) {
            measureSize = heightSize;
        } else if (heightMode == MeasureSpec.UNSPECIFIED) {
            measureSize = widthSize;
        }
        setMeasuredDimension(measureSize, measureSize);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldW, int oldH) {
        super.onSizeChanged(w, h, oldW, oldH);
        mPanelWidth = w;
        float outLine = 10.0f;
        mLineHeight = (mPanelWidth * 1.0f - 2.0f * outLine) / MAX_LINE;
        startPos = outLine;
        endPos = w - outLine;
        int pieceSize = (int) (mLineHeight * ratioPieceOfLineHeight);
        mWhitePiece = Bitmap.createScaledBitmap(mWhitePiece, pieceSize, pieceSize, false);
        mBlackPiece = Bitmap.createScaledBitmap(mBlackPiece, pieceSize, pieceSize, false);
    }

    private Point getValidPoint(int x, int y) {
        return new Point((int) (x / mLineHeight), (int) (y / mLineHeight));
    }

    public int getChessCount() {
        return chessArray.size();
    }

    public void removeLastChess() {
        Point p = chessArray.get(chessArray.size() - 1);
        chessArray.remove(chessArray.size() - 1);
        if (mBoard[p.y][p.x] == RenjuConstant.BLACK_CHESS) {
            mBlackArray.remove(mBlackArray.size() - 1);
        } else if (mBoard[p.y][p.x] == RenjuConstant.WHITE_CHESS) {
            mWhiteArray.remove(mWhiteArray.size() - 1);
        }
        mBoard[p.y][p.x] = RenjuConstant.N0_CHESS;
    }

    public void undo() {
        final int canUndoSize = 2;
        if (chessArray.size() >= canUndoSize) {
            mIsGameOver = false;
            suggestPoint = null;
            removeLastChess();
            removeLastChess();
        }
        postInvalidate();
    }

    @SuppressLint("ClickableViewAccessibility")
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (mIsGameOver || !isUserBout) {
            return false;
        }
        int action = event.getAction();
        if (action == MotionEvent.ACTION_DOWN) {
            return true;
        }
        if (action == MotionEvent.ACTION_UP) {
            int x = (int) event.getX();
            int y = (int) event.getY();

            Point p = getValidPoint(x, y);
            if (mWhiteArray.contains(p) || mBlackArray.contains(p)) {
                return false;
            }
            suggestPoint = null;
            addChess(p, userChess);
            setUserBout(!isHumanComputer());
            if (!isHumanComputer()) {
                userChess = (userChess == RenjuConstant.WHITE_CHESS) ? RenjuConstant.BLACK_CHESS : RenjuConstant.WHITE_CHESS;
            }
            checkGameOver();
            invalidate();

            if (!mIsGameOver) {
                callBack.atBell(p, false, isUserBlack());
            }
            return true;
        }
        return super.onTouchEvent(event);
    }


    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        drawBoard(canvas);
        drawPiece(canvas);
    }

    public void addChess(Point point, int chessType) {
        mBoard[point.y][point.x] = chessType;
        chessArray.add(point);
        if (chessType == RenjuConstant.BLACK_CHESS) {
            mBlackArray.add(point);
        } else if (chessType == RenjuConstant.WHITE_CHESS) {
            mWhiteArray.add(point);
        }
        invalidate();
    }

    public void setGameMode(int gameMode) {
        this.gameMode = gameMode;
    }

    public int getGameMode() {
        return gameMode;
    }

    public void checkGameOver() {
        boolean blackWin = checkFiveInLine(mBlackArray);
        boolean whiteWin = !blackWin && checkFiveInLine(mWhiteArray);
        if (whiteWin || blackWin) {
            mIsGameOver = true;
            mWinner = whiteWin ? RenjuConstant.WHITE_CHESS : RenjuConstant.BLACK_CHESS;
            if (mWinner == userChess) {
                userScore++;
            } else {
                aiScore++;
            }
            callBack.gameOver(mWinner);
            invalidate();
        } else if (isFull()) {
            mIsGameOver = true;
            mWinner = RenjuConstant.N0_CHESS;
            callBack.gameOver(mWinner);
            invalidate();
        }
    }

    public boolean checkFiveInLine(List<Point> points) {
        List<Point> dirArray = new ArrayList<>();
        dirArray.add(new Point(1, 0));
        dirArray.add(new Point(0, 1));
        dirArray.add(new Point(1, 1));
        dirArray.add(new Point(1, -1));
        for (Point p : points) {
            for (Point dir : dirArray) {
                if (checkFiveOneLine(dir, p.x, p.y, points)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 检查棋子在某个方向是否已经连五
     *
     * @param dir    dir
     * @param x      x
     * @param y      y
     * @param points points
     * @return 胜利
     */
    public boolean checkFiveOneLine(Point dir, int x, int y, List<Point> points) {
        int count = 1;
        fiveArray.clear();
        fiveArray.add(new Point(x, y));
        final int successSize = 5;
        for (int i = 1; i < successSize; i++) {
            Point p = new Point(x + dir.x * i, y + dir.y * i);
            if (points.contains(p)) {
                fiveArray.add(p);
                count++;
            } else {
                break;
            }
        }
        for (int i = 1; i < successSize; i++) {
            Point p = new Point(x - dir.x * i, y - dir.y * i);
            if (points.contains(p)) {
                fiveArray.add(p);
                count++;
            } else {
                break;
            }
        }
        return count >= 5;
    }


    private void drawPiece(Canvas canvas) {
        mPaint.setStrokeWidth(2.0f);
        mPaint.setTextSize(24);
        Paint.FontMetricsInt fontMetrics = mPaint.getFontMetricsInt();
        for (int i = 0; i < mWhiteArray.size(); i++) {
            Point whitePoint = mWhiteArray.get(i);
            float left = startPos + (whitePoint.x + (1 - ratioPieceOfLineHeight) / 2) * mLineHeight;
            float top = startPos + (whitePoint.y + (1 - ratioPieceOfLineHeight) / 2) * mLineHeight;
            canvas.drawBitmap(mWhitePiece, left, top, null);
            if (isDrawChessNum) {
                mPaint.setColor(Color.BLACK);
                float textTop = startPos + whitePoint.y * mLineHeight;
                float textBottom = textTop + mLineHeight;
                float baseline = (textTop + textBottom - fontMetrics.ascent - fontMetrics.descent) / 2;
                float centerX = startPos + (whitePoint.x + 0.5f) * mLineHeight;
                canvas.drawText(String.format("%S", 2 + i * 2), centerX, baseline, mPaint);
            }
        }
        for (int i = 0; i < mBlackArray.size(); i++) {
            Point blackPoint = mBlackArray.get(i);
            float left = startPos + (blackPoint.x + (1 - ratioPieceOfLineHeight) / 2) * mLineHeight;
            float top = startPos + (blackPoint.y + (1 - ratioPieceOfLineHeight) / 2) * mLineHeight;
            canvas.drawBitmap(mBlackPiece, left, top, null);
            if (isDrawChessNum) {
                mPaint.setColor(Color.WHITE);
                float textTop = startPos + blackPoint.y * mLineHeight;
                float textBottom = textTop + mLineHeight;
                float baseline = (textTop + textBottom - fontMetrics.ascent - fontMetrics.descent) / 2;
                float centerX = startPos + (blackPoint.x + 0.5f) * mLineHeight;
                canvas.drawText(String.format("%S", 1 + i * 2), centerX, baseline, mPaint);
            }
        }
    }

    private void drawBoard(Canvas canvas) {
        mPaint.setColor(Color.BLACK);
        mPaint.setStrokeWidth(2.0f);
        int w = mPanelWidth;
        float lineHeight = mLineHeight;
        //画棋盘线
        for (int i = 0; i < MAX_LINE; i++) {
            int startX = (int) (startPos + lineHeight / 2);
            int endX = (int) (endPos - lineHeight / 2);
            int y = (int) (startPos + (0.5 + i) * lineHeight);
            canvas.drawLine(startX, y, endX, y, mPaint);
        }
        for (int i = 0; i < MAX_LINE; i++) {
            int startY = (int) (startPos + lineHeight / 2);
            int endY = (int) (endPos - lineHeight / 2);
            int x = (int) (startPos + (0.5 + i) * lineHeight);
            canvas.drawLine(x, startY, x, endY, mPaint);
        }
        //画棋盘坐标
        mPaint.setTextSize(20);
        mPaint.setStrokeWidth(1.7f);
        Paint.FontMetricsInt fontMetrics = mPaint.getFontMetricsInt();
        for (int i = 0; i < MAX_LINE; i++) {
            float y = startPos + (0.5f + i) * lineHeight;
            float textTop = y - 0.5f * mLineHeight;
            float textBottom = y + 0.5f * mLineHeight;
            float baseline = (textTop + textBottom - fontMetrics.ascent - fontMetrics.descent) / 2;
            float x = 12;
            canvas.drawText(String.format("%S", MAX_LINE - i), x, baseline, mPaint);
        }
        for (int i = 0; i < MAX_LINE; i++) {
            float y = w - 12;
            float textTop = y - 0.5f * mLineHeight;
            float textBottom = y + 0.5f * mLineHeight;
            float baseline = (textTop + textBottom - fontMetrics.ascent - fontMetrics.descent) / 2;
            float x = startPos + (0.5f + i) * lineHeight;
            String text = String.valueOf((char) ('A' + i));
            canvas.drawText(text, x, baseline, mPaint);
        }
        //棋盘边缘线
        mPaint.setStrokeWidth(4.0f);
        int min = (int) lineHeight / 2 + 4, max = w - min;
        canvas.drawLine(min - 2, min, max + 2, min, mPaint);
        canvas.drawLine(min - 2, max, max + 2, max, mPaint);
        canvas.drawLine(min, min, min, max, mPaint);
        canvas.drawLine(max, min, max, max, mPaint);
        //画五个小黑点
        mPaint.setStrokeWidth(8f);
        final float startSize = 3.5f;
        final float endSize = MAX_LINE - 3.5f;
        final float middleSize = MAX_LINE / 2f;
        //左上
        canvas.drawCircle(startPos + startSize * lineHeight, startPos + startSize * lineHeight, 5, mPaint);
        //右上
        canvas.drawCircle(startPos + endSize * lineHeight, startPos + startSize * lineHeight, 5, mPaint);
        //左下
        canvas.drawCircle(startPos + startSize * lineHeight, startPos + endSize * lineHeight, 5, mPaint);
        //右下
        canvas.drawCircle(startPos + endSize * lineHeight, startPos + endSize * lineHeight, 5, mPaint);
        //中间
        canvas.drawCircle(startPos + middleSize * lineHeight, startPos + middleSize * lineHeight, 5, mPaint);
        mPaint.setColor(Color.GREEN);
        mPaint.setStrokeWidth(4.0f);
        if (!mIsGameOver) {
            //标识最后一子
            if (chessArray.size() > 0) {
                drawCircle(canvas, chessArray.get(chessArray.size() - 1));
            }
            //标识建议位置
            if (suggestPoint != null) {
                mPaint.setColor(Color.GRAY);
                drawCircle(canvas, suggestPoint);
            }
        } else {
            //标识连五
            for (Point point : fiveArray) {
                drawCircle(canvas, point);
            }
        }
    }

    public void drawCircle(Canvas canvas, Point point) {
        float cx = startPos + (0.5f + point.x) * mLineHeight;
        float cy = startPos + (0.5f + point.y) * mLineHeight;
        float radius = ratioPieceOfLineHeight * mLineHeight / 2;
        canvas.drawCircle(cx, cy, radius, mPaint);
    }

    public void showSuggest(Point point) {
        this.suggestPoint = point;
        postInvalidate();
    }

    public void showChessNum() {
        isDrawChessNum = !isDrawChessNum;
        postInvalidate();
    }

    public void start() {
        for (int i = 0; i < MAX_LINE; i++) {
            for (int j = 0; j < MAX_LINE; j++) {
                mBoard[i][j] = 0;
            }
        }
        mBlackArray.clear();
        mWhiteArray.clear();
        chessArray.clear();
        suggestPoint = null;
        mIsGameOver = false;
        mWinner = 0;
        userChess = RenjuConstant.BLACK_CHESS;
        invalidate();
    }

    public boolean isFull() {
        for (int i = 0; i < MAX_LINE; i++) {
            for (int j = 0; j < MAX_LINE; j++) {
                if (mBoard[i][j] == RenjuConstant.N0_CHESS) {
                    return false;
                }
            }
        }
        return true;
    }

    public void setUserChess(int userChess) {
        this.userChess = userChess;
    }

    public void setUserBout(boolean userBout) {
        isUserBout = userBout;
    }

    public void setCallBack(RenjuCallback callBack) {
        this.callBack = callBack;
    }

    public int getUserScore() {
        return userScore;
    }

    public int getAiScore() {
        return aiScore;
    }

    public boolean isGameOver() {
        return mIsGameOver;
    }

    public int getUserChess() {
        return userChess;
    }

    /**
     * 玩家是否执黑
     *
     * @return boolean
     */
    public boolean isUserBlack() {
        return userChess == (isHumanComputer() ? RenjuConstant.BLACK_CHESS : RenjuConstant.WHITE_CHESS);
    }

    /**
     * 是否人机
     *
     * @return 人机
     */
    public boolean isHumanComputer() {
        return gameMode == RenjuConstant.HUMAN_COMPUTER;
    }
}

主要都在onDraw方法中：

坐标.png 棋盘线和小黑点.png

用约束布局布置页面:

布局页面.png

Ai实现类代码，也就是jar包代码，如果需要定制，可修改方法的访问修饰符:

package win.regin.renju

import android.graphics.Point
import kotlinx.coroutines.experimental.android.UI
import kotlinx.coroutines.experimental.launch

/**
 * @author :Reginer in  2018/7/9 20:07.
 * 联系方式:QQ:282921012
 * 功能描述:五子棋ai
 */
class Ai(private val callBack: RenjuCallback) {
    var aiChess: Int = RenjuConstant.N0_CHESS
    private val aiObject: Long
    private var lastPoint: Point? = null
    private val timeMap = arrayListOf(2000, 5000, 10000, 30000, 60000)
    /**
     * ai是否正在思考
     */
    var isAiThing = false

    /**
     * 获取ai
     */
    private external fun getAiObject(): Long

    /**
     * 思考最佳点
     */
    private external fun getBestPoint(aiObject: Long, move: Int): Int

    /**
     * 重新开始
     */
    private external fun aiRestart(aiObject: Long)

    /**
     * 悔棋
     */
    private external fun aiUndo(aiObject: Long)

    /**
     * 玩家下一子
     */
    private external fun aiMove(aiObject: Long, move: Int)

    /**
     * 思考结束时间
     */
    private external fun setStepTime(aiObject: Long, time: Int)

    /**
     * 提示
     */
    private external fun getSuggest(aiObject: Long): Int

    init {
        this.aiObject = getAiObject()
    }

    /**
     * 当前回合轮到AI
     *
     * @param p p
     */
    fun aiBout(p: Point?) {
        launch {
            isAiThing = true
            lastPoint = p
            val lastMove: Int = if (null == lastPoint) {
                -1
            } else {
                lastPoint!!.x * 16 + lastPoint!!.y
            }

            val best = getBestPoint(aiObject, lastMove)
            val bestPoint = Point(getPointX(best), getPointY(best))
            launch(UI) {
                callBack.atBell(bestPoint, true, aiChess == RenjuConstant.BLACK_CHESS)
                isAiThing = false
            }
        }
    }

    fun addChess(p: Point) {
        lastPoint = p
        aiMove(aiObject, p.x * 16 + p.y)
    }

    /**
     * AI建议
     *
     * @return Point
     */
    fun suggest(): Point {
        isAiThing = true
        val p = getSuggest(aiObject)
        isAiThing = false
        return Point(getPointX(p), getPointY(p))
    }

    fun restart() {
        isAiThing = true
        aiRestart(aiObject)
        isAiThing = false
    }

    fun undo() {
        isAiThing = true
        aiUndo(aiObject)
        isAiThing = false
    }

    /**
     * 设置级别
     * @param level 0初级 1中级  2高级 3大师 4特大
     */
    fun setLevel(level: Int) {
        isAiThing = true
        setStepTime(aiObject, timeMap[level])
        isAiThing = false
    }

    /**
     * 获取玩家执子
     */
    fun getUserChess(): Int {
        return if (aiChess == RenjuConstant.WHITE_CHESS) RenjuConstant.BLACK_CHESS else RenjuConstant.WHITE_CHESS
    }

    private fun getPointX(p: Int): Int {
        return p shr 4
    }

    private fun getPointY(p: Int): Int {
        return p and 15
    }

    companion object {

        init {
            System.loadLibrary("renju-lib")
        }
    }
}

下面开始撸代码:

进入页面选择执子:

/**
     * 初始化PopWindow
     *
     * @param width  宽度
     * @param height 高度
     */
    private fun initPop(width: Int, height: Int) {
        if (mChooseChess == null) {
            val view = View.inflate(this, R.layout.view_pop_choose_chess, null)
            val white = view.findViewById<ImageButton>(R.id.choose_white)
            val black = view.findViewById<ImageButton>(R.id.choose_black)
            white.setOnClickListener {
                SoundPlayUtils.play(HintConstant.GAME_START)
                rvRenju.setUserBout(false)
                rvRenju.userChess = RenjuConstant.WHITE_CHESS
                mAi.aiChess = RenjuConstant.BLACK_CHESS
                aiThink(null)
                mChooseChess?.dismiss()
            }
            black.setOnClickListener {
                SoundPlayUtils.play(HintConstant.GAME_START)
                rvRenju.setUserBout(true)
                rvRenju.userChess = RenjuConstant.BLACK_CHESS
                mAi.aiChess = RenjuConstant.WHITE_CHESS
                mChooseChess?.dismiss()
            }
            mChooseChess = PopupWindow(view, width, height)
            mChooseChess?.isOutsideTouchable = false
            mChooseChess?.showAtLocation(rvRenju, Gravity.CENTER, 0, 0)
        }
    }

落子:

override fun atBell(p0: Point, isAi: Boolean, isBlack: Boolean) {
        imgFlag.setImageResource(if (isBlack) R.drawable.ic_white_chess
        else R.drawable.ic_black_chess)
        SoundPlayUtils.play(HintConstant.GAME_MOVE)
        if (isAi) aiAtBell(p0) else userAtBell(p0)
    }

 /**
     * ai落子
     */
    private fun aiAtBell(p: Point?) {
        rvRenju.addChess(p, mAi.aiChess)
        rvRenju.setUserBout(true)
        rvRenju.checkGameOver()
    }

    /**
     * 玩家落子
     */
    private fun userAtBell(p: Point) {
        if (rvRenju.isHumanComputer) aiThink(p) else mAi.addChess(p)
    }

新局:

newRenju -> {
                if (rvRenju.isHumanComputer) {
                    mChooseChess?.showAtLocation(rvRenju, Gravity.CENTER, 0, 0)
                }
                mAi.restart()
                rvRenju.start()
            }

悔棋：

 undo -> {
                if (rvRenju.chessCount >= 2) {
                    mAi.undo()
                    rvRenju.undo()
                }
            }

Ai级别:

 level -> {
                var levelPosition = SpUtils[RenjuConstant.RENJU_LEVEL, 0] as Int
                levelPosition = if (levelPosition < 4) levelPosition + 1 else 0
                level.text = resources.getStringArray(R.array.renju_level)[levelPosition]
                SpUtils.put(RenjuConstant.RENJU_LEVEL,levelPosition)
                mAi.setLevel(levelPosition)
            }

提示:

 suggest -> {
                if (!rvRenju.isGameOver) {
                    rvRenju.setUserBout(false)
                    launch {
                        val suggestPoint = mAi.suggest()
                        launch(UI) {
                            rvRenju.setUserBout(true)
                            rvRenju.showSuggest(suggestPoint)
                        }
                    }
                }
            }

模式：人机、人人:

mode -> {
                if (TextUtils.equals(mode.text.toString(), getString(R.string.human_human))) {
                    mode.text = getString(R.string.human_computer)
                    rvRenju.gameMode = RenjuConstant.HUMAN_COMPUTER
                    mAi.aiChess = rvRenju.userChess
                    rvRenju.userChess = mAi.getUserChess()
                    rvRenju.setUserBout(false)
                    aiThink(null)
                } else {
                    mode.text = getString(R.string.human_human)
                    rvRenju.gameMode = RenjuConstant.HUMAN_HUMAN
                }
            }

游戏结束:

override fun gameOver(winner: Int) {
        SoundPlayUtils.play(HintConstant.GAME_OVER)
        toast(
                when (winner) {
                    RenjuConstant.BLACK_CHESS -> R.string.black_win
                    RenjuConstant.WHITE_CHESS -> R.string.white_win
                    else -> R.string.no_win
                })
    }

源码地址