سورس بازی دوز GUI با پایتون

0 دیدگاه

سورس بازی دوز با پایتون

در این مطلب، شما را با یک پروژه پیشرفته پایتون در مورد بازی دوز یا همون تیک تاک تو با رابط گرافیکی (GUI) با پایتون آشنا می‌کنم. این بازی بسیار محبوب است و در خود بازی بسیار ساده است. این بازی دو نفره است. در این بازی، یک صفحه با ۳×۳ مربع وجود دارد.

سورس بازی دوز با پایتون (Tic Tac Toe)

در این بازی، هر بازیکن می‌تواند یکی از دو نماد را انتخاب کند که معمولاً “X” و “O” هستند. اگر بازیکن اول “X” را انتخاب کند، بازیکن دوم باید با “O” بازی کند و بالعکس. هر بازیکن یکی از مربع‌های ۳×۳ را با نماد خود (احتمالاً “X” یا “O”) علامت می‌زند و هدف او این است که یک خط مستقیم افقی یا عمودی یا قطری ایجاد کند با دو هدف:

ایجاد یک خط مستقیم قبل از حریف خود برای برنده شدن در بازی.
جلوگیری از ایجاد خط مستقیم توسط حریف خود.

پیشنهاد ویژه : دوره آموزش طراحی سایت با پایتون و جنگو

اگر هیچ‌کدام از بازیکنان نتوانند منطقی یک خط مستقیم با نماد خود ایجاد کنند، بازی با تساوی تمام می‌شود. بنابراین سه نتیجه ممکن وجود دارد: یک بازیکن برنده می‌شود، حریف او (انسان یا کامپیوتر) برنده می‌شود، یا بازی به تساوی می‌انجامد.

تیک تاک تو GUI با پایتون

در این بازی دو منطق اساسی وجود دارد؛ زمانی که هر دو بازیکن انسان هستند و زمانی که یکی از آنها کامپیوتر است. من این رابط گرافیکی بازی دوز با پایتون را برای دو بازیکن آماده خواهم کرد. در اینجا سورس کد کامل شما آمده است:

from tkinter import *
import numpy as np

size_of_board = 600
symbol_size = (size_of_board / 3 - size_of_board / 8) / 2
symbol_thickness = 50
symbol_X_color = '#EE4035'
symbol_O_color = '#0492CF'
Green_color = '#7BC043'


