精华内容
下载资源
问答
  • 井字棋游戏规则
    千次阅读
    2022-02-08 21:09:25
    # 全局常量
    best_weizhi = (4, 0, 2, 6, 8, 1, 3, 5, 7)
    win = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6))
    X = "X"
    O = "O"
    EMPTY = " "
    
    
    # 定义函数产生一个新的棋盘
    def new_board():
        board = []
        for square in range(9):
            board.append(EMPTY)
        return board
    
    
    # 询问该谁下棋
    def ask_yes_no(question):
        response = None
        # 如果输入不是"y", "n",继续重新输入
        while response not in ("y", "n"):
            response = input(question).lower()
        return response
    
    
    # 询问谁先走,先走方为X,后走方为O
    # 函数返回电脑方、玩家的角色代号
    def pieces():
        go_first = ask_yes_no("玩家你是否先走 (y/n): ")
        if go_first == "y":
            print("\n玩家你先走.")
            human = X
            computer = O
        else:
            print("\n电脑先走.")
            computer = X
            human = O
        return computer, human
    
    
    # 显示棋盘
    def display_board(board):
        board2 = board[:]  # 创建副本,修改不影响原来列表board
        for i in range(len(board)):
            if board[i] == EMPTY:
                board2[i] = i
        print("\t", board2[0], "|", board2[1], "|", board2[2])
        print("\t", "---------")
        print("\t", board2[3], "|", board2[4], "|", board2[5])
        print("\t", "---------")
        print("\t", board2[6], "|", board2[7], "|", board2[8], "\n")
    
    
    # 输入你想下的位置数字
    def ask_number(question, low, high):
        response = None
        while response not in range(low, high):
            response = int(input(question))
        return response
    
    
    # 产生可以合法走棋位置序列(也就是还未下过子位置)
    def legal_moves(board):
        moves = []
        for i in range(9):
            if board[i] == EMPTY:
                moves.append(i)
        return moves
    
    
    # 判断输赢
    def winner(board):
        for row in win:
            if board[row[0]] == board[row[1]] == board[row[2]] != EMPTY:
                winner = board[row[0]]
                return winner  # 返回赢方
        # 棋盘没有空位置
        if EMPTY not in board:
            return "True"  # "平局和棋,游戏结束"
        return False
    
    
    # 人走棋
    def human_move(board, human):
        legal = legal_moves(board)
        move = None
        while move not in legal:
            move = ask_number("你走那个位置? (0 - 9):", 0, 9)
            if move not in legal:
                print("\n此位置已经落过子了")
        return move
    
    
    # 电脑走棋
    def computer_move(board, computer, human):
        # make a copy to work with since function will be changing list
        board = board[:]  # 创建副本,修改不影响原来列表board
        # 按优劣顺序排序的下棋位置best_weizhi
        # 如果电脑能赢,就走那个位置
        for move in legal_moves(board):
            board[move] = computer
            if winner(board) == computer:
                print("电脑下棋位置是", move)
                return move
            # 取消走棋方案
            board[move] = EMPTY
        # 如果玩家能赢,就堵住那个位置
        for move in legal_moves(board):
            board[move] = human
            if winner(board) == human:
                print("电脑下棋位置是", move)
                return move
            # 取消走棋方案
            board[move] = EMPTY
        # 不是上面情况则,也就是这一轮时都赢不了则
        # 从最佳下棋位置表中挑出第一个合法位置
        for move in best_weizhi:
            if move in legal_moves(board):
                print("电脑下棋位置是", move)
                return move
    
    
    # 转换角色
    def next_turn(turn):
        if turn == X:
            return O
        else:
            return X
    
    
    # 主方法:
    def main():
        computer, human = pieces()
        turn = X
        board = new_board()
        display_board(board)
    
        while not winner(board):
            if turn == human:
                move = human_move(board, human)
                board[move] = human
            else:
                move = computer_move(board, computer, human)
                board[move] = computer
            display_board(board)
            turn = next_turn(turn)
            the_winner = winner(board)
        # 游戏结束输出输赢信息
        if the_winner == computer:
            print("电脑赢!\n")
        elif the_winner == human:
            print("玩家赢!\n")
        elif the_winner == "True":  # "平局"
            print("平局,和棋,游戏结束\n")
    
    
    # start the program
    main()
    input("按任意键退出游戏.")
    # 全局常量
    best_weizhi = (4, 0, 2, 6, 8, 1, 3, 5, 7)
    win = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6))
    X = "X"
    O = "O"
    EMPTY = " "
    
    
    # 定义函数产生一个新的棋盘
    def new_board():
        board = []
        for square in range(9):
            board.append(EMPTY)
        return board
    
    
    # 询问该谁下棋
    def ask_yes_no(question):
        response = None
        # 如果输入不是"y", "n",继续重新输入
        while response not in ("y", "n"):
            response = input(question).lower()
        return response
    
    
    # 询问谁先走,先走方为X,后走方为O
    # 函数返回电脑方、玩家的角色代号
    def pieces():
        go_first = ask_yes_no("玩家你是否先走 (y/n): ")
        if go_first == "y":
            print("\n玩家你先走.")
            human = X
            computer = O
        else:
            print("\n电脑先走.")
            computer = X
            human = O
        return computer, human
    
    
    # 显示棋盘
    def display_board(board):
        board2 = board[:]  # 创建副本,修改不影响原来列表board
        for i in range(len(board)):
            if board[i] == EMPTY:
                board2[i] = i
        print("\t", board2[0], "|", board2[1], "|", board2[2])
        print("\t", "---------")
        print("\t", board2[3], "|", board2[4], "|", board2[5])
        print("\t", "---------")
        print("\t", board2[6], "|", board2[7], "|", board2[8], "\n")
    
    
    # 输入你想下的位置数字
    def ask_number(question, low, high):
        response = None
        while response not in range(low, high):
            response = int(input(question))
        return response
    
    
    # 产生可以合法走棋位置序列(也就是还未下过子位置)
    def legal_moves(board):
        moves = []
        for i in range(9):
            if board[i] == EMPTY:
                moves.append(i)
        return moves
    
    
    # 判断输赢
    def winner(board):
        for row in win:
            if board[row[0]] == board[row[1]] == board[row[2]] != EMPTY:
                winner = board[row[0]]
                return winner  # 返回赢方
        # 棋盘没有空位置
        if EMPTY not in board:
            return "True"  # "平局和棋,游戏结束"
        return False
    
    
    # 人走棋
    def human_move(board, human):
        legal = legal_moves(board)
        move = None
        while move not in legal:
            move = ask_number("你走那个位置? (0 - 9):", 0, 9)
            if move not in legal:
                print("\n此位置已经落过子了")
        return move
    
    
    # 电脑走棋
    def computer_move(board, computer, human):
        # make a copy to work with since function will be changing list
        board = board[:]  # 创建副本,修改不影响原来列表board
        # 按优劣顺序排序的下棋位置best_weizhi
        # 如果电脑能赢,就走那个位置
        for move in legal_moves(board):
            board[move] = computer
            if winner(board) == computer:
                print("电脑下棋位置是", move)
                return move
            # 取消走棋方案
            board[move] = EMPTY
        # 如果玩家能赢,就堵住那个位置
        for move in legal_moves(board):
            board[move] = human
            if winner(board) == human:
                print("电脑下棋位置是", move)
                return move
            # 取消走棋方案
            board[move] = EMPTY
        # 不是上面情况则,也就是这一轮时都赢不了则
        # 从最佳下棋位置表中挑出第一个合法位置
        for move in best_weizhi:
            if move in legal_moves(board):
                print("电脑下棋位置是", move)
                return move
    
    
    # 转换角色
    def next_turn(turn):
        if turn == X:
            return O
        else:
            return X
    
    
    # 主方法:
    def main():
        computer, human = pieces()
        turn = X
        board = new_board()
        display_board(board)
    
        while not winner(board):
            if turn == human:
                move = human_move(board, human)
                board[move] = human
            else:
                move = computer_move(board, computer, human)
                board[move] = computer
            display_board(board)
            turn = next_turn(turn)
            the_winner = winner(board)
        # 游戏结束输出输赢信息
        if the_winner == computer:
            print("电脑赢!\n")
        elif the_winner == human:
            print("玩家赢!\n")
        elif the_winner == "True":  # "平局"
            print("平局,和棋,游戏结束\n")
    
    
    # start the program
    main()
    input("按任意键退出游戏.")
    
    

    需求分析

    能实现人机交替落子,当行,列或对角有连续三个相同一方棋时,则判定一方胜利,若无此情形为和局。

    系统设计

    游戏中,board棋盘存储玩家、计算机的落子信息,未落子处未EMPTY。由于人机对战,需要实现计算机智能性,下面是为这个计算机机器人设计的简单策略:
    如果有一步棋可以让计算机机器人在本轮获胜,那就选那一步走。
    否则,如果有一步棋可以让玩家在本轮获胜,那就选那一步走。
    否则,计算机机器人应该选择最佳位置来走。
    最佳位置就是中间,其次是四个角
    定义第一个元组best_weizhi存储最佳方格位置:
    按优劣顺序排序的下棋位置
    best_weizhi= (4, 0, 2, 6, 8, 1, 3, 5, 7)
    井字棋盘输赢判断规则只有8种方式。每种获胜方式都被写成一个元组,利用嵌套元组表达:
    win = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6),(1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6))

    更多相关内容
  • 井字棋盘游戏

    2021-02-07 20:23:17
    井字棋盘游戏规则:一共有三行三列的位置,在这九个位置中如果有其中一行或者一列是相同的则下该棋子的人获胜 你的游戏对手是ai package game; public class Main { public static void main(String[] args) { ...

    问题描述:

    井字棋盘游戏规则:一共有三行三列的位置,在这九个位置中如果有其中一行或者一列是相同的则下该棋子的人获胜 你的游戏对手是ai

    package game;
    
    public class Main {
        public static void main(String[] args) {
            Player player =new Player();
            Game game=new Game(player);
    
            while(true) {
                game.initialize();
                game.play();
                game.destroy();
                boolean b=player.queryContinue();
                if(!b) {
                    System.out.println("游戏结束");
                    break;
                }
            }
        }
    
    
    }
    
    
    package game;
    //实例化一个Game 是一局游戏,,有三种构造方法  initialize  play  destroy
    public class Game {
        private final Chessboard chessboard;
        private final Player player;
        private final AI ai;
    
        public Game(Player player) {
            this.ai=new AI();
            this.chessboard=new Chessboard();
            this.player=new Player();
    
        }
    
        //游戏开始前的准备工作
        public void initialize(){
            System.out.println("进入井字游戏");
            System.out.println(chessboard);
        }
    
        //游戏主循环
        public void play(){
            while(true) {
    
                if(aiTurn()) {
                    break;
                }
    
                if(playerTurn()) {
                    break;
                }
            }
        }
    
        private boolean aiTurn() {
            System.out.println("AI 落子");
            int [] rc=ai.getRowColumn();
            int row=rc[0];
            int column=rc[1];
            while (!chessboard.moveCircleAt(row,column)) {
                rc=ai.getRowColumn();
                row=rc[0];
                column=rc[1];
    
            }
    
            System.out.println(chessboard);
    
            return chessboard.getState()!=Chessboard.Continue;
        }
    
        private boolean playerTurn() {
            System.out.println("玩家落子");
            int [] rc=player.getRowColumn();
            int row=rc[0];
            int column=rc[1];
            while (!chessboard.moveCrossAt(row,column)) {
                System.out.println("落子位置有子,请重新选位置落子");
                rc=player.getRowColumn();
                row=rc[0];
                column=rc[1];
            }
            System.out.println(chessboard);
            return chessboard.getState()!=Chessboard.Continue;
        }
        //游戏结束 {
    
        public void destroy() {
            chessboard.reset();
        }
    
    }
    
    
    package game;
    
    import java.util.Arrays;
    
    public class Chessboard {
        private static int 空白=0;
        private static int=1;
        private static int=2;
    
        private int[][] array={
                {空白,空白,空白},
                {空白,空白,空白},
                {空白,空白,空白}
        };
        public boolean moveCircleAt(int row,int column) {
            if(array[row][column]==||array[row][column]==) {
                return false;
            }
            array[row][column]=;
            return true;
        }
    
        public boolean moveCrossAt(int row, int column) {
            if(array[row][column]==||array[row][column]==) {
                return false;
            }
            array[row][column]=;
            return true;
        }
        public static final int Circle_win=0;  //圈赢了
        public static final int Cross_win=1;  //×赢了
        public static final int Draw=2;  //平局
        public static final int Continue=3; //继续
        public int getState() {
            for (int i=0;i<3;i++) {
                if(array[0][i]==array[1][i]&&array[0][i]==array[2][i]&&array[0][i]!=空白) {
                    if(array[0][i]==) {
                        System.out.println("恭喜ai获胜");
                        return Circle_win;
                    } else {
                        System.out.println("恭喜玩家获胜");
                        return Cross_win;
                    }
                }
                if(array[i][0]==array[i][1]&&array[i][0]==array[i][2]&&array[i][0]!=空白) {
                    if(array[i][0]==) {
                        System.out.println("恭喜ai获胜");
                        return Circle_win;
                    } else {
                        System.out.println("恭喜玩家获胜");
                        return Cross_win;
                    }
                }
    
            }
            if(array[0][0]==array[1][1]&&array[0][0]==array[2][2]&&array[0][0]!=空白){  //斜线位置有人赢了
                if(array[0][0]==){
                    System.out.println("恭喜ai获胜");
                    return Circle_win;
                }else {
                    System.out.println("恭喜玩家获胜");
                    return Cross_win;
                }
            }
            if(array[0][2]==array[1][1]&&array[0][2]==array[2][0]&&array[0][2]!=空白){  //斜线位置有人赢了
                if(array[0][2]==){
                    System.out.println("恭喜ai获胜");
                    return Circle_win;
                }else {
                    System.out.println("恭喜玩家获胜");
                    return Cross_win;
                }
            }
            for (int i=0;i<3;i++) {
                for (int j=0;j<3;j++) {
                    if(array[i][j]==空白){
                        System.out.println("游戏继续");
                        return Continue;
                    }
                }
            }
            System.out.println("平局");
            return Draw;
        }
    
        private static String 显示(int i) {
            if(i==空白) {
                return "空白";
            }
            if(i==) {
                return "圈";
            }
            if(i==) {
                return "叉";
            }
            return "  ";
        }
    
        @Override
        public String toString() {
            String s="+-+-+-+\n";
            for (int i=0;i<2;i++) {
                s+=String.format("|%s|%s|%s|\n", 显示(array[i][0]),显示(array[i][1]),显示(array[i][2]));
                s+="+-+-+-+\n";
            }
            s+=String.format("|%s|%s|%s|\n", 显示(array[2][0]),显示(array[2][1]),显示(array[2][2]));
            s+="+-+-+-+\n";
            return s;
        }
    
        public void reset() {
            Arrays.fill(array,空白);
        }
    
    
    
    }
    
    
    ```java
    package game;
    
    import java.util.Random;
    
    public class AI {
        private final Random random=new Random();
        //返回落子位置
        public int [] getRowColumn() {
            int r=random.nextInt(3);
            int c=random.nextInt(3);
            int [] m={r,c};
            return m;
        }
    }
    
    
    package game;
    
    import java.util.Scanner;
    
    public class Player {
        //private Scanner scanner=new Scanner(System.in);
    
        public int[] getRowColumn() {
            System.out.println("输入要落子的位置  行 ");
            Scanner sc=new Scanner(System.in);
            int r=sc.nextInt();
            System.out.println("输入要落子的位置  列");
            Scanner sca=new Scanner(System.in);
            int c=sca.nextInt();
            System.out.println(">>>");
            if((r<0||r>2)||(c<0||c>2)) {
                System.out.println("不满足有效范围");
                return null;
            }
    
            return new int[] {r,c};
        }
    
        //询问用户是否继续
        public boolean queryContinue() {
            System.out.println("是否开始一局新游戏");
            System.out.println(">>>");
            Scanner scanner =new Scanner(System.in);
            return scanner.nextBoolean();
        }
    }
    
    
    展开全文
  • 一、两人井字棋游戏 在井字游戏中,两个玩家使用各自的标志(一方用 X 则另一方就用 O ),轮流标记 3 ×3 的网格中的某个空格。当一个玩家在网格的水平方向、垂直方向或者对角线方向上标记了三个相同的 X 或三个...

    一、两人井字棋游戏

    在井字游戏中,两个玩家使用各自的标志(一方用 X 则另一方就用 O ),轮流标记 3 ×3 的网格中的某个空格。当一个玩家在网格的水平方向、垂直方向或者对角线方向上标记了三个相同的 X 或三个相同的 O 时,游戏结束,该玩家获胜。平局(没有赢家)是指当网格中所有的空格都被填满时没有玩家获胜的情况。
     

    完整代码来自这篇博客:

    Java 井字游戏_Sun Tech的博客-CSDN博客_java 井字游戏创建一个玩井字游戏的程序。程序提示两个玩家交替输入 X 和 O 标记。当输入一个标记时,程序在控制台上重新显示棋盘,然后确定游戏的状态(是获胜、平局还是继续)。https://blog.csdn.net/baidu_34431530/article/details/100133846

    import java.util.Scanner;
    public class Game {
        private static Scanner input = new Scanner(System.in);
        public static void main(String[] args) {
            char[][] board = new char[3][3];
            displayBoard(board);
            while (true) {
                makeAMove(board, 'X');
                displayBoard(board);
                if (isWon('X', board)) {
                    System.out.println("玩家 X 获胜");
                    System.exit(1);
                }
                else if (isDraw(board)) {
                    System.out.println("平局");
                    System.exit(2);
                }
                makeAMove(board, 'O');
                displayBoard(board);
                if (isWon('O', board)) {
                    System.out.println("玩家 O 获胜");
                    System.exit(3);
                }
                else if (isDraw(board)) {
                    System.out.println("平局");
                    System.exit(4);
                }
            }
        }
        private static void makeAMove(char[][] board, char player) {
            boolean done = false;
            do {
                System.out.print("玩家 " + player + " :(行,列) = ");
                int row = input.nextInt();
                int column = input.nextInt();
                if (board[row][column] == '\0') {
                    board[row][column] = player;
                    done = true;
                }
                else
                    System.out.println("无效输入");
            }
            while (!done);
        }
        private static void displayBoard(char[][] board) {
            System.out.println("\n ——— ——— ———");
            for (int i = 0; i < 3; i++) {
                System.out.print("| ");
                for (int j = 0; j < 3; j++)
                    System.out.print(board[i][j] != '\0' ?  board[i][j] + " | ": "  | ");
                System.out.println("\n ——— ——— ———");
            }
        }
        private static boolean isWon(char ch, char[][] board) {
            for (int i = 0; i < 3; i++)
                if (ch == board[i][0] && ch == board[i][1] && ch == board[i][2])
                    return true;
            for (int j = 0; j < 3; j++)
                if (ch == board[0][j] && ch == board[1][j] && ch == board[2][j])
                    return true;
            if (ch == board[0][0] && ch == board[1][1] && ch == board[2][2])
                return true;
            return ch == board[0][2] && ch == board[1][1] && ch == board[2][0];
        }
        private static boolean isDraw(char[][] board) {
            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j++)
                    if (board[i][j] == '\0')
                        return false;
            return true;
        }
    }

    二、多人井字棋游戏

    今天我们要做的就是对其进行创新。新增规则如下:

    (1)支持3~10人同时玩游戏。棋盘大小为玩家人数+1

    (2)游戏开始前,设定游戏获胜需要多少个连续的棋子,连续棋子的个数最少为3,最大为玩家人数+1(即棋盘的大小)

    代码

    设计了3个类

     1. Board 类

    package com.tictactoe;
    
    public class Board {
        private char[][] board ;
    
        //创建棋盘
        //Done!
        public void createBoard(int size){
            board = new char[size][size];  //创建初始棋盘,棋子默认为空
        }
    
        //绘制棋盘
        //Done!
        public void drawBoard(int size){
            for(int i=0; i< size; i++){  //最上面的线
                System.out.print(" ———");
            }
            System.out.print("\n");
            for (int i = 0; i < size; i++) { //每一列
                System.out.print("| ");
                for (int j = 0; j < size; j++)
                    System.out.print(board[i][j] != '\0' ?  board[i][j] + " | ": "  | ");
                System.out.print("\n");
                for(int k=0; k< size; k++){  //最下面的线
                    System.out.print(" ———");
                }
                System.out.print("\n");
            }
            System.out.print("\n");
       }
    
       //玩家下棋后,改变棋盘数组board
       //Done!
        public void changeBoard(int row,int column,char player){
            board[row][column]=player;
        }
    
        //查看棋盘
        //Done!
        public char[][] getBoard() {
            return board;
        }
    }
    

    棋盘类中没有什么难点。主要就是创建一个二维char类型的空棋盘、在控制台画出棋盘和已有的棋子、改变棋盘等操作。

    2. GameLogic 类(难点!

    package com.tictactoe;
    import java.util.Scanner;
    
    
    public class GameLogic {
        private static Scanner input = new Scanner(System.in);
    
        //玩家下一个棋子,改变棋盘布局
        //Done!
        public void makeAMove(Board board, char player) {
            char[][] board2 = board.getBoard();     //获取棋盘目前状态
            boolean done = false;  //用来判断循环,用户第一次输入的是正确位置就一次循环;否则进入下一次
            do {
                System.out.print("玩家 " + player + " :(行,列) = ");
                int row = input.nextInt();  //玩家输入棋子的行数
                int column = input.nextInt();  //玩家输入棋子的列数
                if (board2[row][column] == '\0') {
                    board.changeBoard(row,column,player);  //玩家成功下了一棋!
                    done = true;  //有位置就放下,跳出这个循环
                }
                else
                    System.out.println("无效输入");  //玩家选择的位置已经有棋子了,重新下
            }
            while (!done);
        }
    
        //判断player是否赢了,返回true为赢
        //思路:仿照卷积核进行卷积的过程
        public boolean isWon(char player, Board board,int piece,int size) {
            char[][] board2 = board.getBoard();     //获取棋盘目前状态
    
            for(int row=0; row<=size-piece;row++){
                for(int col=0;col<=size-piece;col++){
                    /*-----------------以piece×piece为大小的内部检查-------------*/
                    //行相同
                    for(int i=row;i<row+piece;i++){
                        for(int j=col;j<col+piece;j++){
                            if(player==board2[i][j]){
                                if(j==col+piece-1) return true; //找到满足条件的行
                            }else break;  //这一行不满足,跳出内循环,检查下一行
                        }
                    }
                    //列相同
                    for(int j=col;j<col+piece;j++){
                        for(int i=row;i<row+piece;i++){
                            if(player==board2[i][j]){
                                if(i==row+piece-1) return true; //找到满足条件的列
                            }else break; //这一列不满足,检查下一列
                        }
                    }
                    //正对角线相同
                    for(int k=0;k<piece;k++){
                        if(player==board2[row+k][col+k]){
                            if(row+k==row+piece-1) return true; //找到满足条件的正对角线
                        }else break; //正对角线不满足
                    }
                    //负对角线
                    int row2=row+piece-1;
                    int col2=col;
                    for(int k=0;k<piece;k++){
                        if(player==board2[row2-k][col2+k]){
                            if(row2-k==row) return true; //找到满足条件的副对角线
                        }else break; //负对角线不满足
                    }
                }
            }
            return false;
        }
    
        //判断是否平局:返回false为否,返回true为平局
        //Done!
        public boolean isDraw(Board board,int size) {
            char [][]board2 = board.getBoard();
            for (int i = 0; i < size; i++)
                for (int j = 0; j < size; j++)
                    if (board2[i][j] == '\0')
                        return false; //棋盘存在空白,未平局
            return true;
        }
    }
    

    makeAMove()方法较容易理解,一行一行看下来基本上就知道逻辑了,注释也都写得很清晰。

    难点在于isWon()方法,即对player是否获胜的判断。这里利用的是卷积核的思想(不懂可以去搜“卷积神经网络”)。我们假设玩家人数为n(那么棋盘大小就是n+1),玩家规定连续m个棋子赢得游戏。那么我们就可以把棋盘看成一张(n+1)×(n+1)大小的图像,卷积核大小是m×m。在m×m大小的区域内,检查行、列、主对角线、副对角线是否有连续相同的,一旦有一种情况满足条件,立刻返回true。

    isDraw()方法:判断是否平局。棋盘都下满了就是平局,所以关键在于判断棋盘满了没有。

    3. tictactoe2 类

    package com.tictactoe;
    
    import java.util.Scanner;
    
    public class tictactoe2 {
        private static Scanner input = new Scanner(System.in);
        public static void main(String[] args) {
            /*--------输入玩家人数、输入连续棋子的个数------*/
            System.out.println("请输入玩家的个数(3~10人):");
            int player_num = input.nextInt();
            System.out.println("请输入赢家连续棋子的个数(最少为3,最大为玩家人数+1):");
            int piece_num = input.nextInt();
    
            /*-------------初始化棋盘---------------*/
            int size = player_num + 1; //棋盘的大小
            Board board = new Board();
            board.createBoard(size); //创建棋盘
            board.drawBoard(size); //绘制初始棋盘
    
            /*-------------初始化玩家------------*/
            char player[] = new char[player_num];
            for(int i=0; i<player_num;i++){
                int temp = 97+i;  //准备由int向char进行转换
                player[i]= (char) temp;  //用字母a~j表示0号~9号玩家(根据题目要求,最多10人,第10人为j)
            }
            /*--------------开始下棋-------------*/
            GameLogic logic = new GameLogic();
            int play_i=0; //从0号玩家开始
            while (true) {
    
                logic.makeAMove(board,player[play_i]);  //下棋,更新棋盘
                board.drawBoard(size); //绘制新棋盘
                if (logic.isWon(player[play_i], board,piece_num,size)) {  //判断第i号玩家是否获胜
                    System.out.println("玩家"+player[play_i]+"获胜");
                    System.exit(1);
                }
                else if (logic.isDraw(board,size)) {  //判断是否平局
                    System.out.println("平局");
                    System.exit(2);
                }
    
                if(play_i<player_num-1){
                    play_i++; //下一个玩家
                }else {
                    play_i=0;  //又轮到0号玩家
                }
            }
        }
    
    }
    
    
    

    这里稍微难一点的地方有两点。

    1)利用int类型向char类型的转换,把1~10号玩家分别用字母a~j去表示。

    2)另一个难点在于如何实现玩家轮着下棋。重点看play_i这个变量就明白了

    4. 玩法示例

    (1)示例1

    (2)平局示例

     

    5. 总结

    (1)对类的封装还不是太好,如果再写一个player类,程序的封装性就更好了

    (2)学习了Sanner的使用。主要就是四个函数。

            

    展开全文
  • 井字棋游戏

    2016-05-19 22:10:20
    人工智能大作业,井字棋游戏,并以图形界面展示
  • 井字游戏规则算法

    2021-08-18 16:56:19
    井字游戏 EE-551 Python 项目 客观的: 这个 EE-551 项目旨在使用 python 开发一个 Tic Tac Toe 游戏。它主要包括开发和实现一个计算机程序,该程序可以与另一个玩家玩 Tic Tac Toe。 为了了解什么是井字游戏以及...

    井字游戏

    EE-551 Python 项目

    客观的:

    这个 EE-551 项目旨在使用 python 开发一个 Tic Tac Toe 游戏。它主要包括开发和实现一个计算机程序,该程序可以与另一个玩家玩 Tic Tac Toe。
    为了了解什么是井字游戏以及如何玩游戏,以下是说明。

    游戏说明:

    Tic Tac Toe 是一种两人游戏(其中一个由计算机或人类玩)。在这个游戏中,有一个 3 x 3 方格的棋盘。

    两名玩家轮流在 3x3 棋盘上打分。Tic Tac Toe 游戏的目标是成为在 3 x 3 网格上水平、垂直或对角线获得三个相同符号的玩家之一。最先获得 3 个他/她的符号(标记)的玩家 - 垂直、水平或对角线赢得游戏,另一个玩家输掉游戏。游戏可以由两个玩家玩。玩家有两种选择:(a) 人类 (b) 计算机

    游戏规则:

    玩家可以与对手在两个符号之间进行选择,通常的游戏使用“X”和“O”。

    1. 先上场的玩家将获得“X”标记(我们称他/她的玩家为 1),第二位上场的玩家将获得“O”标记(我们称他/她为玩家 2)。

    2. 玩家 1 和 2 轮流走棋,玩家 1 玩标记“X”,玩家 2 玩标记“O”。

    3. 玩家用他的标记(“X”或“O”)标记任何 3x3 方格,他们的目标是创建一条水平、垂直或对角线的直线,有两个意图:
      a. 一名玩家连续获得三个他/她的分数(垂直、水平或对角线),即该玩家赢得游戏。
      湾 如果没有人可以用自己的标记创建一条直线,并且棋盘上的所有位置都被占用,则游戏以平局/平局结束。

    实施计划:

    本项目的实施工作流程如下:

    为了可视化定义的游戏规则和描述,游戏如下图所示。

    首先,游戏将从空棋盘开始。

    然后玩家 1 将通过在该板上打标记“X”来移动。然后玩家 2 将通过在该板上打标记“O”来移动。这将继续下去,直到棋盘上满是分数。

    然后程序将检查是“X”的玩家 1 获胜还是“O”的玩家 2 获胜,并且该场景将如下:(可以是垂直、水平或对角线)。

    如果没有玩家获胜,程序将检查平局。

    所有这些决策都是通过使用 Minimax 算法完成的。

    极大极小算法

    Minimax 是一种应用于两人 Tic Tac Toe 游戏的人工智能算法。这种游戏被称为零和游戏,因为在数学表示中:一个玩家赢(+1),另一个玩家输(-1)或两个人都输(0)。

    Minimax 是一种递归算法,用于选择导致 Max 玩家赢或不输(平局)的最佳移动。它考虑游戏的当前状态和该状态下的可用移动,然后对于它播放的每个有效移动(交替最小和最大),直到找到最终状态 - 赢、平或输。

    它的目标是最小化最大损失,即最小化最坏情况。

    举例说明

    为了应用这一点,让我们举一个游戏快结束时的例子,轮到我了。我是 X。显然,我在这里的目标是最大化我的最终游戏得分。

    如果这张图片的顶部代表轮到我时的游戏状态,那么我有一些选择,我可以玩三个地方,其中一个明显导致我获胜并获得 10 分。如果我不这样做,O 很容易获胜。而且我不希望 O 赢,所以我在这里的目标,作为第一个球员,应该是选择最大的得分动作。

    但是O呢?

    我们应该假设 O 也在玩赢得这场比赛,但相对于我们,第一个玩家,O 想要选择给我们带来最差分数的移动,它想要选择一个可以最小化我们最终的移动分数。让我们从 O 的角度来看事情,从上面的另外两个游戏状态开始,我们不会立即获胜。

    选择很明确,O 会选择任何导致得分为 -10 的动作。

    描述极小极大

    Minimax 算法的关键是两个玩家之间的来回,其中“轮到它”的玩家希望选择得分最高的移动。反过来,每个可用移动的分数由对方玩家决定其可用移动中的哪个具有最低分数来确定。对手玩家移动的分数再次由试图最大化其分数的轮流玩家决定,依此类推,一直到移动树到结束状态。

    算法的描述,假设 X 是轮到玩家:

    • 如果游戏结束,从 X 的角度返回分数。
    • 否则,获取每个可能移动的新游戏状态列表。
    • 创建分数列表。
    • 对于这些状态中的每一个,将该状态的极小极大结果添加到分数列表中。
    • 如果轮到 X,则返回分数列表中的最高分数。
    • 如果轮到 O,则返回分数列表中的最低分数。

    让我们用完整的走法树来看看算法的执行过程,并从算法上看,如何选择即时获胜的走法:

    • 轮到 X 进入状态 1。X 生成状态 2、3 和 4,并在这些状态上调用 minimax。
    • 状态 2 将 +10 的分数推送到状态 1 的分数列表,因为游戏处于结束状态。
    • 状态 3 和 4 不在结束状态,因此 3 生成状态 5 和 6 并对其调用 minimax,而状态 4 生成状态 7 和 8 并对其调用 minimax。
    • 状态 5 将 -10 的分数推送到状态 3 的分数列表,而状态 7 也会发生同样的情况,将 -10 的分数推送到状态 4 的分数列表。
    • 状态 6 和 8 生成唯一可用的移动,即结束状态,因此它们都将 +10 的分数添加到状态 3 和 4 的移动列表中。
    • 因为在状态 3 和状态 4 中轮到 O,所以 O 将寻求找到最小分数,并且在 -10 和 +10 之间进行选择时,状态 3 和 4 都将产生 -10。
    • 最后,状态 2、3 和 4 的得分列表分别用 +10、-10 和 -10 填充,寻求最大化得分的状态 1 将选择得分为 +10 的获胜棋步,状态 2。

    让我们通过查看可能的移动树来看看这里发生了什么:

    • 给定棋盘状态 1,其中两个玩家都玩得很完美,而 O 是计算机玩家。O 在状态 5 中选择了移动,然后当 X 在状态 9 中获胜时立即失败。
    • 但是如果 O 像状态 3 那样阻止 X 的胜利,那么 X 显然会阻止 O 的潜在胜利,如状态 7 所示。
    • 如状态 10 和 11 所示,这为 X 带来了两次确定的胜利,因此无论 O 在状态 7 中选择哪一步,X 最终都会获胜。

    该算法的另一个重要因素是深度。

    该算法的关键改进是考虑到游戏结束的“深度”或回合数,无论棋盘安排如何,完美的玩家都会完美地玩。基本上完美的球员应该完美地打球,但尽可能地延长比赛时间。

    所以每次我们调用 minimax 时,深度都会增加 1,当最终计算结束游戏状态时,分数会根据深度进行调整。

    由于这是一个非常复杂的算法,我们有一台计算机来执行这个算法。

    代码实施

    • 为了运行此代码,需要安装 pygame 库。要安装它,请打开命令提示符并键入“pip install pygame”。

    • 运行完整代码 TicTacToeGame.ipynb。

    • 运行代码后,屏幕上将显示以下窗口(空板):

    • 游戏包含两个按钮 - vs Human 和 vs AI,以便我们可以选择我们的对手。一旦我们点击按钮,通过点击游戏板开始玩游戏。由于我们先玩,我们将被定义为玩家 X。

    • 游戏结束后,游戏屏幕上将显示获胜者姓名(X 或 O)或抽奖游戏的消息。

    展开全文
  • 超级井字棋游戏棋盘每小格为小宫格,每3*3小宫格一组为大宫格,游戏规则如下: 1.3*3小宫格和3*3大宫格获胜条件与经典井字棋一致。 2.开局先手可在任意小宫格落子。 3.后手在前一落子所对应的大宫格内落子。 4.若...
  • 利用α-β剪枝算法,按照不同搜索深度,设计多个水平级别的“一字棋”游戏。...“井字棋游戏规则与“五子棋”十分类似,“五子棋”的规则是一方首先五子连成一线就胜利;“井字棋”是一方首先三子连成一线就胜利。
  • 井字棋游戏课程设计总结报告丽水学院计算机信息学院《C语言课程设计(短一)》指导书二 ○ 一一 年 三 附件二 封面格式丽水学院C语言课程设计总结报告题 目 井字棋指导教师 曹红院 系 计算机与信息工程学院专 业 ...
  • C语言实现井字棋游戏

    2021-07-27 23:11:59
    要实现井字棋,可以分一下步骤 一.打印菜单 二.打印棋盘 三.下棋 我们共创建三个文件实现游戏,game.h,game.c和gamezero.c 以上三步是大纲,由gamezero.c文件实现,gamezero.c内部调用的函数则封装在game.c中...
  • 153 }154 155 156 intmain()157 {158 puts("欢迎来玩井字棋!") ;159 160 while(1) { //游戏 161 char theBoard[10];162 for (int i = 1; i ; i++) //将棋盘设为空白 163 theBoard[i] = ‘ ‘;164 char playerLetter...
  • 本文为大家分享了python实现井字棋游戏,供大家参考,具体内容如下周五晚上上了python的选修课,本来以为老师是从python的基础语法开始的,没想到是从turtle画图开始,正好补上了我以前一些不懂的地方,有人讲一下...
  • 井字棋是一个经典的小游戏,在九宫格上玩家轮流画OXO,当每列或每行或是两个对角成一线时便是获胜。今天就用Python编写一个井字棋游戏,与电脑对战。程序执行画面如下图所示:程序提供了两种人工智能选择,一个是强...
  • 但是环境类中的4个函数都是空的,本文将描述怎么实现那4个函数,实现一个完整的井字棋游戏的环境。游戏规则:两个玩家在3x3的棋盘上,一方执X,一方执O。哪方先下的连续3个子(不管在对角,竖直还是水平方向)为胜。...
  • 井字棋

    千次阅读 2015-08-21 09:41:28
    小武是井字棋的忠实粉丝,井字棋,又称为井字游戏、井字过三关等,是种纸笔游戏。其具体玩法为: 两个玩家,一个打圈(O),一个打叉(X),轮流在3乘3的格上打自己的符号,最先以横、直、斜连成一线则为胜。当9个格子...
  • qt制作棋牌游戏之XO棋(井字棋)

    千次阅读 2022-02-11 16:53:43
    原理很简单,就是点击鼠标进行下子,电脑与你进行博弈 没事做做还是挺有意思的。 源码在下面: mylabel.h #ifndef MYLABEL_H #define MYLABEL_H #include <QWidget> #include <...
  • 井字棋系统分析

    2022-06-17 08:34:53
    1.可行性分析:井字棋游戏设计对于为初学者来说,是个比较适合和有研究意义的题目。“井字棋”游戏(又叫“三子棋”),或是一字棋,是一款十分经典的益智小游戏
  • 简单井字棋设计

    2022-08-01 10:08:09
    首先介绍一下井字棋规则:在3*3的9宫格内自己的三个棋子连成一条直线为胜利。 前期准备: 首先我们需要创建两个源文件和一个头文件,如下图所示 首先我们规定test.c : 用于游戏开始时菜单的打印; 开始游戏和退出...
  • python实现井字棋

    万次阅读 多人点赞 2022-01-10 15:26:34
    参考学习:Python实现井字棋游戏 闲扯 井字棋(Tic-Tac-Toe),初高中进行打发时间的一种画x画o的游戏,3*3的格子组成,一方把行列斜行连成相同的就算获胜。 那么怎么利用进行人机对弈这种简单的小游戏那。我们先不...
  • 井字棋游戏(课程设计)总结报告C语言贪吃蛇游戏设计总结报告PAGEPAGE 5丽水学院计算机信息学院《C语言课程设计(短一)》指导书二 ○ 一一 年 三附件二 封面格式丽水学院C语言课程设计总结报告题 目 井字棋指导教师 ...
  • python入门游戏井字棋实例代码

    千次阅读 2021-12-21 16:40:42
    井字棋简介 井字棋又称三子棋,英文名为Tic Tac Toe。具体玩法为在一个3x3的棋盘上,一个玩家用X做棋子,另一个玩家用O做棋子,谁先在棋盘上的一行、一列或对角线上画满三个棋子,即可获胜,如果棋盘下满无人胜出,...
  • Python实现井字棋游戏

    千次阅读 2019-11-27 20:00:35
    推荐自己的专栏:分享一些Python案例,将所学用出来 井字棋,英文名叫Tic-Tac-Toe,是一种在3*3格子上进行的连珠游戏,和五子棋类似,由于棋盘一般不画边框,格线排成井字故得名。 游戏需要的工具仅为纸和笔,然后由...
  • 通过游戏编程学Python(7)— 井字棋(上) 通过游戏编程学Python(番外篇)— 单词小测验 通过游戏编程学Python(6)— 英汉词典、背单词 文章目录通过游戏编程学Python前言第6个游戏井字棋(下)1. 玩法简介2. ...
  • Java井字棋游戏

    千次阅读 2022-02-05 12:28:59
    // o数量 // 读入矩阵 System.out.println("---------井字棋游戏-------"); System.out.println("规则:输入1,代表X,输入0,代表O"); for (int i = 0 ; i ; i++){ // 表示这个board有几行 for (int j = 0 ; j [i]....
  • 井字棋是比较便捷休闲娱乐的一种迷你棋,玩法比较简单,只需要一个九宫格棋盘就可以实现两人对战,规则为谁先连成三个棋子的一条线即可获胜。本游戏,需要满足两个主要功能:1.能实现玩家对战;2.能实现玩家和电脑...
  • 【C语言/入门游戏设计】三子棋(井字棋)的设计和实现
  • python棋盘游戏
  • C语言小游戏——井字棋

    多人点赞 2021-11-11 20:37:54
    前言:在我们小时候经常上课开小差,与同桌下“井字棋”---也叫“三子棋”,想不想在vs上重温小时候的快乐,往下看看吧! 目录 完整代码 今天要完成一个相对于之前学习更有挑战性的小程序——三子棋。 相信...
  • 在我写这个游戏时,我发现后期会有很多函数要存储,还要经常传递棋盘的行和列,调用函数库,所以我强烈建议写一个头文件去存储行列信息,包含函数库,对函数进行声明等操作,既能方便书写,还能让代码更有流程和条理...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,132
精华内容 452
热门标签
关键字:

井字棋游戏规则

友情链接: TFT2.4Chinese.rar