🐍 Π‘Π°ΠΌΠΎΡƒΡ‡ΠΈΡ‚Π΅Π»ΡŒ ΠΏΠΎ Python для Π½Π°Ρ‡ΠΈΠ½Π°ΡŽΡ‰ΠΈΡ…. Π§Π°ΡΡ‚ΡŒ 21: ΠžΡΠ½ΠΎΠ²Ρ‹ Ρ€Π°Π·Ρ€Π°Π±ΠΎΡ‚ΠΊΠΈ ΠΈΠ³Ρ€ Π½Π° Pygame

Учимся Π°Π½ΠΈΠΌΠΈΡ€ΠΎΠ²Π°Ρ‚ΡŒ Π³Ρ€Π°Ρ„ΠΈΠΊΡƒ ΠΈ изобраТСния, ΠΎΠ±Ρ€Π°Π±Π°Ρ‚Ρ‹Π²Π°Ρ‚ΡŒ столкновСния, Π·Π°ΠΏΠΎΠΌΠΈΠ½Π°Ρ‚ΡŒ состояния ΠΈ ΡƒΠΏΡ€Π°Π²Π»ΡΡ‚ΡŒ пСрсонаТами. Π’ ΠΊΠΎΠ½Ρ†Π΅ ΡΡ‚Π°Ρ‚ΡŒΠΈ сдСлаСм 10 ΠΌΠΈΠ½ΠΈ-симуляторов ΠΈ Π»Π°ΠΉΡ‚-вСрсий извСстных ΠΈΠ³Ρ€.

Python – ΠΈΠ½Ρ‚Π΅Ρ€ΠΏΡ€Π΅Ρ‚ΠΈΡ€ΡƒΠ΅ΠΌΡ‹ΠΉ язык, ΠΈ ΠΏΠΎ этой ΠΏΡ€ΠΈΡ‡ΠΈΠ½Π΅ ΠΎΠ½ Π½Π΅ отличаСтся высокой ΠΏΡ€ΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡ‚Π΅Π»ΡŒΠ½ΠΎΡΡ‚ΡŒΡŽ, которая Π½Π΅ΠΎΠ±Ρ…ΠΎΠ΄ΠΈΠΌΠ° для слоТных ΠΈΠ³Ρ€ с гипСррСалистичной Π³Ρ€Π°Ρ„ΠΈΠΊΠΎΠΉ. Π’Π΅ΠΌ Π½Π΅ ΠΌΠ΅Π½Π΅Π΅ Π΅ΡΡ‚ΡŒ нСсколько способов ΠΎΠΏΡ‚ΠΈΠΌΠΈΠ·Π°Ρ†ΠΈΠΈ, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹Π΅ Π·Π½Π°Ρ‡ΠΈΡ‚Π΅Π»ΡŒΠ½ΠΎ ΡƒΡΠΊΠΎΡ€ΡΡŽΡ‚ Π²Ρ‹ΠΏΠΎΠ»Π½Π΅Π½ΠΈΠ΅ Python-ΠΊΠΎΠ΄Π°, Ρ‡Ρ‚ΠΎ позволяСт ΠΏΠΈΡΠ°Ρ‚ΡŒ Π½Π° ΠŸΠΈΡ‚ΠΎΠ½Π΅ Π²ΠΏΠΎΠ»Π½Π΅ ΠΏΡ€ΠΈΠ»ΠΈΡ‡Π½Ρ‹Π΅ ΠΈΠ³Ρ€Ρ‹. ΠžΠΏΡ‚ΠΈΠΌΠΈΠ·Π°Ρ†ΠΈΡŽ Π½Π΅ΠΎΠ±ΡΠ·Π°Ρ‚Π΅Π»ΡŒΠ½ΠΎ Π΄Π΅Π»Π°Ρ‚ΡŒ ΡΠ°ΠΌΠΎΡΡ‚ΠΎΡΡ‚Π΅Π»ΡŒΠ½ΠΎ – Π² Π·Π½Π°Ρ‡ΠΈΡ‚Π΅Π»ΡŒΠ½ΠΎΠΉ стСпСни эту Π·Π°Π΄Π°Ρ‡Ρƒ Π±Π΅Ρ€ΡƒΡ‚ Π½Π° сСбя ΡΠΏΠ΅Ρ†ΠΈΠ°Π»ΡŒΠ½Ρ‹Π΅ Ρ„Ρ€Π΅ΠΉΠΌΠ²ΠΎΡ€ΠΊΠΈ ΠΈ Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠΈ. Π€Ρ€Π΅ΠΉΠΌΠ²ΠΎΡ€ΠΊΠΎΠ² ΠΈ Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊ для Ρ€Π°Π·Ρ€Π°Π±ΠΎΡ‚ΠΊΠΈ ΠΈΠ³Ρ€ Π½Π° основС Python довольно ΠΌΠ½ΠΎΠ³ΠΎ, Π²ΠΎΡ‚ самыС популярныС:

  • Pygame
  • PyKyra
  • Pyglet
  • Panda3D
  • Kivy
  • PyopenGL

ΠœΡ‹ остановимся Π½Π° самой популярной Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠ΅, Pygame – ΠΎΠ½Π° ΠΎΡ‚Π»ΠΈΡ‡Π½ΠΎ ΠΏΠΎΠ΄Ρ…ΠΎΠ΄ΠΈΡ‚ для Π½Π°Ρ‡ΠΈΠ½Π°ΡŽΡ‰ΠΈΡ… Ρ€Π°Π·Ρ€Π°Π±ΠΎΡ‚Ρ‡ΠΈΠΊΠΎΠ², ΠΈ ΠΊ Ρ‚ΠΎΠΌΡƒ ΠΆΠ΅ часто ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΠ΅Ρ‚ΡΡ для быстрого прототипирования ΠΈΠ³Ρ€. На ΠΎΡ„ΠΈΡ†ΠΈΠ°Π»ΡŒΠ½ΠΎΠΌ сайтС Pygame Π΅ΡΡ‚ΡŒ ΠΊΠ°Ρ‚Π°Π»ΠΎΠ³ ΠΈΠ³Ρ€, созданных с ΠΏΠΎΠΌΠΎΡ‰ΡŒΡŽ Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠΈ. Π•Ρ‰Π΅ ΠΏΡ€ΠΈΠΌΠ΅Ρ€Ρ‹ ΠΈΠ³Ρ€ Π½Π° Pygame ΠΌΠΎΠΆΠ½ΠΎ ΠΏΠΎΡΠΌΠΎΡ‚Ρ€Π΅Ρ‚ΡŒ здСсь.

Pygame Π½Π΅ Π²Ρ…ΠΎΠ΄ΠΈΡ‚ Π² ΡΡ‚Π°Π½Π΄Π°Ρ€Ρ‚Π½ΡƒΡŽ поставку Python, для установки Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠΈ Π²Ρ‹ΠΏΠΎΠ»Π½ΠΈΡ‚Π΅:

pip install pygame

ВсС возмоТности Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠΈ Pygame Π½Π΅Ρ€Π΅Π°Π»ΡŒΠ½ΠΎ Ρ€Π°ΡΡΠΌΠΎΡ‚Ρ€Π΅Ρ‚ΡŒ Π² ΠΎΠ΄Π½ΠΎΠΉ ΡΡ‚Π°Ρ‚ΡŒΠ΅, поэтому здСсь ΠΌΡ‹ Π·Π°Ρ‚Ρ€ΠΎΠ½Π΅ΠΌ Ρ‚ΠΎΠ»ΡŒΠΊΠΎ самыС Π±Π°Π·ΠΎΠ²Ρ‹Π΅ ΠΊΠΎΠ½Ρ†Π΅ΠΏΡ†ΠΈΠΈ – рисованиС, Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ ΠΎΠ±ΡŠΠ΅ΠΊΡ‚ΠΎΠ², ΠΏΠΎΠΊΠ°Π΄Ρ€ΠΎΠ²ΡƒΡŽ Π°Π½ΠΈΠΌΠ°Ρ†ΠΈΡŽ, ΠΎΠ±Ρ€Π°Π±ΠΎΡ‚ΠΊΡƒ событий, ΠΎΠ±Π½ΠΎΠ²Π»Π΅Π½ΠΈΠ΅ счСтчика, ΠΎΠ±Π½Π°Ρ€ΡƒΠΆΠ΅Π½ΠΈΠ΅ столкновСния.

πŸπŸŽ“ Π‘ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠ° собСса ΠΏΠΎ Python
ΠŸΠΎΠ΄Ρ‚ΡΠ½ΡƒΡ‚ΡŒ свои знания ΠΏΠΎ Python Π²Ρ‹ ΠΌΠΎΠΆΠ΅Ρ‚Π΅ Π½Π° нашСм Ρ‚Π΅Π»Π΅Π³Ρ€Π°ΠΌ-ΠΊΠ°Π½Π°Π»Π΅ Β«Π‘ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠ° собСса ΠΏΠΎ PythonΒ»
🐍🧩 Π‘ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠ° Π·Π°Π΄Π°Ρ‡ ΠΏΠΎ Python
Π˜Π½Ρ‚Π΅Ρ€Π΅ΡΠ½Ρ‹Π΅ Π·Π°Π΄Π°Ρ‡ΠΈ ΠΏΠΎ Python для ΠΏΡ€Π°ΠΊΡ‚ΠΈΠΊΠΈ ΠΌΠΎΠΆΠ½ΠΎ Π½Π°ΠΉΡ‚ΠΈ Π½Π° нашСм Ρ‚Π΅Π»Π΅Π³Ρ€Π°ΠΌ-ΠΊΠ°Π½Π°Π»Π΅ Β«Π‘ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠ° Π·Π°Π΄Π°Ρ‡ ΠΏΠΎ PythonΒ»

Окно ΠΈ Π³Π»Π°Π²Π½Ρ‹ΠΉ Ρ†ΠΈΠΊΠ» прилоТСния

Π‘ΠΎΠ·Π΄Π°Π½ΠΈΠ΅ любого прилоТСния Π½Π° Π±Π°Π·Π΅ Pygame начинаСтся с ΠΈΠΌΠΏΠΎΡ€Ρ‚Π° ΠΈ ΠΈΠ½ΠΈΡ†ΠΈΠ°Π»ΠΈΠ·Π°Ρ†ΠΈΠΈ Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠΈ. Π—Π°Ρ‚Π΅ΠΌ Π½ΡƒΠΆΠ½ΠΎ ΠΎΠΏΡ€Π΅Π΄Π΅Π»ΠΈΡ‚ΡŒ ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ ΠΎΠΊΠ½Π°, ΠΈ ΠΏΠΎ ТСланию – Π·Π°Π΄Π°Ρ‚ΡŒ Ρ†Π²Π΅Ρ‚ (ΠΈΠ»ΠΈ ΠΈΠ·ΠΎΠ±Ρ€Π°ΠΆΠ΅Π½ΠΈΠ΅) Ρ„ΠΎΠ½Π°:

import pygame

# ΠΈΠ½ΠΈΡ†ΠΈΠ°Π»ΠΈΠ·ΠΈΡ€ΡƒΠ΅ΠΌ Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΡƒ Pygame
pygame.init()

# опрСдСляСм Ρ€Π°Π·ΠΌΠ΅Ρ€Ρ‹ ΠΎΠΊΠ½Π°
window_size = (300, 300)

# Π·Π°Π΄Π°Π΅ΠΌ Π½Π°Π·Π²Π°Π½ΠΈΠ΅ ΠΎΠΊΠ½Π°
pygame.display.set_caption("Π‘ΠΈΠ½ΠΈΠΉ Ρ„ΠΎΠ½")

# создаСм окно
screen = pygame.display.set_mode(window_size)

# Π·Π°Π΄Π°Π΅ΠΌ Ρ†Π²Π΅Ρ‚ Ρ„ΠΎΠ½Π°
background_color = (0, 0, 255)  # синий

# заполняСм Ρ„ΠΎΠ½ Π·Π°Π΄Π°Π½Π½Ρ‹ΠΌ Ρ†Π²Π΅Ρ‚ΠΎΠΌ
screen.fill(background_color)

# обновляСм экран для отобраТСния ΠΈΠ·ΠΌΠ΅Π½Π΅Π½ΠΈΠΉ
pygame.display.flip()

# ΠΏΠΎΠΊΠ°Π·Ρ‹Π²Π°Π΅ΠΌ ΠΎΠΊΠ½ΠΎ, ΠΏΠΎΠΊΠ° ΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚Π΅Π»ΡŒ Π½Π΅ Π½Π°ΠΆΠΌΠ΅Ρ‚ ΠΊΠ½ΠΎΠΏΠΊΡƒ "Π—Π°ΠΊΡ€Ρ‹Ρ‚ΡŒ"
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

