Как написать пинг понг на python

Продолжая наш цикл аркадных игр на Python, напишем свою реализацю игры Пин-Понг на Python с использованием библиотеки tkinter.

1. Создание игрового поля.
2. Движение мячика.
3. Управление ракетками.
4. Реализация отскоков.
5. Подсчет отчков и респаун мячика.

Создание игрового поля.

Начнем с установки игрового поля. Зададим родительское окно, область для отрисовки анимации и основные элементы игрового поля.

Обратите внимание на создание глобальных переменных в начале скрипта. Они нам пригодятся для того, чтобы нам было легче настраивать нашу игру. Если у нас ширина 900 пикселей, то проще создать переменную WIDTH, присвоить ей значение 900 и использовать ее имя в тексте программы, чем вручную каждый раз переписывать 900. Вы ощутите пользу от этого, когда захотите изменить ширину окна, и сможете сделать это просто изменив значение этой переменной:

from tkinter import *

# глобальные переменные
# настройки окна
WIDTH = 900
HEIGHT = 300

# настройки ракеток

# ширина ракетки
PAD_W = 10
# высота ракетки
PAD_H = 100

# настройки мяча

# радиус мяча
BALL_RADIUS = 30

# устанавливаем окно
root = Tk()
root.title("PythonicWay Pong")

# область анимации
c = Canvas(root, width=WIDTH, height=HEIGHT, background="#003300")
c.pack()

# элементы игрового поля

# левая линия
c.create_line(PAD_W, 0, PAD_W, HEIGHT, fill="white")
# правая линия
c.create_line(WIDTH-PAD_W, 0, WIDTH-PAD_W, HEIGHT, fill="white")
# центральная линия
c.create_line(WIDTH/2, 0, WIDTH/2, HEIGHT, fill="white")

# установка игровых объектов

# создаем мяч
BALL = c.create_oval(WIDTH/2-BALL_RADIUS/2,
                     HEIGHT/2-BALL_RADIUS/2,
                     WIDTH/2+BALL_RADIUS/2,
                     HEIGHT/2+BALL_RADIUS/2, fill="white")

# левая ракетка
LEFT_PAD = c.create_line(PAD_W/2, 0, PAD_W/2, PAD_H, width=PAD_W, fill="yellow")

# правая ракетка
RIGHT_PAD = c.create_line(WIDTH-PAD_W/2, 0, WIDTH-PAD_W/2, 
                          PAD_H, width=PAD_W, fill="yellow")

# запускаем работу окна
root.mainloop()

Должно получиться примерно следующее:

Заставляем мячик двигаться.

Создадим функцию move_ball в которой пропишем код движения мяча. После этого создадим функцию main в которой будем вызывать move_ball и рекурсивно саму себя через root.after

# добавим глобальные переменные для скорости движения мяча
# по горизонтали
BALL_X_CHANGE = 20
# по вертикали
BALL_Y_CHANGE = 0

def move_ball():
    c.move(BALL, BALL_X_CHANGE, BALL_Y_CHANGE)

def main():
    move_ball()
    # вызываем саму себя каждые 30 миллисекунд
    root.after(30, main)

# запускаем движение
main()

Если вы все правильно добавили, то при запуске скрипта мяч летит в правую сторону. Вы можете изменить скорость и направление движения по горизонтали, изменяя значение BALL_X_CHANGE.

Задаем управление движением ракеток.

Логика движения ракеток будет следующая. Задается скорость ракетки — изначально она равна нулю, то есть ракетка стоит на месте. Как только пользователь нажимает клавишу — скорость изменяется, и ракетка едет вверх либо вниз. Когда игрок отпускает клавишу скорость ракетки опять становится равна нулю.

# зададим глобальные переменные скорости движения ракеток
# скорось с которой будут ездить ракетки
PAD_SPEED = 20
# скорость левой платформы
LEFT_PAD_SPEED = 0
# скорость правой ракетки
RIGHT_PAD_SPEED = 0

