# CARGO-BOT # # Program a crane to move the crates! A pygame version of Cargo-Bot, the iPad # game by Two Lives Left that was later released as open source. # # Drag commands from the toolbox into program F1, then press PLAY. # LEFT and RIGHT move the crane. DOWN grabs a crate, or drops the one it holds. # F2, F3 and F4 run another program, then carry on. A program can even run itself! # Drag a colour onto a command so it only runs when the claw holds that colour. # Right-click a command to remove its colour, and again to remove the command. # Or click a toolbox tile to add it to the end of the selected program. # Keys: SPACE play/pause, S step, R reset, ESC level list. # # Fewer instructions earn more stars. Your programs are saved as you go. # # The game is split over files: # machine.py runs your programs (the computer inside the crane) # levels.py every level as a few lines of text: easy to add your own # storage.py saves your progress # # Try this: # 1. Design a level of your own in levels.py. # 2. Make purple crates (hint: machine.py, levels.py and CRATE_COLOURS here). # 3. Show how many steps the program took when a level is complete. import asyncio import math import pygame try: import pygameonline # PygameOnline achievements (not on a normal desktop Python) except ImportError: pygameonline = None from levels import LEVELS, unpack from machine import CONDITIONS, Machine, count_instructions from storage import load_progress, save_progress WIDTH, HEIGHT = 960, 640 TILE = 44 GAP = 6 BACKGROUND = (22, 24, 34) PANEL = (34, 38, 54) PANEL_LIGHT = (50, 56, 78) LINE = (72, 80, 108) TEXT = (232, 234, 242) DIM = (150, 156, 178) COMMAND = (70, 84, 116) CALL = (112, 80, 162) HIGHLIGHT = (255, 214, 90) DANGER = (240, 96, 96) SUCCESS = (110, 210, 120) CRANE = (240, 168, 48) STAR = (255, 204, 64) CRATE_COLOURS = {"red": (222, 72, 72), "green": (76, 186, 92), "blue": (70, 130, 232), "yellow": (238, 198, 58)} SCENE = pygame.Rect(16, 52, 620, 290) GOAL = pygame.Rect(652, 52, 292, 122) HINT = pygame.Rect(652, 182, 292, 108) CALLS = pygame.Rect(652, 418, 292, 206) TOOLBOX_Y = 360 PROGRAM_Y = 424 ROW_H = 52 CRATE = 32 FLOOR = SCENE.bottom - 18 RAIL = SCENE.top + 16 REST = SCENE.top + 50 # where the claw waits, raised above the tallest stack SPEEDS = [1, 2.5, 6] DURATION = {"move": 0.35, "down": 0.55, "bump": 0.4, "call": 0.12, "skip": 0.15, "end": 0.01} TIPS = { "left": "LEFT: move the crane one step left", "right": "RIGHT: move the crane one step right", "down": "DOWN: grab a crate, or drop the one the claw holds", "f1": "F1: run program F1 from the top", "f2": "F2: run program F2, then carry on", "f3": "F3: run program F3, then carry on", "f4": "F4: run program F4, then carry on", "red": "Red: only run when the claw holds a red crate", "green": "Green: only run when the claw holds a green crate", "blue": "Blue: only run when the claw holds a blue crate", "yellow": "Yellow: only run when the claw holds a yellow crate", "any": "Any colour: only run when the claw holds a crate", "none": "Empty: only run when the claw holds nothing", } def stars_for(count, par): if count <= par: return 3 return 2 if count <= par + max(2, par // 2) else 1 def level_key(name): """The PygameOnline achievement for beating a level: "Long Haul" -> "cargo-bot-long-haul".""" return "cargo-bot-" + name.lower().replace(" ", "-") def lerp(a, b, t): return a + (b - a) * t class App: def __init__(self): pygame.init() self.screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Cargo-Bot") self.fonts = {size: pygame.font.Font(None, size) for size in (16, 18, 20, 22, 24, 28, 32, 40, 64)} saved = load_progress() self.best = {k: v for k, v in saved.get("best", {}).items() if isinstance(v, int)} self.saved_programs = saved.get("programs", {}) self.view = "menu" self.mouse = (0, 0) self.speed = 0 self.drag = None self.asked = set() # ----- Saving and achievements ----------------------------------------- def save(self): self.saved_programs[self.level["name"]] = [[list(i) if i else None for i in code] for code in self.programs] save_progress({"best": self.best, "programs": self.saved_programs}) def unlock(self, key): if pygameonline and key not in self.asked: self.asked.add(key) pygameonline.unlock(key) # ----- Levels ------------------------------------------------------------ def open_level(self, index): self.index = index self.level = unpack(LEVELS[index]) slots = self.level["slots"] self.commands = ["left", "right", "down"] + [f"f{n + 1}" for n in range(len(slots))] self.conditions = [c for c in CONDITIONS if c in self.level.get("conditions", [])] self.programs = [[None] * size for size in slots] # Load the saved program, ignoring anything that doesn't fit this level. saved = self.saved_programs.get(self.level["name"], []) for p, code in enumerate(saved[:len(slots)]): for s, item in enumerate(code[:slots[p]]): if (isinstance(item, list) and len(item) == 2 and item[0] in self.commands and item[1] in [None] + self.conditions): self.programs[p][s] = (item[0], item[1]) self.tools = [] x = 16 for command in self.commands: self.tools.append(("command", command, pygame.Rect(x, TOOLBOX_Y, TILE, TILE))) x += TILE + GAP x += 24 for condition in self.conditions: self.tools.append(("condition", condition, pygame.Rect(x, TOOLBOX_Y, TILE, TILE))) x += TILE + GAP self.selected = 0 self.view = "level" self.reset() def reset(self): self.machine = Machine(self.level, self.programs) self.playing = False self.anim = None def edited(self): self.reset() self.save() def advance(self): event = self.machine.step() if event: self.anim = {"event": event, "t": 0.0, "dur": DURATION[event["kind"]]} if self.machine.status == "won": self.won() def won(self): name = self.level["name"] count = count_instructions(self.programs) if name not in self.best or count < self.best[name]: self.best[name] = count self.save() self.unlock(level_key(name)) # PygameOnline gives XP for each level beaten for p, code in enumerate(self.programs): if any(item and item[0] == f"f{p + 1}" for item in code): self.unlock("cargo-bot-recursion") if all(level["name"] in self.best for level in LEVELS): self.unlock("cargo-bot-all") if all(stars_for(self.best[level["name"]], level["par"]) == 3 for level in LEVELS): self.unlock("cargo-bot-three-stars") def toggle_play(self): if self.machine.status != "running": self.reset() self.playing = True else: self.playing = not self.playing def step_once(self): self.playing = False if self.machine.status != "running": self.reset() self.anim = None self.advance() def update(self, dt): if self.view != "level": return if self.anim: self.anim["t"] += dt * SPEEDS[self.speed] / self.anim["dur"] if self.anim["t"] >= 1: self.anim = None if self.anim is None and self.playing and self.machine.status == "running": self.advance() if self.machine.status != "running": self.playing = False # ----- Layout -------------------------------------------------------------- def slot_rect(self, program, slot): return pygame.Rect(72 + slot * (TILE + GAP), PROGRAM_Y + program * ROW_H, TILE, TILE) def label_rect(self, program): return pygame.Rect(16, PROGRAM_Y + program * ROW_H, 48, TILE) def slot_at(self, pos): for p, code in enumerate(self.programs): for s in range(len(code)): if self.slot_rect(p, s).collidepoint(pos): return p, s return None def buttons(self): names = ["Pause" if self.playing else "Play", "Step", "Reset", f"Speed {SPEEDS[self.speed]}x"] rects = [pygame.Rect(652 + i * 74, 300, 70, 40) for i in range(4)] return list(zip(["play", "step", "reset", "speed"], names, rects)) MENU_BUTTON = pygame.Rect(WIDTH - 112, 8, 96, 32) CLEAR_BUTTON = pygame.Rect(512, PROGRAM_Y + 166, 124, 36) NEXT_BUTTON = pygame.Rect(WIDTH // 2 + 10, 380, 170, 46) AGAIN_BUTTON = pygame.Rect(WIDTH // 2 - 180, 380, 170, 46) def menu_rect(self, index): return pygame.Rect(40 + (index % 4) * 226, 150 + (index // 4) * 132, 210, 116) def result_showing(self): return self.machine.status == "won" and self.anim is None # ----- Input ------------------------------------------------------------------ def handle(self, event): if event.type == pygame.MOUSEMOTION: self.mouse = event.pos if self.view == "menu": if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: for i in range(len(LEVELS)): if self.menu_rect(i).collidepoint(event.pos): self.open_level(i) return if event.type == pygame.KEYDOWN: if self.result_showing() and event.key in (pygame.K_RETURN, pygame.K_KP_ENTER): self.next_level() elif event.key == pygame.K_SPACE: self.toggle_play() elif event.key == pygame.K_s: self.step_once() elif event.key == pygame.K_r: self.reset() elif event.key == pygame.K_ESCAPE: self.view = "menu" elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: self.press(event.pos) elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 3: target = self.slot_at(event.pos) if target and self.programs[target[0]][target[1]]: p, s = target command, condition = self.programs[p][s] self.programs[p][s] = (command, None) if condition else None self.edited() elif event.type == pygame.MOUSEBUTTONUP and event.button == 1 and self.drag: self.drop(event.pos) def next_level(self): if self.index + 1 < len(LEVELS): self.open_level(self.index + 1) else: self.view = "menu" def press(self, pos): if self.result_showing(): if self.NEXT_BUTTON.collidepoint(pos): self.next_level() elif self.AGAIN_BUTTON.collidepoint(pos): self.reset() return if self.MENU_BUTTON.collidepoint(pos): self.view = "menu" return if self.CLEAR_BUTTON.collidepoint(pos): self.programs = [[None] * len(code) for code in self.programs] self.edited() return for name, _, rect in self.buttons(): if rect.collidepoint(pos): if name == "play": self.toggle_play() elif name == "step": self.step_once() elif name == "reset": self.reset() else: self.speed = (self.speed + 1) % len(SPEEDS) return for p in range(len(self.programs)): if self.label_rect(p).collidepoint(pos): self.selected = p return for kind, value, rect in self.tools: if rect.collidepoint(pos): self.drag = {"kind": kind, "value": value, "start": pos, "origin": None} return target = self.slot_at(pos) if target: p, s = target self.selected = p if self.programs[p][s]: self.drag = {"kind": "instruction", "value": self.programs[p][s], "start": pos, "origin": target} self.programs[p][s] = None self.reset() def drop(self, pos): drag, self.drag = self.drag, None moved = math.dist(pos, drag["start"]) > 6 target = self.slot_at(pos) code = self.programs[self.selected] filled = [s for s, item in enumerate(code) if item] if drag["kind"] == "instruction": if not moved: target = drag["origin"] # just a click: put it back if target: p, s = target old = self.programs[p][s] self.programs[p][s] = drag["value"] if old: # swap places with what was there op, os = drag["origin"] self.programs[op][os] = old # dropped outside the programs: deleted elif drag["kind"] == "command": if target and moved: p, s = target old = self.programs[p][s] self.programs[p][s] = (drag["value"], old[1] if old else None) elif not moved: # a click: add it after the last command of the selected program end = filled[-1] + 1 if filled else 0 if end < len(code): code[end] = (drag["value"], None) else: # condition if target and moved: p, s = target if self.programs[p][s]: self.programs[p][s] = (self.programs[p][s][0], drag["value"]) elif not moved and filled: # a click: colour the last command of the selected program code[filled[-1]] = (code[filled[-1]][0], drag["value"]) self.edited() # ----- Drawing ---------------------------------------------------------------------- def text(self, text, pos, size=22, colour=TEXT, anchor="topleft"): image = self.fonts[size].render(str(text), True, colour) rect = image.get_rect(**{anchor: pos}) self.screen.blit(image, rect) return rect def wrapped(self, text, rect, colour=DIM): """Draw text inside rect, shrinking the font until it fits.""" for size in (22, 20, 18, 16): font = self.fonts[size] lines, line = [], "" for word in text.split(): if font.size((line + " " + word).strip())[0] > rect.width: lines.append(line) line = word else: line = (line + " " + word).strip() lines.append(line) if len(lines) * font.get_linesize() <= rect.height: break for i, line in enumerate(lines): self.screen.blit(font.render(line, True, colour), (rect.x, rect.y + i * font.get_linesize())) def panel(self, rect, colour=PANEL, border=LINE, radius=10): pygame.draw.rect(self.screen, colour, rect, border_radius=radius) if border: pygame.draw.rect(self.screen, border, rect, 1, border_radius=radius) def button(self, rect, label, colour=PANEL_LIGHT): hover = rect.collidepoint(self.mouse) self.panel(rect, tuple(min(255, c + 18) for c in colour) if hover else colour) self.text(label, rect.center, 22, TEXT, "center") def crate(self, rect, colour): fill = CRATE_COLOURS[colour] dark = tuple(c * 3 // 5 for c in fill) pygame.draw.rect(self.screen, fill, rect, border_radius=3) pygame.draw.rect(self.screen, dark, rect, 2, border_radius=3) inner = rect.inflate(-rect.width // 3, -rect.height // 3) pygame.draw.rect(self.screen, dark, inner, 1) pygame.draw.line(self.screen, dark, inner.topleft, inner.bottomright) pygame.draw.line(self.screen, dark, inner.topright, inner.bottomleft) def condition_fill(self, rect, condition): """Paint a condition: a colour, four colours for "any", an empty box for "none".""" if condition in CRATE_COLOURS: pygame.draw.rect(self.screen, CRATE_COLOURS[condition], rect) elif condition == "any": w = rect.width / 4 for i, colour in enumerate(CRATE_COLOURS.values()): pygame.draw.rect(self.screen, colour, (rect.x + round(i * w), rect.y, math.ceil(w), rect.height)) else: pygame.draw.rect(self.screen, (16, 16, 22), rect) pygame.draw.rect(self.screen, TEXT, rect, 1) def instruction(self, rect, command, condition=None): colour = CALL if command.startswith("f") else COMMAND pygame.draw.rect(self.screen, colour, rect, border_radius=6) cx, cy = rect.centerx, rect.centery - (4 if condition else 0) if command == "left": pygame.draw.polygon(self.screen, TEXT, [(cx - 11, cy), (cx + 9, cy - 11), (cx + 9, cy + 11)]) elif command == "right": pygame.draw.polygon(self.screen, TEXT, [(cx + 11, cy), (cx - 9, cy - 11), (cx - 9, cy + 11)]) elif command == "down": pygame.draw.rect(self.screen, TEXT, (cx - 4, cy - 13, 8, 12)) pygame.draw.polygon(self.screen, TEXT, [(cx - 12, cy - 2), (cx + 12, cy - 2), (cx, cy + 12)]) else: self.text(command.upper(), (cx, cy), 28, TEXT, "center") if condition: band = pygame.Rect(rect.x + 4, rect.bottom - 11, rect.width - 8, 7) self.condition_fill(band, condition) def star(self, centre, radius, filled): points = [] for i in range(10): angle = -math.pi / 2 + i * math.pi / 5 r = radius if i % 2 == 0 else radius * 0.45 points.append((centre[0] + r * math.cos(angle), centre[1] + r * math.sin(angle))) if filled: pygame.draw.polygon(self.screen, STAR, points) else: pygame.draw.polygon(self.screen, LINE, points, 2) def column_x(self, column, count, area=SCENE): return area.left + (column + 0.5) * area.width / count def draw_scene(self): self.panel(SCENE, (28, 32, 46)) machine = self.machine count = len(machine.stacks) anim = self.anim event = anim["event"] if anim else {"kind": None} t = anim["t"] if anim else 0 bounce = t * 2 if t < 0.5 else 2 - t * 2 # 0 -> 1 -> 0, for going down and back up # Where the crane is, part-way through its current move. crane = machine.crane if event["kind"] == "move": crane = lerp(event["from"], event["to"], t) elif event["kind"] == "bump": crane += event["dir"] * 0.3 * math.sin(math.pi * t) crane_x = self.column_x(crane, count) claw = REST held = machine.held hidden = None # a crate in the stacks that's still in the claw, mid-drop extra = None # a crate the claw hasn't grabbed yet, mid-pick if event["kind"] == "down": target = FLOOR - (event["height"] + 1) * CRATE if event["crate"] else FLOOR - CRATE // 2 claw = lerp(REST, target, bounce) if t < 0.5 and event["crate"]: if event["pick"]: held, extra = None, (machine.crane, event["height"], event["crate"]) elif machine.held is None: held, hidden = event["crate"], machine.crane # Floor and stacks. for column, stack in enumerate(machine.stacks): x = self.column_x(column, count) pygame.draw.rect(self.screen, LINE, (x - 30, FLOOR, 60, 6), border_radius=2) crates = stack[:-1] if hidden == column else stack for height, colour in enumerate(crates): self.crate(pygame.Rect(x - CRATE // 2, FLOOR - (height + 1) * CRATE, CRATE, CRATE), colour) if extra: x = self.column_x(extra[0], count) self.crate(pygame.Rect(x - CRATE // 2, FLOOR - (extra[1] + 1) * CRATE, CRATE, CRATE), extra[2]) # The crane: a rail, a trolley, a cable and a claw. pygame.draw.line(self.screen, LINE, (SCENE.left + 10, RAIL), (SCENE.right - 10, RAIL), 4) pygame.draw.rect(self.screen, CRANE, (crane_x - 18, RAIL - 8, 36, 14), border_radius=3) pygame.draw.line(self.screen, DIM, (crane_x, RAIL + 6), (crane_x, claw - 10), 2) pygame.draw.rect(self.screen, CRANE, (crane_x - 22, claw - 12, 44, 8), border_radius=2) for side in (-1, 1): pygame.draw.rect(self.screen, CRANE, (crane_x + side * 20 - 2, claw - 8, 4, 18 if held else 12)) if held: self.crate(pygame.Rect(crane_x - CRATE // 2, claw, CRATE, CRATE), held) if machine.status in ("crashed", "finished") and not anim: banner = pygame.Rect(SCENE.x + 20, SCENE.y + 70, SCENE.width - 40, 44) self.panel(banner, (90, 36, 40), DANGER) self.text(machine.message, banner.center, 24, TEXT, "center") def draw_goal(self): self.panel(GOAL) self.text("Goal", (GOAL.x + 12, GOAL.y + 8), 22, DIM) size = 14 area = GOAL.inflate(-20, 0) floor = GOAL.bottom - 12 for column, stack in enumerate(self.level["goal"]): x = self.column_x(column, len(self.level["goal"]), area) pygame.draw.rect(self.screen, LINE, (x - 14, floor, 28, 3)) for height, colour in enumerate(stack): self.crate(pygame.Rect(x - size // 2, floor - (height + 1) * size, size, size), colour) def draw_programs(self): current = self.machine.current if self.machine.steps else None skipped = self.anim and self.anim["event"]["kind"] == "skip" hover = self.slot_at(self.mouse) if self.drag else None for p, code in enumerate(self.programs): label = self.label_rect(p) chosen = p == self.selected self.panel(label, CALL if chosen else PANEL, HIGHLIGHT if chosen else LINE, 6) self.text(f"F{p + 1}", label.center, 28, TEXT, "center") for s, item in enumerate(code): rect = self.slot_rect(p, s) pygame.draw.rect(self.screen, PANEL, rect, border_radius=6) pygame.draw.rect(self.screen, HIGHLIGHT if hover == (p, s) else LINE, rect, 1, border_radius=6) if item: self.instruction(rect, *item) if current == (p, s): pygame.draw.rect(self.screen, DIM if skipped else HIGHLIGHT, rect.inflate(6, 6), 3, border_radius=8) used = count_instructions(self.programs) par = self.level["par"] self.text("Instructions", (512, PROGRAM_Y), 20, DIM) self.text(used, (512, PROGRAM_Y + 18), 40) self.text(f"3 stars: {par} or fewer", (512, PROGRAM_Y + 52), 18, DIM) best = self.best.get(self.level["name"]) self.text("Best" if best else "Not solved yet", (512, PROGRAM_Y + 82), 20, DIM) if best: self.text(best, (556, PROGRAM_Y + 82), 20, TEXT) for i in range(3): self.star((522 + i * 26, PROGRAM_Y + 116), 11, i < stars_for(best, par)) self.button(self.CLEAR_BUTTON, "Clear all") def draw_call_stack(self): self.panel(CALLS) self.text("Call stack", (CALLS.x + 12, CALLS.y + 8), 22, DIM) frames = self.machine.frames if self.machine.steps and self.machine.status == "running" else [] if not frames: self.wrapped("When a program calls another, the caller waits here until it finishes.", pygame.Rect(CALLS.x + 12, CALLS.y + 36, CALLS.width - 24, 80)) return shown = min(len(frames), 6) for i in range(shown): program = frames[-1 - i][0] row = pygame.Rect(CALLS.x + 12, CALLS.y + 34 + i * 25, CALLS.width - 24, 22) self.panel(row, CALL if i == 0 else PANEL_LIGHT, None, 4) self.text(f"F{program + 1}", (row.x + 8, row.centery), 20, TEXT, "midleft") self.text("running" if i == 0 else "waiting", (row.right - 8, row.centery), 18, DIM, "midright") if len(frames) > shown: self.text(f"+ {len(frames) - shown} more waiting", (CALLS.x + 12, CALLS.y + 186), 18, DIM) def draw_toolbox(self): hover_tip = None for kind, value, rect in self.tools: if kind == "command": self.instruction(rect, value) else: pygame.draw.rect(self.screen, PANEL, rect, border_radius=6) self.condition_fill(rect.inflate(-10, -10), value) if rect.collidepoint(self.mouse) and not self.drag: pygame.draw.rect(self.screen, HIGHLIGHT, rect, 2, border_radius=6) hover_tip = TIPS[value] tip = hover_tip or "Drag tiles into a program. Right-click to remove." self.text(tip, (self.tools[-1][2].right + 24, TOOLBOX_Y + TILE // 2), 20, TEXT if hover_tip else DIM, "midleft") def draw_dragged(self): if not self.drag or math.dist(self.mouse, self.drag["start"]) <= 6: return rect = pygame.Rect(0, 0, TILE, TILE) rect.center = self.mouse if self.drag["kind"] == "condition": self.condition_fill(rect.inflate(-10, -10), self.drag["value"]) elif self.drag["kind"] == "command": self.instruction(rect, self.drag["value"]) else: self.instruction(rect, *self.drag["value"]) def draw_result(self): shade = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) shade.fill((0, 0, 0, 150)) self.screen.blit(shade, (0, 0)) box = pygame.Rect(0, 0, 440, 280) box.center = (WIDTH // 2, 300) self.panel(box, PANEL, SUCCESS, 14) self.text("Level complete!", (box.centerx, box.y + 40), 40, SUCCESS, "center") used = count_instructions(self.programs) par = self.level["par"] for i in range(3): self.star((box.centerx - 60 + i * 60, box.y + 100), 24, i < stars_for(used, par)) message = f"You used {used} instructions." if used <= par else f"You used {used}. Can you do it in {par}?" self.text(message, (box.centerx, box.y + 148), 24, TEXT, "center") self.button(self.AGAIN_BUTTON, "Try again") self.button(self.NEXT_BUTTON, "Next level" if self.index + 1 < len(LEVELS) else "All levels", CALL) def draw_level(self): self.text("CARGO-BOT", (16, 14), 32, CRANE) self.text(f"{self.index + 1}. {self.level['name']}", (WIDTH // 2, 24), 32, TEXT, "center") self.button(self.MENU_BUTTON, "Levels") self.draw_scene() self.draw_goal() self.panel(HINT) self.wrapped(self.level["hint"], HINT.inflate(-20, -16)) for name, label, rect in self.buttons(): self.button(rect, label, SUCCESS if name == "play" and not self.playing else PANEL_LIGHT) self.draw_toolbox() self.draw_programs() self.draw_call_stack() self.draw_dragged() if self.result_showing(): self.draw_result() def draw_menu(self): self.text("CARGO-BOT", (WIDTH // 2, 56), 64, CRANE, "center") self.text("Program the crane to move the crates. Small programs can run other programs, and even themselves.", (WIDTH // 2, 104), 22, DIM, "center") total = 0 for i, level in enumerate(LEVELS): rect = self.menu_rect(i) best = self.best.get(level["name"]) stars = stars_for(best, level["par"]) if best else 0 total += stars self.panel(rect, PANEL_LIGHT if rect.collidepoint(self.mouse) else PANEL, SUCCESS if best else LINE, 12) self.text(i + 1, (rect.x + 14, rect.y + 12), 40, DIM) self.text(level["name"], (rect.x + 14, rect.y + 52), 28, TEXT) for s in range(3): self.star((rect.x + 26 + s * 30, rect.bottom - 24), 12, s < stars) self.text(f"Stars: {total} / {len(LEVELS) * 3}", (WIDTH // 2, HEIGHT - 70), 28, STAR, "center") self.text("Based on Cargo-Bot by Two Lives Left.", (WIDTH // 2, HEIGHT - 36), 20, DIM, "center") def draw(self): self.screen.fill(BACKGROUND) if self.view == "menu": self.draw_menu() else: self.draw_level() pygame.display.flip() async def main(): app = App() clock = pygame.time.Clock() while True: for event in pygame.event.get(): if event.type == pygame.QUIT: return app.handle(event) app.update(clock.tick(60) / 1000) app.draw() await asyncio.sleep(0) asyncio.run(main())