Pygame Simple Jump Game Example

import pygame
import random
from pygame.sprite import Group, Sprite

spritecollide = pygame.sprite.spritecollide

class DisplayEngine:
    def __init__(self, caption, width, height, flags=0):
        pygame.display.set_caption(caption)
        self.surface = pygame.display.set_mode((width, height), flags)
        self.rect = self.surface.get_rect()
        self.clock = pygame.time.Clock()
        self.running = False
        self.delta = 0
        self.fps = 60

    def main_loop(self, game):
        self.running = True
        while self.running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                else:
                    game.event(event)

            game.draw(self.surface)
            game.update(self.delta)
            pygame.display.flip()
            self.delta = self.clock.tick(self.fps)

class Player(Sprite):
    def __init__(self, position):
        Sprite.__init__(self)
        self.image = pygame.Surface((30, 30))
        self.rect = self.image.get_rect(midbottom=position)
        self.position = pygame.Vector2(self.rect.center)
        self.image.fill(pygame.Color("gold"))

    def clamp(self, rect):
        clamp = self.rect.clamp(rect)
        if self.rect.x != clamp.x:
            self.position.x = clamp.centerx

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

        self.rect = clamp

    def move(self, x, y):
        self.position.x += x
        self.position.y += y
        self.rect.center = tuple(map(int, self.position))

    def move_clamp(self, x, y, rect):
        self.move(x, y)
        self.clamp(rect)

    def offset(self, top, bottom):
        diff = 0
        if self.position.y < top:
            diff = top - self.position.y
            self.position.y = top

        elif self.position.y > bottom:
            diff = bottom - self.position.y
            self.position.y = bottom

        self.rect.center = tuple(map(int, self.position))
        return diff

class Platform(Sprite):
    def __init__(self, image, position, groups):
        Sprite.__init__(self, groups)
        self.image = image
        self.rect = self.image.get_rect(topleft=position)
        self.y = self.rect.y

    def update(self, map_position):
        self.rect.y = self.y + map_position

class PlatformData:
    def __init__(self, count, sprites, game_width, game_height):
        self.images = []
        self.sprites = sprites
        self.group = Group()

        self.height = 10
        self.count = count
        self.next_level = game_height - 50
        self.color = pygame.Color("lawngreen")
        self.widths = tuple(range(50, 120, 10))
        self.game_width = game_width

        image = pygame.Surface((game_width, self.height))
        image.fill(pygame.Color('firebrick'))
        position = (0, game_height - self.height)
        self.bottom_platform = Platform(image, position, (sprites, self.group))

        self.create_images()
        self.create()

    def create_images(self):
        for width in self.widths:
            surface = pygame.Surface((width, self.height))
            surface.fill(self.color)
            self.images.append(surface)

    def create(self):
        for c in range(self.count):
            image = random.choice(self.images)
            width = image.get_width()
            x = random.randint(0, self.game_width - width)
            y = random.randint(60, 120)
            self.next_level -= y
            position = x, self.next_level
            Platform(image, position, (self.group, self.sprites))

class PlayerMovement:
    climbing_state = 1
    jumping_state = 2
    landed_state = 3
    falling_state = 4

    def __init__(self, game):
        self.game = game
        self.acc = 0.08
        self.velocity = 0
        self.max_jump = 120
        self.jump_count = 0
        self.velocity_start = 0.2
        self.state = PlayerMovement.landed_state

        self.last_platform = game.platforms.bottom_platform

    def collision(self):
        collision = spritecollide(self.game.player, self.game.platforms.group, False)

        value = len(collision)
        if value > 0:
            self.last_platform = collision[0]

        return value

    def fall(self):
        if self.state not in (PlayerMovement.jumping_state, PlayerMovement.falling_state):
            rect = self.game.player.rect.copy()
            rect.y += 1

            if not rect.colliderect(self.last_platform.rect):
                self.state = PlayerMovement.falling_state
                self.velocity = self.velocity_start

    def is_climbing(self, delta):
        y = self.velocity_start * delta
        self.game.player.move(0, -y)

        if self.collision() == 0:
            self.game.player.rect.bottom = self.last_platform.rect.top
            self.game.player.position.y = self.game.player.rect.centery
            self.state = PlayerMovement.landed_state

    def is_jumping(self, keys, delta):
        if self.jump_count < self.max_jump:
            if keys[pygame.K_SPACE] or keys[pygame.K_w] or keys[pygame.K_UP]:
                y = self.velocity * delta
                self.game.player.move(0, -y)
                self.jump_count += y
            else:
                self.state = PlayerMovement.falling_state
                self.jump_count = 0
        else:
            self.state = PlayerMovement.falling_state
            self.jump_count = 0

    def is_falling(self, delta):
        if self.collision() > 0:
            self.state = PlayerMovement.climbing_state
        else:
            y = self.velocity * delta
            self.game.player.move(0, y)

    def can_jump(self, keys, delta):
        if keys[pygame.K_SPACE] or keys[pygame.K_w] or keys[pygame.K_UP]:
            self.state = PlayerMovement.jumping_state
            self.velocity = self.velocity_start

    def allowed(self, keys, delta):
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:
            x = -self.acc * delta
            self.game.player.move_clamp(x, 0, self.game.engine.rect)
            self.fall()

        if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
            x = self.acc * delta
            self.game.player.move_clamp(x, 0, self.game.engine.rect)
            self.fall()

    def update(self, keys, delta):
        if self.state == PlayerMovement.climbing_state:
            self.is_climbing(delta)

        elif self.state == PlayerMovement.jumping_state:
            self.is_jumping(keys, delta)

        elif self.state == PlayerMovement.falling_state:
            self.is_falling(delta)

        elif self.state == PlayerMovement.landed_state:
            self.can_jump(keys, delta)

        self.allowed(keys, delta)

class JumpGame:
    def __init__(self, engine):
        self.engine = engine
        self.map_position = 0
        self.sprites = Group()
        self.background_color = pygame.Color("dodgerblue")
        self.platforms = PlatformData(1000, self.sprites, *self.engine.rect.size)
        self.max_height = self.engine.rect.height - self.platforms.height
        self.bottom = int(engine.rect.height * 0.7)
        self.top = int(engine.rect.height * 0.3)

        position = engine.rect.centerx, engine.rect.bottom - self.platforms.height
        self.player = Player(position)
        self.sprites.add(self.player)
        self.movement = PlayerMovement(self)

    def draw(self, surface):
        surface.fill(self.background_color)
        self.sprites.draw(surface)

    def event(self, event):
        pass

    def fall(self):
        if self.player.landed:
            collision = spritecollide(self.player, self.platforms.group, False)

            if len(collision) == 0:
                self.player.landed = False
                self.player.velocity = self.velocity

    def update(self, delta):
        self.platforms.group.update(self.map_position)
        keys = pygame.key.get_pressed()
        self.movement.update(keys, delta)
        self.map_position += self.player.offset(self.top, self.bottom)

        #if self.map_position > self.max_height:
            #self.map_position = self.max_height


def main():
    random.seed(10) # same map every game.
    pygame.init()
    engine = DisplayEngine("Jump Game", 250, 600)
    game = JumpGame(engine)
    engine.main_loop(game)

main()