# функция движения обеих ракеток
def move_pads():
    # для удобства создадим словарь, где ракетке соответствует ее скорость
    PADS = {LEFT_PAD: LEFT_PAD_SPEED, 
            RIGHT_PAD: RIGHT_PAD_SPEED}
    # перебираем ракетки
    for pad in PADS:
        # двигаем ракетку с заданной скоростью
        c.move(pad, 0, PADS[pad])
        # если ракетка вылезает за игровое поле возвращаем ее на место
        if c.coords(pad)[1] < 0:
            c.move(pad, 0, -c.coords(pad)[1])
        elif c.coords(pad)[3] > HEIGHT:
            c.move(pad, 0, HEIGHT - c.coords(pad)[3])

# Вставляем созданную функцию в main
def main():
     move_ball()
     move_pads()
     root.after(30, main)

# Установим фокус на Canvas чтобы он реагировал на нажатия клавиш
c.focus_set()

# Напишем функцию обработки нажатия клавиш
def movement_handler(event):
    global LEFT_PAD_SPEED, RIGHT_PAD_SPEED
    if event.keysym == "w":
        LEFT_PAD_SPEED = -PAD_SPEED
    elif event.keysym == "s":
        LEFT_PAD_SPEED = PAD_SPEED
    elif event.keysym == "Up":
        RIGHT_PAD_SPEED = -PAD_SPEED
    elif event.keysym == "Down":
        RIGHT_PAD_SPEED = PAD_SPEED

# Привяжем к Canvas эту функцию
c.bind("<KeyPress>", movement_handler)

# Создадим функцию реагирования на отпускание клавиши
def stop_pad(event):
    global LEFT_PAD_SPEED, RIGHT_PAD_SPEED
    if event.keysym in "ws":
        LEFT_PAD_SPEED = 0
    elif event.keysym in ("Up", "Down"):
        RIGHT_PAD_SPEED = 0

# Привяжем к Canvas эту функцию
c.bind("<KeyRelease>", stop_pad)

Теперь мы можем управлять обеими ракетками.

Отскок мячика от стенок и «ракеток».

Отскок реализуется достаточно просто: при соприкосновении со стенкой или «ракеткой» мы будем изменять значение переменных движения мяча на противоположные. Ради интереса при ударе о ракетку будет увеличиваться горизонтальная скорость мячика и случайным образом изменяться вертикальная.

# импортируем библиотеку random
import random

# Добавляем глобальные переменные
# Насколько будет увеличиваться скорость мяча с каждым ударом
BALL_SPEED_UP = 1.05
# Максимальная скорость мяча
BALL_MAX_SPEED = 40
# Начальная скорость по горизонтали
BALL_X_SPEED = 20
# Начальная скорость по вертикали
BALL_Y_SPEED = 20
# Добавим глобальную переменную отвечающую за расстояние
# до правого края игрового поля
right_line_distance = WIDTH - PAD_W

# функция отскока мяча
def bounce(action):
    global BALL_X_SPEED, BALL_Y_SPEED
    # ударили ракеткой
    if action == "strike":
        BALL_Y_SPEED = random.randrange(-10, 10)
        if abs(BALL_X_SPEED) < BALL_MAX_SPEED:
            BALL_X_SPEED *= -BALL_SPEED_UP
        else:
            BALL_X_SPEED = -BALL_X_SPEED
    else:
        BALL_Y_SPEED = -BALL_Y_SPEED

