จะสร้างเกม Tic-Tac-Toe ใน Python ได้อย่างไร?

ให้เราสร้างเกม Tic Tac Toe อย่างง่ายใน Python มันจะช่วยให้คุณสร้างตรรกะของเกมและเข้าใจวิธีจัดโครงสร้างโค้ด

การเล่นเกมเป็นหนึ่งในความบันเทิงที่มนุษย์มี เราสามารถค้นหาเกมประเภทต่างๆ บนเว็บ มือถือ เดสก์ท็อป ฯลฯ เราไม่ได้อยู่ที่นี่เพื่อสร้างเกมหนักๆ สักเกมหนึ่งในตอนนี้ เรากำลังจะสร้างเกม CLI tic-tac-toe โดยใช้ Python

หากคุณไม่คุ้นเคยกับ Tic Tac Toe ให้เล่นด้วยสายตา ที่นี่ เข้าใจไหม. ไม่ต้องกังวลแม้ว่าคุณจะไม่เข้าใจเราจะดู

Tic Tac Toe

บทช่วยสอนแบ่งออกเป็นสามส่วนที่แตกต่างกัน ในส่วนแรก คุณจะได้เรียนรู้วิธีเล่นเกมโอเอกซ์ หลังจากนั้นเราจะเห็นอัลกอริธึมที่ช่วยให้เราคิดตรรกะของเกมได้ สุดท้าย เราจะเห็นโค้ดที่มีโครงสร้างและคำอธิบาย

คุณอาจข้ามส่วนแรกหากคุณรู้วิธีเล่น Tic Tac Toe แล้ว

ดังนั้น โดยไม่ต้องกังวลใจอีกต่อไป มาดำดิ่งในส่วนแรกของเรากัน

เล่น Tic Tac Toe

จะมีผู้เล่นสองคนในเกม สองป้ายเป็นตัวแทนของผู้เล่นแต่ละคน ป้ายทั่วไปที่ใช้ในเกมคือ X และ O สุดท้ายจะมีกระดานที่มี 9 กล่อง

ดูกระดาน tic-tac-toe ด้วยสายตา

บอร์ด Tic Tac Toe

รูปแบบการเล่นจะเป็นดังนี้

• ขั้นแรก ผู้ใช้รายหนึ่งจะลงชื่อเข้าใช้ในช่องว่างที่มีอยู่
• ถัดไป ผู้ใช้คนที่สองจะลงชื่อเข้าใช้ในช่องว่างที่มีอยู่
• เป้าหมายของผู้เล่นคือการวางสัญลักษณ์ตามลำดับหรือคอลัมน์หรือแนวทแยงมุม
• เกมจะดำเนินต่อไปจนกว่าผู้เล่นจะชนะเกมหรือจบลงด้วยการเสมอกันโดยการกรอกช่องทั้งหมดโดยไม่ชนะการแข่งขัน

มาดูการเล่นเกมกันบ้าง

Tic Tac Toe ชนะการเล่นเกม

ผู้เล่น X ชนะเกมในการเล่นเกมด้านบน กล่องทั้งหมดตามแนวทแยงมุมเติมด้วยเครื่องหมาย X ดังนั้นผู้เล่นแต่ละคนจะชนะเกม

มีทั้งหมด 8 วิธีในการจัดเรียงสัญลักษณ์เดียวกันและชนะเกม มาดูการจัด 8 อย่างที่จะชนะเกมนี้กัน

การเตรียมการชนะ Tic Tac Toe

และสุดท้าย การจับฉลากจะเต็มกระดานโดยไม่มีการชนะใดๆ ฉันหวังว่าคุณจะเข้าใจวิธี Tic Tac Toe ในตอนนี้

ตอนนี้เป็นเวลาเล่นสำหรับคุณ ไปก็ได้ ที่นี่ และเล่นเพื่อทำความเข้าใจการเล่นเกมอย่างสมบูรณ์ ปล่อยไว้ถ้าได้รับแล้ว

ตอนนี้ได้เวลาย้ายส่วนอัลกอริทึมแล้ว

อัลกอริทึม

