ZX Spectrum Chuckie Egg - Python Pygame

import math, random, sys, time, zlib, base64
import pygame
from pygame.locals import *

def unpackSurface(data, color1, color2, colorKey = None):
    size, compressedPixelsString = data.decode('base64').decode('zlib').split(':')

    imageWidth, imageHeight = map(int, size.split(','))
    compressedPixels = map(int, compressedPixelsString.split(','))

    surface = pygame.Surface((imageWidth, imageHeight))

    colors = [color1, color2]
    colorIndex = 0

    pixelArray = pygame.PixelArray(surface)
    pixelIndex = 0

    for pixelCount in compressedPixels:
        for n in range(pixelCount):
            pixelArray[pixelIndex % imageWidth, pixelIndex / imageWidth] = colors[colorIndex]
            pixelIndex += 1
        colorIndex = 1 - colorIndex

    pixelArray.close()
    if colorKey: surface.set_colorkey(colorKey, pygame.RLEACCEL)
    return imageWidth * 4, imageHeight * 4, pygame.transform.scale(surface, (imageWidth * 4, imageHeight * 4))

def resetAll(l):
    for o in l: o.reset()

# define some colors
FUCHSIA = (255,   0, 255)
PURPLE  = (128,   0, 128)
TEAL    = (  0, 128, 128)
LIME    = (  0, 255,   0)
GREEN   = (  0, 128,   0)
OLIVE   = (128, 128,   0)
YELLOW  = (255, 255,   0)
ORANGE  = (255, 165,   0)
RED     = (255,   0,   0)
MAROON  = (128,   0,   0)
SILVER  = (192, 192, 192)
GRAY    = (128, 128, 128)
BLUE    = (  0,   0, 255)
NAVY    = (  0,   0, 128)
AQUA    = (  0, 255, 255)
WHITE   = (255, 255, 255)
BLACK   = (  0,   0,   0)

TITLE_ZIP = "\
eJyVVFsSwyAIvJAfQdFo73+wAoto0jYzHRNdkTdo5iNRe3EaiXIqqctPxwTlRiaec7dZiORzSVnG\
UAFDzdcee51J5Z8YSW0Zp3wtEITU9kLgh6Dab76ufTE07ozVHJmMEkcAahOFUADCULEqumusYz9g\
IQ3V0yeVzkBwmvKOwtn6objfzixE905iOGWi4TwLkGdGSza+alxnlv2mU7lplCRvKWbbtU0PKFmj\
M2mCC2afZZyiHyv9lCZtI0hHRx1yVsxsMz5grfrfKkiM98DC+m8M3XgYrbMns1mZu7E8JVLDh6FT\
3VqdHtWY7qyD70W+lpHQQLy3IPvtmGRvxHmlqFoj1sstzkr40AFSTdHDDE/xjSXuD4T7hFTmneYB\
huziyfAur4emu/LH1wYK31144s0="

FONT_ZIP = "\
eJydVmty7iAI3ZA/qoAm3f/CrshB0drvznQyCfgAlMMjUp70fAs9Kac8PpxKyp2mFy/3V1cq9Y9w\
H1OSZFS/tQvUwRN263rrtAze3oa1MvdEPU51177vpPrIGJtN6ZxJ60ny+JruivN1KT1AVaYMW3of\
woloSFWcvriJOswUHEfNEKjzBLqu+PmV6Z7b1aKbTlcJgChhrnXOH/rgrkjzFwa3DXQ5iPFmIF9k\
NVQYe3O5KB2T4gOGL02EpymBGkJY6PiF+gYF/vzPzwzsXsid6/5woASZdT05QlYmfq3vXHhYMFnQ\
lvDdsfqN0gzZ+zoPy6YvxoSnwBt8Z3eRmXoc0tEheg0R3oK2BsfXi9Pc0F/BaMgwCXMRAL+MBHsy\
asq6cDv4BufHBIlOXEmyz+UUnSwzIArGz0XXCUiFXgmydmYe8m7rDXJR5wgZXXgS8mNVzRMR0+K1\
aUcjlqlPiDCqI9I/uvoGxSqxPHPprzWLf9m75soPmCNMMYx2F651l/A5wZkrypbLLbv1Auu+r7fE\
1VO88Btv3l8HI/SipdANn4gwmkV2LyusbWSvt6C9IlkBjl3jbLoaQ3vTjU34dlNf3+U88b2ZLu8u\
73gzldl4XcYdUwPfEn4ZVB8p0Io04/597k30D/NbkeY="
FONT_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890:!?."

class font:
    def __init__(s):
        global BLACK, WHITE
        global FONT_ZIP, FONT_CHARS
        s.fontSurfaceWidth, s.fontSurfaceHeight, s.fontSurface = unpackSurface(FONT_ZIP, BLACK, WHITE, BLACK)
        s.charWidth = s.fontSurfaceWidth / len(FONT_CHARS)

    def write(s, text, x, y, color = None, returnSurface = False):
        global DS
        global FONT_CHARS

        textLength = len(text)
        textSurface = pygame.Surface((s.charWidth * textLength, s.fontSurfaceHeight))
        if color:
            textColorSurface = textSurface.copy()
            textColorSurface.fill(color)
        textSurface.set_colorkey(BLACK, pygame.RLEACCEL)

        xOffset = 0
        for char in text:
            if char != ' ':
                charXPos = FONT_CHARS.find(char) * s.charWidth
                textSurface.blit(s.fontSurface, (xOffset, 0), (charXPos, 0, s.charWidth, s.fontSurfaceHeight))
            xOffset += s.charWidth

        if color:
            textSurface.blit(textColorSurface, (0, 0), None, pygame.BLEND_MULT)

        if returnSurface: return textSurface
        DS.blit(textSurface, (x, y))