# Переписываем функцию движения мяча с учетом наших изменений
def move_ball():
    # определяем координаты сторон мяча и его центра
    ball_left, ball_top, ball_right, ball_bot = c.coords(BALL)
    ball_center = (ball_top + ball_bot) / 2

    # вертикальный отскок
    # Если мы далеко от вертикальных линий - просто двигаем мяч
    if ball_right + BALL_X_SPEED < right_line_distance and 
            ball_left + BALL_X_SPEED > PAD_W:
        c.move(BALL, BALL_X_SPEED, BALL_Y_SPEED)
    # Если мяч касается своей правой или левой стороной границы поля
    elif ball_right == right_line_distance or ball_left == PAD_W:
        # Проверяем правой или левой стороны мы касаемся
        if ball_right > WIDTH / 2:
            # Если правой, то сравниваем позицию центра мяча
            # с позицией правой ракетки.
            # И если мяч в пределах ракетки делаем отскок
            if c.coords(RIGHT_PAD)[1] < ball_center < c.coords(RIGHT_PAD)[3]:
                bounce("strike")
            else:
                # Иначе игрок пропустил - тут оставим пока pass, его мы заменим на подсчет очков и респаун мячика
                pass
        else:
            # То же самое для левого игрока
            if c.coords(LEFT_PAD)[1] < ball_center < c.coords(LEFT_PAD)[3]:
                bounce("strike")
            else:
                pass
    # Проверка ситуации, в которой мячик может вылететь за границы игрового поля.
    # В таком случае просто двигаем его к границе поля.
    else:
        if ball_right > WIDTH / 2:
            c.move(BALL, right_line_distance-ball_right, BALL_Y_SPEED)
        else:
            c.move(BALL, -ball_left+PAD_W, BALL_Y_SPEED)
    # горизонтальный отскок
    if ball_top + BALL_Y_SPEED < 0 or ball_bot + BALL_Y_SPEED > HEIGHT:
        bounce("ricochet")

Теперь наш мячек отскакивает от стенок и ракеток и зависает если попадает в вертикальную границу поля, но не попадает в ракетку.

Подсчет очков и респаун мячика.

Создадим глобальные переменные очков для каждого игрока и обнулим их.

PLAYER_1_SCORE = 0
PLAYER_2_SCORE = 0

Теперь добавим текстовые объекты в которых будем отображать счет.

p_1_text = c.create_text(WIDTH-WIDTH/6, PAD_H/4,
                         text=PLAYER_1_SCORE,
                         font="Arial 20",
                         fill="white")

p_2_text = c.create_text(WIDTH/6, PAD_H/4,
                          text=PLAYER_2_SCORE,
                          font="Arial 20",
                          fill="white")

Создадим функции изменения счета и респауна мяча

# Добавьте глобальную переменную INITIAL_SPEED
INITIAL_SPEED = 20

def update_score(player):
    global PLAYER_1_SCORE, PLAYER_2_SCORE
    if player == "right":
        PLAYER_1_SCORE += 1
        c.itemconfig(p_1_text, text=PLAYER_1_SCORE)
    else:
        PLAYER_2_SCORE += 1
        c.itemconfig(p_2_text, text=PLAYER_2_SCORE)

def spawn_ball():
    global BALL_X_SPEED
    # Выставляем мяч по центру
    c.coords(BALL, WIDTH/2-BALL_RADIUS/2,
             HEIGHT/2-BALL_RADIUS/2,
             WIDTH/2+BALL_RADIUS/2,
             HEIGHT/2+BALL_RADIUS/2)
    # Задаем мячу направление в сторону проигравшего игрока,
    # но снижаем скорость до изначальной
    BALL_X_SPEED = -(BALL_X_SPEED * -INITIAL_SPEED) / abs(BALL_X_SPEED)

 Осталось вставить вызов этих функций вместо pass в функцию move_ball. Замените

...
            if c.coords(RIGHT_PAD)[1] < ball_center < c.coords(RIGHT_PAD)[3]:
                bounce("strike")
            else:
                # Иначе игрок пропустил - тут оставим пока pass, его мы заменим на подсчет очков и респаун мячика
                pass
        else:
            # То же самое для левого игрока
            if c.coords(LEFT_PAD)[1] < ball_center < c.coords(LEFT_PAD)[3]:
                bounce("strike")
            else:
                pass
...

