Создаём игры на Python с Tkinter: от крестиков-ноликов до змейки

import tkinter as tk

# Создание главного окна
root = tk.Tk()
root.title("Моя первая игра")
root.geometry("600x400")

# Добавление виджетов и логики
# ...

# Запуск главного цикла обработки событий
root.mainloop()

# Создание холста
canvas = tk.Canvas(root, width=600, height=400, bg="black")
canvas.pack()

# Рисование прямоугольника (x1, y1, x2, y2, параметры)
rect_id = canvas.create_rectangle(100, 100, 200, 200, fill="red")

# Рисование овала (x1, y1, x2, y2, параметры)
oval_id = canvas.create_oval(300, 150, 350, 200, fill="blue")

# Добавление текста
text_id = canvas.create_text(400, 300, text="Счёт: 0", fill="white", font=("Arial", 16))

# Перемещение объекта
def move_object():
canvas.move(rect_id, 5, 0) # Сдвиг на 5 пикселей вправо
root.after(50, move_object) # Повтор через 50 мс

move_object() # Запуск анимации

# Обработка нажатия клавиш
def on_key_press(event):
if event.keysym == "Up":
# Логика движения вверх
print("Вверх")
elif event.keysym == "Down":
# Логика движения вниз
print("Вниз")

# Привязка функции к событию нажатия клавиши
root.bind("<KeyPress>", on_key_press)

# Обработка кликов мыши
def on_canvas_click(event):
x, y = event.x, event.y
# Логика реакции на клик в координатах x, y
print(f"Клик в точке ({x}, {y})")

# Привязка функции к событию клика мыши
canvas.bind("<Button-1>", on_canvas_click)

def game_loop():
# Обновление состояния игры
update_game_state()

# Обновление отображения
update_display()

# Проверка условий окончания игры
if not game_over():
# Повторный вызов через 100 мс
root.after(100, game_loop)
else:
show_game_over_screen()

# Запуск игрового цикла
game_loop()

class Game:
def __init__(self, master):
self.master = master
self.canvas = tk.Canvas(master, width=600, height=400)
self.canvas.pack()

self.setup_game()
self.bind_events()
self.start_game_loop()

def setup_game(self):
# Инициализация игровых объектов
pass

def bind_events(self):
# Привязка обработчиков событий
pass

def start_game_loop(self):
# Запуск игрового цикла
pass

# Создание игры
root = tk.Tk()
game = Game(root)
root.mainloop()

import tkinter as tk
from tkinter import messagebox

class TicTacToe:
def __init__(self, root):
self.root = root
self.root.title("Крестики-нолики")
self.current_player = "X"
self.board = [""] * 9 # Пустая доска 3x3
self.create_widgets()

def create_widgets(self):
# Создаём рамку для кнопок
self.frame = tk.Frame(self.root)
self.frame.pack()

# Создаём кнопки (игровое поле)
self.buttons = []
for i in range(9):
button = tk.Button(
self.frame, 
text="", 
font=("Arial", 24), 
height=2, 
width=5,
command=lambda idx=i: self.on_button_click(idx)
)
row, col = i // 3, i % 3
button.grid(row=row, column=col)
self.buttons.append(button)

# Добавляем метку для отображения текущего игрока
self.player_label = tk.Label(
self.root,
text=f"Ход игрока: {self.current_player}",
font=("Arial", 16)
)
self.player_label.pack(pady=10)

# Кнопка для сброса игры
self.reset_button = tk.Button(
self.root,
text="Начать заново",
font=("Arial", 12),
command=self.reset_game
)
self.reset_button.pack(pady=5)

def on_button_click(self, idx):
# Если ячейка уже занята, выходим
if self.board[idx] != "":
return

# Устанавливаем символ текущего игрока
self.buttons[idx].config(text=self.current_player)
self.board[idx] = self.current_player

# Проверяем выигрыш
if self.check_winner():
messagebox.showinfo("Победа!", f"Игрок {self.current_player} выиграл!")
self.reset_game()
return

# Проверяем ничью
if "" not in self.board:
messagebox.showinfo("Ничья!", "Игра закончилась вничью!")
self.reset_game()
return