HARRY_ZIP = "\
eJylUtEOwyAI/CEeiiiM/v+HDRDL2qbLksXAnXieRFUG5L0DgVrgluQFCM3iGftf0QG1WXYvd1uI\
4V/43YVD1bztALc9F2RNKsnFhmFYbXzgeX2k88Kep4wDn/QUTZTeZ2T+1+H6VafQ3jW/6+R2UZjn\
zqfj6KueUjMoLn3WJTkl19hDoePkkt9kaorHuqU30uNxXw=="
HARRY_WALK_JUMP_RIGHT = [0, 1]
HARRY_WALK_JUMP_LEFT = [2, 3]
HARRY_CLIMB_LADDER = [4, 5, 6, 7]
HARRY_TOTAL_ANIM_FRAMES = 8
HARRY_WALKING_SPEED = 4
HARRY_JUMPING_SPEED = 4
HARRY_JUMPING_HEIGHT = 16
HARRY_JUMPING_TABLE = [-1 + (-1 * -(n / HARRY_JUMPING_HEIGHT)) * 2 for n in range(HARRY_JUMPING_HEIGHT * 2)]
HARRY_MOVEMENT = [
    {'dx' : 0, 'fi' : False, 'fi_reset' : True, 'as' : None},
    {'dx' : HARRY_WALKING_SPEED, 'fi' : True, 'fi_reset' : False, 'as' : HARRY_WALK_JUMP_RIGHT},
    {'dx' : -HARRY_WALKING_SPEED, 'fi' : True, 'fi_reset' : False, 'as' : HARRY_WALK_JUMP_LEFT},
]

class harry:
    def __init__(s):
        global YELLOW
        global HARRY_ZIP, HARRY_TOTAL_ANIM_FRAMES
        s.harrySurfaceWidth, s.harrySurfaceHeight, s.harrySurface = unpackSurface(HARRY_ZIP, BLACK, YELLOW, BLACK)
        s.harryWidth = s.harrySurfaceWidth / HARRY_TOTAL_ANIM_FRAMES
        s.reset()

    def reset(s):
        global H
        s.frameIndex = 0
        s.currentAnimSet = HARRY_WALK_JUMP_RIGHT
        s.x, s.y = 0, H  - s.harrySurfaceHeight
        s.dx = 0
        s.jumping = False
        s.jumpingDx = 0

        s.onLadder = False

    def draw(s):
        global DS
        DS.blit(s.harrySurface, (s.x, s.y), (s.currentAnimSet[s.frameIndex] * s.harryWidth, 0, s.harryWidth, s.harrySurfaceHeight))

    def move(s):
        global W, H
        global HARRY_MOVEMENT, HARRY_JUMPING_TABLE, HARRY_JUMPING_SPEED, HARRY_JUMPING_HEIGHT
        global keysHandler

        # if player requests jump
        if keysHandler.action[1] and not s.jumping:
            s.jumping = 1
            s.jumpingDx = HARRY_MOVEMENT[keysHandler.action[0]]['dx']

        if not s.jumping:
            s.x += HARRY_MOVEMENT[keysHandler.action[0]]['dx']
        else:
            s.x += s.jumpingDx
            s.y += HARRY_JUMPING_TABLE[s.jumping] * HARRY_JUMPING_SPEED
            s.jumping += 1
            if s.jumping == HARRY_JUMPING_HEIGHT * 2 - 1: s.jumping = False

        if HARRY_MOVEMENT[keysHandler.action[0]]['fi'] or s.jumping:
            s.frameIndex += 1
        elif HARRY_MOVEMENT[keysHandler.action[0]]['fi_reset'] and not s.jumping:
            s.frameIndex = 0

        if HARRY_MOVEMENT[keysHandler.action[0]]['as'] and not s.jumping:
            s.currentAnimSet = HARRY_MOVEMENT[keysHandler.action[0]]['as']
        if s.frameIndex > len(s.currentAnimSet) - 1: s.frameIndex = 0


    def do(s):
        s.draw()
        s.move()

class keys:
    def reset(s):
        s.exit = False
        s.action = [0] * 2

    def do(s):
        k = pygame.key.get_pressed()

        if k[pygame.K_ESCAPE]:
            s.exit = True
            return

        if k[pygame.K_SPACE]:
            s.action[1] = True
        else:
            s.action[1] = False

        if k[pygame.K_LEFT]:
            s.action[0] = 2
        elif k[pygame.K_RIGHT]:
            s.action[0] = 1
        else:
            s.action[0] = 0

        """
        if k[pygame.K_UP]:
            s.action[s.UP] = 1
        elif k[pygame.K_DOWN]:
            s.action[s.DOWN] = 1
        """

# define display surface
W, H = 1024, 768
HW, HH = W / 2, H / 2

# initialise display
pygame.init()
DS = pygame.display.set_mode((W, H), pygame.DOUBLEBUF | pygame.HWSURFACE)
pygame.display.set_caption("Chuckie Egg")

CLOCK = pygame.time.Clock()
FPS = 60

TITLE_WIDTH, TITLE_HEIGHT, TITLE = unpackSurface(TITLE_ZIP, BLACK, YELLOW, BLACK)

# Game variables / objects
textHandler = font()
keysHandler = keys()
harryHandler = harry()

RESET_LIST = [keysHandler, harryHandler]
resetAll(RESET_LIST)

EXIT = textHandler.write("Press ESC to exit!", 0, 0, None, True)

# main loop
while not keysHandler.exit:
    pygame.event.get() # purge the events

    DS.fill(BLACK)
    DS.blit(EXIT, (0, 0))

    keysHandler.do()
    harryHandler.do()

    pygame.display.update()
    CLOCK.tick(FPS)
pygame.quit()
sys.exit()