Pygame Arc jump

# Rough Example. Jump in arc.
import pygame
import os

from pygame.sprite import Sprite, Group

class State:
    def on_draw(self, surface): pass
    def on_event(self, event): pass
    def on_update(self, delta): pass

class Engine:
    @classmethod
    def setup(cls, caption, width, height, center=False):
        pygame.display.set_caption(caption)
        cls.surface = pygame.display.set_mode((width, height))
        cls.rect = cls.surface.get_rect()
        cls.clock = pygame.time.Clock()
        cls.running = False
        cls.delta = 0
        cls.fps = 30

        if center:
            os.environ['SDL_VIDEO_CENTERED'] = '1'

        cls.state = State()
        cls.extension = {}

    @classmethod
    def mainloop(cls):
        cls.running = True
        while cls.running:
            for event in pygame.event.get():
                cls.state.on_event(event)

            cls.state.on_update(cls.delta)
            cls.state.on_draw(cls.surface)

            for extension in cls.extension.values():
                extension.update(cls)

            pygame.display.flip()
            cls.delta = cls.clock.tick(cls.fps)

class OnKeys:
    def __init__(self):
        self.on_keys = []

    def add(self, method):
        self.on_keys.append(method)

    def update(self, engine):
        keys = pygame.key.get_pressed()
        for method in self.on_keys:
            method.on_keys(keys, engine.delta)

class SimpleSprite(Sprite):
    @classmethod
    def load_image(cls, w, h):
        cls.image = pygame.Surface((w, h))
        cls.image.fill(pygame.Color('dodgerblue'))

    def __init__(self, position, anchor="topleft"):
        Sprite.__init__(self)
        self.image = SimpleSprite.image
        self.rect = self.image.get_rect()
        setattr(self.rect, anchor, position)

class MoveSystem:
    def __init__(self, sprite, speed=0.03):
        self.sprite = sprite
        self.speed = speed
        self.direction = pygame.Vector2(0, 0)
        self.position = pygame.Vector2(sprite.rect.topleft)
        Engine.extension['onkeys'].add(self)
        self.jump = JumpSystem(self, 30)

    def move(self, vector):
        self.position += vector
        self.sprite.rect.topleft = self.position

    def update_rect(self):
        self.sprite.rect.topleft = self.position

    def on_keys(self, keys, delta):
        if self.jump.active:
            self.jump.move(delta)
            self.clamp()
        elif keys[pygame.K_SPACE]:
            self.jump.move(delta)
            self.clamp()
        else:
            x = 0
            if keys[pygame.K_LEFT]:
                x -= 1

            if keys[pygame.K_RIGHT]:
                x += 1

            self.direction = pygame.Vector2(x, 0)
            if x != 0:
                self.move(self.direction * self.speed * delta)
                self.clamp()

    def clamp(self):
        rect = self.sprite.rect
        clamp = self.sprite.rect.clamp(Engine.rect)
        if rect.x != clamp.x:
            rect.x = clamp.x
            self.position.x = clamp.x

        if rect.y != clamp.y:
            rect.y = clamp.y
            self.position.y = clamp.y

class JumpSystem:
    def __init__(self, move_system, distance, force=3):
        self.move_system = move_system
        self.active = False
        self.action = None
        self.floor = None
        self.speed = 1 / 30

        # Variables for arc jump
        self.force = force * 3
        self.distance = distance / 2
        self.normalize = (1 / distance) ** 2
        self.base = None

    def move(self, delta):
        if self.base is None:
            self.active = True
            self.base = -self.distance
            self.floor = self.move_system.position.y

        direction = self.move_system.direction
        speed = self.move_system.speed
        self.base += self.speed * delta
        self.base = min(self.base, self.distance)

        if self.base > 0:
            direction.y = self.base ** 2 * self.normalize * self.force
        else:
            direction.y = -(self.base ** 2 * self.normalize * self.force)

        self.move_system.move(direction * speed * delta)
        self.move_system.position.y = min(self.move_system.position.y, self.floor)
        self.move_system.update_rect()
        if self.base >= self.distance:
            self.move_system.position.y = self.floor
            self.move_system.update_rect()
            self.active = False
            self.base = None

class Example(State):
    def __init__(self):
        self.sprites = Group()

        sprite = SimpleSprite((50, 500))
        sprite.add(self.sprites)
        MoveSystem(sprite, 0.08)

    def on_draw(self, surface):
        surface.fill(pygame.Color('black'))
        self.sprites.draw(surface)

    def on_event(self, event):
        if event.type == pygame.QUIT:
            Engine.running = False

def main():
    pygame.init()
    Engine.setup("Example", 800, 600, True)
    Engine.extension['onkeys'] = OnKeys()
    SimpleSprite.load_image(20, 20)
    Engine.state = Example()
    Engine.mainloop()

if __name__ == "__main__":
    main()