Pymunk and PyGame - Physics Balls

import pygame as pg
import pymunk.pygame_util
from pygame.locals import *
from random import uniform, randrange
from sys import exit as sysExit
import gameSettings

pymunk.pygame_util.positive_y_is_up = False

WIDTH, HEIGHT = 1280, 720
FPS = 60

# объявление всего необходимого
pg.init()

settings = gameSettings.parseSettings()

display = pg.display.set_mode((WIDTH, HEIGHT), pg.RESIZABLE)
pg.display.set_caption("Мячики с физикой на PyGame + Pymunk")
clock = pg.time.Clock()
draw_option = pymunk.pygame_util.DrawOptions(display)

space = pymunk.Space()
space.gravity = 0, 2000

""" объекты """
# платформы
segment_shape = pymunk.Segment(space.static_body, (0, HEIGHT + 35), (WIDTH + 10000, HEIGHT + 35), 50)
segment_shape.elasticity = 0.5
segment_shape.friction = 0.5
space.add(segment_shape)

verifyLimitCreation = False
temp = []


def createWindowLimits(create):
    global temp
    global verifyLimitCreation
    if create:
        temp = []
        verifyLimitCreation = True
        segment_shape = pymunk.Segment(space.static_body, (-35, 0), (-35, pg.display.get_window_size()[1]), 50)
        segment_shape.elasticity = 0.5
        segment_shape.friction = 0.5
        temp.append(segment_shape)

        segment_shape = pymunk.Segment(space.static_body, (pg.display.get_window_size()[0] + 35, 0),
                                       (pg.display.get_window_size()[0] + 35, pg.display.get_window_size()[1]), 50)
        segment_shape.elasticity = 0.5
        segment_shape.friction = 0.5
        temp.append(segment_shape)

        segment_shape = pymunk.Segment(space.static_body, (0, 0 - 35), (pg.display.get_window_size()[0], 0 - 35), 50)
        segment_shape.elasticity = 0.5
        segment_shape.friction = 0.5
        temp.append(segment_shape)
        for i in temp:
            space.add(i)
    else:
        for i in temp:
            space.remove(i)
        verifyLimitCreation = False


# создать мячик
ball_arr = []
ball_size = settings[0]
ballSize_font = pg.font.SysFont('serif', 18)
ballSize_fontRender = ballSize_font.render(f"Размер мячиков: {ball_size}(↑ or ↓)", True, (0, 0, 0))
placePos_ballSizeFont = ballSize_fontRender.get_rect(topleft=(5, 18))

ball_elasticity = settings[1]
ballElasticity_font = pg.font.SysFont('serif', 18)
ballElasticity_fontRender = ballElasticity_font.render(f"Упругость мячиков: {ball_elasticity}(F1 or F2)", True,
                                                       (0, 0, 0))
placePos_ballElasticityFont = ballElasticity_fontRender.get_rect(topleft=(5, 36))

ball_friction = settings[2]
ballFriction_font = pg.font.SysFont('serif', 18)
ballFriction_fontRender = ballFriction_font.render(f"Трение мячиков: {ball_friction}(F3 or F4)", True, (0, 0, 0))
placePos_ballFrictionFont = ballFriction_fontRender.get_rect(topleft=(5, 54))

ball_mass = settings[3]
ballMass_font = pg.font.SysFont('serif', 18)
ballMass_fontRender = ballMass_font.render(f"Масса мячиков: {ball_mass}(F5 or F6)", True, (0, 0, 0))
placePos_ballMassFont = ballMass_fontRender.get_rect(topleft=(5, 72))


def createBall(mass, radius, position, elasticity, friction, color):
    ball_mass, ball_radius = mass, radius
    ball_moment = pymunk.moment_for_circle(ball_mass, 0, ball_radius)
    ball_body = pymunk.Body(ball_mass, ball_moment)
    ball_body.position = position
    ball_shape = pymunk.Circle(ball_body, ball_radius)
    ball_shape.elasticity = elasticity
    ball_shape.friction = friction
    ball_shape.color = color
    space.add(ball_body, ball_shape)
    ball_arr.append(ball_body)
    ball_arr.append(ball_shape)


# статическая линия для рисования платформ
painter_line_arr = []
# painter_line_arrTemp - нужен для запоминания удалённых объектов для их возвращения на сцену
painter_line_arrTemp = []
painter_line_size = 10
painter_line_font = pg.font.SysFont('serif', 18)
painter_line_fontRender = painter_line_font.render(f"Размер кисти препятствий: {painter_line_size}(→ or ←)", True,
                                                   (0, 0, 0))