Π¦ΠΈΠΊΠ» while True ΠΈΠ³Ρ€Π°Π΅Ρ‚ Ρ€ΠΎΠ»ΡŒ Π³Π»Π°Π²Π½ΠΎΠ³ΠΎ Ρ†ΠΈΠΊΠ»Π° ΠΏΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΡ‹ – Π² Π½Π΅ΠΌ происходит отслСТиваниС событий прилоТСния ΠΈ дСйствий ΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚Π΅Π»Ρ. Ѐункция pygame.quit() Π·Π°Π²Π΅Ρ€ΡˆΠ°Π΅Ρ‚ Ρ€Π°Π±ΠΎΡ‚Ρƒ прилоТСния, ΠΈ Π΅Π΅ ΠΌΠΎΠΆΠ½ΠΎ Π½Π°Π·Π²Π°Ρ‚ΡŒ ΠΏΡ€ΠΎΡ‚ΠΈΠ²ΠΎΠΏΠΎΠ»ΠΎΠΆΠ½ΠΎΡΡ‚ΡŒΡŽ Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ pygame.init(). Для Π·Π°Π²Π΅Ρ€ΡˆΠ΅Π½ΠΈΡ Python-процСсса ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΠ΅Ρ‚ΡΡ exit(), с Ρ‚ΠΎΠΉ ΠΆΠ΅ Ρ†Π΅Π»ΡŒΡŽ ΠΌΠΎΠΆΠ½ΠΎ ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚ΡŒ sys.exit(), Π½ΠΎ Π΅Π΅ Π½ΡƒΠΆΠ½ΠΎ ΠΈΠΌΠΏΠΎΡ€Ρ‚ΠΈΡ€ΠΎΠ²Π°Ρ‚ΡŒ Π² Π½Π°Ρ‡Π°Π»Π΅ ΠΏΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΡ‹: import sys.

Π’ качСствС Ρ„ΠΎΠ½Π° ΠΌΠΎΠΆΠ½ΠΎ ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚ΡŒ ΠΈΠ·ΠΎΠ±Ρ€Π°ΠΆΠ΅Π½ΠΈΠ΅:

import pygame

pygame.init()

window_size = (400, 400)
screen = pygame.display.set_mode(window_size)
pygame.display.set_caption("Peter the Piglet")

# Π·Π°Π³Ρ€ΡƒΠΆΠ°Π΅ΠΌ ΠΈΠ·ΠΎΠ±Ρ€Π°ΠΆΠ΅Π½ΠΈΠ΅
background_image = pygame.image.load("background.png")

# подгоняСм ΠΌΠ°ΡΡˆΡ‚Π°Π± ΠΏΠΎΠ΄ Ρ€Π°Π·ΠΌΠ΅Ρ€ ΠΎΠΊΠ½Π°
background_image = pygame.transform.scale(background_image, window_size)

# Π½Π°ΠΊΠ»Π°Π΄Ρ‹Π²Π°Π΅ΠΌ ΠΈΠ·ΠΎΠ±Ρ€Π°ΠΆΠ΅Π½ΠΈΠ΅ Π½Π° ΠΏΠΎΠ²Π΅Ρ€Ρ…Π½ΠΎΡΡ‚ΡŒ
screen.blit(background_image, (0, 0))

pygame.display.flip()

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

ΠžΠ±Ρ€Π°Π±ΠΎΡ‚ΠΊΡƒ событий (Π½Π°ΠΆΠ°Ρ‚ΠΈΠΉ клавиш ΠΈ ΠΊΠ»ΠΈΠΊΠΎΠ²) Π² Pygame Ρ€Π΅Π°Π»ΠΈΠ·ΠΎΠ²Π°Ρ‚ΡŒ ΠΎΡ‡Π΅Π½ΡŒ просто – благодаря встроСнным функциям. ΠŸΡ€ΠΈΠ²Π΅Π΄Π΅Π½Π½Ρ‹ΠΉ Π½ΠΈΠΆΠ΅ ΠΊΠΎΠ΄ измСняСт Ρ†Π²Π΅Ρ‚ Ρ„ΠΎΠ½Π° послС ΠΊΠ»ΠΈΠΊΠ° ΠΏΠΎ ΠΊΠ½ΠΎΠΏΠΊΠ΅. ΠžΠ±Ρ€Π°Ρ‚ΠΈΡ‚Π΅ Π²Π½ΠΈΠΌΠ°Π½ΠΈΠ΅, Ρ‡Ρ‚ΠΎ Π² Pygame ΠΌΠΎΠΆΠ½ΠΎ Π·Π°Π΄Π°Π²Π°Ρ‚ΡŒ Ρ†Π²Π΅Ρ‚ нСсколькими способами:

import pygame

pygame.init()
pygame.display.set_caption('ИзмСни Ρ†Π²Π΅Ρ‚ Ρ„ΠΎΠ½Π°')
window_surface = pygame.display.set_mode((300, 300))
background = pygame.Surface((300, 300))
background.fill(pygame.Color('#000000'))

color_list = [
    pygame.Color('#FF0000'),  # красный
    pygame.Color('#00FF00'),  # Π·Π΅Π»Π΅Π½Ρ‹ΠΉ
    pygame.Color('#0000FF'),  # синий
    pygame.Color('#FFFF00'),  # ΠΆΠ΅Π»Ρ‚Ρ‹ΠΉ
    pygame.Color('#00FFFF'),  # Π±ΠΈΡ€ΡŽΠ·ΠΎΠ²Ρ‹ΠΉ
    pygame.Color('#FF00FF'),  # ΠΏΡƒΡ€ΠΏΡƒΡ€Π½Ρ‹ΠΉ
    pygame.Color('#FFFFFF')   # Π±Π΅Π»Ρ‹ΠΉ
]

current_color_index = 0

button_font = pygame.font.SysFont('Verdana', 15) # ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΠ΅ΠΌ ΡˆΡ€ΠΈΡ„Ρ‚ Verdana
button_text_color = pygame.Color("black")
button_color = pygame.Color("gray")
button_rect = pygame.Rect(100, 115, 100, 50)
button_text = button_font.render('НаТми!', True, button_text_color)

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()
        elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
            if button_rect.collidepoint(event.pos):
                current_color_index = (current_color_index + 1) % len(color_list)
                background.fill(color_list[current_color_index])

        window_surface.blit(background, (0, 0))
        pygame.draw.rect(window_surface, button_color, button_rect)
        button_rect_center = button_text.get_rect(center=button_rect.center)
        window_surface.blit(button_text, button_rect_center)
        pygame.display.update()

Как ΠΎΡ‡Π΅Π²ΠΈΠ΄Π½ΠΎ ΠΈΠ· ΠΏΡ€ΠΈΠ²Π΅Π΄Π΅Π½Π½ΠΎΠ³ΠΎ Π²Ρ‹ΡˆΠ΅ ΠΏΡ€ΠΈΠΌΠ΅Ρ€Π°, основной Ρ†ΠΈΠΊΠ» Pygame прилоТСния состоит ΠΈΠ· Ρ‚Ρ€Π΅Ρ… ΠΏΠΎΠ²Ρ‚ΠΎΡ€ΡΡŽΡ‰ΠΈΡ…ΡΡ дСйствий:

  • ΠžΠ±Ρ€Π°Π±ΠΎΡ‚ΠΊΠ° событий (Π½Π°ΠΆΠ°Ρ‚ΠΈΠΉ клавиш ΠΈΠ»ΠΈ ΠΊΠ½ΠΎΠΏΠΎΠΊ).
  • ОбновлСниС состояния.
  • ΠžΡ‚Ρ€ΠΈΡΠΎΠ²ΠΊΠ° состояния Π½Π° экранС.
Π‘ΠΎΠ»ΡŒΡˆΠ΅ ΠΏΠΎΠ»Π΅Π·Π½Ρ‹Ρ… ΠΌΠ°Ρ‚Π΅Ρ€ΠΈΠ°Π»ΠΎΠ² Π²Ρ‹ Π½Π°ΠΉΠ΄Π΅Ρ‚Π΅ Π½Π° нашСм Ρ‚Π΅Π»Π΅Π³Ρ€Π°ΠΌ-ΠΊΠ°Π½Π°Π»Π΅ Β«Π‘ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠ° питониста»

GUI для PyGame

Pygame позволяСт Π»Π΅Π³ΠΊΠΎ ΠΈ быстро ΠΈΠ½Ρ‚Π΅Π³Ρ€ΠΈΡ€ΠΎΠ²Π°Ρ‚ΡŒ Π² ΠΏΡ€ΠΎΠ΅ΠΊΡ‚ ΠΌΠ½ΠΎΠ³ΠΈΠ΅ Π½ΡƒΠΆΠ½Ρ‹Π΅ Π²Π΅Ρ‰ΠΈ – ΡˆΡ€ΠΈΡ„Ρ‚Ρ‹, Π·Π²ΡƒΠΊ, ΠΎΠ±Ρ€Π°Π±ΠΎΡ‚ΠΊΡƒ событий, – ΠΎΠ΄Π½Π°ΠΊΠΎ Π½Π΅ ΠΈΠΌΠ΅Π΅Ρ‚ встроСнных Π²ΠΈΠ΄ΠΆΠ΅Ρ‚ΠΎΠ² для создания ΠΊΠ½ΠΎΠΏΠΎΠΊ, Π»Π΅ΠΉΠ±Π»ΠΎΠ², ΠΈΠ½Π΄ΠΈΠΊΠ°Ρ‚ΠΎΡ€ΠΎΠ² выполнСния ΠΈ Π΄Ρ€ΡƒΠ³ΠΈΡ… ΠΏΠΎΠ΄ΠΎΠ±Π½Ρ‹Ρ… элСмСнтов интСрфСйса. Π­Ρ‚Ρƒ ΠΏΡ€ΠΎΠ±Π»Π΅ΠΌΡƒ Ρ€Π°Π·Ρ€Π°Π±ΠΎΡ‚Ρ‡ΠΈΠΊ Π΄ΠΎΠ»ΠΆΠ΅Π½ Ρ€Π΅ΡˆΠ°Ρ‚ΡŒ Π»ΠΈΠ±ΠΎ ΡΠ°ΠΌΠΎΡΡ‚ΠΎΡΡ‚Π΅Π»ΡŒΠ½ΠΎ (Π½Π°Ρ€ΠΈΡΠΎΠ²Π°Ρ‚ΡŒ ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊ, Π½Π°Π·Π½Π°Ρ‡ΠΈΡ‚ΡŒ Π΅ΠΌΡƒ Ρ„ΡƒΠ½ΠΊΡ†ΠΈΡŽ ΠΊΠ½ΠΎΠΏΠΊΠΈ), Π»ΠΈΠ±ΠΎ с ΠΏΠΎΠΌΠΎΡ‰ΡŒΡŽ Π΄ΠΎΠΏΠΎΠ»Π½ΠΈΡ‚Π΅Π»ΡŒΠ½Ρ‹Ρ… GUI-Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊ. Π’Π°ΠΊΠΈΡ… Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊ нСсколько, ΠΊ самым популярным относятся:

Π’ΠΎΡ‚ простой ΠΏΡ€ΠΈΠΌΠ΅Ρ€ использования Pygame GUI – Π·Π΅Π»Π΅Π½Ρ‹Π΅ Π½ΡƒΠ»ΠΈ ΠΈ Π΅Π΄ΠΈΠ½ΠΈΡ†Ρ‹ ΠΏΠ°Π΄Π°ΡŽΡ‚ Π²Π½ΠΈΠ· Π² стилС Β«ΠœΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹Β»:

import pygame
import pygame_gui
import random

window_size = (800, 600)
window = pygame.display.set_mode(window_size)
pygame.display.set_caption('ΠœΠ°Ρ‚Ρ€ΠΈΡ†Π° Lite')
pygame.init()
gui_manager = pygame_gui.UIManager(window_size)

font = pygame.font.SysFont('Consolas', 20)
text_color = pygame.Color('green')
text_symbols = ['0', '1']
text_pos = [(random.randint(0, window_size[0]), 0) for i in range(50)]
text_speed = [(0, random.randint(1, 5)) for i in range(50)]
text_surface_list = []

button_size = (100, 50)
button_pos = (350, 250)
button_text = 'ΠœΠ°Ρ‚Ρ€ΠΈΡ†Π°!'

button = pygame_gui.elements.UIButton(
    relative_rect=pygame.Rect(button_pos, button_size),
    text=button_text,
    manager=gui_manager
)

while True:
    time_delta = pygame.time.Clock().tick(60) 

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

        if event.type == pygame_gui.UI_BUTTON_PRESSED:
            text_surface_list = []
            for i in range(50):
                text_symbol = random.choice(text_symbols)
                text_surface = font.render(text_symbol, True, text_color)
                text_surface_list.append(text_surface)

        gui_manager.process_events(event)

    gui_manager.update(time_delta)

    window.fill(pygame.Color('black'))

    for i in range(50):
        text_pos[i] = (text_pos[i][0], text_pos[i][1] + text_speed[i][1])
        if text_pos[i][1] > window_size[1]:
            text_pos[i] = (random.randint(0, window_size[0]), -20)
        if len(text_surface_list) > i:
            window.blit(text_surface_list[i], text_pos[i])

    gui_manager.draw_ui(window)
    pygame.display.update()

РисованиС

Π’ Pygame Π΅ΡΡ‚ΡŒ Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ для простого рисования гСомСтричСских Ρ„ΠΈΠ³ΡƒΡ€ – ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΎΠ², окруТностСй, эллипсов, Π»ΠΈΠ½ΠΈΠΉ, ΠΌΠ½ΠΎΠ³ΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΎΠ². Π’ΠΎΡ‚ ΠΏΡ€ΠΈΠΌΠ΅Ρ€:

import pygame
import math