на

            
            if c.coords(RIGHT_PAD)[1] < ball_center < c.coords(RIGHT_PAD)[3]:
                bounce("strike")
            else:
                update_score("left")
                spawn_ball()
        else:
            if c.coords(LEFT_PAD)[1] < ball_center < c.coords(LEFT_PAD)[3]:
                bounce("strike")
            else:
                update_score("right")
                spawn_ball()

Теперь наш пин-понг можно считать завершенным.

Приятной игры!

Полный код игры пин-понг на Python на GitHub.

from tkinter import * # импортируем библиотеку random import random # Добавляем глобальные переменные # глобальные переменные # настройки окна WIDTH = 900 HEIGHT = 300 # настройки ракеток # ширина ракетки PAD_W = 10 # высота ракетки PAD_H = 100 # настройки мяча # Насколько будет увеличиваться скорость мяча с каждым ударом BALL_SPEED_UP = 1.05 # Максимальная скорость мяча BALL_MAX_SPEED = 40 # радиус мяча BALL_RADIUS = 30 INITIAL_SPEED = 20 BALL_X_SPEED = INITIAL_SPEED BALL_Y_SPEED = INITIAL_SPEED # Счет игроков PLAYER_1_SCORE = 0 PLAYER_2_SCORE = 0 # Добавим глобальную переменную отвечающую за расстояние # до правого края игрового поля right_line_distance = WIDTH — PAD_W def update_score(player): global PLAYER_1_SCORE, PLAYER_2_SCORE if player == «right»: PLAYER_1_SCORE += 1 c.itemconfig(p_1_text, text=PLAYER_1_SCORE) else: PLAYER_2_SCORE += 1 c.itemconfig(p_2_text, text=PLAYER_2_SCORE) def spawn_ball(): global BALL_X_SPEED # Выставляем мяч по центру c.coords(BALL, WIDTH/2—BALL_RADIUS/2, HEIGHT/2—BALL_RADIUS/2, WIDTH/2+BALL_RADIUS/2, HEIGHT/2+BALL_RADIUS/2) # Задаем мячу направление в сторону проигравшего игрока, # но снижаем скорость до изначальной BALL_X_SPEED = —(BALL_X_SPEED * —INITIAL_SPEED) / abs(BALL_X_SPEED) # функция отскока мяча def bounce(action): global BALL_X_SPEED, BALL_Y_SPEED # ударили ракеткой if action == «strike»: BALL_Y_SPEED = random.randrange(—10, 10) if abs(BALL_X_SPEED) < BALL_MAX_SPEED: BALL_X_SPEED *= —BALL_SPEED_UP else: BALL_X_SPEED = —BALL_X_SPEED else: BALL_Y_SPEED = —BALL_Y_SPEED # устанавливаем окно root = Tk() root.title(«PythonicWay Pong») # область анимации c = Canvas(root, width=WIDTH, height=HEIGHT, background=«#003300») c.pack() # элементы игрового поля # левая линия c.create_line(PAD_W, 0, PAD_W, HEIGHT, fill=«white») # правая линия c.create_line(WIDTH—PAD_W, 0, WIDTH—PAD_W, HEIGHT, fill=«white») # центральная линия c.create_line(WIDTH/2, 0, WIDTH/2, HEIGHT, fill=«white») # установка игровых объектов # создаем мяч BALL = c.create_oval(WIDTH/2—BALL_RADIUS/2, HEIGHT/2—BALL_RADIUS/2, WIDTH/2+BALL_RADIUS/2, HEIGHT/2+BALL_RADIUS/2, fill=«white») # левая ракетка LEFT_PAD = c.create_line(PAD_W/2, 0, PAD_W/2, PAD_H, width=PAD_W, fill=«yellow») # правая ракетка RIGHT_PAD = c.create_line(WIDTH—PAD_W/2, 0, WIDTH—PAD_W/2, PAD_H, width=PAD_W, fill=«yellow») p_1_text = c.create_text(WIDTH—WIDTH/6, PAD_H/4, text=PLAYER_1_SCORE, font=«Arial 20», fill=«white») p_2_text = c.create_text(WIDTH/6, PAD_H/4, text=PLAYER_2_SCORE, font=«Arial 20», fill=«white») # добавим глобальные переменные для скорости движения мяча # по горизонтали BALL_X_CHANGE = 20 # по вертикали BALL_Y_CHANGE = 0 def move_ball(): # определяем координаты сторон мяча и его центра ball_left, ball_top, ball_right, ball_bot = c.coords(BALL) ball_center = (ball_top + ball_bot) / 2 # вертикальный отскок # Если мы далеко от вертикальных линий — просто двигаем мяч if ball_right + BALL_X_SPEED < right_line_distance and ball_left + BALL_X_SPEED > PAD_W: c.move(BALL, BALL_X_SPEED, BALL_Y_SPEED) # Если мяч касается своей правой или левой стороной границы поля elif ball_right == right_line_distance or ball_left == PAD_W: # Проверяем правой или левой стороны мы касаемся if ball_right > WIDTH / 2: # Если правой, то сравниваем позицию центра мяча # с позицией правой ракетки. # И если мяч в пределах ракетки делаем отскок if c.coords(RIGHT_PAD)[1] < ball_center < c.coords(RIGHT_PAD)[3]: bounce(«strike») else: # Иначе игрок пропустил — тут оставим пока pass, его мы заменим на подсчет очков и респаун мячика update_score(«left») spawn_ball() else: # То же самое для левого игрока if c.coords(LEFT_PAD)[1] < ball_center < c.coords(LEFT_PAD)[3]: bounce(«strike») else: update_score(«right») spawn_ball() # Проверка ситуации, в которой мячик может вылететь за границы игрового поля. # В таком случае просто двигаем его к границе поля. else: if ball_right > WIDTH / 2: c.move(BALL, right_line_distance—ball_right, BALL_Y_SPEED) else: c.move(BALL, —ball_left+PAD_W, BALL_Y_SPEED) # горизонтальный отскок if ball_top + BALL_Y_SPEED < 0 or ball_bot + BALL_Y_SPEED > HEIGHT: bounce(«ricochet») # зададим глобальные переменные скорости движения ракеток # скорось с которой будут ездить ракетки PAD_SPEED = 20 # скорость левой платформы LEFT_PAD_SPEED = 0 # скорость правой ракетки RIGHT_PAD_SPEED = 0 # функция движения обеих ракеток def move_pads(): # для удобства создадим словарь, где ракетке соответствует ее скорость PADS = {LEFT_PAD: LEFT_PAD_SPEED, RIGHT_PAD: RIGHT_PAD_SPEED} # перебираем ракетки for pad in PADS: # двигаем ракетку с заданной скоростью c.move(pad, 0, PADS[pad]) # если ракетка вылезает за игровое поле возвращаем ее на место if c.coords(pad)[1] < 0: c.move(pad, 0, —c.coords(pad)[1]) elif c.coords(pad)[3] > HEIGHT: c.move(pad, 0, HEIGHT — c.coords(pad)[3]) def main(): move_ball() move_pads() # вызываем саму себя каждые 30 миллисекунд root.after(30, main) # Установим фокус на Canvas чтобы он реагировал на нажатия клавиш c.focus_set() # Напишем функцию обработки нажатия клавиш def movement_handler(event): global LEFT_PAD_SPEED, RIGHT_PAD_SPEED if event.keysym == «w»: LEFT_PAD_SPEED = —PAD_SPEED elif event.keysym == «s»: LEFT_PAD_SPEED = PAD_SPEED elif event.keysym == «Up»: RIGHT_PAD_SPEED = —PAD_SPEED elif event.keysym == «Down»: RIGHT_PAD_SPEED = PAD_SPEED # Привяжем к Canvas эту функцию c.bind(«<KeyPress>», movement_handler) # Создадим функцию реагирования на отпускание клавиши def stop_pad(event): global LEFT_PAD_SPEED, RIGHT_PAD_SPEED if event.keysym in «ws»: LEFT_PAD_SPEED = 0 elif event.keysym in («Up», «Down»): RIGHT_PAD_SPEED = 0 # Привяжем к Canvas эту функцию c.bind(«<KeyRelease>», stop_pad) # запускаем движение main() # запускаем работу окна root.mainloop()

