Capstone — Make the Platformer Yours

import pgzrun
from pgzhelper import *

WIDTH = 800
HEIGHT = 600

# --- tuning ---
GRAVITY = 0.6        # pulls the player down every frame
MOVE_SPEED = 5       # sideways pixels per frame
JUMP_SPEED = -14     # negative = upwards
MAX_FALL = 18        # terminal velocity, stops tunnelling through platforms

TILE_W = 60          # platform1.png is 60 x 30
TILE_H = 30

MONSTER_SPEED = 2    # skeletons walk slower than the player

MAX_HP = 100         # a full health bar
TOUCH_DAMAGE = 10    # hp lost each time a skeleton touches you
HURT_COOLDOWN = 1.0  # seconds of mercy before the same touch hurts again

# --- player ---
# player.png is 900x900 but the character only fills a 434x570 area in the
# middle. subrect crops to that box so the collision rect matches the drawing.
player = Actor('player', subrect=(210, 181, 434, 570))
player.scale = 0.12
player.pos = (100, 200)
player.vx = 0
player.vy = 0
player.on_ground = False
player.hp = MAX_HP
player.hurt_timer = 0    # seconds left before he can be hurt again

START_POS = player.pos

# --- level: (x, y, how many tiles wide) ---
LEVEL = [
    (0,   570, 5),    # ground, left half
    (420, 570, 7),    # ground, right half (gap in between = a pit)
    (60,  360, 2),
    (200, 470, 3),
    (240, 250, 3),
    (400, 390, 3),
    (620, 310, 2),
]

platforms = []
for x, y, count in LEVEL:
    for i in range(count):
        platforms.append(Actor('platform1', topleft=(x + i * TILE_W, y)))

# --- monsters: (x, y) = where the feet stand, y is a platform's top ---
MONSTERS = [
    (250, 570),
    (620, 570),
    (300, 470),
    (500, 390),
]

monsters = []
for x, y in MONSTERS:
    # skeleton.png is 599x333; the drawing sits in a 240x278 box inside it
    m = Actor('skeleton', subrect=(211, 27, 240, 278))
    m.scale = 0.22
    m.midbottom = (x, y)
    m.home = (x, y)      # where respawn() puts it back
    m.vx = MONSTER_SPEED
    monsters.append(m)

def overlaps(a, b):
    """True if two actors' rectangles overlap."""
    return (a.right > b.left and a.left < b.right and
            a.bottom > b.top and a.top < b.bottom)

def ground_at(x, y):
    """True if some platform covers the single point (x, y)."""
    for p in platforms:
        if p.left <= x < p.right and p.top <= y < p.bottom:
            return True
    return False

def update_monsters():
    for m in monsters:
        m.x += m.vx

        # look one pixel past the toes and a little below the feet.
        toes = m.right + 1 if m.vx > 0 else m.left - 1
        turn = not ground_at(toes, m.bottom + 2)

        for p in platforms:
            if overlaps(m, p):
                if m.vx > 0:
                    m.right = p.left
                else:
                    m.left = p.right
                turn = True

        if m.left < 0:
            m.left = 0
            turn = True
        elif m.right > WIDTH:
            m.right = WIDTH
            turn = True

        if turn:
            m.vx = -m.vx
            m.flip_x = m.vx < 0

def update(dt):
    # ---- horizontal movement ----
    player.vx = 0
    if keyboard.a:
        player.vx = -MOVE_SPEED
    if keyboard.d:
        player.vx = MOVE_SPEED

    if player.vx < 0 and not player.flip_x:
        player.flip_x = True
    elif player.vx > 0 and player.flip_x:
        player.flip_x = False

    player.x += player.vx
    for p in platforms:
        if overlaps(player, p):
            if player.vx > 0:
                player.right = p.left
            elif player.vx < 0:
                player.left = p.right

    if player.left < 0:
        player.left = 0
    if player.right > WIDTH:
        player.right = WIDTH

    # ---- vertical movement ----
    player.vy = min(player.vy + GRAVITY, MAX_FALL)
    player.y += player.vy

    player.on_ground = False
    for p in platforms:
        if overlaps(player, p):
            if player.vy > 0:
                player.bottom = p.top
                player.on_ground = True
            elif player.vy < 0:
                player.top = p.bottom
            player.vy = 0

    # ---- monsters ----
    update_monsters()

    if player.hurt_timer > 0:
        player.hurt_timer -= dt

    for m in monsters:
        if overlaps(player, m):
            if player.hurt_timer <= 0:
                player.hp -= TOUCH_DAMAGE
                player.hurt_timer = HURT_COOLDOWN
                if player.hp <= 0:
                    respawn()
            break

    if player.top > HEIGHT:
        respawn()

def on_key_down(key):
    if key == keys.SPACE and player.on_ground:
        player.vy = JUMP_SPEED
        player.on_ground = False
    elif key == keys.R:
        respawn()

def respawn():
    player.pos = START_POS
    player.vx = 0
    player.vy = 0
    player.hp = MAX_HP
    player.hurt_timer = 0
    for m in monsters:
        m.midbottom = m.home
        m.vx = MONSTER_SPEED
        m.flip_x = False

def draw_health():
    bar = Rect(560, 12, 220, 26)
    screen.draw.filled_rect(bar, (30, 30, 40))
    if player.hp > 0:
        fill = Rect(bar.x, bar.y, bar.width * player.hp // MAX_HP, bar.height)
        screen.draw.filled_rect(fill, (200, 50, 50))
    screen.draw.rect(bar, (255, 255, 255))
    screen.draw.text("%d / %d" % (player.hp, MAX_HP), center=bar.center,
                     fontsize=24, color="white")

def draw():
    screen.fill((92, 148, 200))
    for p in platforms:
        p.draw()
    for m in monsters:
        m.draw()

    # blink five times a second while the mercy window is running
    if player.hurt_timer <= 0 or int(player.hurt_timer * 10) % 2 == 0:
        player.draw()

    screen.draw.text("A / D = move    SPACE = jump    R = respawn",
                     topleft=(10, 10), fontsize=28, color="white")
    draw_health()

pgzrun.go()