pygame.init()
screen_width = 640
screen_height = 480
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("ГСомСтричСскиС Ρ„ΠΈΠ³ΡƒΡ€Ρ‹")

black = (0, 0, 0)
white = (255, 255, 255)
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
yellow = (255, 255, 0)
pink = (255, 192, 203)

# рисуСм ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊ
rect_x = 50
rect_y = 50
rect_width = 100
rect_height = 50
pygame.draw.rect(screen, red, (rect_x, rect_y, rect_width, rect_height))

# рисуСм ΠΊΡ€ΡƒΠ³
circle_x = 200
circle_y = 75
circle_radius = 30
pygame.draw.circle(screen, green, (circle_x, circle_y), circle_radius)

# рисуСм Ρ‚Ρ€Π΅ΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊ
triangle_x = 350
triangle_y = 50
triangle_width = 100
triangle_height = 100
triangle_points = [(triangle_x, triangle_y), (triangle_x + triangle_width, triangle_y),
                   (triangle_x + triangle_width / 2, triangle_y + triangle_height)]
pygame.draw.polygon(screen, blue, triangle_points)

# рисуСм ΠΏΡΡ‚ΠΈΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊ
pent_x = 500
pent_y = 100
radius = 40
sides = 5
pent_points = []
for i in range(sides):
    angle_deg = 360 * i / sides
    angle_rad = math.radians(angle_deg)
    x = pent_x + radius * math.sin(angle_rad)
    y = pent_y - radius * math.cos(angle_rad)
    pent_points.append((x, y))
pygame.draw.polygon(screen, white, pent_points)

# рисуСм эллипс
ellipse_x = 100
ellipse_y = 275
ellipse_width = 150
ellipse_height = 60
pygame.draw.ellipse(screen, red, (ellipse_x, ellipse_y, ellipse_width, ellipse_height))

# Π³ΠΎΡ€ΠΈΠ·ΠΎΠ½Ρ‚Π°Π»ΡŒΠ½Π°Ρ линия
horiz_line_y = 400
pygame.draw.line(screen, blue, (50, horiz_line_y), (590, horiz_line_y), 5)

# Π²Π΅Ρ€Ρ‚ΠΈΠΊΠ°Π»ΡŒΠ½Π°Ρ линия
vert_line_x = 320
pygame.draw.line(screen, green, (vert_line_x, 50), (vert_line_x, 430), 5)

# рисуСм ΠΆΠ΅Π»Ρ‚ΡƒΡŽ Π·Π²Π΅Π·Π΄Ρƒ
yellow_star_points = [(260 - 50, 250 - 70), (310 - 50, 250 - 70), (325 - 50, 200 - 70),
                      (340 - 50, 250 - 70), (390 - 50, 250 - 70), (350 - 50, 290 - 70),
                      (365 - 50, 340 - 70), (325 - 50, 305 - 70), (285 - 50, 340 - 70),
                      (300 - 50, 290 - 70)]
pygame.draw.polygon(screen, yellow, yellow_star_points)

# рисуСм ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ с ΠΊΠ²Π°Π΄Ρ€Π°Ρ‚ΠΎΠΌ Π²Π½ΡƒΡ‚Ρ€ΠΈ
circle2_x = 490
circle2_y = 350
circle2_radius = 80
pygame.draw.circle(screen, white, (circle2_x, circle2_y), circle2_radius)
square_side = 60
square_x = circle2_x - square_side / 2
square_y = circle2_y - square_side / 2
pygame.draw.rect(screen, pink, (square_x, square_y, square_side, square_side))

pygame.display.update()

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

Анимация ΠΈ ΠΎΠ±Ρ€Π°Π±ΠΎΡ‚ΠΊΠ° событий

Π’Ρ‹ΡˆΠ΅, Π² ΠΏΡ€ΠΈΠΌΠ΅Ρ€Π΅ с ΠΏΠ°Π΄Π°ΡŽΡ‰ΠΈΠΌΠΈ символами Π² Β«ΠœΠ°Ρ‚Ρ€ΠΈΡ†Π΅Β», ΡƒΠΆΠ΅ Π±Ρ‹Π» ΠΏΠΎΠΊΠ°Π·Π°Π½ ΠΏΡ€ΠΈΠ½Ρ†ΠΈΠΏ ΠΏΡ€ΠΎΡΡ‚Π΅ΠΉΡˆΠ΅ΠΉ ΠΈΠΌΠΈΡ‚Π°Ρ†ΠΈΠΈ двиТСния, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹ΠΉ Π·Π°ΠΊΠ»ΡŽΡ‡Π°Π΅Ρ‚ΡΡ Π² ΠΏΠΎΡΠ»Π΅Π΄ΠΎΠ²Π°Ρ‚Π΅Π»ΡŒΠ½ΠΎΠΌ ΠΈΠ·ΠΌΠ΅Π½Π΅Π½ΠΈΠΈ ΠΊΠΎΠΎΡ€Π΄ΠΈΠ½Π°Ρ‚ ΠΎΠ±ΡŠΠ΅ΠΊΡ‚Π° ΠΈ ΠΎΠ±Π½ΠΎΠ²Π»Π΅Π½ΠΈΠΈ экрана с установлСнной частотой ΠΊΠ°Π΄Ρ€Π° pygame.time.Clock().tick(60). УслоТним Π·Π°Π΄Π°Ρ‡Ρƒ – сдСлаСм ΠΏΡ€ΠΎΡΡ‚ΡƒΡŽ Π°Π½ΠΈΠΌΠ°Ρ†ΠΈΡŽ с ΠΏΠ°Π΄Π°ΡŽΡ‰ΠΈΠΌΠΈ Ρ€ΠΎΠ·ΠΎΠ²Ρ‹ΠΌΠΈ Β«Π·Π²Π΅Π·Π΄Π°ΠΌΠΈΒ». ΠŸΡ€ΠΈΠ»ΠΎΠΆΠ΅Π½ΠΈΠ΅ Π±ΡƒΠ΄Π΅Ρ‚ ΠΏΠΎΠ΄Π΄Π΅Ρ€ΠΆΠΈΠ²Π°Ρ‚ΡŒ ΠΎΠ±Ρ€Π°Π±ΠΎΡ‚ΠΊΡƒ Π΄Π²ΡƒΡ… событий:

  • ΠŸΡ€ΠΈ ΠΊΠ»ΠΈΠΊΠ΅ ΠΌΡ‹ΡˆΡŒΡŽ ΠΏΠΎ экрану анимация останавливаСтся.
  • ΠŸΡ€ΠΈ Π½Π°ΠΆΠ°Ρ‚ΠΈΠΈ клавиши Enter – возобновляСтся.

ΠšΡ€ΠΎΠΌΠ΅ Ρ‚ΠΎΠ³ΠΎ, Π΄ΠΎΠ±Π°Π²ΠΈΠΌ счСтчик ΡƒΠΏΠ°Π²ΡˆΠΈΡ… Π·Π²Π΅Π·Π΄. Π“ΠΎΡ‚ΠΎΠ²Ρ‹ΠΉ ΠΊΠΎΠ΄ выглядит Ρ‚Π°ΠΊ:

import pygame
import random

pygame.init()

screen_width = 640
screen_height = 480
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Π—Π²Π΅Π·Π΄Ρ‹ ΠΏΠ°Π΄Π°ΡŽΡ‚ Π²Π½ΠΈΠ·")

black = (0, 0, 0)
white = (255, 255, 255)
pink = (255, 192, 203)

font = pygame.font.SysFont("Verdana", 15)

star_list = []
for i in range(50):
    x = random.randrange(screen_width)
    y = random.randrange(-200, -50)
    speed = random.randrange(1, 5)
    star_list.append([x, y, speed])
score = 0

freeze = False # Ρ„Π»Π°Π³ для опрСдСлСния ΠΌΠΎΠΌΠ΅Π½Ρ‚Π° остановки

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()
        if event.type == pygame.MOUSEBUTTONDOWN: # останавливаСм ΠΏΠ°Π΄Π΅Π½ΠΈΠ΅ Π·Π²Π΅Π·Π΄ ΠΏΠΎ ΠΊΠ»ΠΈΠΊΡƒ
            freeze = True
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_RETURN: # возобновляСм Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ Π²Π½ΠΈΠ·, Ссли Π½Π°ΠΆΠ°Ρ‚ Enter
                freeze = False

    if not freeze: # Ссли Ρ„Π»Π°Π³ Π½Π΅ Π°ΠΊΡ‚ΠΈΠ²Π΅Π½,
        # Π·Π²Π΅Π·Π΄Ρ‹ ΠΏΠ°Π΄Π°ΡŽΡ‚ Π²Π½ΠΈΠ·
        for star in star_list:
            star[1] += star[2]
            if star[1] > screen_height:
                star[0] = random.randrange(screen_width)
                star[1] = random.randrange(-200, -50)
                score += 1

    # рисуСм Π·Π²Π΅Π·Π΄Ρ‹, Π²Ρ‹Π²ΠΎΠ΄ΠΈΠΌ Ρ€Π΅Π·ΡƒΠ»ΡŒΡ‚Π°Ρ‚Ρ‹ подсчСта
    screen.fill(black)
    for star in star_list:
        pygame.draw.circle(screen, pink, (star[0], star[1]), 3)
    score_text = font.render("Π£ΠΏΠ°Π»ΠΎ Π·Π²Π΅Π·Π΄: " + str(score), True, white)
    screen.blit(score_text, (10, 10))

    pygame.display.update()

    # устанавливаСм частоту обновлСния экрана
    pygame.time.Clock().tick(60)

ΠŸΠΎΠΊΠ°Π΄Ρ€ΠΎΠ²Π°Ρ анимация

Если Ρƒ вас Π΅ΡΡ‚ΡŒ Π² запасС ΠΊΠ°Ρ€Ρ‚ΠΈΠ½ΠΊΠΈ с раскадровкой двиТСния, ΠΏΡ€Π΅Π²Ρ€Π°Ρ‚ΠΈΡ‚ΡŒ ΠΈΡ… Π² Π°Π½ΠΈΠΌΠ°Ρ†ΠΈΡŽ Π½Π΅ составит Ρ‚Ρ€ΡƒΠ΄Π°:

import pygame

pygame.init()

window_size = (640, 480)
screen = pygame.display.set_mode(window_size)
color = (216, 233, 243)
screen.fill(color)
pygame.display.flip()
pygame.display.set_caption("ΠŸΠΎΠΊΠ°Π΄Ρ€ΠΎΠ²Π°Ρ анимация")
clock = pygame.time.Clock()

# Π·Π°Π³Ρ€ΡƒΠΆΠ°Π΅ΠΌ ΠΊΠ°Π΄Ρ€Ρ‹
frame_images = []
for i in range(1, 9):
    frame_images.append(pygame.image.load(f"frame{i}.png"))

# ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ Π°Π½ΠΈΠΌΠ°Ρ†ΠΈΠΈ
animation_length = len(frame_images)
animation_speed = 15  # ΠΊΠ°Π΄Ρ€Ρ‹ Π² сСкунду
current_frame_index = 0
animation_timer = 0
frame_position = [0, 0]

# вычисляСм ΠΏΠΎΠ·ΠΈΡ†ΠΈΡŽ для Π²Ρ‹Π²ΠΎΠ΄Π° ΠΊΠ°Π΄Ρ€ΠΎΠ² Π² зависимости ΠΎΡ‚ высоты ΠΎΠΊΠ½Π°
window_height = screen.get_height()
frame_height = frame_images[0].get_height()
frame_position[1] = int(window_height * 0.45) - int(frame_height / 2)

# запускаСм основной Ρ†ΠΈΠΊΠ»
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # ΠΎΠ±Π½ΠΎΠ²Π»Π΅Π½ΠΈΠ΅ состояния
    time_delta = clock.tick(60) / 1000.0
    animation_timer += time_delta
    if animation_timer >= 1.0 / animation_speed:
        current_frame_index = (current_frame_index + 1) % animation_length
        animation_timer -= 1.0 / animation_speed

    frame_position[0] += 1  # сдвигаСм ΠΊΠ°Π΄Ρ€ Π²ΠΏΡ€Π°Π²ΠΎ

    # Π²Ρ‹Π²ΠΎΠ΄ΠΈΠΌ ΠΊΠ°Π΄Ρ€Ρ‹, обновляСм экран
    current_frame = frame_images[current_frame_index]
    screen.blit(current_frame, frame_position)
    pygame.display.flip()

pygame.quit()

Π‘Ρ‚ΠΎΠ»ΠΊΠ½ΠΎΠ²Π΅Π½ΠΈΠ΅ ΠΎΠ±ΡŠΠ΅ΠΊΡ‚ΠΎΠ²

Π’ этом ΠΏΡ€ΠΈΠΌΠ΅Ρ€Π΅ расстояниС ΠΌΠ΅ΠΆΠ΄Ρƒ ΠΎΠ±ΡŠΠ΅ΠΊΡ‚Π°ΠΌΠΈ провСряСтся Π΄ΠΎ Ρ‚Π΅Ρ… ΠΏΠΎΡ€, ΠΏΠΎΠΊΠ° ΠΎΠ±ΡŠΠ΅ΠΊΡ‚Ρ‹ Π½Π΅ столкнутся. Π’ ΠΌΠΎΠΌΠ΅Π½Ρ‚ столкновСниС Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ прСкращаСтся, Π° Ρ†Π²Π΅Ρ‚ ΠΎΠ±ΡŠΠ΅ΠΊΡ‚ΠΎΠ² – измСняСтся:

import pygame
import math

pygame.init()
screen_width = 400
screen_height = 480
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("ДраматичСскоС столкновСниС")

# Ρ€Π°Π·ΠΌΠ΅Ρ€Ρ‹ ΠΈ позиция окруТности
circle_pos = [screen_width/2, 50]
circle_radius = 20

# Ρ€Π°Π·ΠΌΠ΅Ρ€Ρ‹ ΠΈ позиция ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠ°
rect_pos = [screen_width/2, screen_height-50]
rect_width = 100
rect_height = 50

# Ρ†Π²Π΅Ρ‚Π° окруТности ΠΈ ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠ°
white = (255, 255, 255)
black = (0, 0, 0)
green = (0, 255, 0)
red = (255, 0, 0)

# ΡΠΊΠΎΡ€ΠΎΡΡ‚ΡŒ двиТСния окруТности
speed = 5

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

    # ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ двиТСтся Π²Π½ΠΈΠ·
    circle_pos[1] += speed

    # провСряСм (ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΡ Ρ„ΠΎΡ€ΠΌΡƒΠ»Ρƒ расстояния),
    # ΡΡ‚ΠΎΠ»ΠΊΠ½ΡƒΠ»Π°ΡΡŒ Π»ΠΈ ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ с ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΎΠΌ
    circle_x = circle_pos[0]
    circle_y = circle_pos[1]
    rect_x = rect_pos[0]
    rect_y = rect_pos[1]
    distance_x = abs(circle_x - rect_x)
    distance_y = abs(circle_y - rect_y)
    if distance_x <= (rect_width/2 + circle_radius) and distance_y <= (rect_height/2 + circle_radius):
        circle_color = red # измСняСм Ρ†Π²Π΅Ρ‚ Ρ„ΠΈΠ³ΡƒΡ€
        rect_color = green # Π² ΠΌΠΎΠΌΠ΅Π½Ρ‚ столкновСния
    else:
        circle_color = green
        rect_color = black

    # рисуСм ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ ΠΈ ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊ Π½Π° экранС
    screen.fill(white)
    pygame.draw.circle(screen, circle_color, circle_pos, circle_radius)
    pygame.draw.rect(screen, rect_color, (rect_pos[0]-rect_width/2, rect_pos[1]-rect_height/2, rect_width, rect_height))

    pygame.display.update()

    # останавливаСм Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ окруТности, Ссли ΠΎΠ½Π°
    # ΡΡ‚ΠΎΠ»ΠΊΠ½ΡƒΠ»Π°ΡΡŒ с ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΎΠΌ
    if circle_pos[1] + circle_radius >= rect_pos[1] - rect_height/2:
        speed = 0

    # Π·Π°Π΄Π°Π΅ΠΌ частоту обновлСния экрана
    pygame.time.Clock().tick(60)

Π£ΠΏΡ€Π°Π²Π»Π΅Π½ΠΈΠ΅ Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ΠΌ ΠΎΠ±ΡŠΠ΅ΠΊΡ‚Π°

Для управлСния Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ΠΌ (Π² нашСм случаС – с ΠΏΠΎΠΌΠΎΡ‰ΡŒΡŽ клавиш ← ΠΈ β†’) ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΡŽΡ‚ΡΡ pygame.K_RIGHT (Π²ΠΏΡ€Π°Π²ΠΎ) ΠΈ pygame.K_LEFT (Π²Π»Π΅Π²ΠΎ). Π’ ΠΏΡ€ΠΈΠ²Π΅Π΄Π΅Π½Π½ΠΎΠΌ Π½ΠΈΠΆΠ΅ ΠΏΡ€ΠΈΠΌΠ΅Ρ€Π΅ ΠΏΠ΅Ρ€Π΅Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ ΠΏΠ°Π΄Π°ΡŽΡ‰ΠΈΡ… окруТностСй Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎ Ρ‚ΠΎΠ»ΡŒΠΊΠΎ Π΄ΠΎ ΠΌΠΎΠΌΠ΅Π½Ρ‚Π° призСмлСния Π½Π° Π΄Π½ΠΎ ΠΈΠ³Ρ€ΠΎΠ²ΠΎΠ³ΠΎ поля, ΠΈΠ»ΠΈ Π½Π° ΠΏΡ€Π΅Π΄Ρ‹Π΄ΡƒΡ‰ΠΈΠ΅ Ρ„ΠΈΠ³ΡƒΡ€Ρ‹. Для упрощСния вычислСния Ρ„Π°ΠΊΡ‚Π° столкновСния Ρ„ΠΈΠ³ΡƒΡ€ окруТности Π²ΠΏΠΈΡΡ‹Π²Π°ΡŽΡ‚ΡΡ Π² ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΈ:

import pygame
import random

pygame.init()
screen_width = 640
screen_height = 480
screen = pygame.display.set_mode((screen_width, screen_height))

# Ρ†Π²Π΅Ρ‚Π° окруТностСй
white = (255, 255, 255)
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
black = (0, 0, 0)
yellow = (255, 255, 0)

