| |
| """Eight original in-session Codex teacher games. Admission still needs Godot.""" |
| from pathlib import Path |
| import hashlib |
| import json |
| import sys |
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT / 'src')) |
| from vibegame.seeds import PROJECT, SCENE, UI |
| from vibegame.project import parse_project |
|
|
| SCRIPTS = [ |
| '''extends Node2D |
| var lane = 0 |
| var progress = 0.0 |
| var lost = false |
| var gaps = [1,0,1,1,0,0,1,0,1,0,0,1] |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| lane = 0 |
| progress = 0.0 |
| lost = false |
| if not lost and progress < 12.0: |
| if Input.is_action_just_pressed("ui_left"): |
| lane = 0 |
| if Input.is_action_just_pressed("ui_right"): |
| lane = 1 |
| var before = int(progress) |
| progress += dt * 0.7 |
| if int(progress) > before and lane == gaps[before]: |
| lost = true |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("RAIL SWITCH", "Left / Right: select rail | Avoid dark gaps | R: restart") |
| for i in range(12): |
| var y = 490.0 + (progress - float(i + 1)) * 145.0 |
| if y > 80 and y < 640: |
| for track in range(2): |
| var color = Color("354866") if gaps[i] != track else Color("090b16") |
| draw_rect(Rect2(300 + track * 260, y - 80, 100, 110), color) |
| var finish_y = 490.0 + (progress - 12.0) * 145.0 |
| if finish_y > 100: |
| draw_line(Vector2(280, finish_y), Vector2(690, finish_y), Color("ffdc75"), 8) |
| draw_circle(Vector2(350 + lane * 260, 490), 22, Color("5ef2d0")) |
| draw_line(Vector2(350 + lane * 260, 490), Vector2(350 + lane * 260, 490) + Vector2.from_angle(progress * 8) * 18, Color.WHITE, 3) |
| text_at("Sections %d / 12" % mini(int(progress), 12), Vector2(26, 620)) |
| if lost or progress >= 12: |
| text_at("Missing rail! R to retry" if lost else "Finish reached! R to replay", Vector2(245, 320), 30) |
| ''', |
| '''extends Node2D |
| var shield = Rect2(345, 385, 270, 15) |
| var drag_start = Vector2.ZERO |
| var dragging = false |
| var umbrella = true |
| var drops: Array[Vector3] = [] |
| var spawn = 0.0 |
| var elapsed = 0.0 |
| var health = 5 |
| var water = 7.0 |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| drops.clear() |
| elapsed = 0.0 |
| health = 5 |
| water = 7.0 |
| shield = Rect2(345, 385, 270, 15) |
| umbrella = true |
| spawn = 0 |
| dragging = false |
| if health > 0 and water > 0 and elapsed < 30: |
| elapsed += dt |
| water -= dt * 0.5 |
| var mouse = get_global_mouse_position().clamp(Vector2(230, 145), Vector2(730, 485)) |
| if Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT): |
| if not dragging: |
| drag_start = mouse |
| dragging = true |
| shield = Rect2(drag_start, mouse - drag_start).abs() |
| shield.size = shield.size.max(Vector2(24, 12)) |
| else: |
| dragging = false |
| if Input.is_action_just_pressed("ui_accept"): |
| umbrella = not umbrella |
| spawn -= dt |
| if spawn <= 0: |
| spawn = 0.45 |
| drops.append(Vector3(randf_range(250, 710), 105, 1 if randf() < 0.65 else 0)) |
| for i in range(drops.size() - 1, -1, -1): |
| drops[i].y += 180 * dt |
| if shield.has_point(Vector2(drops[i].x, drops[i].y)): |
| if (umbrella and drops[i].z == 0) or (not umbrella and drops[i].z == 1): |
| drops.remove_at(i) |
| continue |
| if drops[i].y > 550: |
| if drops[i].z == 0: |
| health -= 1 |
| else: |
| water = minf(12, water + 1) |
| drops.remove_at(i) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("GARDEN GUARD", "Drag mouse: draw shield | Space: stone mesh / rain cover | R: restart") |
| draw_rect(Rect2(230, 555, 500, 45), Color("456735")) |
| for x in range(270, 720, 50): |
| draw_line(Vector2(x, 555), Vector2(x, 525), Color("5ef2d0"), 5) |
| for drop in drops: |
| draw_circle(Vector2(drop.x, drop.y), 10, Color("69baff") if drop.z == 1 else Color("ad8790")) |
| draw_rect(shield, Color("ffdc75") if umbrella else Color("69baff"), false, 4) |
| text_at("%s | Health %d | Water %.1f | %.0f / 30s" % ["Stone mesh" if umbrella else "Rain cover", health, water, elapsed], Vector2(30, 625), 21) |
| if health <= 0 or water <= 0 or elapsed >= 30: |
| text_at("Garden saved!" if elapsed >= 30 else "Garden lost. R to retry", Vector2(300, 270), 30) |
| ''', |
| '''extends Node2D |
| var a = Vector2(70, 350) |
| var b = Vector2(340, 60) |
| var goal_a = Vector2(340, 60) |
| var goal_b = Vector2(70, 350) |
| var walls_a = [Rect2(140, 170, 130, 28), Rect2(70, 260, 80, 28)] |
| var walls_b = [Rect2(180, 235, 150, 28), Rect2(110, 95, 28, 90)] |
| var won = false |
| func move_piece(p: Vector2, motion: Vector2, walls: Array) -> Vector2: |
| for axis in range(2): |
| var candidate = p |
| candidate[axis] += motion[axis] |
| candidate = candidate.clamp(Vector2(16, 16), Vector2(394, 424)) |
| var blocked = false |
| for wall in walls: |
| if wall.grow(12).has_point(candidate): |
| blocked = true |
| if not blocked: |
| p = candidate |
| return p |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| a = Vector2(70, 350) |
| b = Vector2(340, 60) |
| won = false |
| if not won: |
| var motion = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down") * 170 * dt |
| a = move_piece(a, motion, walls_a) |
| b = move_piece(b, -motion, walls_b) |
| won = a.distance_to(goal_a) < 20 and b.distance_to(goal_b) < 20 |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("MIRROR PARTNERS", "Arrows move both in opposite directions | Reach both gold pads | R: restart") |
| var offsets = [Vector2(35, 135), Vector2(515, 135)] |
| for i in range(2): |
| var off = offsets[i] |
| draw_rect(Rect2(off, Vector2(410, 440)), Color("172541")) |
| var walls = walls_a if i == 0 else walls_b |
| for wall in walls: |
| draw_rect(Rect2(off + wall.position, wall.size), Color("546783")) |
| draw_circle(off + (goal_a if i == 0 else goal_b), 23, Color("ffdc75")) |
| draw_circle(off + (a if i == 0 else b), 12, Color("5ef2d0") if i == 0 else Color("e69fff")) |
| text_at("Both pads occupied!" if won else "Walls stop each piece independently. Find the route.", Vector2(90, 625), 24) |
| ''', |
| '''extends Node2D |
| var rider = Vector2(100, 330) |
| var parcels = [Vector2(170, 170), Vector2(360, 480), Vector2(480, 230)] |
| var doors = [Vector2(820, 170), Vector2(800, 450), Vector2(660, 300)] |
| var colors = [Color("ff647e"), Color("5ef2d0"), Color("ffdc75")] |
| var delivered = [false, false, false] |
| var carried = -1 |
| var remaining = 45.0 |
| var count = 0 |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| rider = Vector2(100, 330) |
| delivered = [false, false, false] |
| carried = -1 |
| remaining = 45.0 |
| count = 0 |
| if remaining > 0 and count < 3: |
| remaining = maxf(0, remaining - dt) |
| rider += Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down") * 210 * dt |
| rider = rider.clamp(Vector2(25, 115), Vector2(935, 580)) |
| if carried < 0: |
| for i in range(3): |
| if not delivered[i] and rider.distance_to(parcels[i]) < 26: |
| carried = i |
| break |
| elif rider.distance_to(doors[carried]) < 35: |
| delivered[carried] = true |
| carried = -1 |
| count += 1 |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("PARCEL PEDAL", "Arrows: bicycle | Touch parcel, then matching door | Carry one | R: restart") |
| for i in range(3): |
| draw_rect(Rect2(doors[i] - Vector2(24, 32), Vector2(48, 64)), colors[i].darkened(0.3)) |
| text_at("OK" if delivered[i] else str(i + 1), doors[i] + Vector2(-15, 6), 22) |
| if not delivered[i] and carried != i: |
| draw_rect(Rect2(parcels[i] - Vector2(12, 12), Vector2(24, 24)), colors[i]) |
| draw_circle(rider + Vector2(-12, 10), 9, Color.WHITE, false, 3) |
| draw_circle(rider + Vector2(12, 10), 9, Color.WHITE, false, 3) |
| draw_line(rider + Vector2(-12, 10), rider + Vector2(0, -8), Color("69baff"), 4) |
| draw_line(rider + Vector2(0, -8), rider + Vector2(12, 10), Color("69baff"), 4) |
| if carried >= 0: |
| draw_rect(Rect2(rider + Vector2(-8, -26), Vector2(16, 16)), colors[carried]) |
| text_at("Delivered %d / 3 | Time %.1f" % [count, remaining], Vector2(25, 625)) |
| if remaining <= 0 or count == 3: |
| text_at("All delivered!" if count == 3 else "Time ran out. R to retry", Vector2(295, 370), 30) |
| ''', |
| '''extends Node2D |
| var angle = 0.0 |
| var direction = 1.0 |
| var objects: Array[Vector3] = [] |
| var spawn = 0.0 |
| var stars = 0 |
| var lives = 3 |
| var center = Vector2(480, 360) |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| stars = 0 |
| lives = 3 |
| angle = 0 |
| spawn = 0 |
| direction = 1 |
| objects.clear() |
| if lives > 0 and stars < 8: |
| if Input.is_action_just_pressed("ui_accept"): |
| direction = -direction |
| angle += dt * direction * 1.7 |
| spawn -= dt |
| if spawn <= 0: |
| spawn = 1.1 |
| objects.append(Vector3(randf_range(-PI, PI), 320, 1 if randf() < 0.65 else 0)) |
| var satellite = center + Vector2.from_angle(angle) * 185 |
| for i in range(objects.size() - 1, -1, -1): |
| objects[i].y -= dt * 90 |
| var p = center + Vector2.from_angle(objects[i].x) * objects[i].y |
| if satellite.distance_to(p) < 26: |
| if objects[i].z == 1: |
| stars += 1 |
| else: |
| lives -= 1 |
| objects.remove_at(i) |
| elif objects[i].y < 50: |
| objects.remove_at(i) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("ORBIT FLIP", "Space: reverse direction | Collect 8 gold stars, avoid red debris | R: restart") |
| draw_circle(center, 185, Color("334970"), false, 2) |
| draw_circle(center, 55, Color("4267a0")) |
| for obj in objects: |
| var p = center + Vector2.from_angle(obj.x) * obj.y |
| if obj.z == 1: |
| draw_colored_polygon(PackedVector2Array([p + Vector2(0,-13), p + Vector2(10,0), p + Vector2(0,13), p + Vector2(-10,0)]), Color("ffdc75")) |
| else: |
| draw_circle(p, 14, Color("ff647e")) |
| draw_circle(center + Vector2.from_angle(angle) * 185, 12, Color("5ef2d0")) |
| text_at("Stars %d / 8 | Lives %d" % [stars, lives], Vector2(25, 625)) |
| if lives <= 0 or stars >= 8: |
| text_at("Orbit mastered!" if stars >= 8 else "Satellite lost. R to retry", Vector2(305, 365), 26) |
| ''', |
| '''extends Node2D |
| var p = Vector2(75, 520) |
| var velocity = 0.0 |
| var gravity = 1.0 |
| var deaths = 0 |
| var won = false |
| var platforms = [Rect2(0, 600, 960, 18), Rect2(0, 100, 960, 18), Rect2(170, 410, 240, 18), Rect2(470, 270, 230, 18), Rect2(760, 460, 160, 18)] |
| var spikes = [Rect2(230, 580, 150, 20), Rect2(530, 118, 145, 20)] |
| var goal = Rect2(860, 365, 48, 80) |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| p = Vector2(75, 520) |
| velocity = 0 |
| gravity = 1 |
| deaths = 0 |
| won = false |
| if not won: |
| if Input.is_action_just_pressed("ui_accept"): |
| gravity = -gravity |
| velocity = 0 |
| p.x = clampf(p.x + Input.get_axis("ui_left", "ui_right") * 220 * dt, 12, 948) |
| var old_y = p.y |
| velocity = clampf(velocity + gravity * 500 * dt, -300, 300) |
| p.y += velocity * dt |
| for ledge in platforms: |
| if p.x + 12 > ledge.position.x and p.x - 12 < ledge.end.x: |
| if velocity > 0 and old_y + 12 <= ledge.position.y and p.y + 12 >= ledge.position.y: |
| p.y = ledge.position.y - 12 |
| velocity = 0 |
| elif velocity < 0 and old_y - 12 >= ledge.end.y and p.y - 12 <= ledge.end.y: |
| p.y = ledge.end.y + 12 |
| velocity = 0 |
| for spike in spikes: |
| if spike.grow(11).has_point(p): |
| p = Vector2(75, 520) |
| velocity = 0 |
| gravity = 1 |
| deaths += 1 |
| won = goal.has_point(p) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("GRAVITY SWITCH", "Left / Right: move | Space: reverse gravity | Reach green door | R: restart") |
| for ledge in platforms: |
| draw_rect(ledge, Color("506383")) |
| for spike in spikes: |
| draw_rect(spike, Color("ff647e")) |
| draw_rect(goal, Color("28795c")) |
| draw_rect(Rect2(p - Vector2(12,12), Vector2(24,24)), Color("5ef2d0")) |
| text_at("Falls %s | Resets %d" % ["down" if gravity > 0 else "up", deaths], Vector2(25, 633), 21) |
| if won: |
| text_at("Door reached! R to replay", Vector2(275, 350), 30) |
| ''', |
| '''extends Node2D |
| var parcels: Array[Vector2] = [] |
| var junction = 0 |
| var spawn = 0.0 |
| var quota = 0 |
| var misses = 0 |
| var colors = [Color("ff647e"), Color("5ef2d0"), Color("ffdc75")] |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| parcels.clear() |
| quota = 0 |
| misses = 0 |
| spawn = 0 |
| junction = 0 |
| if quota < 12 and misses < 5: |
| if Input.is_action_just_pressed("ui_up"): |
| junction = maxi(0, junction - 1) |
| if Input.is_action_just_pressed("ui_down"): |
| junction = mini(2, junction + 1) |
| spawn -= dt |
| if spawn <= 0: |
| spawn = 1.6 |
| parcels.append(Vector2(30, randi_range(0, 2))) |
| for i in range(parcels.size() - 1, -1, -1): |
| parcels[i].x += 155 * dt |
| if parcels[i].x >= 725: |
| if int(parcels[i].y) == junction: |
| quota += 1 |
| else: |
| misses += 1 |
| parcels.remove_at(i) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("SORTING SHIFT", "Up / Down: choose bin before object reaches junction | 12 correct to win | R: restart") |
| draw_rect(Rect2(20, 320, 710, 65), Color("354866")) |
| for i in range(3): |
| draw_line(Vector2(725, 350), Vector2(835, 185 + i * 150), colors[i].darkened(0.5), 8) |
| draw_rect(Rect2(825, 145 + i * 150, 110, 85), colors[i].darkened(0.3)) |
| text_at(["CIRCLE", "SQUARE", "TRIANGLE"][i], Vector2(830, 194 + i * 150), 17) |
| draw_line(Vector2(725,350), Vector2(835,185 + junction * 150), Color.WHITE, 4) |
| for parcel in parcels: |
| var p = Vector2(parcel.x, 350) |
| if parcel.y == 0: |
| draw_circle(p, 17, colors[0]) |
| elif parcel.y == 1: |
| draw_rect(Rect2(p - Vector2(16,16), Vector2(32,32)), colors[1]) |
| else: |
| draw_colored_polygon(PackedVector2Array([p + Vector2(0,-19), p + Vector2(-19,17), p + Vector2(19,17)]), colors[2]) |
| text_at("Quota %d / 12 | Mistakes %d / 5" % [quota, misses], Vector2(25, 625)) |
| if quota >= 12 or misses >= 5: |
| text_at("Shift complete!" if quota >= 12 else "Too many mistakes. R to retry", Vector2(225, 245), 28) |
| ''', |
| '''extends Node2D |
| var a = Vector2(100, 230) |
| var b = Vector2(100, 460) |
| var switch_a = Vector2(440, 230) |
| var switch_b = Vector2(440, 460) |
| var unlocked = false |
| var won = false |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| a = Vector2(100,230) |
| b = Vector2(100,460) |
| unlocked = false |
| won = false |
| if not won: |
| var wasd = Vector2(float(Input.is_physical_key_pressed(KEY_D)) - float(Input.is_physical_key_pressed(KEY_A)), float(Input.is_physical_key_pressed(KEY_S)) - float(Input.is_physical_key_pressed(KEY_W))) |
| a += wasd.limit_length() * 220 * dt |
| b += Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down") * 220 * dt |
| a = a.clamp(Vector2(35,140), Vector2(925 if unlocked else 665,310)) |
| b = b.clamp(Vector2(35,370), Vector2(925 if unlocked else 665,540)) |
| if a.distance_to(switch_a) < 25 and b.distance_to(switch_b) < 25: |
| unlocked = true |
| won = unlocked and a.x > 850 and b.x > 850 |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("TWO BOXES, ONE PLAN", "Cyan: WASD | Purple: arrows | Occupy both switches, then exits | R: restart") |
| for y in [125,355]: |
| draw_rect(Rect2(20,y,920,200), Color("172541")) |
| draw_circle(switch_a, 26, Color("5ef2d0") if a.distance_to(switch_a) < 25 else Color("60583b")) |
| draw_circle(switch_b, 26, Color("e69fff") if b.distance_to(switch_b) < 25 else Color("60583b")) |
| for y in [140,370]: |
| draw_rect(Rect2(850,y,75,170), Color("28795c")) |
| if not unlocked: |
| draw_rect(Rect2(680,y,18,170), Color("ff647e")) |
| draw_rect(Rect2(a - Vector2(14,14), Vector2(28,28)), Color("5ef2d0")) |
| draw_rect(Rect2(b - Vector2(14,14), Vector2(28,28)), Color("e69fff")) |
| text_at("Both escaped!" if won else ("Gates latched open. Reach both exits." if unlocked else "Leave one box on its switch while moving the other."), Vector2(70,615), 23) |
| ''' |
| ] |
|
|
| def main(): |
| prompts = [json.loads(line) for line in (ROOT / 'data/teacher_prompts.jsonl').read_text().splitlines()][:8] |
| rows = [] |
| provenance = [] |
| for prompt, script in zip(prompts, SCRIPTS): |
| files = {'project.godot': PROJECT % prompt['id'], 'main.tscn': SCENE, 'main.gd': script + UI} |
| output = json.dumps({'files': files}, ensure_ascii=False) |
| parse_project(output) |
| rows.append({'instruction': prompt['instruction'], 'output': output}) |
| provenance.append({'id': prompt['id'], 'output_sha256': hashlib.sha256(output.encode()).hexdigest(), 'author': 'in-session Codex assistant', 'license': 'Apache-2.0', 'origin': 'Original gameplay authored here; fixed original project/scene/UI helper. Not a Qwen teacher output.', 'validation': 'Static project contract only; requires separate Linux Godot import and full 60s run before training.'}) |
| out = ROOT / 'data/codex_teacher_batch_root.jsonl' |
| out.write_text(''.join(json.dumps(row, ensure_ascii=False) + '\n' for row in rows)) |
| out.with_name('codex_teacher_batch_root_provenance.json').write_text(json.dumps(provenance, indent=2) + '\n') |
| print('Wrote', len(rows), 'original teacher candidates; runtime admission pending') |
|
|
| if __name__ == '__main__': |
| main() |
|
|