# Меняем игрока
self.current_player = "O" if self.current_player == "X" else "X"
self.player_label.config(text=f"Ход игрока: {self.current_player}")

def check_winner(self):
# Выигрышные комбинации (индексы)
win_combinations = [
[0, 1, 2], [3, 4, 5], [6, 7, 8], # горизонтали
[0, 3, 6], [1, 4, 7], [2, 5, 8], # вертикали
[0, 4, 8], [2, 4, 6] # диагонали
]

# Проверяем все выигрышные комбинации
for combo in win_combinations:
a, b, c = combo
if (self.board[a] == self.board[b] == self.board[c] != ""):
# Подсветим выигрышную комбинацию
for idx in combo:
self.buttons[idx].config(bg="light green")
return True
return False

def reset_game(self):
# Сбрасываем состояние игры
self.board = [""] * 9
self.current_player = "X"

# Обновляем интерфейс
for button in self.buttons:
button.config(text="", bg="SystemButtonFace")
self.player_label.config(text=f"Ход игрока: {self.current_player}")

if __name__ == "__main__":
root = tk.Tk()
game = TicTacToe(root)
root.mainloop()

import tkinter as tk
import random

class Snake:
def __init__(self, root):
self.root = root
self.root.title("Змейка")
self.root.resizable(False, False)

# Константы
self.WIDTH = 600
self.HEIGHT = 400
self.SEGMENT_SIZE = 20
self.GAME_SPEED = 150 # миллисекунды

# Начальные значения
self.direction = "Right"
self.score = 0
self.snake = [(100, 100), (80, 100), (60, 100)]
self.food = self.create_food()

# Создание холста
self.canvas = tk.Canvas(root, width=self.WIDTH, height=self.HEIGHT, bg="black")
self.canvas.pack()

# Отображение счёта
self.score_display = self.canvas.create_text(
50, 20, text=f"Счёт: {self.score}", fill="white", font=("Arial", 14)
)

# Привязка клавиш
self.root.bind("<KeyPress>", self.on_key_press)

# Запуск игрового цикла
self.move_snake()