import turtle

sc = turtle.Screen()

sc.title("Pong game")

sc.bgcolor("white")

sc.setup(width=1000, height=600)

left_pad = turtle.Turtle()

left_pad.speed(0)

left_pad.shape("square")

left_pad.color("black")

left_pad.shapesize(stretch_wid=6, stretch_len=2)

left_pad.penup()

left_pad.goto(-400, 0)

right_pad = turtle.Turtle()

right_pad.speed(0)

right_pad.shape("square")

right_pad.color("black")

right_pad.shapesize(stretch_wid=6, stretch_len=2)

right_pad.penup()

right_pad.goto(400, 0)

hit_ball = turtle.Turtle()

hit_ball.speed(40)

hit_ball.shape("circle")

hit_ball.color("blue")

hit_ball.penup()

hit_ball.goto(0, 0)

hit_ball.dx = 5

hit_ball.dy = -5

left_player = 0

right_player = 0

sketch = turtle.Turtle()

sketch.speed(0)

sketch.color("blue")

sketch.penup()

sketch.hideturtle()

sketch.goto(0, 260)

sketch.write("Left_player : 0    Right_player: 0",

             align="center", font=("Courier", 24, "normal"))

def paddleaup():

    y = left_pad.ycor()

    y += 20

    left_pad.sety(y)