# Ρ†Π²Π΅Ρ‚, ΡΠΊΠΎΡ€ΠΎΡΡ‚ΡŒ, Π½Π°Ρ‡Π°Π»ΡŒΠ½Π°Ρ позиция окруТности
circle_radius = 30
circle_speed = 3
circle_color = random.choice([red, green, blue, yellow, white])
circle_pos = [screen_width//2, -circle_radius]
circle_landed = False

# список ΠΏΡ€ΠΈΠ·Π΅ΠΌΠ»ΠΈΠ²ΡˆΠΈΡ…ΡΡ окруТностСй ΠΈ ΠΈΡ… ΠΏΠΎΠ·ΠΈΡ†ΠΈΠΉ
landed_circles = []

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

    # Ссли ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ Π½Π΅ ΠΏΡ€ΠΈΠ·Π΅ΠΌΠ»ΠΈΠ»Π°ΡΡŒ
    if not circle_landed:
        # мСняСм Π½Π°ΠΏΡ€Π°Π²Π»Π΅Π½ΠΈΠ΅ ΠΏΠΎ Π½Π°ΠΆΠ°Ρ‚ΠΈΡŽ клавиши
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            circle_pos[0] -= circle_speed
        if keys[pygame.K_RIGHT]:
            circle_pos[0] += circle_speed

        # провСряСм, ΡΡ‚ΠΎΠ»ΠΊΠ½ΡƒΠ»Π°ΡΡŒ Π»ΠΈ ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ с Π΄Ρ€ΡƒΠ³ΠΎΠΉ ΠΏΡ€ΠΈΠ·Π΅ΠΌΠ»ΠΈΠ²ΡˆΠ΅ΠΉΡΡ ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒΡŽ
        for landed_circle in landed_circles:
            landed_rect = pygame.Rect(landed_circle[0]-circle_radius, landed_circle[1]-circle_radius, circle_radius*2, circle_radius*2)
            falling_rect = pygame.Rect(circle_pos[0]-circle_radius, circle_pos[1]-circle_radius, circle_radius*2, circle_radius*2)
            if landed_rect.colliderect(falling_rect):
                circle_landed = True
                collision_x = circle_pos[0]
                collision_y = landed_circle[1] - circle_radius*2
                landed_circles.append((collision_x, collision_y, circle_color))
                break

        # Ссли ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ Π½Π΅ ΡΡ‚ΠΎΠ»ΠΊΠ½ΡƒΠ»Π°ΡΡŒ с Π΄Ρ€ΡƒΠ³ΠΎΠΉ ΠΏΡ€ΠΈΠ·Π΅ΠΌΠ»ΠΈΠ²ΡˆΠ΅ΠΉΡΡ ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒΡŽ
        if not circle_landed:
            # ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ двиТСтся Π²Π½ΠΈΠ·
            circle_pos[1] += circle_speed

            # провСряСм, достигла Π»ΠΈ ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ Π΄Π½Π°
            if circle_pos[1] + circle_radius > screen_height:
                circle_pos[1] = screen_height - circle_radius
                circle_landed = True
                # добавляСм ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ ΠΈ Π΅Π΅ ΠΏΠΎΠ·ΠΈΡ†ΠΈΡŽ Π² список ΠΏΡ€ΠΈΠ·Π΅ΠΌΠ»ΠΈΠ²ΡˆΠΈΡ…ΡΡ окруТностСй
                landed_circles.append((circle_pos[0], circle_pos[1], circle_color))

    if circle_landed:
        # Ссли ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ ΠΏΡ€ΠΈΠ·Π΅ΠΌΠ»ΠΈΠ»Π°ΡΡŒ, Π·Π°Π΄Π°Π΅ΠΌ ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ Π½ΠΎΠ²ΠΎΠΉ
        circle_pos = [screen_width//2, -circle_radius]
        circle_color = random.choice([red, green, blue, yellow, white])
        circle_landed = False

    # рисуСм окруТности
    screen.fill(black)
    for landed_circle in landed_circles:
        pygame.draw.circle(screen, landed_circle[2], (landed_circle[0], landed_circle[1]), circle_radius)
    pygame.draw.circle(screen, circle_color, circle_pos, circle_radius)
    pygame.display.update()

    # частота обновлСния экрана
    pygame.time.Clock().tick(60)

ΠŸΡ€Π°ΠΊΡ‚ΠΈΠΊΠ°

Π—Π°Π΄Π°Π½ΠΈΠ΅ 1 – ЛСстница

ΠΠ°ΠΏΠΈΡˆΠΈΡ‚Π΅ Pygame ΠΈΠ³Ρ€Ρƒ, Π² ΠΊΠΎΡ‚ΠΎΡ€ΠΎΠΉ ΠΈΠ³Ρ€ΠΎΠΊ (красная ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ) поднимаСтся Π²Π²Π΅Ρ€Ρ… ΠΏΠΎ ступСням лСстницы. НСобходимо ΠΏΠΎΠ΄ΡΡ‡ΠΈΡ‚Ρ‹Π²Π°Ρ‚ΡŒ сдСланныС шаги.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame

pygame.init()
WINDOW_WIDTH = 500
WINDOW_HEIGHT = 500
game_display = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption('Π’Π²Π΅Ρ€Ρ… ΠΏΠΎ лСстницС')

# ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ ступСнСй
STEP_WIDTH = 20
STEP_HEIGHT = STEP_WIDTH
STEP_COLOR = (255, 255, 255)

# ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ ΠΈΠ³Ρ€ΠΎΠΊΠ°, Ρ€Π°Π·ΠΌΠ΅Ρ€Ρ‹ ΠΈ Ρ†Π²Π΅Ρ‚ ΡˆΡ€ΠΈΡ„Ρ‚Π°
PLAYER_RADIUS = 10
PLAYER_COLOR = (255, 0, 0)
FONT_SIZE = 20
FONT_COLOR = (255, 255, 255)
clock = pygame.time.Clock()

def game_loop():
    game_exit = False
    # стартовая позиция ΠΈΠ³Ρ€ΠΎΠΊΠ°
    player_x = PLAYER_RADIUS
    player_y = WINDOW_HEIGHT - PLAYER_RADIUS * 3
    # Π½Π°Ρ‡Π°Π»ΡŒΠ½Ρ‹Π΅ ΠΊΠΎΠΎΡ€Π΄ΠΈΠ½Π°Ρ‚Ρ‹ ступСнСй
    step_x = 0
    step_y = WINDOW_HEIGHT - STEP_HEIGHT
    # создаСм счСтчик шагов
    step_count = 0

    while not game_exit:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game_exit = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_RIGHT:
                    # удаляСм ΠΈΠ³Ρ€ΠΎΠΊΠ° ΠΈΠ· ΠΏΡ€Π΅Π΄Ρ‹Π΄ΡƒΡ‰Π΅ΠΉ ΠΏΠΎΠ·ΠΈΡ†ΠΈΠΈ
                    pygame.draw.circle(game_display, (0, 0, 0), (player_x, player_y), PLAYER_RADIUS)
                    # обновляСм ΠΏΠΎΠ·ΠΈΡ†ΠΈΡŽ ΠΈ счСт
                    player_x += 20
                    player_y -= 20
                    step_count += 1

        # рисуСм лСстницу
        while step_x < WINDOW_WIDTH and step_y >= 0:
            pygame.draw.rect(game_display, STEP_COLOR, [step_x, step_y, STEP_WIDTH, STEP_HEIGHT])
            step_x += STEP_WIDTH
            step_y -= STEP_HEIGHT

        # ΠΏΠ΅Ρ€Π΅ΠΌΠ΅Ρ‰Π°Π΅ΠΌ ΠΈΠ³Ρ€ΠΎΠΊΠ° Π½Π° ΡΡ‚ΡƒΠΏΠ΅Π½ΡŒ Π²Ρ‹ΡˆΠ΅
        pygame.draw.circle(game_display, PLAYER_COLOR, (player_x, player_y), PLAYER_RADIUS)

        # подсчитываСм сдСланныС шаги
        pygame.draw.rect(game_display, (0, 0, 0), (10, 10, 100, FONT_SIZE))
        font = pygame.font.SysFont('Arial', FONT_SIZE)
        text = font.render(f'Π¨Π°Π³: {str(step_count)}', True, FONT_COLOR)
        game_display.blit(text, (10, 10))
        pygame.display.update()
        clock.tick(60)
game_loop()
pygame.quit()

Π—Π°Π΄Π°Π½ΠΈΠ΅ 2 – Π›Π°Π±ΠΈΡ€ΠΈΠ½Ρ‚

ΠΠ°ΠΏΠΈΡˆΠΈΡ‚Π΅ Pygame ΠΈΠ³Ρ€Ρƒ, которая Π³Π΅Π½Π΅Ρ€ΠΈΡ€ΡƒΠ΅Ρ‚ Π»Π°Π±ΠΈΡ€ΠΈΠ½Ρ‚ ΠΈΠ· Π²Π΅Ρ€Ρ‚ΠΈΠΊΠ°Π»ΡŒΠ½Ρ‹Ρ… стСн со случайным количСством Π΄Π²Π΅Ρ€Π΅ΠΉ. Π˜Π³Ρ€ΠΎΠΊ (красная ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ) Π΄ΠΎΠ»ΠΆΠ΅Π½ ΠΏΡ€ΠΎΡ…ΠΎΠ΄ΠΈΡ‚ΡŒ Ρ‡Π΅Ρ€Π΅Π· Π΄Π²Π΅Ρ€ΠΈ.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame
import random

pygame.init()
screen_width = 640
screen_height = 480
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption('Π›Π°Π±ΠΈΡ€ΠΈΠ½Ρ‚')

black = (0,0,0)
white = (255,255,255)
red = (255,0,0)
blue = (0,0,255)
green = (0,255,0)

# ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ стСн ΠΈ Π΄Π²Π΅Ρ€Π΅ΠΉ
line_width = 10
line_gap = 40
line_offset = 20
door_width = 20
door_gap = 40
max_openings_per_line = 5

# ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ ΠΈ стартовая позиция ΠΈΠ³Ρ€ΠΎΠΊΠ°
player_radius = 10
player_speed = 5
player_x = screen_width - 12
player_y = screen_height - line_offset

# рисуСм стСны ΠΈ Π΄Π²Π΅Ρ€ΠΈ
lines = []
for i in range(0, screen_width, line_gap):
    rect = pygame.Rect(i, 0, line_width, screen_height)
    num_openings = random.randint(1, max_openings_per_line)
    if num_openings == 1:
        # ΠΎΠ΄Π½Π° Π΄Π²Π΅Ρ€ΡŒ посСрСдинС стСны
        door_pos = random.randint(line_offset + door_width, screen_height - line_offset - door_width)
        lines.append(pygame.Rect(i, 0, line_width, door_pos - door_width))
        lines.append(pygame.Rect(i, door_pos + door_width, line_width, screen_height - door_pos - door_width))
    else:
        # нСсколько Π΄Π²Π΅Ρ€Π΅ΠΉ
        opening_positions = [0] + sorted([random.randint(line_offset + door_width, screen_height - line_offset - door_width) for _ in range(num_openings-1)]) + [screen_height]
        for j in range(num_openings):
            lines.append(pygame.Rect(i, opening_positions[j], line_width, opening_positions[j+1]-opening_positions[j]-door_width))

clock = pygame.time.Clock()

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

    # ΠΏΠ΅Ρ€Π΅Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ ΠΈΠ³Ρ€ΠΎΠΊΠ°
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_x > player_radius:
        player_x -= player_speed
    elif keys[pygame.K_RIGHT] and player_x < screen_width - player_radius:
        player_x += player_speed
    elif keys[pygame.K_UP] and player_y > player_radius:
        player_y -= player_speed
    elif keys[pygame.K_DOWN] and player_y < screen_height - player_radius:
        player_y += player_speed

    # ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° столкновСний ΠΈΠ³Ρ€ΠΎΠΊΠ° со стСнами
    player_rect = pygame.Rect(player_x - player_radius, player_y - player_radius, player_radius * 2, player_radius * 2)
    for line in lines:
        if line.colliderect(player_rect):
            # Π² случаС столкновСния Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π°Π΅ΠΌ ΠΈΠ³Ρ€ΠΎΠΊΠ° Π½Π°Π·Π°Π΄
            if player_x > line.left and player_x < line.right:
                if player_y < line.top:
                    player_y = line.top - player_radius
                else:
                    player_y = line.bottom + player_radius
            elif player_y > line.top and player_y < line.bottom:
                if player_x < line.left:
                    player_x = line.left - player_radius
                else:
                    player_x = line.right + player_radius
    screen.fill(black)
    for line in lines:
        pygame.draw.rect(screen, green, line)
    pygame.draw.circle(screen, red, (player_x, player_y), player_radius)
    pygame.display.update()
    clock.tick(60)

Π—Π°Π΄Π°Π½ΠΈΠ΅ 3 – Π”ΠΎΠΆΠ΄ΡŒ

Π˜ΡΠΏΠΎΠ»ΡŒΠ·ΡƒΡ Pygame, Π½Π°ΠΏΠΈΡˆΠΈΡ‚Π΅ симулятор доТдя: ΠΏΠ°Π΄Π΅Π½ΠΈΠ΅ ΠΊΠ°ΠΆΠ΄ΠΎΠΉ сотни капСль ΠΏΡ€ΠΈΠ²ΠΎΠ΄ΠΈΡ‚ ΠΊ ΠΏΠΎΠ΄ΡŠΠ΅ΠΌΡƒ уровня Π²ΠΎΠ΄Ρ‹ Π½Π° 1 пиксСль.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame
import random

class RainSimulator:
    def __init__(self):
        pygame.init()
        self.screen_width = 500
        self.screen_height = 700
        self.screen = pygame.display.set_mode((self.screen_width, self.screen_height))
        pygame.display.set_caption("Π”ΠΎΠΆΠ΄ΡŒ")
        self.font = pygame.font.SysFont("Consolas", 20)
        self.background_color = (0, 0, 0)
        self.blue = (173, 216, 230)

        # ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ Π΄ΠΎΠΆΠ΄Π΅Π²Ρ‹Ρ… капСль
        self.drops = []
        self.drops_landed = 0
        self.drops_per_pixel = 100
        self.level_height = 0

        self.clock = pygame.time.Clock()

    # добавляСм капли доТдя
    def add_drop(self):
        self.drops.append([random.randint(0, self.screen_width), 0])

    # рисуСм доТдь
    def draw_drops(self):
        for drop in self.drops:
            pygame.draw.line(self.screen, self.blue, (drop[0], drop[1]), (drop[0], drop[1] + 5), 2)

    # подсчитываСм ΠΊΠ°ΠΏΠ»ΠΈ, ΠΏΠΎΠ΄Π½ΠΈΠΌΠ°Π΅ΠΌ ΡƒΡ€ΠΎΠ²Π΅Π½ΡŒ Π²ΠΎΠ΄Ρ‹
    def update_drops(self):
        for drop in self.drops:
            drop[1] += 5
            if drop[1] >= self.screen_height:
                self.drops.remove(drop)
                self.drops_landed += 1
                if self.drops_landed % self.drops_per_pixel == 0:
                    self.level_height += 1

    # Π²Ρ‹Π²ΠΎΠ΄ΠΈΠΌ количСство капСль
    def draw_score(self):
        score_text = self.font.render(f"КапСль доТдя: {str(self.drops_landed)}", True, (255, 255, 255))
        self.screen.blit(score_text, (10, 10))
        pygame.draw.rect(self.screen, self.blue, (0, self.screen_height-self.level_height, self.screen_width, self.level_height))

    def run_rain(self):
        running = True
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
            self.add_drop()
            self.update_drops()
            self.screen.fill(self.background_color)
            self.draw_drops()
            self.draw_score()
            pygame.display.update()
            self.clock.tick(60)

        pygame.quit()

if __name__ == "__main__":
    app = RainSimulator()
    app.run_rain()

Π—Π°Π΄Π°Π½ΠΈΠ΅ 4 – ΠœΠ΅Ρ€Ρ†Π°ΡŽΡ‰ΠΈΠ΅ Π·Π²Π΅Π·Π΄Ρ‹

Π˜ΡΠΏΠΎΠ»ΡŒΠ·ΡƒΡ Pygame, Π½Π°ΠΏΠΈΡˆΠΈΡ‚Π΅ симулятор Π·Π²Π΅Π·Π΄Π½ΠΎΠ³ΠΎ Π½Π΅Π±Π° – окруТности, ΠΏΡ€Π΅Π΄ΡΡ‚Π°Π²Π»ΡΡŽΡ‰ΠΈΠ΅ собой Π·Π²Π΅Π·Π΄Ρ‹, ΡΠΆΠΈΠΌΠ°ΡŽΡ‚ΡΡ ΠΈ Ρ€Π°ΡΡˆΠΈΡ€ΡΡŽΡ‚ΡΡ, имитируя ΠΌΠ΅Ρ€Ρ†Π°Π½ΠΈΠ΅.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame
import random

pygame.init()
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600
screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("ΠœΠ΅Ρ€Ρ†Π°ΡŽΡ‰ΠΈΠ΅ Π·Π²Π΅Π·Π΄Ρ‹")

# ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ Π·Π²Π΅Π·Π΄
MAX_STARS = 200
stars = []
for i in range(MAX_STARS):
    star_radius = random.randint(1, 3)
    star_color = (255, 255, 237)
    star_position = (random.randint(0, WINDOW_WIDTH), random.randint(0, WINDOW_HEIGHT))
    star_expand = True
    star_expand_speed = random.uniform(0.1, 0.5)
    stars.append((star_radius, star_color, star_position, star_expand, star_expand_speed))

clock = pygame.time.Clock()
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

    for i in range(MAX_STARS):
        star_radius, star_color, star_position, star_expand, star_expand_speed = stars[i]

        # вычислСниС радиуса Ρ€Π°ΡΡˆΠΈΡ€Π΅Π½ΠΈΡ
        if star_expand:
            star_radius += star_expand_speed
            if star_radius >= 5:
                star_expand = False
        else:
            star_radius -= star_expand_speed
            if star_radius <= 1:
                star_expand = True

        # измСняСм ΠΏΠΎΠ·ΠΈΡ†ΠΈΠΈ Π·Π²Π΅Π·Π΄ для создания эффСкта мСрцания
        star_position = (
            star_position[0] + random.randint(-1, 1),
            star_position[1] + random.randint(-1, 1)
        )

        stars[i] = (star_radius, star_color, star_position, star_expand, star_expand_speed)

    # рисуСм Π·Π²Π΅Π·Π΄Ρ‹
    screen.fill((0, 0, 0))
    for star in stars:
        star_radius, star_color, star_position, _, _ = star
        pygame.draw.circle(screen, star_color, star_position, star_radius)

    pygame.display.update()
    clock.tick(60)

Π—Π°Π΄Π°Π½ΠΈΠ΅ 5 – Колобок

Π˜ΡΠΏΠΎΠ»ΡŒΠ·ΡƒΡ Pygame, создайтС Π°Π½ΠΈΠΌΠ°Ρ†ΠΈΡŽ, Π² ΠΊΠΎΡ‚ΠΎΡ€ΠΎΠΉ лиса (состоящая ΠΈΠ· этих Ρ„Ρ€Π΅ΠΉΠΌΠΎΠ²) прСслСдуСт Колобка. Колобок вращаСтся Π²ΠΎΠΊΡ€ΡƒΠ³ своСй оси.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ ΠΈ Π½Π΅ΠΎΠ±Ρ…ΠΎΠ΄ΠΈΠΌΡ‹Π΅ изобраТСния.

import pygame

pygame.init()
background = (24, 113, 147)
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 300
game_display = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption('Колобок')

# Π·Π°Π³Ρ€ΡƒΠΆΠ°Π΅ΠΌ ΠΈΠ·ΠΎΠ±Ρ€Π°ΠΆΠ΅Π½ΠΈΠ΅ Колобка
kolobok = pygame.image.load('kolobok.png')
# стартовый ΡƒΠ³ΠΎΠ» вращСния ΠΈ ΡΠΊΠΎΡ€ΠΎΡΡ‚ΡŒ
kolobok_angle = 0
kolobok_rotation_speed = 2

# Π·Π°Π³Ρ€ΡƒΠΆΠ°Π΅ΠΌ Ρ„Ρ€Π΅ΠΉΠΌΡ‹ лисы
fox = []
for i in range(8):
    fox.append(pygame.image.load(f'fox{i+1}.png'))

# частота обновлСния Ρ„Ρ€Π΅ΠΉΠΌΠΎΠ² лисы
fox_frame = 0
fox_frame_rate = 8
fox_frame_timer = 0

# стартовыС ΠΏΠΎΠ·ΠΈΡ†ΠΈΠΈ ΠΈ ΡΠΊΠΎΡ€ΠΎΡΡ‚ΡŒ двиТСния лисы ΠΈ Колобка
kolobok_x = 0
kolobok_y = WINDOW_HEIGHT // 2 + kolobok.get_height() // 4 
fox_x = -fox[0].get_width()
fox_y = WINDOW_HEIGHT // 2 - fox[0].get_height() // 2
movement_speed = 3
clock = pygame.time.Clock()

# Π³Π»Π°Π²Π½Ρ‹ΠΉ Ρ†ΠΈΠΊΠ»
game_exit = False
while not game_exit:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_exit = True

    # Π²Ρ€Π°Ρ‰Π°Π΅ΠΌ ΠΈΠ·ΠΎΠ±Ρ€Π°ΠΆΠ΅Π½ΠΈΠ΅ Колобка Π²ΠΎΠΊΡ€ΡƒΠ³ своСй оси
    kolobok_angle += kolobok_rotation_speed
    if kolobok_angle >= 360:
        kolobok_angle = 0
    rotated_kolobok = pygame.transform.rotate(kolobok, kolobok_angle)

    # Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ Колобка ΠΈ лисы слСва Π½Π°ΠΏΡ€Π°Π²ΠΎ
    kolobok_x += movement_speed
    if kolobok_x > WINDOW_WIDTH:
        kolobok_x = 0 - fox[0].get_width()
    fox_x += movement_speed
    if fox_x > WINDOW_WIDTH:
        fox_x = 0 - fox[0].get_width() 

    # ΠΏΡ€ΠΈΠ²ΠΎΠ΄ΠΈΠΌ ΡΠΊΠΎΡ€ΠΎΡΡ‚ΡŒ Π°Π½ΠΈΠΌΠ°Ρ†ΠΈΠΈ лисы Π² соотвСтствиС с частотой обновлСния экрана
    fox_frame_timer += clock.tick(60)
    if fox_frame_timer >= 1000 / fox_frame_rate:
        fox_frame_timer -= 1000 / fox_frame_rate
        fox_frame = (fox_frame + 1) % len(fox)

    # рисуСм Ρ„ΠΎΠ½, Π²Ρ‹Π²ΠΎΠ΄ΠΈΠΌ Ρ„ΠΈΠ³ΡƒΡ€Ρ‹ Колобка ΠΈ лисы
    game_display.fill(background)
    game_display.blit(rotated_kolobok, (kolobok_x, kolobok_y))
    game_display.blit(fox[fox_frame], (fox_x, fox_y))
    pygame.display.update()

pygame.quit()

Π—Π°Π΄Π°Π½ΠΈΠ΅ 6 – Π‘Π²Π΅Ρ‚ΠΎΡ„ΠΎΡ€

ΠΠ°ΠΏΠΈΡˆΠΈΡ‚Π΅ Pygame ΠΏΡ€ΠΈΠ»ΠΎΠΆΠ΅Π½ΠΈΠ΅ для дСмонстрации Ρ€Π°Π±ΠΎΡ‚Ρ‹ свСтофора: ΠΊΠΎΠ³Π΄Π° Π³ΠΎΡ€ΠΈΡ‚ Π·Π΅Π»Π΅Π½Ρ‹ΠΉ свСт (6 сСкунд), ΠΏΡ€ΡΠΌΠΎΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΈ-Π°Π²Ρ‚ΠΎΠΌΠΎΠ±ΠΈΠ»ΠΈ двиТутся Π²ΠΏΠ΅Ρ€Π΅Π΄. ΠšΡ€Π°ΡΠ½Ρ‹ΠΉ ΠΈ ΠΆΠ΅Π»Ρ‚Ρ‹ΠΉ свСт Π²ΠΊΠ»ΡŽΡ‡Π°ΡŽΡ‚ΡΡ Π½Π° 2 сСкунды ΠΊΠ°ΠΆΠ΄Ρ‹ΠΉ, Π² это врСмя Ρ‚Ρ€Π°Ρ„ΠΈΠΊ останавливаСтся.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame
import random

pygame.init()
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600
game_display = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption('Π‘Π²Π΅Ρ‚ΠΎΡ„ΠΎΡ€')
clock = pygame.time.Clock()

BLACK = (0, 0, 0)
DARK_GRAY = (64, 64, 64)
GRAY = (128, 128, 128)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)


def game_loop():
    game_exit = False

    # опрСдСляСм Ρ†Π²Π΅Ρ‚Π° для свСтофора
    colors = [RED, YELLOW, GREEN]
    active_index = 0
    last_switch = pygame.time.get_ticks()
    interval = 2000

    # ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ Π°Π²Ρ‚ΠΎΠΌΠΎΠ±ΠΈΠ»Π΅ΠΉ
    car_width = 40
    car_height = 60
    car_speed = 2
    horizontal_spacing = 12
    vertical_spacing = 20
    car_rects = []
    for i in range(2):
        left_rect = pygame.Rect(100, random.randint(50, WINDOW_HEIGHT - car_height), car_width, car_height)
        right_rect = pygame.Rect(WINDOW_WIDTH - 300 - car_width, random.randint(50, WINDOW_HEIGHT - car_height), car_width, car_height)
        car_rects.append(left_rect)
        car_rects.append(right_rect)

    # Π²Π΅Ρ€Ρ‚ΠΈΠΊΠ°Π»ΡŒΠ½Π°Ρ ΠΈ Π³ΠΎΡ€ΠΈΠ·ΠΎΠ½Ρ‚Π°Π»ΡŒΠ½Π°Ρ дистанция ΠΌΠ΅ΠΆΠ΄Ρƒ автомобилями
    for i in range(1, len(car_rects)):
        if car_rects[i].left - car_rects[i-1].right < horizontal_spacing:
            car_rects[i].left = car_rects[i-1].right + horizontal_spacing
        if car_rects[i].top - car_rects[i-1].bottom < vertical_spacing:
            car_rects[i].top = car_rects[i-1].bottom + vertical_spacing

    while not game_exit:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game_exit = True

        # опрСдСляСм Π½ΡƒΠΆΠ½Ρ‹ΠΉ Ρ†Π²Π΅Ρ‚ свСтофора
        now = pygame.time.get_ticks()
        if now - last_switch >= interval:
            active_index = (active_index + 1) % len(colors)
            last_switch = now

        # Π²Ρ€Π΅ΠΌΠ΅Π½Π½ΠΎΠΉ ΠΈΠ½Ρ‚Π΅Ρ€Π²Π°Π» для Π·Π΅Π»Π΅Π½ΠΎΠ³ΠΎ Ρ†Π²Π΅Ρ‚Π° - 6 сСкунд, для ΠΎΡΡ‚Π°Π»ΡŒΠ½Ρ‹Ρ… - 2
        interval = 6000 if active_index == 2 else 2000

        # двиТСниС машин
        if active_index == 0 or active_index == 1:
            car_speed = 0
        else:
            car_speed = 2
        for car_rect in car_rects:
            car_rect.move_ip(0, -car_speed)
            if car_rect.bottom <= 0:
                car_rect.top = WINDOW_HEIGHT
                car_rect.left = 100 if car_rect.left == WINDOW_WIDTH - 100 - car_width else WINDOW_WIDTH - 100 - car_width

        # рисуСм свСтофор
        game_display.fill(GRAY)
        light_rect = pygame.Rect((WINDOW_WIDTH - 200) // 2, (WINDOW_HEIGHT - 300) // 2, 100, 300)
        pygame.draw.rect(game_display, DARK_GRAY, light_rect, 5)
        light_width = light_rect.width
        light_height = light_rect.height // 3
        light_y = light_rect.top
        for i in range(3):
            circle_rect = pygame.Rect(light_rect.left + 10, light_y + i * light_height + 10, light_width - 20, light_height - 20)
            circle_color = colors[i] if i == active_index else BLACK
            pygame.draw.circle(game_display, circle_color, circle_rect.center, circle_rect.width // 2)

        # рисуСм Π°Π²Ρ‚ΠΎΠΌΠΎΠ±ΠΈΠ»ΠΈ
        for car_rect in car_rects:
            pygame.draw.rect(game_display, BLUE, car_rect)

        pygame.display.update()
        clock.tick(60)
    pygame.quit()
game_loop()

Π—Π°Π΄Π°Π½ΠΈΠ΅ 7 – Π’ΠΈΠ·ΡƒΠ°Π»ΡŒΠ½Π°Ρ ΠΏΠ°ΠΌΡΡ‚ΡŒ

ΠΠ°ΠΏΠΈΡˆΠΈΡ‚Π΅ Π»Π°ΠΉΡ‚-Π²Π΅Ρ€ΡΠΈΡŽ ΠΈΠ³Ρ€Ρ‹ Memory game, ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΡ возмоТности Pygame. Π‘Π½Π°Ρ‡Π°Π»Π° ΠΏΡ€ΠΈΠ»ΠΎΠΆΠ΅Π½ΠΈΠ΅ Π²Ρ‹Π²ΠΎΠ΄ΠΈΡ‚ (Π² случайном порядкС) Ρ†Π²Π΅Ρ‚Π½Ρ‹Π΅ окруТности ΠΈ Π΄Π°Π΅Ρ‚ Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎΡΡ‚ΡŒ ΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚Π΅Π»ΡŽ Π·Π°ΠΏΠΎΠΌΠ½ΠΈΡ‚ΡŒ ΠΈΡ… располоТСниС Π² Ρ‚Π΅Ρ‡Π΅Π½ΠΈΠ΅ Π½Π΅ΡΠΊΠΎΠ»ΡŒΠΊΠΈΡ… сСкунд. Π—Π°Ρ‚Π΅ΠΌ ΠΏΡ€ΠΈΠ»ΠΎΠΆΠ΅Π½ΠΈΠ΅ Π·Π°ΠΊΡ€Ρ‹Π²Π°Π΅Ρ‚ Ρ†Π²Π΅Ρ‚Π½Ρ‹Π΅ окруТности сСрыми: ΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚Π΅Π»ΡŒ Π΄ΠΎΠ»ΠΆΠ΅Π½ ΠΏΠΎ памяти ΡΠΎΠΏΠΎΡΡ‚Π°Π²ΠΈΡ‚ΡŒ Ρ†Π²Π΅Ρ‚Π½Ρ‹Π΅ ΠΏΠ°Ρ€Ρ‹. КаТдая угаданная ΠΏΠ°Ρ€Π° приносит ΠΏΠΎΠ»ΡŒΠ·ΠΎΠ²Π°Ρ‚Π΅Π»ΡŽ 1 Π±Π°Π»Π».

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame
from random import shuffle

pygame.init()
# опрСдСляСм Ρ†Π²Π΅Ρ‚Π° ΠΈΠ³Ρ€Ρ‹
black = (0, 0, 0)
white = (255, 255, 255)
red = (255, 0, 0)
blue = (0, 0, 255)
green = (0, 255, 0)
yellow = (255, 255, 0)
purple = (128, 0, 128)
grey = (192, 192, 192)

screen_width = 800
screen_height = 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Π’Ρ€Π΅Π½ΠΈΡ€ΡƒΠ΅ΠΌ Π²ΠΈΠ·ΡƒΠ°Π»ΡŒΠ½ΡƒΡŽ ΠΏΠ°ΠΌΡΡ‚ΡŒ")

# Π·Π°Π΄Π°Π΅ΠΌ ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ окруТностСй ΠΈ ΠΏΠ΅Ρ€Π΅ΠΌΠ΅ΡˆΠΈΠ²Π°Π΅ΠΌ ΠΏΠ°Ρ€Ρ‹
circle_radius = 50
circle_colors = [red, blue, green, yellow, purple, white]
circle_pairs = circle_colors * 2
shuffle(circle_pairs)

# Ρ„ΠΎΡ€ΠΌΠΈΡ€ΡƒΠ΅ΠΌ список окруТностСй
circle_positions = []
for i in range(6):
    for j in range(2):
        center_x = ((screen_width / 6) * (i + 1)) - (screen_width / 12)
        center_y = ((screen_height / 3) * (j + 1)) - (screen_height / 6)
        circle_positions.append([center_x, center_y])

# Π·Π°ΠΏΠΎΠΌΠΈΠ½Π°Π΅ΠΌ ΠΏΠΎΠ·ΠΈΡ†ΠΈΠΈ ΠΈ Ρ†Π²Π΅Ρ‚Π° окруТностСй
original_circle_positions = circle_positions.copy()
original_circle_colors = circle_pairs.copy()

# рисуСм Ρ†Π²Π΅Ρ‚Π½Ρ‹Π΅ окруТности
for i in range(len(circle_pairs)):
    position = circle_positions[i]
    color = circle_pairs[i]
    pygame.draw.circle(screen, color, position, circle_radius)

font = pygame.font.SysFont('Arial', 20)
pygame.display.update()

# ΠΆΠ΄Π΅ΠΌ 5 сСкунд
pygame.time.wait(5000)

# Π·Π°ΠΊΡ€Ρ‹Π²Π°Π΅ΠΌ Ρ†Π²Π΅Ρ‚Π½Ρ‹Π΅ окруТности сСрыми
for i in range(len(circle_pairs)):
    position = circle_positions[i]
    pygame.draw.circle(screen, grey, position, circle_radius)

pygame.display.update()
uncovered_circles = []
last_uncovered_circle = None
score = 0

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

        if event.type == pygame.MOUSEBUTTONDOWN:
            mouse_pos = event.pos
            for i in range(len(circle_positions)):
                position = circle_positions[i]
                if ((position[0] - mouse_pos[0]) ** 2 + (position[1] - mouse_pos[1]) ** 2) ** 0.5 < circle_radius:
                    if i not in uncovered_circles:
                        uncovered_circles.append(i)
                        color = original_circle_colors[i]
                        pygame.draw.circle(screen, color, position, circle_radius)
                        pygame.display.update()
                        if last_uncovered_circle is not None and original_circle_colors[last_uncovered_circle] == original_circle_colors[i]:
                            score += 1
                        last_uncovered_circle = i

            if len(uncovered_circles) == len(circle_pairs):
                # Π²Ρ‹Π²ΠΎΠ΄ Ρ€Π΅Π·ΡƒΠ»ΡŒΡ‚Π°Ρ‚Π°
                final_score_text = font.render(f"Π£Ρ€ΠΎΠ²Π΅Π½ΡŒ памяти: {str(score)} ΠΈΠ· 6", True, white)
                screen.blit(final_score_text, (screen_width // 2, screen_height // 2 + 125))
                pygame.display.update()
                pygame.time.wait(3000)
                pygame.quit()
                exit()

Π—Π°Π΄Π°Π½ΠΈΠ΅ 8 – ΠŸΠΎΠ΄ΡΡ‡Π΅Ρ‚ Ρ„ΠΈΠ³ΡƒΡ€

ΠΠ°ΠΏΠΈΡˆΠΈΡ‚Π΅ Pygame ΠΏΡ€ΠΈΠ»ΠΎΠΆΠ΅Π½ΠΈΠ΅, Π² ΠΊΠΎΡ‚ΠΎΡ€ΠΎΠΌ свСрху ΠΎΠΊΠ½Π° Π²Π½ΠΈΠ· ΠΏΠ»Π°Π²Π½ΠΎ ΡΠΏΡƒΡΠΊΠ°ΡŽΡ‚ΡΡ случайныС Ρ€Π°Π·Π½ΠΎΡ†Π²Π΅Ρ‚Π½Ρ‹Π΅ Ρ„ΠΈΠ³ΡƒΡ€Ρ‹ – Ρ‚Ρ€Π΅ΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΈ, ΠΊΠ²Π°Π΄Ρ€Π°Ρ‚Ρ‹ ΠΈ окруТности. Π¦Π²Π΅Ρ‚ для Ρ„ΠΈΠ³ΡƒΡ€ выбираСтся случайным ΠΎΠ±Ρ€Π°Π·ΠΎΠΌ, Ρ€Π΅Π·ΡƒΠ»ΡŒΡ‚Π°Ρ‚Ρ‹ подсчСта выводятся Π² Π²Π΅Ρ€Ρ…Π½Π΅ΠΌ Π»Π΅Π²ΠΎΠΌ ΡƒΠ³Π»Ρƒ ΠΎΠΊΠ½Π°.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame
import random

pygame.init()
width = 800
height = 600
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("ΠŸΠΎΠ΄ΡΡ‡Π΅Ρ‚ Ρ„ΠΈΠ³ΡƒΡ€")
clock = pygame.time.Clock()

white = (255, 255, 255)
black = (0, 0, 0)
colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255)]

# ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ Ρ„ΠΈΠ³ΡƒΡ€
class Circle:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.color = color
        self.radius = 30

    def draw(self):
        pygame.draw.circle(screen, self.color, (self.x, self.y), self.radius)

class Triangle:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.color = color
        self.width = 60
        self.height = 60

    def draw(self):
        pygame.draw.polygon(screen, self.color, [(self.x, self.y), (self.x + self.width, self.y), (self.x + self.width/2, self.y - self.height)])

class Square:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.color = color
        self.width = 60
        self.height = 60

    def draw(self):
        pygame.draw.rect(screen, self.color, (self.x, self.y, self.width, self.height))

# создаСм список Ρ„ΠΈΠ³ΡƒΡ€
shapes = []
x = random.randint(0, width - 60)
y = random.randint(-500, -50)
color = random.choice(colors)
shape_type = random.choice(["circle", "triangle", "square"])
if shape_type == "circle":
    shape = Circle(x, y, color)
elif shape_type == "triangle":
    shape = Triangle(x, y, color)
else:
    shape = Square(x, y, color)
shapes.append(shape)

# счСтчики Ρ„ΠΈΠ³ΡƒΡ€
circle_count = 0
triangle_count = 0
square_count = 0

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

    screen.fill(black)

    # рисуСм ΠΈ подсчитываСм Ρ„ΠΈΠ³ΡƒΡ€Ρ‹
    for shape in shapes:
        shape.draw()
        shape.y += 5
        if shape.y > height:
            shapes.remove(shape)
            if isinstance(shape, Circle):
                circle_count += 1
            elif isinstance(shape, Triangle):
                triangle_count += 1
            else:
                square_count += 1
            x = random.randint(0, width - 60)
            y = random.randint(-500, -50)
            color = random.choice(colors)
            shape_type = random.choice(["circle", "triangle", "square"])
            if shape_type == "circle":
                shape = Circle(x, y, color)
            elif shape_type == "triangle":
                shape = Triangle(x, y, color)
            else:
                shape = Square(x, y, color)
            shapes.append(shape)

    # Π²Ρ‹Π²ΠΎΠ΄ΠΈΠΌ счСтчики
    font = pygame.font.SysFont("Verdana", 25)
    circle_text = font.render(f"ΠžΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΠΈ: {circle_count}", True, white)
    triangle_text = font.render(f"Π’Ρ€Π΅ΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΈ: {triangle_count}", True, white)
    square_text = font.render(f"ΠšΠ²Π°Π΄Ρ€Π°Ρ‚Ρ‹: {square_count}", True, white)
    screen.blit(circle_text, (10, 10))
    screen.blit(triangle_text, (10, 40))
    screen.blit(square_text, (10, 70))

    pygame.display.update()
    clock.tick(60)

Π—Π°Π΄Π°Π½ΠΈΠ΅ 9 – ΠŸΡ€ΠΈΠ·Ρ‹ ΠΈ Π±ΠΎΠΌΠ±Ρ‹

ΠΠ°ΠΏΠΈΡˆΠΈΡ‚Π΅ Pygame ΠΈΠ³Ρ€Ρƒ, Π² ΠΊΠΎΡ‚ΠΎΡ€ΠΎΠΉ ΠΈΠ³Ρ€ΠΎΠΊ (зСлСная ΠΎΠΊΡ€ΡƒΠΆΠ½ΠΎΡΡ‚ΡŒ) Π΄ΠΎΠ»ΠΆΠ΅Π½ Β«Π»ΠΎΠ²ΠΈΡ‚ΡŒΒ» синиС Ρ‚Ρ€Π΅ΡƒΠ³ΠΎΠ»ΡŒΠ½ΠΈΠΊΠΈ (Β«ΠΏΡ€ΠΈΠ·Ρ‹Β»), избСгая столкновСния с красными окруТностями (Β«Π±ΠΎΠΌΠ±Π°ΠΌΠΈΒ»). ΠšΠΎΠ»ΠΈΡ‡Π΅ΡΡ‚Π²ΠΎ ΠΏΠΎΠΉΠΌΠ°Π½Π½Ρ‹Ρ… ΠΏΡ€ΠΈΠ·ΠΎΠ² Π½ΡƒΠΆΠ½ΠΎ ΠΏΠΎΠ΄ΡΡ‡ΠΈΡ‚Ρ‹Π²Π°Ρ‚ΡŒ.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame
import random

class RewardsBombs():
    def __init__(self):
        pygame.init()
        self.screen_width = 600
        self.screen_height = 600
        self.screen = pygame.display.set_mode((self.screen_width, self.screen_height))
        pygame.display.set_caption("ΠŸΡ€ΠΈΠ·Ρ‹ ΠΈ Π±ΠΎΠΌΠ±Ρ‹")
        self.clock = pygame.time.Clock()
        self.green_pos = [self.screen_width // 2, self.screen_height - 30]
        self.red_positions = []
        self.red_speed = 2
        self.score = 0
        self.font = pygame.font.SysFont("Arial", 24)
        self.run()

    def run(self):
        while True:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    exit()

                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT:
                        if self.green_pos[0] - 20 >= 0:
                            self.green_pos[0] -= 20
                    elif event.key == pygame.K_RIGHT:
                        if self.green_pos[0] + 20 <= self.screen_width:
                            self.green_pos[0] += 20
                    elif event.key == pygame.K_UP:
                        if self.green_pos[1] - 20 >= 0:
                            self.green_pos[1] -= 20
                    elif event.key == pygame.K_DOWN:
                        if self.green_pos[1] + 20 <= self.screen_height:
                            self.green_pos[1] += 20

            # Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ красных Π±ΠΎΠΌΠ±
            for i in range(len(self.red_positions)):
                self.red_positions[i][1] += self.red_speed

            # созданиС Π±ΠΎΠΌΠ± ΠΈ ΠΏΡ€ΠΈΠ·ΠΎΠ²
            if random.random() < 0.02:
                x = random.randint(0, self.screen_width)
                num = random.randint(1, 10)
                if num % 2 == 0:
                    self.red_positions.append([x, 0, False])
                else:
                    self.red_positions.append([x, 0, True])

            # ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° столкновСний с ΠΈΠ³Ρ€ΠΎΠΊΠΎΠΌ
            for pos in self.red_positions:
                if pos[2]:
                    if abs(pos[0] - self.green_pos[0]) <= 20 and abs(pos[1] - self.green_pos[1]) <= 20:
                        self.score += 1
                        self.red_positions.remove(pos)
                else:
                    if (pos[0] - self.green_pos[0]) ** 2 + (pos[1] - self.green_pos[1]) ** 2 < 400:
                        self.game_over()

            # ΡƒΠ±ΠΈΡ€Π°Π΅ΠΌ Π±ΠΎΠΌΠ±Ρ‹ Π·Π° ΠΏΡ€Π΅Π΄Π΅Π»Π°ΠΌΠΈ ΠΎΠΊΠ½Π°
            self.red_positions = [pos for pos in self.red_positions if pos[1] < self.screen_height]
            self.screen.fill((0, 0, 0))

            for pos in self.red_positions:
                if pos[2]:
                    pygame.draw.polygon(self.screen, (0, 0, 255), [[pos[0], pos[1]-10], [pos[0]+10, pos[1]+10], [pos[0]-10, pos[1]+10]])
                else:
                    pygame.draw.circle(self.screen, (255, 0, 0), pos[:2], 10)

            pygame.draw.circle(self.screen, (0, 255, 0), self.green_pos, 10)

            self.draw_score()
            pygame.display.update()
            self.clock.tick(60)

    def draw_score(self):
        score_surface = self.font.render(f"ΠŸΡ€ΠΈΠ·Ρ‹: {self.score}", True, (255, 255, 255))
        self.screen.blit(score_surface, (10, 10))

    def game_over(self):
        message_surface = self.font.render(f"Π˜Π³Ρ€Π° Π·Π°ΠΊΠΎΠ½Ρ‡Π΅Π½Π°! ΠŸΡ€ΠΈΠ·Ρ‹: {self.score}", True, (255, 0, 0))
        self.screen.blit(message_surface, (self.screen_width // 2 - message_surface.get_width() // 2, self.screen_height // 2 - message_surface.get_height() // 2))
        pygame.display.update()
        pygame.time.wait(3000)
        pygame.quit()
        exit()

if __name__ == "__main__":
    RewardsBombs()

Π—Π°Π΄Π°Π½ΠΈΠ΅ 10 – Π—ΠΌΠ΅ΠΉΠΊΠ°

ΠΠ°ΠΏΠΈΡˆΠΈΡ‚Π΅ Π»Π°ΠΉΡ‚-Π²Π΅Ρ€ΡΠΈΡŽ ΠΈΠ³Ρ€Ρ‹ Β«Π—ΠΌΠ΅ΠΉΠΊΠ°Β», ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΡ Pygame. Π—ΠΌΠ΅ΠΉΠΊΠ° Сст красныС яблоки, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹Π΅ ΠΏΠΎΡΠ²Π»ΡΡŽΡ‚ΡΡ Π² случайных позициях Π² ΠΏΡ€Π΅Π΄Π΅Π»Π°Ρ… ΠΈΠ³Ρ€ΠΎΠ²ΠΎΠ³ΠΎ поля, ΠΈ прибавляСт Π² Π΄Π»ΠΈΠ½Π΅ послС ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ яблока. ΠŸΡ€ΠΈ столкновСнии с хвостом ΠΈΠ»ΠΈ Π³Ρ€Π°Π½ΠΈΡ†Π΅ΠΉ ΠΎΠΊΠ½Π° ΠΈΠ³Ρ€Π° заканчиваСтся.

ΠŸΡ€ΠΈΠΌΠ΅Ρ€:

РСшСниС:

Код Ρ€Π΅ΡˆΠ΅Π½ΠΈΡ.

import pygame
import random

pygame.init()
screen_width = 600
screen_height = 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Π—ΠΌΠ΅ΠΉΠΊΠ°")
green = (0, 255, 0)
red = (255, 0, 0)
font = pygame.font.SysFont("Arial", 20)
clock = pygame.time.Clock()

# основныС ΠΏΠ°Ρ€Π°ΠΌΠ΅Ρ‚Ρ€Ρ‹ ΠΈΠ³Ρ€Ρ‹
cell_size = 20
snake_speed = 5
snake_length = 3
snake_body = []

for i in range(snake_length):
    snake_body.append(pygame.Rect((screen_width / 2) - (cell_size * i), screen_height / 2, cell_size, cell_size))
snake_direction = "right"
new_direction = "right"
apple_position = pygame.Rect(random.randint(0, screen_width - cell_size), random.randint(0, screen_height - cell_size), cell_size, cell_size)

game_over = False
while not game_over:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_over = True
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_UP and snake_direction != "down":
                new_direction = "up"
            elif event.key == pygame.K_DOWN and snake_direction != "up":
                new_direction = "down"
            elif event.key == pygame.K_LEFT and snake_direction != "right":
                new_direction = "left"
            elif event.key == pygame.K_RIGHT and snake_direction != "left":
                new_direction = "right"

    # Π½ΠΎΠ²ΠΎΠ΅ Π½Π°ΠΏΡ€Π°Π²Π»Π΅Π½ΠΈΠ΅ двиТСния
    snake_direction = new_direction
    # ΡƒΠΏΡ€Π°Π²Π»Π΅Π½ΠΈΠ΅ Π·ΠΌΠ΅ΠΉΠΊΠΎΠΉ
    if snake_direction == "up":
        snake_body.insert(0, pygame.Rect(snake_body[0].left, snake_body[0].top - cell_size, cell_size, cell_size))
    elif snake_direction == "down":
        snake_body.insert(0, pygame.Rect(snake_body[0].left, snake_body[0].top + cell_size, cell_size, cell_size))
    elif snake_direction == "left":
        snake_body.insert(0, pygame.Rect(snake_body[0].left - cell_size, snake_body[0].top, cell_size, cell_size))
    elif snake_direction == "right":
        snake_body.insert(0, pygame.Rect(snake_body[0].left + cell_size, snake_body[0].top, cell_size, cell_size))

    # провСряСм, съСла Π»ΠΈ змСя яблоко
    if snake_body[0].colliderect(apple_position):
        apple_position = pygame.Rect(random.randint(0, screen_width - cell_size), random.randint(0, screen_height-cell_size), cell_size, cell_size)
        snake_length += 1

    if len(snake_body) > snake_length:
        snake_body.pop()

    # ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° столкновСния со стСнами
    if snake_body[0].left < 0 or snake_body[0].right > screen_width or snake_body[0].top < 0 or snake_body[0].bottom > screen_height:
        game_over = True

    # ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° столкновСния с собствСнным Ρ‚Π΅Π»ΠΎΠΌ
    for i in range(1, len(snake_body)):
        if snake_body[0].colliderect(snake_body[i]):
            game_over = True

    screen.fill((0, 0, 0))
    # рисуСм Π·ΠΌΠ΅ΠΉΠΊΡƒ
    for i in range(len(snake_body)):
        if i == 0:
            pygame.draw.circle(screen, green, snake_body[i].center, cell_size / 2)
        else:
            pygame.draw.circle(screen, green, snake_body[i].center, cell_size / 2)
            pygame.draw.circle(screen, (0, 200, 0), snake_body[i].center, cell_size / 4)

    # рисуСм яблоко
    pygame.draw.circle(screen, red, apple_position.center, cell_size / 2)

    # Π²Ρ‹Π²ΠΎΠ΄ΠΈΠΌ количСство яблок
    score_text = font.render(f"БъСдСно яблок: {snake_length - 3}", True, (255, 255, 255))
    screen.blit(score_text, (10, 10))
    pygame.display.update()

    clock.tick(snake_speed)

pygame.quit()

ПодвСдСм ΠΈΡ‚ΠΎΠ³ΠΈ

ΠœΡ‹ рассмотрСли самыС простыС ΠΏΡ€ΠΈΠ΅ΠΌΡ‹ Ρ€Π°Π·Ρ€Π°Π±ΠΎΡ‚ΠΊΠΈ ΠΈΠ³Ρ€ Π² Pygame – возмоТности этой Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠΈ Π½Π°ΠΌΠ½ΠΎΠ³ΠΎ ΠΎΠ±ΡˆΠΈΡ€Π½Π΅Π΅. К ΠΏΡ€ΠΈΠΌΠ΅Ρ€Ρƒ, для быстрой Ρ€Π°Π·Ρ€Π°Π±ΠΎΡ‚ΠΊΠΈ Π² Pygame ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΡŽΡ‚ΡΡ спрайты – ΠΎΠ±ΡŠΠ΅ΠΊΡ‚Ρ‹ для опрСдСлСния свойств ΠΈ повСдСния ΠΈΠ³Ρ€ΠΎΠ²Ρ‹Ρ… элСмСнтов. ВстроСнныС классы Group, GroupSingle ΠΈ RenderUpdates ΠΏΠΎΠ·Π²ΠΎΠ»ΡΡŽΡ‚ быстро, просто ΠΈ эффСктивно Π³Ρ€ΡƒΠΏΠΏΠΈΡ€ΠΎΠ²Π°Ρ‚ΡŒ, ΠΎΠ±Π½ΠΎΠ²Π»ΡΡ‚ΡŒ ΠΈ ΠΎΡ‚Ρ€ΠΈΡΠΎΠ²Ρ‹Π²Π°Ρ‚ΡŒ ΠΈΠ³Ρ€ΠΎΠ²Ρ‹Π΅ элСмСнты.

Π’ ΡΠ»Π΅Π΄ΡƒΡŽΡ‰Π΅ΠΉ Π³Π»Π°Π²Π΅ Π±ΡƒΠ΄Π΅ΠΌ ΠΈΠ·ΡƒΡ‡Π°Ρ‚ΡŒ Ρ€Π°Π±ΠΎΡ‚Ρƒ с SQL ΠΈ Π±Π°Π·Π°ΠΌΠΈ Π΄Π°Π½Π½Ρ‹Ρ….

***

Π‘ΠΎΠ΄Π΅Ρ€ΠΆΠ°Π½ΠΈΠ΅ самоучитСля

  1. ΠžΡΠΎΠ±Π΅Π½Π½ΠΎΡΡ‚ΠΈ, сфСры примСнСния, установка, ΠΎΠ½Π»Π°ΠΉΠ½ IDE
  2. ВсС, Ρ‡Ρ‚ΠΎ Π½ΡƒΠΆΠ½ΠΎ для изучСния Python с нуля – ΠΊΠ½ΠΈΠ³ΠΈ, сайты, ΠΊΠ°Π½Π°Π»Ρ‹ ΠΈ курсы
  3. Π’ΠΈΠΏΡ‹ Π΄Π°Π½Π½Ρ‹Ρ…: ΠΏΡ€Π΅ΠΎΠ±Ρ€Π°Π·ΠΎΠ²Π°Π½ΠΈΠ΅ ΠΈ Π±Π°Π·ΠΎΠ²Ρ‹Π΅ ΠΎΠΏΠ΅Ρ€Π°Ρ†ΠΈΠΈ
  4. ΠœΠ΅Ρ‚ΠΎΠ΄Ρ‹ Ρ€Π°Π±ΠΎΡ‚Ρ‹ со строками
  5. ΠœΠ΅Ρ‚ΠΎΠ΄Ρ‹ Ρ€Π°Π±ΠΎΡ‚Ρ‹ со списками ΠΈ списковыми Π²ΠΊΠ»ΡŽΡ‡Π΅Π½ΠΈΡΠΌΠΈ
  6. ΠœΠ΅Ρ‚ΠΎΠ΄Ρ‹ Ρ€Π°Π±ΠΎΡ‚Ρ‹ со словарями ΠΈ Π³Π΅Π½Π΅Ρ€Π°Ρ‚ΠΎΡ€Π°ΠΌΠΈ словарСй
  7. ΠœΠ΅Ρ‚ΠΎΠ΄Ρ‹ Ρ€Π°Π±ΠΎΡ‚Ρ‹ с ΠΊΠΎΡ€Ρ‚Π΅ΠΆΠ°ΠΌΠΈ
  8. ΠœΠ΅Ρ‚ΠΎΠ΄Ρ‹ Ρ€Π°Π±ΠΎΡ‚Ρ‹ со мноТСствами
  9. ΠžΡΠΎΠ±Π΅Π½Π½ΠΎΡΡ‚ΠΈ Ρ†ΠΈΠΊΠ»Π° for
  10. Условный Ρ†ΠΈΠΊΠ» while
  11. Π€ΡƒΠ½ΠΊΡ†ΠΈΠΈ с ΠΏΠΎΠ·ΠΈΡ†ΠΈΠΎΠ½Π½Ρ‹ΠΌΠΈ ΠΈ ΠΈΠΌΠ΅Π½ΠΎΠ²Π°Π½Π½Ρ‹ΠΌΠΈ Π°Ρ€Π³ΡƒΠΌΠ΅Π½Ρ‚Π°ΠΌΠΈ
  12. АнонимныС Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ
  13. РСкурсивныС Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ
  14. Π€ΡƒΠ½ΠΊΡ†ΠΈΠΈ Π²Ρ‹ΡΡˆΠ΅Π³ΠΎ порядка, замыкания ΠΈ Π΄Π΅ΠΊΠΎΡ€Π°Ρ‚ΠΎΡ€Ρ‹
  15. ΠœΠ΅Ρ‚ΠΎΠ΄Ρ‹ Ρ€Π°Π±ΠΎΡ‚Ρ‹ с Ρ„Π°ΠΉΠ»Π°ΠΌΠΈ ΠΈ Ρ„Π°ΠΉΠ»ΠΎΠ²ΠΎΠΉ систСмой
  16. РСгулярныС выраТСния
  17. ΠžΡΠ½ΠΎΠ²Ρ‹ скрапинга ΠΈ парсинга
  18. ΠžΡΠ½ΠΎΠ²Ρ‹ ООП: инкапсуляция ΠΈ наслСдованиС
  19. ΠžΡΠ½ΠΎΠ²Ρ‹ ООП: абстракция ΠΈ ΠΏΠΎΠ»ΠΈΠΌΠΎΡ€Ρ„ΠΈΠ·ΠΌ
  20. ГрафичСский интСрфСйс Π½Π° Tkinter
  21. ΠžΡΠ½ΠΎΠ²Ρ‹ Ρ€Π°Π·Ρ€Π°Π±ΠΎΡ‚ΠΊΠΈ ΠΈΠ³Ρ€ Π½Π° Pygame
  22. ΠžΡΠ½ΠΎΠ²Ρ‹ Ρ€Π°Π±ΠΎΡ‚Ρ‹ с SQLite
  23. ΠžΡΠ½ΠΎΠ²Ρ‹ Π²Π΅Π±-Ρ€Π°Π·Ρ€Π°Π±ΠΎΡ‚ΠΊΠΈ Π½Π° Flask
  24. ΠžΡΠ½ΠΎΠ²Ρ‹ Ρ€Π°Π±ΠΎΡ‚Ρ‹ с NumPy
  25. ΠžΡΠ½ΠΎΠ²Ρ‹ Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½Ρ‹Ρ… с Pandas
***

ΠœΠ°Ρ‚Π΅Ρ€ΠΈΠ°Π»Ρ‹ ΠΏΠΎ Ρ‚Π΅ΠΌΠ΅

Π›Π£Π§Π¨Π˜Π• БВАВЬИ ПО Π’Π•ΠœΠ•

admin
11 дСкабря 2018

ООП Π½Π° Python: ΠΊΠΎΠ½Ρ†Π΅ΠΏΡ†ΠΈΠΈ, ΠΏΡ€ΠΈΠ½Ρ†ΠΈΠΏΡ‹ ΠΈ ΠΏΡ€ΠΈΠΌΠ΅Ρ€Ρ‹ Ρ€Π΅Π°Π»ΠΈΠ·Π°Ρ†ΠΈΠΈ

ΠŸΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΠΈΡ€ΠΎΠ²Π°Π½ΠΈΠ΅ Π½Π° Python допускаСт Ρ€Π°Π·Π»ΠΈΡ‡Π½Ρ‹Π΅ ΠΌΠ΅Ρ‚ΠΎΠ΄ΠΎΠ»ΠΎΠ³ΠΈΠΈ, Π½ΠΎ Π² Π΅Π³ΠΎ основС...
admin
28 июня 2018

3 самых Π²Π°ΠΆΠ½Ρ‹Ρ… сфСры примСнСния Python: возмоТности языка

БущСствуСт мноТСство областСй примСнСния Python, Π½ΠΎ Π² Π½Π΅ΠΊΠΎΡ‚ΠΎΡ€Ρ‹Ρ… ΠΎΠ½ особСнно...
admin
13 фСвраля 2017

ΠŸΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΠΈΡ€ΠΎΠ²Π°Π½ΠΈΠ΅ Π½Π° Python: ΠΎΡ‚ Π½ΠΎΠ²ΠΈΡ‡ΠΊΠ° Π΄ΠΎ профСссионала

Пошаговая инструкция для всСх, ΠΊΡ‚ΠΎ Ρ…ΠΎΡ‡Π΅Ρ‚ ΠΈΠ·ΡƒΡ‡ΠΈΡ‚ΡŒΒ ΠΏΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΠΈΡ€ΠΎΠ²Π°Π½ΠΈΠ΅ Π½Π° Python...