placePos_painter_ballFont = painter_line_fontRender.get_rect(topleft=(5, 0))

# вот тут вот я РАНЬШЕ не понимал, в чём проблема и как заставить это работать(сейчас это работает)
lastMousePos = None
mousePressed = False


def createPainterLine(radius, singleClickVerify):
    if singleClickVerify == False:
        segment_shape = pymunk.Segment(space.static_body, lastMousePos,
                                       (pg.mouse.get_pos()[0], pg.mouse.get_pos()[1]), radius)
        segment_shape.elasticity = 0.4
        segment_shape.friction = 0.5
        space.add(segment_shape)
        painter_line_arr.append(segment_shape)
    else:
        segment_shape = pymunk.Segment(space.static_body, lastMousePos,
                                       (pg.mouse.get_pos()[0] + 1, pg.mouse.get_pos()[1] + 1), radius)
        segment_shape.elasticity = 0.4
        segment_shape.friction = 0.5
        space.add(segment_shape)
        painter_line_arr.append(segment_shape)


def deletePainterLine():
    for i in range(0, len(painter_line_arr)):
        space.remove(painter_line_arr[i])
    painter_line_arr.clear()


def deleteBalls():
    for i in range(0, len(ball_arr)):
        space.remove(ball_arr[i])
    ball_arr.clear()


def deleteRectangles():
    for i in range(0, len(rectangle_arr)):
        space.remove(rectangle_arr[i])
    rectangle_arr.clear()


# надпись с FPS
fps_font = pg.font.SysFont('serif', 18)
fps_fontRender = fps_font.render(f"FPS = {round(clock.get_fps(), 2)}", True, (0, 0, 0))
display_rect = display.get_rect()
placePos_fps_font = painter_line_fontRender.get_rect(topright=(pg.display.get_window_size()[0] + 220, 0))

# создать прямоугольник
rectangle_arr = []
rectangle_mass = settings[4]
rectangle_width = settings[5]
rectangle_height = settings[6]
rectangle_elasticity = settings[7]
rectangle_friction = settings[8]

rect_font = pg.font.SysFont('serif', 18)
rectWidth_fontRender = rect_font.render(f"Ширина прям-ов: {rectangle_width}(F7 or F8)", True, (0, 0, 0))
placePos_rectWidthFont = rectWidth_fontRender.get_rect(topleft=(320, 0))

rectHeight_fontRender = rect_font.render(f"Высота прям-ов: {rectangle_height}(F9 or F10)", True, (0, 0, 0))
placePos_rectHeightFont = ballSize_fontRender.get_rect(topleft=(320, 18))

rectMass_fontRender = rect_font.render(f"Масса прям-ов: {rectangle_mass}(F11 or F12)", True, (0, 0, 0))
placePos_rectMassFont = ballSize_fontRender.get_rect(topleft=(320, 36))

rectElasticity_fontRender = rect_font.render(f"Упругость прям-ов: {rectangle_elasticity}(1 or 2)", True, (0, 0, 0))
placePos_rectElasticityFont = rectElasticity_fontRender.get_rect(topleft=(320, 54))

rectFriction_fontRender = rect_font.render(f"Трение прям-ов: {rectangle_friction}(3 or 4)", True, (0, 0, 0))
placePos_rectFrictionFont = rectElasticity_fontRender.get_rect(topleft=(320, 72))


def CreateRectangle(rectangle_mass, pos, rectangle_height, rectangle_width, rectangle_elasticity, rectangle_friction):
    square_mass, square_size = rectangle_mass, (rectangle_width, rectangle_height)
    square_moment = pymunk.moment_for_box(square_mass, square_size)
    square_body = pymunk.Body(square_mass, square_moment)
    square_body.position = pos
    square_shape = pymunk.Poly.create_box(square_body, square_size)
    square_shape.elasticity = rectangle_elasticity
    square_shape.friction = rectangle_friction
    square_shape.color = [randrange(256) for i in range(4)]
    rectangle_arr.append(square_shape)
    space.add(square_body, square_shape)


# надпись гравитации
gravity = True
gravity_font = pg.font.SysFont('serif', 18)
gravity_fontRender = rect_font.render(f"Гравитация: {gravity}(G)", True, (0, 0, 0))
placePos_GravityFont = gravity_fontRender.get_rect(topright=(pg.display.get_window_size()[0] - 5, 18))