ตอนนี้เราจะพูดถึงอัลกอริทึมในการเขียนโค้ด อัลกอริทึมนี้จะช่วยให้คุณเขียนโค้ดในภาษาโปรแกรมใดก็ได้ที่คุณเลือก เรามาดูกันว่ามันทำอย่างไร

• สร้างบอร์ดโดยใช้อาร์เรย์ 2 มิติและเริ่มต้นแต่ละองค์ประกอบให้ว่างเปล่า
  • คุณสามารถแทนค่าว่างโดยใช้สัญลักษณ์ใดก็ได้ที่คุณชอบ ในที่นี้ เราจะใช้ยัติภังค์ ‘-‘.
• เขียนฟังก์ชันเพื่อตรวจสอบว่ากระดานเต็มหรือไม่
  • วนซ้ำบนกระดานและคืนค่าเท็จหากกระดานมีเครื่องหมายว่างหรือคืนค่าเป็น จริง
• เขียนฟังก์ชันเพื่อตรวจสอบว่าผู้เล่นชนะหรือไม่
  • เราต้องตรวจสอบความเป็นไปได้ทั้งหมดที่เรากล่าวถึงในส่วนก่อนหน้า
  • ตรวจสอบแถว คอลัมน์ และแนวทแยงสองเส้นทั้งหมด
• เขียนฟังก์ชั่นเพื่อแสดงกระดานในขณะที่เราจะแสดงกระดานหลายครั้งให้กับผู้ใช้ในขณะที่พวกเขากำลังเล่น
• เขียนฟังก์ชั่นเพื่อเริ่มเกม
  • เลือกเทิร์นแรกของผู้เล่นแบบสุ่ม
  • เขียนวนไม่สิ้นสุดที่จะหยุดเมื่อเกมจบลง (ไม่ว่าจะชนะหรือเสมอ)
    • แสดงกระดานให้ผู้ใช้เลือกจุดสำหรับการย้ายครั้งต่อไป
    • ขอให้ผู้ใช้ป้อนหมายเลขแถวและคอลัมน์
    • อัปเดตจุดที่มีสัญลักษณ์ผู้เล่นตามลำดับ
    • ตรวจสอบว่าผู้เล่นปัจจุบันชนะเกมหรือไม่
    • หากผู้เล่นคนปัจจุบันชนะเกม ให้พิมพ์ข้อความที่ชนะและทำลายการวนซ้ำที่ไม่สิ้นสุด
    • ถัดไป ตรวจสอบว่ากระดานเต็มหรือไม่
    • หากกระดานเต็มแล้ว ให้พิมพ์ข้อความวาดและตัดวงจรที่ไม่มีที่สิ้นสุด
  • สุดท้าย แสดงให้ผู้ใช้เห็นมุมมองสุดท้ายของกระดาน

คุณอาจนึกภาพออกว่าเกิดอะไรขึ้น อย่ากังวลแม้ว่าคุณจะไม่เข้าใจมันอย่างถ่องแท้ คุณจะได้รับความชัดเจนมากขึ้นเมื่อคุณเห็นรหัส

มาเข้าสู่ส่วนโค้ดกัน ฉันคิดว่าคุณได้ติดตั้ง Python บนพีซีของคุณเพื่อลองใช้รหัส

รหัส

ผ่านรหัสด้านล่าง

import random


