Rust小练习，编写井字棋

画叉画圈的游戏通常指的是 井字棋（Tic-Tac-Toe），是一个简单的两人游戏，规则如下：

游戏规则

1. 棋盘：游戏在一个3x3的方格上进行。
2. 玩家：有两个玩家，一个用“X”表示，另一个用“O”表示。
3. 目标：玩家轮流在空格中填入自己的标记，目标是先在横向、纵向或斜向上连续放置三个相同的标记。
4. 胜利条件：一旦有玩家先形成连续的三个标记，该玩家获胜。如果所有格子都填满且没有玩家获胜，则游戏平局。

示例棋盘

 X | O | X
-----------
 O | X | O
-----------
 O |   | X

在这个示例中，标记“X”在右列形成了三个相同的标记，因此“X”获胜。

游戏策略

虽然井字棋的规则简单，但为了增加趣味性，玩家可以在游戏中使用不同的策略，例如：

• 尽量占据中心位置，以便于创建更多的胜利路径。
• 阻止对手形成连续的三个标记。

井字棋游戏Rust示例实现代码

下面是一个简单的用 Rust 编写的井字棋（Tic-Tac-Toe）游戏示例。这个示例包括基本的游戏逻辑、玩家输入处理以及胜利条件的判断。

use std::io;

#[derive(Clone, Copy, PartialEq)]
enum Player {
    X,
    O,
}

#[derive(Clone)]
struct Game {
    board: [[Option<Player>; 3]; 3],
    current_player: Player,
}

impl Game {
    fn new() -> Self {
        Game {
            board: [[None; 3]; 3],
            current_player: Player::X,
        }
    }

    // 打印棋盘
    fn print_board(&self) {
        for row in &self.board {
            for cell in row {
                let display = match cell {
                    Some(Player::X) => " X ",
                    Some(Player::O) => " O ",
                    None => " . ",
                };
                print!("{}", display);
            }
            println!();
        }
    }

    // 玩家移动
    fn player_move(&mut self, row: usize, col: usize) -> bool {
        if self.board[row][col].is_none() {
            self.board[row][col] = Some(self.current_player);
            true
        } else {
            false
        }
    }

    // 检查胜利条件
    fn check_winner(&self) -> Option<Player> {
        // 检查行
        for row in 0..3 {
            if self.board[row][0].is_some()
                && self.board[row][0] == self.board[row][1]
                && self.board[row][1] == self.board[row][2]
            {
                return self.board[row][0];
            }
        }

        // 检查列
        for col in 0..3 {
            if self.board[0][col].is_some()
                && self.board[0][col] == self.board[1][col]
                && self.board[1][col] == self.board[2][col]
            {
                return self.board[0][col];
            }
        }

        // 检查对角线
        if self.board[0][0].is_some()
            && self.board[0][0] == self.board[1][1]
            && self.board[1][1] == self.board[2][2]
        {
            return self.board[0][0];
        }

        if self.board[0][2].is_some()
            && self.board[0][2] == self.board[1][1]
            && self.board[1][1] == self.board[2][0]
        {
            return self.board[0][2];
        }

        None
    }

    // 切换玩家
    fn switch_player(&mut self) {
        self.current_player = match self.current_player {
            Player::X => Player::O,
            Player::O => Player::X,
        };
    }

    // 检查平局
    fn is_draw(&self) -> bool {
        self.board.iter().all(|row| row.iter().all(|&cell| cell.is_some()))
    }
}

fn main() {
    let mut game = Game::new();

    loop {
        game.print_board();

        println!(
            "玩家 {:?}，请输入行和列 (0-2) 用空格分隔：",
            game.current_player
        );

        let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap();
        let coords: Vec<usize> = input
            .trim()
            .split_whitespace()
            .filter_map(|s| s.parse().ok())
            .collect();

        if coords.len() != 2 {
            println!("请输入两个数字！");
            continue;
        }

        let (row, col) = (coords[0], coords[1]);

        if row >= 3 || col >= 3 {
            println!("行和列必须在 0 到 2 之间！");
            continue;
        }

        if game.player_move(row, col) {
            if let Some(winner) = game.check_winner() {
                game.print_board();
                println!("玩家 {:?} 获胜！", winner);
                break;
            }

            if game.is_draw() {
                game.print_board();
                println!("游戏平局！");
                break;
            }

            game.switch_player();
        } else {
            println!("该位置已经被占用，请选择其他位置！");
        }
    }
}

代码说明

1. 枚举和结构体：

   • Player 枚举表示玩家，可能是 X 或 O。
   • Game 结构体表示游戏状态，包括棋盘和当前玩家。

2. 游戏初始化：

   • new() 方法创建一个新的游戏实例，初始化棋盘为空（None）并将当前玩家设置为 X。

3. 打印棋盘：

   • print_board() 方法将棋盘的状态输出到终端，未占用的位置显示为 .，玩家的标记分别显示为 X 或 O。

4. 玩家移动：

   • player_move() 方法接受行和列参数，并在指定位置放置当前玩家的标记。若该位置已被占用则返回 false。

5. 胜利条件检查：

   • check_winner() 方法检查当前棋盘是否有玩家获胜。它检查每行、每列和两个对角线。

6. 切换玩家：

   • switch_player() 方法在两个玩家之间切换。

7. 平局检查：

   • is_draw() 方法检查棋盘是否已满且没有获胜者，若是则返回 true。

8. 主循环：

   • 在 main 函数中，程序不断循环，直到游戏结束。
   • 每次循环打印当前棋盘，接收玩家输入，进行移动，检查胜利或平局，并切换玩家。

运行程序

1. 依赖：这个程序不需要额外的依赖。
2. 编译和运行：使用 Rust 工具链编译和运行程序。确保你已经安装了 Rust 环境。

   cargo run
   

总结

这个简单的井字棋游戏示例展示了如何使用 Rust 进行基本的输入处理、游戏状态管理和胜利条件检查。你可以在此基础上进行扩展，例如增加图形界面、实现更复杂的 AI 玩家或优化游戏体验。希望这个示例对你有帮助！