def paddleadown():

    y = left_pad.ycor()

    y -= 20

    left_pad.sety(y)

def paddlebup():

    y = right_pad.ycor()

    y += 20

    right_pad.sety(y)

def paddlebdown():

    y = right_pad.ycor()

    y -= 20

    right_pad.sety(y)

sc.listen()

sc.onkeypress(paddleaup, "e")

sc.onkeypress(paddleadown, "x")

sc.onkeypress(paddlebup, "Up")

sc.onkeypress(paddlebdown, "Down")

while True:

    sc.update()

    hit_ball.setx(hit_ball.xcor()+hit_ball.dx)

    hit_ball.sety(hit_ball.ycor()+hit_ball.dy)

    if hit_ball.ycor() > 280:

        hit_ball.sety(280)

        hit_ball.dy *= -1

    if hit_ball.ycor() < -280:

        hit_ball.sety(-280)

        hit_ball.dy *= -1

    if hit_ball.xcor() > 500:

        hit_ball.goto(0, 0)

        hit_ball.dy *= -1

        left_player += 1

        sketch.clear()

        sketch.write("Left_player : {}    Right_player: {}".format(

                      left_player, right_player), align="center",

                      font=("Courier", 24, "normal"))

    if hit_ball.xcor() < -500:

        hit_ball.goto(0, 0)

        hit_ball.dy *= -1

        right_player += 1

        sketch.clear()

        sketch.write("Left_player : {}    Right_player: {}".format(

                                 left_player, right_player), align="center",

                                 font=("Courier", 24, "normal"))

    if (hit_ball.xcor() > 360 and

                        hit_ball.xcor() < 370) and

                        (hit_ball.ycor() < right_pad.ycor()+40 and

                        hit_ball.ycor() > right_pad.ycor()-40):

        hit_ball.setx(360)

        hit_ball.dx*=-1

    if (hit_ball.xcor()<-360 and

                       hit_ball.xcor()>-370) and

                       (hit_ball.ycor()<left_pad.ycor()+40 and

                        hit_ball.ycor()>left_pad.ycor()-40):

        hit_ball.setx(-360)

        hit_ball.dx*=-1