def create_food(self):
# Создаём еду в случайном месте
x = random.randint(1, (self.WIDTH – self.SEGMENT_SIZE) // self.SEGMENT_SIZE) * self.SEGMENT_SIZE
y = random.randint(1, (self.HEIGHT – self.SEGMENT_SIZE) // self.SEGMENT_SIZE) * self.SEGMENT_SIZE
return (x, y)

def draw_snake(self):
# Очищаем холст перед рисованием
self.canvas.delete("snake")

# Рисуем каждый сегмент змейки
for segment in self.snake:
x, y = segment
self.canvas.create_rectangle(
x, y, 
x + self.SEGMENT_SIZE, y + self.SEGMENT_SIZE,
fill="green", tags="snake"
)

def draw_food(self):
# Очищаем предыдущую еду
self.canvas.delete("food")

# Рисуем новую еду
x, y = self.food
self.canvas.create_oval(
x, y, 
x + self.SEGMENT_SIZE, y + self.SEGMENT_SIZE,
fill="red", tags="food"
)

def on_key_press(self, event):
# Обработка нажатий клавиш для изменения направления
new_direction = event.keysym

# Предотвращаем разворот на 180 градусов
if (new_direction == "Up" and self.direction != "Down" or
new_direction == "Down" and self.direction != "Up" or
new_direction == "Left" and self.direction != "Right" or
new_direction == "Right" and self.direction != "Left"):
self.direction = new_direction

def move_snake(self):
# Получаем координаты головы
head_x, head_y = self.snake[0]

# Определяем новые координаты головы в зависимости от направления
if self.direction == "Up":
new_head = (head_x, head_y – self.SEGMENT_SIZE)
elif self.direction == "Down":
new_head = (head_x, head_y + self.SEGMENT_SIZE)
elif self.direction == "Left":
new_head = (head_x – self.SEGMENT_SIZE, head_y)
elif self.direction == "Right":
new_head = (head_x + self.SEGMENT_SIZE, head_y)

# Добавляем новую голову
self.snake.insert(0, new_head)

# Проверяем, съела ли змейка еду
if self.snake[0] == self.food:
# Увеличиваем счёт
self.score += 1
self.canvas.itemconfig(self.score_display, text=f"Счёт: {self.score}")

# Создаём новую еду
self.food = self.create_food()
self.draw_food()

# Немного ускоряем игру
self.GAME_SPEED = max(50, self.GAME_SPEED – 5)
else:
# Удаляем последний сегмент, если не съели еду
self.snake.pop()

# Проверяем столкновения
if self.check_collisions():
self.game_over()
return

# Отрисовываем змейку и еду
self.draw_snake()
self.draw_food()

# Планируем следующий ход
self.root.after(self.GAME_SPEED, self.move_snake)

def check_collisions(self):
# Получаем координаты головы
head_x, head_y = self.snake[0]

# Проверяем столкновение со стенами
if (head_x < 0 or head_x >= self.WIDTH or
head_y < 0 or head_y >= self.HEIGHT):
return True

# Проверяем столкновение с собой (начиная с 3-го сегмента)
if len(self.snake) > 3 and self.snake[0] in self.snake[3:]:
return True

return False

def game_over(self):
# Отображаем сообщение о конце игры
self.canvas.create_text(
self.WIDTH // 2, self.HEIGHT // 2,
text=f"Игра окончена! Счёт: {self.score}",
fill="white", font=("Arial", 24)
)

# Создаём кнопку для перезапуска
restart_button = tk.Button(
self.root, text="Начать заново", command=self.restart_game
)
restart_button_window = self.canvas.create_window(
self.WIDTH // 2, self.HEIGHT // 2 + 40,
window=restart_button
)

def restart_game(self):
# Сбрасываем игру к начальному состоянию
self.direction = "Right"
self.score = 0
self.snake = [(100, 100), (80, 100), (60, 100)]
self.food = self.create_food()
self.GAME_SPEED = 150

# Очищаем холст
self.canvas.delete("all")

# Создаём новый дисплей счёта
self.score_display = self.canvas.create_text(
50, 20, text=f"Счёт: {self.score}", fill="white", font=("Arial", 14)
)

# Запускаем игровой цикл
self.move_snake()

if __name__ == "__main__":
root = tk.Tk()
game = Snake(root)
root.mainloop()

import tkinter as tk
import random

class PongGame:
def __init__(self, root):
self.root = root
self.root.title("Пинг-понг")

# Константы
self.WIDTH = 800
self.HEIGHT = 500
self.PADDLE_WIDTH = 10
self.PADDLE_HEIGHT = 100
self.BALL_SIZE = 20
self.BALL_SPEED = 3
self.PADDLE_SPEED = 8

# Состояние игры
self.score_left = 0
self.score_right = 0
self.ball_dx = self.BALL_SPEED * random.choice([1, -1])
self.ball_dy = self.BALL_SPEED * random.choice([1, -1])

# Создание холста
self.canvas = tk.Canvas(root, width=self.WIDTH, height=self.HEIGHT, bg="black")
self.canvas.pack()

# Создание элементов игры
self.left_paddle = self.canvas.create_rectangle(
10, self.HEIGHT//2 – self.PADDLE_HEIGHT//2,
10 + self.PADDLE_WIDTH, self.HEIGHT//2 + self.PADDLE_HEIGHT//2,
fill="white"
)

self.right_paddle = self.canvas.create_rectangle(
self.WIDTH – 10 – self.PADDLE_WIDTH, self.HEIGHT//2 – self.PADDLE_HEIGHT//2,
self.WIDTH – 10, self.HEIGHT//2 + self.PADDLE_HEIGHT//2,
fill="white"
)

self.ball = self.canvas.create_oval(
self.WIDTH//2 – self.BALL_SIZE//2, self.HEIGHT//2 – self.BALL_SIZE//2,
self.WIDTH//2 + self.BALL_SIZE//2, self.HEIGHT//2 + self.BALL_SIZE//2,
fill="white"
)

# Центральная линия
for i in range(0, self.HEIGHT, 30):
self.canvas.create_line(
self.WIDTH//2, i, self.WIDTH//2, i + 15, fill="white", width=2
)

# Отображение счёта
self.score_display = self.canvas.create_text(
self.WIDTH//2, 30, text=f"{self.score_left} {self.score_right}",
fill="white", font=("Arial", 36)
)

# Отслеживание нажатых клавиш
self.pressed_keys = set()
self.root.bind("<KeyPress>", self.key_press)
self.root.bind("<KeyRelease>", self.key_release)

# Запуск игрового цикла
self.game_loop()

def key_press(self, event):
self.pressed_keys.add(event.keysym)

def key_release(self, event):
if event.keysym in self.pressed_keys:
self.pressed_keys.remove(event.keysym)

def game_loop(self):
# Обрабатываем нажатые клавиши для движения ракеток
self.move_paddles()

# Перемещаем мяч
self.move_ball()

# Обновляем отображение счёта
self.canvas.itemconfig(self.score_display, text=f"{self.score_left} {self.score_right}")

# Планируем следующий кадр
self.root.after(16, self.game_loop) # примерно 60 FPS

def move_paddles(self):
# Левая ракетка (клавиши W/S)
if "w" in self.pressed_keys and self.canvas.coords(self.left_paddle)[1] > 0:
self.canvas.move(self.left_paddle, 0, -self.PADDLE_SPEED)
if "s" in self.pressed_keys and self.canvas.coords(self.left_paddle)[3] < self.HEIGHT:
self.canvas.move(self.left_paddle, 0, self.PADDLE_SPEED)

# Правая ракетка (клавиши Up/Down)
if "Up" in self.pressed_keys and self.canvas.coords(self.right_paddle)[1] > 0:
self.canvas.move(self.right_paddle, 0, -self.PADDLE_SPEED)
if "Down" in self.pressed_keys and self.canvas.coords(self.right_paddle)[3] < self.HEIGHT:
self.canvas.move(self.right_paddle, 0, self.PADDLE_SPEED)

def move_ball(self):
# Получаем координаты мяча
ball_coords = self.canvas.coords(self.ball)
ball_left, ball_top, ball_right, ball_bottom = ball_coords

# Проверяем столкновение с верхней и нижней стенами
if ball_top <= 0 or ball_bottom >= self.HEIGHT:
self.ball_dy = -self.ball_dy

# Получаем координаты ракеток
left_paddle_coords = self.canvas.coords(self.left_paddle)
right_paddle_coords = self.canvas.coords(self.right_paddle)

# Проверяем столкновение с левой ракеткой
if (ball_left <= left_paddle_coords[2] and 
ball_bottom >= left_paddle_coords[1] and 
ball_top <= left_paddle_coords[3] and 
self.ball_dx < 0):

self.ball_dx = -self.ball_dx
# Добавляем небольшое случайное изменение угла
self.ball_dy += random.uniform(-0.5, 0.5)

# Проверяем столкновение с правой ракеткой
elif (ball_right >= right_paddle_coords[0] and 
ball_bottom >= right_paddle_coords[1] and 
ball_top <= right_paddle_coords[3] and 
self.ball_dx > 0):

self.ball_dx = -self.ball_dx
# Добавляем небольшое случайное изменение угла
self.ball_dy += random.uniform(-0.5, 0.5)

# Проверяем, не забит ли гол
if ball_left <= 0:
# Гол правому игроку
self.score_right += 1
self.reset_ball()
return

if ball_right >= self.WIDTH:
# Гол левому игроку
self.score_left += 1
self.reset_ball()
return

# Перемещаем мяч
self.canvas.move(self.ball, self.ball_dx, self.ball_dy)

def reset_ball(self):
# Размещаем мяч в центре
self.canvas.coords(
self.ball,
self.WIDTH//2 – self.BALL_SIZE//2, 
self.HEIGHT//2 – self.BALL_SIZE//2,
self.WIDTH//2 + self.BALL_SIZE//2, 
self.HEIGHT//2 + self.BALL_SIZE//2
)

# Задаём случайное направление
self.ball_dx = self.BALL_SPEED * random.choice([1, -1])
self.ball_dy = self.BALL_SPEED * random.choice([1, -1])

if __name__ == "__main__":
root = tk.Tk()
game = PongGame(root)
root.mainloop()