class TicTacToe:

    def __init__(self):
        self.board = []

    def create_board(self):
        for i in range(3):
            row = []
            for j in range(3):
                row.append('-')
            self.board.append(row)

    def get_random_first_player(self):
        return random.randint(0, 1)

    def fix_spot(self, row, col, player):
        self.board[row][col] = player

    def is_player_win(self, player):
        win = None

        n = len(self.board)

        # checking rows
        for i in range(n):
            win = True
            for j in range(n):
                if self.board[i][j] != player:
                    win = False
                    break
            if win:
                return win

        # checking columns
        for i in range(n):
            win = True
            for j in range(n):
                if self.board[j][i] != player:
                    win = False
                    break
            if win:
                return win

        # checking diagonals
        win = True
        for i in range(n):
            if self.board[i][i] != player:
                win = False
                break
        if win:
            return win

        win = True
        for i in range(n):
            if self.board[i][n - 1 - i] != player:
                win = False
                break
        if win:
            return win
        return False

        for row in self.board:
            for item in row:
                if item == '-':
                    return False
        return True

    def is_board_filled(self):
        for row in self.board:
            for item in row:
                if item == '-':
                    return False
        return True

    def swap_player_turn(self, player):
        return 'X' if player == 'O' else 'O'

    def show_board(self):
        for row in self.board:
            for item in row:
                print(item, end=" ")
            print()

    def start(self):
        self.create_board()

        player="X" if self.get_random_first_player() == 1 else 'O'
        while True:
            print(f"Player {player} turn")

            self.show_board()

            # taking user input
            row, col = list(
                map(int, input("Enter row and column numbers to fix spot: ").split()))
            print()

            # fixing the spot
            self.fix_spot(row - 1, col - 1, player)

            # checking whether current player is won or not
            if self.is_player_win(player):
                print(f"Player {player} wins the game!")
                break

            # checking whether the game is draw or not
            if self.is_board_filled():
                print("Match Draw!")
                break

            # swapping the turn
            player = self.swap_player_turn(player)

        # showing the final view of board
        print()
        self.show_board()


# starting the game
tic_tac_toe = TicTacToe()
tic_tac_toe.start()

ดูตัวอย่างผลลัพธ์ของรหัส

$ python tic_tac_toe.py 
Player X turn
- - -
- - -
- - -
Enter row and column numbers to fix spot: 1 1

Player O turn
X - -
- - -
- - -
Enter row and column numbers to fix spot: 2 1

Player X turn
X - -
O - -
- - -
Enter row and column numbers to fix spot: 1 2

Player O turn
X X -
O - -
- - -
Enter row and column numbers to fix spot: 1 3

Player X turn
X X O
O - -
- - -
Enter row and column numbers to fix spot: 2 2

Player O turn
X X O
O X -
- - -
Enter row and column numbers to fix spot: 3 3

Player X turn
X X O        
O X -        
- - O
Enter row and column numbers to fix spot: 3 2

Player X wins the game!

X X O
O X -
- X O

ประเด็นสำคัญบางประการที่ช่วยให้คุณเข้าใจโครงสร้างของโค้ด

• เราใช้คลาสเพื่อให้มีวิธีการทั้งหมดในที่เดียว มันสามารถเป็นบันเดิลที่นำกลับมาใช้ใหม่ได้ในโค้ดอื่นเช่นกัน
• ต่อไป เราได้กำหนดหน้าที่ที่แตกต่างกันสำหรับความรับผิดชอบแต่ละอย่าง แม้ว่าจะเป็นงานเล็ก ๆ ก็ตาม ช่วยรักษารหัสได้อย่างง่ายดาย
• สองวิธีข้างต้นช่วยให้เราอัปเดตแอปได้อย่างง่ายดาย หากเราต้องการอัปเดตเกม

อย่าลังเลที่จะปรับโครงสร้างและปรับปรุงตามโครงการของคุณ โครงสร้างโค้ดไม่จำกัด

คำพูดสุดท้าย

เย่! 😎 คุณได้สร้างเกมขึ้นมาโดยสมบูรณ์แล้ว ไม่ใช่เกมภาพที่เราเล่นทุกวัน แต่มันช่วยให้คุณเขียนตรรกะและรักษาโครงสร้างที่สะอาดในโค้ดได้ ทำตามคำแนะนำที่คล้ายกันเพื่อสร้างเกมที่น่าสนใจเช่นนี้ คุณสามารถหาเกมที่คล้ายกันได้หากคุณย้อนเวลากลับไปในวัยเด็กของคุณ

มีความสุขในการเข้ารหัส! 👩‍💻

ต่อไป สำรวจวิธีสร้างเกมเดาตัวเลขและการทดสอบหน่วยด้วย Python unittest Module

สนุกกับการอ่านบทความ? แบ่งปันให้โลกรู้ได้อย่างไร?