В этой статье мы разберём как создать игру Пинг понг на библиотеки PyGame для языка программирования Python, думаю будет очень интересно.

Также перед прочтением этой статья настоятельно рекомендую почитать мой цикл про основы PyGame:

• Основы Python библиотеки PyGame, Часть 1;
• Pygame основы часть 2, Создание фигур;
• PyGame Основы часть 3. Анимация и события;

Знания из них пригодиться в этой статье.

Создание PyGame пинг понг:

Перед тем как сначинать создавать игру, нужно подключить нужные компоненты, вот что мы подключаем:

Как видите мы подключили сам PyGame и sys, последний нужен нам для того чтобы закрывать игру.

Дальше продолжаем подготовку, назначим несколько переменных которые нам пригодятся:

В начале мы инициализируем проект на PyGame, потом назначаем цвета которые будем использовать, после назначаем координаты объектов, сначала блока которым будем управлять, потом шарика, который надо отбивать.

Дальше, самое интересное, создаём переменные которые отвечают за направление шарика, первая это circle_right, если значение True, то направляться будет на право, если False налево, и circle_top, если True, то направление шарика на верх, если False то вниз.

Последние, мы закачаем переменные для скорости и параметров окна игры, создаём окно и берём компонент часы, он нам нужен будет, чтобы настроить FPS.

Теперь перейдём к основному, для этого мы сделаем цикл, в котором будет происходить вся логика:

То есть цикл у нас всегда True, так как он нам нужен для рендеринга, теперь пропишем всё логику:

Тут мы назначаем FPS, с помощью clock.tick(60), как и понятно, он будет 60, потом закрашиваем экран в чёрный цвет, это нужно будет для будущего рендеринга, дальше начинаем отслеживать зажатие клавиши, это нужно для управление блоком, зависимости какая кнопка нажата, мы меняем позицию, ещё можете заметить, что там есть условие, оно нужно для того, чтобы блок не вышел за границы экрана.

Теперь идут условия для позиции шарика, вот они:

В начале мы проверяем дошёл ли шарик до левого края, если да, то меняем направление, потом проверяем дошёл ли шарик до нижнего или верхнего края, если одно из этого верно, то меняем направление.

Дальше зависимо от направление уменьшая или увеличиваем позицию по X или Y, ещё вы можете заметить, что для проверки мы в некоторых случаях уменьшаем или увеличиваем позицию на 50, это связано с тем, что диаметр шара будет 100, соответственно, чтобы он не проваливался, нужно проверять при столкновение его радиус.

Осталась последняя проверка, проверка что шарик оттолкнулся от блока или провалился в за правый край, вот что мы пишем:

В целом тут всё достаточно просто, сначала проверяем что шарик столкнулся с блоком, для этого проверяем столкновение границ шарика и блока.

Также идёт проверка что шарик вышел за приделы окна, в этом случае программа закрывается.

Осталось последние, это проверка для закрытия окна, рендеринг и обновление окна.

В целом на этом все, теперь можете играть, вот что у нас получилось:

Вывод:

В этой статье вы прочитали как создать пинг понг на Pyhon PyGame, думаю было очень интересно, единственное надо ещё немного поработать над ним, например чтобы не выходило из программы а просто появлялось мину со счётом, но это думаю вы и сам сделаете.

Подписываетесь на соц-сети:

Также рекомендую:

Пишем, классическая аркадная игра пинг-поннг на python, с помощью библиотеки

turtle и pygame.

упражнения

1. Измените цвета.
2. Какая частота кадров? Сделайте движение быстрее или медленнее.
3. Измените скорость мяча.
4. Измените размер ракеток.
5. Измените способ отскока мяча от стен.
6. Добавьте второй шар.

from random import choice, random
from turtle import *

from freegames import vector


def value():
    """Randomly generate value between (-5, -3) or (3, 5)."""
    return (3 + random() * 2) * choice([1, -1])