while True:
    settings = gameSettings.parseSettings()
    display.fill((0, 160, 90))

    mouseKeys = pg.mouse.get_pressed()
    keyboardKeys = pg.key.get_pressed()

    for event in pg.event.get():
        if event.type == pg.QUIT:
            sysExit()
        elif event.type == pg.MOUSEBUTTONUP:
            mousePressed = False
            f1pressed = False
        elif event.type == pg.MOUSEBUTTONDOWN:
            if event.button == 1:
                createBall(ball_mass, ball_size, pg.mouse.get_pos(), ball_elasticity, ball_friction,
                           [uniform(0, 255) for i in range(4)])
            elif event.button == 3:
                singleClickVerify = True
                lastMousePos = pg.mouse.get_pos()
                createPainterLine(painter_line_size, singleClickVerify)
                mousePressed = True
            elif event.button == 2:
                deletePainterLine()
                deleteBalls()
                deleteRectangles()
        elif event.type == pg.MOUSEMOTION:
            if mousePressed:
                singleClickVerify = False
                createPainterLine(painter_line_size, singleClickVerify)
                lastMousePos = pg.mouse.get_pos()
        elif event.type == pg.WINDOWSIZECHANGED:
            placePos_GravityFont = gravity_fontRender.get_rect(topright=(pg.display.get_window_size()[0] - 5, 18))
            placePos_fps_font = painter_line_fontRender.get_rect(topright=(pg.display.get_window_size()[0] + 220, 0))
            space.remove(segment_shape)
            segment_shape = pymunk.Segment(space.static_body, (1, pg.display.get_window_size()[1] + 35),
                                           (pg.display.get_window_size()[0], pg.display.get_window_size()[1] + 35), 50)
            segment_shape.elasticity = 0.5
            segment_shape.friction = 0.5
            space.add(segment_shape)

            if verifyLimitCreation:
                for i in temp:
                    space.remove(i)
                createWindowLimits(True)
        elif event.type == pg.KEYDOWN:
            if event.key == pg.K_RIGHT:

                painter_line_size += 1
                painter_line_fontRender = painter_line_font.render(
                    f"Размер кисти препятствий: {painter_line_size}(→ or ←)", True,
                    (0, 0, 0))

            elif event.key == K_LEFT:
                painter_line_size -= 1
                painter_line_fontRender = painter_line_font.render(
                    f"Размер кисти препятствий: {painter_line_size}(→ or ←)", True,
                    (0, 0, 0))

            elif event.key == K_UP:
                gameSettings.changeFileParameters(1, ball_size=True)
            elif event.key == K_DOWN:
                gameSettings.changeFileParameters(1, action=False, ball_size=True)
            elif event.key == K_F1:
                gameSettings.changeFileParameters(0.1, ball_elasticity=True)
            elif event.key == K_F2:
                if settings[1] > 0:
                    gameSettings.changeFileParameters(0.1, action=False, ball_elasticity=True)
                else:
                    pass

            elif event.key == K_F5:
                gameSettings.changeFileParameters(0.1, ball_mass=True)

            elif event.key == K_F6:
                temp_mass = ball_mass
                if settings[3] > 0.1:
                    gameSettings.changeFileParameters(0.1, action=False, ball_mass=True)
                else:
                    pass
            elif event.key == K_F3:
                gameSettings.changeFileParameters(0.1, ball_friction=True)

            elif event.key == K_F4:
                gameSettings.changeFileParameters(0.1, ball_friction=True, action=False)

            elif event.key == K_F7:
                gameSettings.changeFileParameters(1, rectangle_width=True)
            elif event.key == K_F8:
                gameSettings.changeFileParameters(1, action=False, rectangle_width=True)
            elif event.key == K_F9:
                gameSettings.changeFileParameters(1, rectangle_height=True)
            elif event.key == K_F10:
                gameSettings.changeFileParameters(1, action=False, rectangle_height=True)
            elif event.key == K_F11:
                gameSettings.changeFileParameters(0.1, rectangle_mass=True)
            elif event.key == K_F12:
                gameSettings.changeFileParameters(0.1, action=False, rectangle_mass=True)
            elif event.key == K_1:
                gameSettings.changeFileParameters(0.1, rectangle_elasticity=True)
            elif event.key == K_2:
                if settings[7] > 0.1:
                    gameSettings.changeFileParameters(0.1, action=False, rectangle_elasticity=True)
                else:
                    pass
                gameSettings.changeFileParameters(0.1, action=False, rectangle_elasticity=True)
            elif event.key == K_3:
                gameSettings.changeFileParameters(0.1, rectangle_friction=True)
            elif event.key == K_4:
                if settings[8] > 0.1:
                    gameSettings.changeFileParameters(0.1, action=False, rectangle_friction=True)
                else:
                    pass
                gameSettings.changeFileParameters(0.1, action=False, rectangle_friction=True)
            elif event.key == K_l:
                if not verifyLimitCreation:
                    createWindowLimits(True)
                else:
                    createWindowLimits(False)
            elif event.key == K_r:
                CreateRectangle(rectangle_mass, pg.mouse.get_pos(), rectangle_height, rectangle_width,
                                rectangle_elasticity,
                                rectangle_friction)
            elif event.key == K_g:
                if gravity:
                    space.gravity = 0, 0
                    gravity = False
                    gravity_fontRender = rect_font.render(f"Гравитация: {gravity}(G)", True, (0, 0, 0))
                else:
                    space.gravity = 0, 2000
                    gravity = True
                    gravity_fontRender = rect_font.render(f"Гравитация: {gravity}(G)", True, (0, 0, 0))

    if mouseKeys[0] and keyboardKeys[K_LSHIFT]:
        createBall(ball_mass, ball_size, pg.mouse.get_pos(), ball_elasticity, ball_friction,
                   [uniform(0, 255) for i in range(4)])

    elif keyboardKeys[K_r] and keyboardKeys[K_LSHIFT]:
        pass
    if keyboardKeys[K_LCTRL] and keyboardKeys[K_z] and not keyboardKeys[K_LSHIFT]:
        try:
            space.remove(painter_line_arr[-1])
            painter_line_arrTemp.append(painter_line_arr[-1])
            painter_line_arr.pop(-1)
        except IndexError:
            painter_line_arrTemp.clear()
            pass
    if keyboardKeys[K_LCTRL] and keyboardKeys[K_z] and keyboardKeys[K_LSHIFT]:
        try:
            space.add(painter_line_arrTemp[-1])
            painter_line_arr.append(painter_line_arrTemp[-1])
            painter_line_arrTemp.pop(-1)
        except:
            pass
    space.step(1 / FPS)
    space.debug_draw(draw_option)

    display.blit(rectWidth_fontRender, placePos_rectWidthFont)
    display.blit(rectHeight_fontRender, placePos_rectHeightFont)
    display.blit(rectMass_fontRender, placePos_rectMassFont)
    display.blit(rectElasticity_fontRender, placePos_rectElasticityFont)
    display.blit(rectFriction_fontRender, placePos_rectFrictionFont)

    display.blit(painter_line_fontRender, placePos_painter_ballFont)
    display.blit(ballSize_fontRender, placePos_ballSizeFont)
    display.blit(ballElasticity_fontRender, placePos_ballElasticityFont)
    display.blit(ballMass_fontRender, placePos_ballMassFont)
    display.blit(ballFriction_fontRender, placePos_ballFrictionFont)

    display.blit(fps_fontRender, placePos_fps_font)
    display.blit(gravity_fontRender, placePos_GravityFont)

    # мячики
    ball_size = settings[0]
    ball_elasticity = settings[1]
    ball_friction = settings[2]
    ball_mass = settings[3]

    ballSize_fontRender = ballSize_font.render(f"Размер мячиков: {ball_size}(↑ or ↓)", True, (0, 0, 0))
    ballElasticity_fontRender = ballElasticity_font.render(f"Упругость мячиков: {ball_elasticity}(F1 or F2)",
                                                           True, (0, 0, 0))
    ballFriction_fontRender = ballFriction_font.render(f"Трение мячиков: {ball_friction}(F3 or F4)", True,
                                                       (0, 0, 0))
    ballMass_fontRender = ballMass_font.render(f"Масса мячиков: {ball_mass}(F5 or F6)", True,
                                               (0, 0, 0))

    # прямоугольники
    rectangle_mass = settings[4]
    rectangle_width = settings[5]
    rectangle_height = settings[6]
    rectangle_elasticity = settings[7]
    rectangle_friction = settings[8]

    rectWidth_fontRender = rect_font.render(f"Ширина прям-ов: {rectangle_width}(F7 or F8)", True,
                                            (0, 0, 0))
    rectHeight_fontRender = rect_font.render(f"Высота прям-ов: {rectangle_height}(F9 or F10)", True,
                                             (0, 0, 0))
    rectMass_fontRender = rect_font.render(f"Масса прям-ов: {rectangle_mass}(F11 or F12)", True,
                                           (0, 0, 0))
    rectElasticity_fontRender = rect_font.render(f"Упругость прям-ов: {rectangle_elasticity}(1 or 2)", True,
                                                 (0, 0, 0))

    rectFriction_fontRender = rect_font.render(f"Трение прям-ов: {rectangle_friction}(3 or 4)", True, (0, 0, 0))

    pg.display.flip()
    clock.tick(FPS)

    fps_fontRender = fps_font.render(f"FPS: {round(clock.get_fps(), 2)}", True, (0, 0, 0))