class Tic_Tac_Toe():
    # ------------------------------------------------------------------
    # Initialization Functions:
    # ------------------------------------------------------------------
    def __init__(self):
        self.window = Tk()
        self.window.title('Tic-Tac-Toe')
        self.canvas = Canvas(self.window, width=size_of_board, height=size_of_board)
        self.canvas.pack()
        # Input from user in form of clicks
        self.window.bind('<Button-1>', self.click)

        self.initialize_board()
        self.player_X_turns = True
        self.board_status = np.zeros(shape=(3, 3))

        self.player_X_starts = True
        self.reset_board = False
        self.gameover = False
        self.tie = False
        self.X_wins = False
        self.O_wins = False

        self.X_score = 0
        self.O_score = 0
        self.tie_score = 0

    def mainloop(self):
        self.window.mainloop()

    def initialize_board(self):
        for i in range(2):
            self.canvas.create_line((i + 1) * size_of_board / 3, 0, (i + 1) * size_of_board / 3, size_of_board)

        for i in range(2):
            self.canvas.create_line(0, (i + 1) * size_of_board / 3, size_of_board, (i + 1) * size_of_board / 3)

    def play_again(self):
        self.initialize_board()
        self.player_X_starts = not self.player_X_starts
        self.player_X_turns = self.player_X_starts
        self.board_status = np.zeros(shape=(3, 3))

    # ------------------------------------------------------------------
    # Drawing Functions:
    # The modules required to draw required game based object on canvas
    # ------------------------------------------------------------------

    def draw_O(self, logical_position):
        logical_position = np.array(logical_position)
        # logical_position = grid value on the board
        # grid_position = actual pixel values of the center of the grid
        grid_position = self.convert_logical_to_grid_position(logical_position)
        self.canvas.create_oval(grid_position[0] - symbol_size, grid_position[1] - symbol_size,
                                grid_position[0] + symbol_size, grid_position[1] + symbol_size, width=symbol_thickness,
                                outline=symbol_O_color)

    def draw_X(self, logical_position):
        grid_position = self.convert_logical_to_grid_position(logical_position)
        self.canvas.create_line(grid_position[0] - symbol_size, grid_position[1] - symbol_size,
                                grid_position[0] + symbol_size, grid_position[1] + symbol_size, width=symbol_thickness,
                                fill=symbol_X_color)
        self.canvas.create_line(grid_position[0] - symbol_size, grid_position[1] + symbol_size,
                                grid_position[0] + symbol_size, grid_position[1] - symbol_size, width=symbol_thickness,
                                fill=symbol_X_color)

    def display_gameover(self):

        if self.X_wins:
            self.X_score += 1
            text = 'Winner: Player 1 (X)'
            color = symbol_X_color
        elif self.O_wins:
            self.O_score += 1
            text = 'Winner: Player 2 (O)'
            color = symbol_O_color
        else:
            self.tie_score += 1
            text = 'Its a tie'
            color = 'gray'

        self.canvas.delete("all")
        self.canvas.create_text(size_of_board / 2, size_of_board / 3, font="cmr 60 bold", fill=color, text=text)

        score_text = 'Scores \n'
        self.canvas.create_text(size_of_board / 2, 5 * size_of_board / 8, font="cmr 40 bold", fill=Green_color,
                                text=score_text)

        score_text = 'Player 1 (X) : ' + str(self.X_score) + '\n'
        score_text += 'Player 2 (O): ' + str(self.O_score) + '\n'
        score_text += 'Tie                    : ' + str(self.tie_score)
        self.canvas.create_text(size_of_board / 2, 3 * size_of_board / 4, font="cmr 30 bold", fill=Green_color,
                                text=score_text)
        self.reset_board = True

        score_text = 'Click to play again \n'
        self.canvas.create_text(size_of_board / 2, 15 * size_of_board / 16, font="cmr 20 bold", fill="gray",
                                text=score_text)

    # ------------------------------------------------------------------
    # Logical Functions:
    # The modules required to carry out game logic
    # ------------------------------------------------------------------

    def convert_logical_to_grid_position(self, logical_position):
        logical_position = np.array(logical_position, dtype=int)
        return (size_of_board / 3) * logical_position + size_of_board / 6

    def convert_grid_to_logical_position(self, grid_position):
        grid_position = np.array(grid_position)
        return np.array(grid_position // (size_of_board / 3), dtype=int)

    def is_grid_occupied(self, logical_position):
        if self.board_status[logical_position[0]][logical_position[1]] == 0:
            return False
        else:
            return True

    def is_winner(self, player):

        player = -1 if player == 'X' else 1

        # Three in a row
        for i in range(3):
            if self.board_status[i][0] == self.board_status[i][1] == self.board_status[i][2] == player:
                return True
            if self.board_status[0][i] == self.board_status[1][i] == self.board_status[2][i] == player:
                return True

        # Diagonals
        if self.board_status[0][0] == self.board_status[1][1] == self.board_status[2][2] == player:
            return True

        if self.board_status[0][2] == self.board_status[1][1] == self.board_status[2][0] == player:
            return True

        return False

    def is_tie(self):

        r, c = np.where(self.board_status == 0)
        tie = False
        if len(r) == 0:
            tie = True

        return tie

    def is_gameover(self):
        # Either someone wins or all grid occupied
        self.X_wins = self.is_winner('X')
        if not self.X_wins:
            self.O_wins = self.is_winner('O')

        if not self.O_wins:
            self.tie = self.is_tie()

        gameover = self.X_wins or self.O_wins or self.tie

        if self.X_wins:
            print('X wins')
        if self.O_wins:
            print('O wins')
        if self.tie:
            print('Its a tie')

        return gameover





    def click(self, event):
        grid_position = [event.x, event.y]
        logical_position = self.convert_grid_to_logical_position(grid_position)

        if not self.reset_board:
            if self.player_X_turns:
                if not self.is_grid_occupied(logical_position):
                    self.draw_X(logical_position)
                    self.board_status[logical_position[0]][logical_position[1]] = -1
                    self.player_X_turns = not self.player_X_turns
            else:
                if not self.is_grid_occupied(logical_position):
                    self.draw_O(logical_position)
                    self.board_status[logical_position[0]][logical_position[1]] = 1
                    self.player_X_turns = not self.player_X_turns

            # Check if game is concluded
            if self.is_gameover():
                self.display_gameover()
                # print('Done')
        else:  # Play Again
            self.canvas.delete("all")
            self.play_again()
            self.reset_board = False


game_instance = Tic_Tac_Toe()
game_instance.mainloop()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

from tkinter import *

import numpy as np

size_of_board = 600

symbol_size = (size_of_board / 3 - size_of_board / 8) / 2

symbol_thickness = 50

symbol_X_color = '#EE4035'

symbol_O_color = '#0492CF'

Green_color = '#7BC043'

class Tic_Tac_Toe():

# ------------------------------------------------------------------

# Initialization Functions:

# ------------------------------------------------------------------

def __init__(self):

self.window = Tk()

self.window.title('Tic-Tac-Toe')

self.canvas = Canvas(self.window, width=size_of_board, height=size_of_board)

self.canvas.pack()

# Input from user in form of clicks

self.window.bind('<Button-1>', self.click)

self.initialize_board()

self.player_X_turns = True

self.board_status = np.zeros(shape=(3, 3))

self.player_X_starts = True

self.reset_board = False

self.gameover = False

self.tie = False

self.X_wins = False

self.O_wins = False

self.X_score = 0

self.O_score = 0

self.tie_score = 0

def mainloop(self):

self.window.mainloop()

def initialize_board(self):

for i in range(2):

self.canvas.create_line((i + 1) * size_of_board / 3, 0, (i + 1) * size_of_board / 3, size_of_board)

for i in range(2):

self.canvas.create_line(0, (i + 1) * size_of_board / 3, size_of_board, (i + 1) * size_of_board / 3)

def play_again(self):

self.initialize_board()

self.player_X_starts = not self.player_X_starts

self.player_X_turns = self.player_X_starts

self.board_status = np.zeros(shape=(3, 3))

# ------------------------------------------------------------------

# Drawing Functions:

# The modules required to draw required game based object on canvas

# ------------------------------------------------------------------

def draw_O(self, logical_position):

logical_position = np.array(logical_position)

# logical_position = grid value on the board

# grid_position = actual pixel values of the center of the grid

grid_position = self.convert_logical_to_grid_position(logical_position)

self.canvas.create_oval(grid_position[0] - symbol_size, grid_position[1] - symbol_size,

grid_position[0] + symbol_size, grid_position[1] + symbol_size, width=symbol_thickness,

outline=symbol_O_color)

def draw_X(self, logical_position):

grid_position = self.convert_logical_to_grid_position(logical_position)

self.canvas.create_line(grid_position[0] - symbol_size, grid_position[1] - symbol_size,

grid_position[0] + symbol_size, grid_position[1] + symbol_size, width=symbol_thickness,

fill=symbol_X_color)

self.canvas.create_line(grid_position[0] - symbol_size, grid_position[1] + symbol_size,

grid_position[0] + symbol_size, grid_position[1] - symbol_size, width=symbol_thickness,

fill=symbol_X_color)

def display_gameover(self):

if self.X_wins:

self.X_score += 1

text = 'Winner: Player 1 (X)'

color = symbol_X_color

elif self.O_wins:

self.O_score += 1

text = 'Winner: Player 2 (O)'

color = symbol_O_color

else:

self.tie_score += 1

text = 'Its a tie'

color = 'gray'

self.canvas.delete("all")

self.canvas.create_text(size_of_board / 2, size_of_board / 3, font="cmr 60 bold", fill=color, text=text)

score_text = 'Scores \n'

self.canvas.create_text(size_of_board / 2, 5 * size_of_board / 8, font="cmr 40 bold", fill=Green_color,

text=score_text)

score_text = 'Player 1 (X) : ' + str(self.X_score) + '\n'

score_text += 'Player 2 (O): ' + str(self.O_score) + '\n'

score_text += 'Tie : ' + str(self.tie_score)

self.canvas.create_text(size_of_board / 2, 3 * size_of_board / 4, font="cmr 30 bold", fill=Green_color,

text=score_text)

self.reset_board = True

score_text = 'Click to play again \n'

self.canvas.create_text(size_of_board / 2, 15 * size_of_board / 16, font="cmr 20 bold", fill="gray",

text=score_text)

# ------------------------------------------------------------------

# Logical Functions:

# The modules required to carry out game logic

# ------------------------------------------------------------------

def convert_logical_to_grid_position(self, logical_position):

logical_position = np.array(logical_position, dtype=int)

return (size_of_board / 3) * logical_position + size_of_board / 6

def convert_grid_to_logical_position(self, grid_position):

grid_position = np.array(grid_position)

return np.array(grid_position // (size_of_board / 3), dtype=int)

def is_grid_occupied(self, logical_position):

if self.board_status[logical_position[0]][logical_position[1]] == 0:

return False

else:

return True

def is_winner(self, player):

player = -1 if player == 'X' else 1

# Three in a row

for i in range(3):

if self.board_status[i][0] == self.board_status[i][1] == self.board_status[i][2] == player:

return True

if self.board_status[0][i] == self.board_status[1][i] == self.board_status[2][i] == player:

return True

# Diagonals

if self.board_status[0][0] == self.board_status[1][1] == self.board_status[2][2] == player:

return True

if self.board_status[0][2] == self.board_status[1][1] == self.board_status[2][0] == player:

return True

return False

def is_tie(self):

r, c = np.where(self.board_status == 0)

tie = False

if len(r) == 0:

tie = True

return tie

def is_gameover(self):

# Either someone wins or all grid occupied

self.X_wins = self.is_winner('X')

if not self.X_wins:

self.O_wins = self.is_winner('O')

if not self.O_wins:

self.tie = self.is_tie()

gameover = self.X_wins or self.O_wins or self.tie

if self.X_wins:

print('X wins')

if self.O_wins:

print('O wins')

if self.tie:

print('Its a tie')

return gameover

def click(self, event):

grid_position = [event.x, event.y]

logical_position = self.convert_grid_to_logical_position(grid_position)

if not self.reset_board:

if self.player_X_turns:

if not self.is_grid_occupied(logical_position):

self.draw_X(logical_position)

self.board_status[logical_position[0]][logical_position[1]] = -1

self.player_X_turns = not self.player_X_turns

else:

if not self.is_grid_occupied(logical_position):

self.draw_O(logical_position)

self.board_status[logical_position[0]][logical_position[1]] = 1

self.player_X_turns = not self.player_X_turns

# Check if game is concluded

if self.is_gameover():

self.display_gameover()

# print('Done')

else: # Play Again

self.canvas.delete("all")

self.play_again()

self.reset_board = False

game_instance = Tic_Tac_Toe()

game_instance.mainloop()

امیدوارم که این سورس بازی دوز با با زبان برنامه‌ نویسی پایتون برایتان مفید بوده باشد. در صورت داشتن هرگونه سوال ارزشمند، خوشحال می‌شوم که آن را در بخش نظرات زیر بپرسید.

اگر به تازگی برنامه نویسی را شروع کردید و یا هیچ دانشی ندارید حتما پست آموزش برنامه نویسی رو مشاهده کنید. و اگر به دنبال یادگیری برنامه نویسی پایتون در سال 2025 هستید حتما مسیر آموزش برنامه نویسی پایتون در سال 2025 رو ببینید.

سورس بازی پایتون

سورس بازی اسپینر با پایتون

سورس بازی کوئیز با پایتون

سورس بازی سنگ کاغذ قیچی در پایتون

سورس شبیه سازی تاس (Dice Roll Simulator) با پایتون

در صورت تمایل از بخش سورس و پروژه پایتون دیدن فرمایید. همچنین اگر به دنبال یادگیری پایتون هستید حتما از آرشیو آموزش های پایتون استفاده نمایید.

5/5 - (2 امتیاز)

راستی! برای دریافت مطالب جدید در کانال تلگرام یا پیج اینستاگرام سورس باران عضو شوید.

نظرات

صابر بوستانی

داستان من با دنیای برنامه‌ نویسی آغاز شد، و در ادامه به عنوان یک توسعه‌ دهنده نرم‌ افزار، طراح وب سایت و متخصص سئو، مهارت ‌های تکنیکی و تحلیلی خودم رو پرورش دادم. علاقه م به دنیای مالی منو به سمت یادگیری ترید و معامله‌گری سوق داد. و در حال حاضر در برنامه نویسی و معامله گری ارز دیجیتال انجام میدم. از سال 96 سعی کردم معامله گری در کریپتو رو یاد بگیرم. ترید و معامله گری برام پر از چالش و شکست‌ های متعدد بود. اما هر شکست، درسی ارزشمند برام داشت و من رو به یک تریدر و معامله گر قوی‌ تر و هوشمندتر تبدیل کرد. با پشتکار و یادگیری مداوم، تونستم به موفقیت‌های قابل توجهی دست یابم و به معامله گری موفق تبدیل بشم. در اینجا بزرگترین تجربیات و مهمترین دانش خودم رو در اختیار شما قرار میدم تا در مدت زمان کوتاه تر و شکست های کمتر در این مسیر به موفقیت برسید.

پکیج آموزش پروژه محور لاراول و طراحی وب سایت کانون قلم چی