ball = vector(0, 0)
aim = vector(value(), value())
state = {1: 0, 2: 0}


def move(player, change):
    """Move player position by change."""
    state[player] += change


def rectangle(x, y, width, height):
    """Draw rectangle at (x, y) with given width and height."""
    up()
    goto(x, y)
    down()
    begin_fill()
    for count in range(2):
        forward(width)
        left(90)
        forward(height)
        left(90)
    end_fill()


def draw():
    """Draw game and move pong ball."""
    clear()
    rectangle(-200, state[1], 10, 50)
    rectangle(190, state[2], 10, 50)

    ball.move(aim)
    x = ball.x
    y = ball.y

    up()
    goto(x, y)
    dot(10)
    update()

    if y < -200 or y > 200:
        aim.y = -aim.y

    if x < -185:
        low = state[1]
        high = state[1] + 50

        if low <= y <= high:
            aim.x = -aim.x
        else:
            return

    if x > 185:
        low = state[2]
        high = state[2] + 50

        if low <= y <= high:
            aim.x = -aim.x
        else:
            return

    ontimer(draw, 50)


setup(420, 420, 370, 0)
hideturtle()
tracer(False)
listen()
onkey(lambda: move(1, 20), 'w')
onkey(lambda: move(1, -20), 's')
onkey(lambda: move(2, 20), 'i')
onkey(lambda: move(2, -20), 'k')
draw()
done()

https://t.me/pythonl

Просмотры: 1 841

The ping pong game is one of the most famous games of arcadia, which is quite similar to table tennis. The rules of this game are simple:

• There are two players.
• Both have control over the paddle of their side.
• They can move the paddle on vertical sides from up to down and down to up.

Players can strike back and forth on the ball by using the paddle.

Turtle: The turtle is a built-in module in Python which is used for graphical illustrations. The users can use it as a pen and panel to illustrate the graphics.

The following are the steps used for illustrating Ping Pong game:

• Step 1: The user has to create two Paddles for the «Left Side» and «Right Side» of the screen.
• Step 2: The user then has to create the ball.
• Step 3: Then, create an event for moving the paddles vertically by pressing the particular keys, that is, for «Left Paddle«: «R» for «Up» and «C» for «Down«, for «Right Paddle«: «Up key ()» for «Up» and «Down key ()» for «Down«.
• Step 4: At last, create the function for updating the score after each player misses the strike on the ball.

Code 1: For Creating Illustrating the Ball and Paddle:

Output:

Explanation:

First, we imported the turtle library. Then we wrote the code for the background screen by using turtle.Screen() function. We created the Left and Right paddle by using the turtle.Turtle() function and positioned them by using goto() function. at last, we created the ball by using a turtle.Turtle() function and mentioned its moving speed on screen by using speed() function and other required parameters. The illustration of the ball and paddle on the screen is ready.

Code 2: The Complete Code for Illustrating the Ping Pong Game with Two Players.

Output:

Explanation:

In the above code, after illustrating the outlook of the screen with paddles and ball, we will first initialize the score of both the players, that is, Zero. Then, we will display the score on the screen, which will increase with the opposite player missing the strike. We will then implement the functions for moving the paddle vertically. We will bind the keys for each function, that is, for «Left Paddle»: «R» for «Up» and «C» for «Down», for «Right Paddle»: «Up key» for «Up» and «Down key» for «Down». Then, we will initiate how the ball and striking of the paddle will work, as if the ball hit the paddle, it will go for the opposite player, but if the paddle missed the ball, then the ball will hit the border, and the opposite player will get the score. If the code is correct and no error is found, the screen of Ping Pong Game will pop up after running the code, and the players can play. The ball will first go for the right player.

Conclusion

In this tutorial, we have created a simple illustration of a ping pong game on the screen by using the built-in library of Python, that is, Turtle. The user can create different moving illustrations by using the turtle library and its different functions.

---