| |
| """Materialize 32 original in-session Codex-authored games; no model/API call. |
| |
| This is authorship tooling, not a claim of executed Godot validation. Admission |
| requires the separate Linux engine import and full 60-second runtime check. |
| """ |
| import hashlib |
| import json |
| from pathlib import Path |
| import sys |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT / "src")) |
| from vibegame.project import parse_project, project_sha256 |
|
|
| PROJECT = '''config_version=5 |
| [application] |
| config/name="%s" |
| run/main_scene="res://main.tscn" |
| [display] |
| window/size/viewport_width=960 |
| window/size/viewport_height=640 |
| [rendering] |
| renderer/rendering_method="gl_compatibility" |
| environment/defaults/default_clear_color=Color(0.035, 0.047, 0.09, 1) |
| ''' |
| SCENE = '''[gd_scene load_steps=2 format=3] |
| [ext_resource type="Script" path="res://main.gd" id="1"] |
| [node name="Game" type="Node2D"] |
| script = ExtResource("1") |
| ''' |
| HELPERS = ''' |
| func text_at(s: String, p: Vector2, size: int = 22, color: Color = Color.WHITE) -> void: |
| \tdraw_string(ThemeDB.fallback_font, p, s, HORIZONTAL_ALIGNMENT_LEFT, -1, size, color) |
| func backdrop(title: String, controls: String) -> void: |
| \tdraw_rect(Rect2(0, 0, 960, 88), Color("121d35")) |
| \ttext_at(title, Vector2(24, 35), 27, Color("5ef2d0")) |
| \ttext_at(controls, Vector2(24, 68), 17, Color("c1cfe8")) |
| ''' |
| GAMES = {} |
| GAMES[21] = ("Four Floor Courier", '''extends Node2D |
| var people: Array[Dictionary] = [] |
| var cabin: float = 520.0 |
| var remaining: float = 100.0 |
| var delivered: int = 0 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| people.clear() |
| for i in range(8): |
| people.append({"floor": i % 4, "dest": (i % 4 + 1 + i / 4) % 4, "state": 0}) |
| cabin = 520.0 |
| remaining = 100.0 |
| delivered = 0 |
| outcome = "" |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| remaining -= dt |
| cabin = clampf(cabin + Input.get_axis("ui_up", "ui_down") * 170.0 * dt, 160, 520) |
| for floor in range(4): |
| if absf(cabin - (520.0 - floor * 120.0)) < 9.0: |
| for p in people: |
| if p["state"] == 1 and p["dest"] == floor: |
| p["state"] = 2 |
| delivered += 1 |
| var onboard: int = 0 |
| for p in people: |
| if p["state"] == 1: |
| onboard += 1 |
| for p in people: |
| if p["state"] == 0 and p["floor"] == floor and onboard < 2: |
| p["state"] = 1 |
| onboard += 1 |
| if delivered == 8: |
| outcome = "All eight passengers delivered! R: new shift" |
| elif remaining <= 0: |
| outcome = "Shift ended before all deliveries. R: retry" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("FOUR FLOOR COURIER", "Up / Down: elevator | Automatic pickup and drop-off | Capacity 2 | R: restart") |
| for floor in range(4): |
| var y: float = 520.0 - floor * 120.0 |
| draw_line(Vector2(90, y + 22), Vector2(750, y + 22), Color("46617d"), 3) |
| text_at("FLOOR %d" % (floor + 1), Vector2(760, y), 20) |
| draw_rect(Rect2(447, 115, 86, 452), Color("30455f"), false, 3) |
| draw_rect(Rect2(452, cabin - 44, 76, 66), Color("5ef2d0"), false, 4) |
| var seat: int = 0 |
| for i in range(people.size()): |
| var p: Dictionary = people[i] |
| if p["state"] == 2: |
| continue |
| var pos: Vector2 = Vector2(180 + (i / 4) * 75, 520 - int(p["floor"]) * 120) |
| if p["state"] == 1: |
| pos = Vector2(468 + seat * 32, cabin) |
| seat += 1 |
| draw_circle(pos, 12, Color("ffcd6b")) |
| text_at(str(int(p["dest"]) + 1), pos + Vector2(-6, -20), 20) |
| text_at("Delivered %d / 8 Time %d" % [delivered, ceili(remaining)], Vector2(28, 606)) |
| if outcome != "": |
| text_at(outcome, Vector2(170, 110), 23) |
| ''') |
| GAMES[22] = ("Counterweight", '''extends Node2D |
| var balls: Array[float] = [-100.0, 0.0, 100.0] |
| var speeds: Array[float] = [10.0, -14.0, 6.0] |
| var weight: float = 0.0 |
| var angle: float = 0.0 |
| var spin: float = 0.0 |
| var timer: float = 30.0 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| balls = [-100.0, 0.0, 100.0] |
| speeds = [10.0, -14.0, 6.0] |
| weight = 0.0 |
| angle = 0.0 |
| spin = 0.0 |
| timer = 30.0 |
| outcome = "" |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| timer -= dt |
| weight = clampf(weight + Input.get_axis("ui_left", "ui_right") * 160.0 * dt, -195, 195) |
| var torque: float = (balls[0] + balls[1] + balls[2] + weight * 3.0) * 0.0007 |
| spin += (torque - angle * 0.5 - spin * 1.5) * dt |
| angle = clampf(angle + spin * dt, -0.6, 0.6) |
| for i in range(3): |
| speeds[i] += (sin(angle) * 220.0 - speeds[i] * 0.08) * dt |
| balls[i] += speeds[i] * dt |
| if absf(balls[i]) > 220: |
| outcome = "A ball fell! Move the counterweight earlier. R: retry" |
| if timer <= 0 and outcome == "": |
| outcome = "Balanced for thirty seconds! R: play again" |
| queue_redraw() |
| func point(x: float, y: float = 0.0) -> Vector2: |
| return Vector2(480, 350) + Vector2(x, y).rotated(angle) |
| func _draw() -> void: |
| backdrop("COUNTERWEIGHT", "Left / Right: move the gold weight | Keep all three balls aboard for 30 seconds | R: restart") |
| draw_colored_polygon(PackedVector2Array([Vector2(450, 460), Vector2(510, 460), Vector2(480, 350)]), Color("46617d")) |
| draw_line(point(-230), point(230), Color("c1cfe8"), 12) |
| for i in range(3): |
| draw_circle(point(balls[i], -20), 14, Color.from_hsv(i * 0.2 + 0.45, 0.7, 1.0)) |
| draw_circle(point(weight, 28), 18, Color("ffcd6b")) |
| text_at("Time left %.1f Plank tilt %.1f degrees" % [maxf(timer, 0), rad_to_deg(angle)], Vector2(180, 530)) |
| if outcome != "": |
| text_at(outcome, Vector2(130, 580), 23) |
| ''') |
| GAMES[23] = ("Two Pan Kitchen", '''extends Node2D |
| var heat: Array[float] = [0.0, 0.0] |
| var cooking: Array[bool] = [false, false] |
| var plates: int = 0 |
| var mistakes: int = 0 |
| var time_left: float = 60.0 |
| var message: String = "Click a cold pan to begin. Click again to serve." |
| var outcome: String = "" |
| func pan_rect(i: int) -> Rect2: |
| return Rect2(190 + i * 340, 170, 220, 230) |
| func reset() -> void: |
| heat = [0.0, 0.0] |
| cooking = [false, false] |
| plates = 0 |
| mistakes = 0 |
| time_left = 60.0 |
| outcome = "" |
| message = "Click a cold pan to begin. Click again to serve." |
| func _input(event: InputEvent) -> void: |
| if event is InputEventKey and event.pressed and event.keycode == KEY_R: |
| reset() |
| if outcome != "": |
| return |
| if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT: |
| for i in range(2): |
| if pan_rect(i).has_point(event.position): |
| if not cooking[i]: |
| cooking[i] = true |
| elif heat[i] >= 65 and heat[i] <= 85: |
| plates += 1 |
| message = "Perfectly served!" |
| cooking[i] = false |
| heat[i] = 0 |
| else: |
| mistakes += 1 |
| message = "Too cold or too hot!" |
| cooking[i] = false |
| heat[i] = 0 |
| func _process(dt: float) -> void: |
| if outcome == "": |
| time_left -= dt |
| for i in range(2): |
| if cooking[i]: |
| heat[i] += (20.0 + i * 7.0) * dt |
| if heat[i] >= 100: |
| mistakes += 1 |
| cooking[i] = false |
| heat[i] = 0 |
| message = "Burned!" |
| if plates >= 6: |
| outcome = "Six plates served. Kitchen complete!" |
| elif mistakes >= 3 or time_left <= 0: |
| outcome = "Kitchen closed. R: try another shift" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("TWO PAN KITCHEN", "Click pan: start / serve | Serve between 65 and 85 degrees | Six plates, fewer than 3 mistakes | R: restart") |
| for i in range(2): |
| var r: Rect2 = pan_rect(i) |
| draw_rect(r, Color("23344c")) |
| draw_circle(r.position + Vector2(110, 90), 67, Color("ff875b") if cooking[i] else Color("718199")) |
| text_at("PAN %d" % (i + 1), r.position + Vector2(65, 95)) |
| draw_rect(Rect2(r.position + Vector2(10, 174), Vector2(200, 26)), Color("142037")) |
| draw_rect(Rect2(r.position + Vector2(140, 174), Vector2(40, 26)), Color("25855f")) |
| draw_line(r.position + Vector2(10 + heat[i] * 2, 170), r.position + Vector2(10 + heat[i] * 2, 205), Color.WHITE, 4) |
| text_at("%.0f degrees" % heat[i], r.position + Vector2(43, 225)) |
| text_at("Plates %d / 6 Mistakes %d / 3 Time %d" % [plates, mistakes, ceili(maxf(0, time_left))], Vector2(220, 470)) |
| text_at(message, Vector2(180, 520)) |
| text_at(outcome, Vector2(170, 575), 25, Color("ffcd6b")) |
| ''') |
| GAMES[24] = ("Echo Pads", '''extends Node2D |
| var sequence: Array[int] = [0, 2] |
| var showing: bool = true |
| var show_clock: float = -0.8 |
| var response: int = 0 |
| var flash: int = -1 |
| var flash_time: float = 0.0 |
| var outcome: String = "" |
| func reset() -> void: |
| sequence = [0, 2] |
| showing = true |
| show_clock = -0.8 |
| response = 0 |
| flash = -1 |
| outcome = "" |
| func pad(i: int) -> Rect2: |
| return Rect2(200 + (i % 2) * 300, 160 + (i / 2) * 175, 260, 145) |
| func press(i: int) -> void: |
| if showing or outcome != "": |
| return |
| flash = i |
| flash_time = 0.25 |
| if i != sequence[response]: |
| outcome = "Wrong pad. R: listen to a new round" |
| return |
| response += 1 |
| if response == sequence.size(): |
| if sequence.size() == 8: |
| outcome = "Eight-note sequence remembered! R: replay" |
| else: |
| sequence.append(randi_range(0, 3)) |
| showing = true |
| show_clock = -1.0 |
| response = 0 |
| func _input(event: InputEvent) -> void: |
| if event is InputEventKey and event.pressed and not event.echo: |
| if event.keycode == KEY_R: |
| reset() |
| for i in range(4): |
| if event.keycode == KEY_1 + i: |
| press(i) |
| if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT: |
| for i in range(4): |
| if pad(i).has_point(event.position): |
| press(i) |
| func _process(dt: float) -> void: |
| if outcome == "" and showing: |
| show_clock += dt |
| var index: int = floori(show_clock / 0.8) |
| flash = -1 |
| if index >= sequence.size(): |
| showing = false |
| elif index >= 0 and fmod(show_clock, 0.8) < 0.5: |
| flash = sequence[index] |
| elif not showing: |
| flash_time -= dt |
| if flash_time <= 0: |
| flash = -1 |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("ECHO PADS", "Watch the flashes, then repeat at any speed | Click pads or press 1 / 2 / 3 / 4 | R: restart") |
| for i in range(4): |
| draw_rect(pad(i), Color.from_hsv(i * 0.23, 0.7, 1.0 if flash == i else 0.35)) |
| text_at(str(i + 1), pad(i).position + Vector2(116, 90), 46) |
| text_at("WATCH" if showing else "YOUR TURN - no timing requirement", Vector2(230, 125), 25) |
| text_at("Sequence length %d / 8 Entered %d" % [sequence.size(), response], Vector2(240, 555)) |
| text_at(outcome, Vector2(180, 610), 23, Color("ffcd6b")) |
| ''') |
| GAMES[25] = ("Crane Stack", '''extends Node2D |
| var stack: Array[Rect2] = [] |
| var crane: float = 180.0 |
| var direction: float = 1.0 |
| var falling: bool = false |
| var package_pos: Vector2 = Vector2.ZERO |
| var velocity: float = 0.0 |
| var outcome: String = "" |
| func reset() -> void: |
| stack.clear() |
| crane = 180 |
| direction = 1 |
| falling = false |
| outcome = "" |
| func _input(event: InputEvent) -> void: |
| if event is InputEventKey and event.pressed and not event.echo: |
| if event.keycode == KEY_R: |
| reset() |
| if event.keycode == KEY_SPACE and not falling and outcome == "": |
| falling = true |
| package_pos = Vector2(crane - 58, 130) |
| velocity = 0 |
| func _process(dt: float) -> void: |
| if outcome == "": |
| if not falling: |
| crane += direction * (190 + stack.size() * 23) * dt |
| if crane < 120 or crane > 840: |
| direction *= -1 |
| crane = clampf(crane, 120, 840) |
| else: |
| velocity += 570 * dt |
| package_pos.y += velocity * dt |
| var target: float = 550 - stack.size() * 52 |
| if package_pos.y + 52 >= target: |
| package_pos.y = target - 52 |
| var overlap: float = 116 |
| if not stack.is_empty(): |
| overlap = minf(package_pos.x + 116, stack[-1].end.x) - maxf(package_pos.x, stack[-1].position.x) |
| if package_pos.x < 350 or package_pos.x + 116 > 610 or overlap < 78: |
| outcome = "Unstable placement! Stay inside the outline and overlap. R: retry" |
| else: |
| stack.append(Rect2(package_pos, Vector2(116, 52))) |
| if stack.size() == 6: |
| outcome = "Six stable packages! Tower complete. R: replay" |
| falling = false |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("CRANE STACK", "Space: release package | Stay inside the tower and overlap the previous box | R: restart") |
| draw_rect(Rect2(350, 208, 260, 344), Color("5ef2d0"), false, 3) |
| draw_line(Vector2(80, 550), Vector2(880, 550), Color("c1cfe8"), 4) |
| draw_line(Vector2(100, 115), Vector2(860, 115), Color("46617d"), 5) |
| for i in range(stack.size()): |
| draw_rect(stack[i], Color.from_hsv(i * 0.1, 0.6, 0.95)) |
| draw_rect(stack[i], Color.WHITE, false, 2) |
| if outcome == "": |
| var pos: Vector2 = package_pos if falling else Vector2(crane - 58, 130) |
| draw_rect(Rect2(pos, Vector2(116, 52)), Color("ffcd6b")) |
| if not falling: |
| draw_line(Vector2(crane, 115), Vector2(crane, 130), Color.WHITE, 3) |
| text_at("Stable placements %d / 6" % stack.size(), Vector2(310, 590)) |
| text_at(outcome, Vector2(75, 625), 20) |
| ''') |
| GAMES[26] = ("Trail Territory", '''extends Node2D |
| const W: int = 14 |
| const H: int = 10 |
| const STEP: int = 38 |
| var owned: Dictionary = {} |
| var trail: Array[Vector2i] = [] |
| var player: Vector2i = Vector2i(2, 5) |
| var enemy: Vector2i = Vector2i(11, 5) |
| var move_clock: float = 0.0 |
| var enemy_clock: float = 0.0 |
| var time_left: float = 90.0 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| owned.clear() |
| trail.clear() |
| for y in range(H): |
| for x in range(3): |
| owned[Vector2i(x, y)] = true |
| player = Vector2i(2, 5) |
| enemy = Vector2i(11, 5) |
| move_clock = 0 |
| enemy_clock = 0 |
| time_left = 90 |
| outcome = "" |
| func inside(p: Vector2i) -> bool: |
| return p.x >= 0 and p.y >= 0 and p.x < W and p.y < H |
| func reconnect() -> void: |
| for p in trail: |
| owned[p] = true |
| trail.clear() |
| var reached: Dictionary = {enemy: true} |
| var queue: Array[Vector2i] = [enemy] |
| var cursor: int = 0 |
| while cursor < queue.size(): |
| var cell: Vector2i = queue[cursor] |
| cursor += 1 |
| for direction in [Vector2i.LEFT, Vector2i.RIGHT, Vector2i.UP, Vector2i.DOWN]: |
| var next: Vector2i = cell + direction |
| if inside(next) and not owned.has(next) and not reached.has(next): |
| reached[next] = true |
| queue.append(next) |
| for y in range(H): |
| for x in range(W): |
| var cell: Vector2i = Vector2i(x, y) |
| if not reached.has(cell): |
| owned[cell] = true |
| if owned.size() >= 92: |
| outcome = "Territory secured! R: another expedition" |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| time_left -= dt |
| move_clock -= dt |
| var direction: Vector2i = Vector2i.ZERO |
| if Input.is_action_pressed("ui_left"): |
| direction = Vector2i.LEFT |
| elif Input.is_action_pressed("ui_right"): |
| direction = Vector2i.RIGHT |
| elif Input.is_action_pressed("ui_up"): |
| direction = Vector2i.UP |
| elif Input.is_action_pressed("ui_down"): |
| direction = Vector2i.DOWN |
| if move_clock <= 0 and direction != Vector2i.ZERO: |
| move_clock = 0.13 |
| var next: Vector2i = player + direction |
| if inside(next): |
| if trail.has(next): |
| outcome = "You crossed your own trail. R: retry" |
| else: |
| player = next |
| if owned.has(player): |
| if not trail.is_empty(): |
| reconnect() |
| else: |
| trail.append(player) |
| enemy_clock -= dt |
| if enemy_clock <= 0: |
| enemy_clock = 0.22 |
| var directions: Array[Vector2i] = [Vector2i.LEFT, Vector2i.RIGHT, Vector2i.UP, Vector2i.DOWN] |
| var next: Vector2i = enemy + directions[randi_range(0, 3)] |
| if inside(next) and not owned.has(next): |
| enemy = next |
| if trail.has(enemy): |
| outcome = "Enemy cut the active trail! R: retry" |
| elif time_left <= 0: |
| outcome = "Time expired. R: retry" |
| queue_redraw() |
| func center(p: Vector2i) -> Vector2: |
| return Vector2(215, 155) + Vector2(p) * STEP + Vector2.ONE * STEP * 0.5 |
| func _draw() -> void: |
| backdrop("TRAIL TERRITORY", "Arrows: step | Leave blue safety, draw a loop, reconnect | Avoid the red enemy | R: restart") |
| for y in range(H): |
| for x in range(W): |
| var p: Vector2i = Vector2i(x, y) |
| var color: Color = Color("287a94") if owned.has(p) else Color("182439") |
| if trail.has(p): |
| color = Color("ffcd6b") |
| draw_rect(Rect2(center(p) - Vector2.ONE * 18, Vector2(36, 36)), color) |
| draw_circle(center(enemy), 13, Color("ff6176")) |
| draw_circle(center(player), 11, Color.WHITE) |
| text_at("Claim %d / 92 tiles Time %d" % [owned.size(), ceili(maxf(0, time_left))], Vector2(240, 575)) |
| text_at(outcome, Vector2(220, 620), 23) |
| ''') |
| GAMES[27] = ("Charge Duel", '''extends Node2D |
| var hp: int = 5 |
| var foe_hp: int = 5 |
| var energy: int = 2 |
| var foe_energy: int = 2 |
| var rounds: int = 0 |
| var report: String = "Choose an action. The opponent commits without seeing your choice." |
| var outcome: String = "" |
| var names: Array[String] = ["ATTACK", "BLOCK", "CHARGE"] |
| func reset() -> void: |
| hp = 5 |
| foe_hp = 5 |
| energy = 2 |
| foe_energy = 2 |
| rounds = 0 |
| report = "Attack costs 1 energy. Block defeats attack. Charge restores 1." |
| outcome = "" |
| func button(i: int) -> Rect2: |
| return Rect2(150 + i * 230, 420, 200, 72) |
| func choose(action: int) -> void: |
| if outcome != "": |
| return |
| if action == 0 and energy == 0: |
| report = "No energy: block or charge first." |
| return |
| var rival: int = 2 if foe_energy == 0 else randi_range(0, 2) |
| rounds += 1 |
| if action == 0: |
| energy -= 1 |
| if rival == 0: |
| foe_energy -= 1 |
| if action == 2: |
| energy = mini(energy + 1, 4) |
| if rival == 2: |
| foe_energy = mini(foe_energy + 1, 4) |
| if action == 0: |
| if rival == 1: |
| hp -= 1 |
| else: |
| foe_hp -= 1 |
| if rival == 0: |
| if action == 1: |
| foe_hp -= 1 |
| else: |
| hp -= 1 |
| report = "You: %s Rival: %s Round %d" % [names[action], names[rival], rounds] |
| if hp <= 0 and foe_hp <= 0: |
| outcome = "Mutual knockout! R: rematch" |
| elif foe_hp <= 0: |
| outcome = "You win the duel! R: rematch" |
| elif hp <= 0: |
| outcome = "Rival wins. R: rematch" |
| func _input(event: InputEvent) -> void: |
| if event is InputEventKey and event.pressed and not event.echo: |
| if event.keycode == KEY_R: |
| reset() |
| for i in range(3): |
| if event.keycode == KEY_1 + i: |
| choose(i) |
| if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT: |
| for i in range(3): |
| if button(i).has_point(event.position): |
| choose(i) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("CHARGE DUEL", "Click an action or press 1 / 2 / 3 | Attack beats charge; block counters attack | R: restart") |
| draw_circle(Vector2(280, 235), 70, Color("5ef2d0")) |
| draw_circle(Vector2(690, 235), 70, Color("ff6176")) |
| text_at("YOU", Vector2(252, 244), 25, Color("121d35")) |
| text_at("RIVAL", Vector2(650, 244), 25) |
| text_at("HP %d Energy %d / 4" % [hp, energy], Vector2(180, 345)) |
| text_at("HP %d Energy %d / 4" % [foe_hp, foe_energy], Vector2(570, 345)) |
| for i in range(3): |
| draw_rect(button(i), Color("334966")) |
| text_at("%d: %s" % [i + 1, names[i]], button(i).position + Vector2(18, 45)) |
| text_at(report, Vector2(70, 550), 20) |
| text_at(outcome, Vector2(280, 610), 26, Color("ffcd6b")) |
| ''') |
| GAMES[28] = ("Binary Wires", '''extends Node2D |
| var lamps: int = 0 |
| var target: int = 5 |
| var masks: Array[int] = [3, 6, 7] |
| var moves: int = 0 |
| var puzzles: int = 0 |
| var outcome: String = "" |
| func reset() -> void: |
| lamps = 0 |
| target = 5 |
| moves = 0 |
| puzzles = 0 |
| outcome = "" |
| func toggle(i: int) -> void: |
| if outcome != "": |
| return |
| lamps = lamps ^ masks[i] |
| moves += 1 |
| if lamps == target: |
| puzzles += 1 |
| if puzzles == 4: |
| outcome = "Four circuits repaired! R: restart" |
| else: |
| lamps = target |
| target = (target + 3) % 8 |
| moves = 0 |
| elif moves >= 6: |
| outcome = "Six moves used. Circuit locked! R: retry" |
| func switch_rect(i: int) -> Rect2: |
| return Rect2(150 + 240 * i, 390, 180, 75) |
| func _input(event: InputEvent) -> void: |
| if event is InputEventKey and event.pressed and not event.echo: |
| if event.keycode == KEY_R: |
| reset() |
| for i in range(3): |
| if event.keycode == KEY_1 + i: |
| toggle(i) |
| if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT: |
| for i in range(3): |
| if switch_rect(i).has_point(event.position): |
| toggle(i) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("BINARY WIRES", "Click switches or press 1 / 2 / 3 | Match the target in at most six toggles | R: restart") |
| text_at("TARGET", Vector2(45, 174), 22) |
| text_at("LAMPS", Vector2(45, 278), 22) |
| for j in range(3): |
| var x: float = 240 + 240 * j |
| draw_circle(Vector2(x, 165), 24, Color("5ef2d0") if target & (1 << j) else Color("26394e")) |
| text_at(str((target >> j) & 1), Vector2(x - 6, 172), 21, Color.WHITE) |
| draw_circle(Vector2(x, 265), 35, Color("ffcd6b") if lamps & (1 << j) else Color("26394e")) |
| text_at(str((lamps >> j) & 1), Vector2(x - 7, 273), 24, Color.WHITE) |
| for i in range(3): |
| for j in range(3): |
| if masks[i] & (1 << j): |
| draw_line(Vector2(240 + 240 * i, 390), Vector2(240 + 240 * j, 305), Color.from_hsv(i * 0.24, 0.5, 0.6), 2) |
| draw_rect(switch_rect(i), Color("334966")) |
| text_at("SWITCH %d" % (i + 1), switch_rect(i).position + Vector2(23, 45)) |
| text_at("Repairs %d / 4 Moves %d / 6 Wires show affected lamps" % [puzzles, moves], Vector2(140, 535)) |
| text_at(outcome, Vector2(250, 600), 25) |
| ''') |
| GAMES[29] = ("Water Gates", '''extends Node2D |
| var opened: Array[bool] = [false, false] |
| var levels: Array[int] = [0, 0] |
| var drops: Array[Dictionary] = [] |
| var spawn_clock: float = 0.0 |
| var time_left: float = 65.0 |
| var outcome: String = "" |
| const TARGET: int = 20 |
| func reset() -> void: |
| opened = [false, false] |
| levels = [0, 0] |
| drops.clear() |
| spawn_clock = 0 |
| time_left = 65 |
| outcome = "" |
| func gate(i: int) -> Rect2: |
| return Rect2(270 + i * 320, 210, 100, 55) |
| func _input(event: InputEvent) -> void: |
| if event is InputEventKey and event.pressed and event.keycode == KEY_R: |
| reset() |
| if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT and outcome == "": |
| for i in range(2): |
| if gate(i).has_point(event.position): |
| opened[i] = not opened[i] |
| func _process(dt: float) -> void: |
| if outcome == "": |
| time_left -= dt |
| spawn_clock -= dt |
| if spawn_clock <= 0: |
| spawn_clock = 0.25 |
| for i in range(2): |
| if opened[i]: |
| drops.append({"p": Vector2(320 + i * 320, 265), "v": 0.0, "tank": i}) |
| for k in range(drops.size() - 1, -1, -1): |
| var d: Dictionary = drops[k] |
| d["v"] += 440.0 * dt |
| d["p"] += Vector2(0, float(d["v"]) * dt) |
| var i: int = d["tank"] |
| if d["p"].y >= 555 - levels[i] * 8: |
| levels[i] += 1 |
| drops.remove_at(k) |
| if levels[i] > TARGET: |
| outcome = "A tank overflowed its marked level! R: retry" |
| if levels[0] == TARGET and levels[1] == TARGET and drops.is_empty() and not opened[0] and not opened[1]: |
| outcome = "Both tanks precisely filled! R: another run" |
| elif time_left <= 0 and outcome == "": |
| outcome = "Water service timed out. R: retry" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("WATER GATES", "Click gates: open / close | Fill BOTH tanks to 20 drops | Close early: falling drops still count | R: restart") |
| draw_rect(Rect2(250, 112, 460, 65), Color("2588b5")) |
| text_at("WATER SOURCE", Vector2(380, 155)) |
| for i in range(2): |
| var x: float = 320 + i * 320 |
| draw_line(Vector2(x, 177), Vector2(x, 210), Color("6fbde8"), 12) |
| draw_rect(gate(i), Color("287b65") if opened[i] else Color("9e5263")) |
| text_at("OPEN" if opened[i] else "CLOSED", gate(i).position + Vector2(7, 36), 20) |
| draw_rect(Rect2(x - 100, 330, 200, 225), Color("182f49"), false, 4) |
| draw_rect(Rect2(x - 95, 555 - levels[i] * 8, 190, levels[i] * 8), Color("329fd2")) |
| draw_line(Vector2(x - 105, 395), Vector2(x + 105, 395), Color("ffcd6b"), 3) |
| text_at("%d / 20" % levels[i], Vector2(x - 35, 590)) |
| for d in drops: |
| draw_circle(d["p"], 7, Color("79d7ff")) |
| text_at("Time %d" % ceili(maxf(0, time_left)), Vector2(25, 120), 20) |
| text_at(outcome, Vector2(190, 626), 23) |
| ''') |
| GAMES[30] = ("Shuttle Platforms", '''extends Node2D |
| var player: Vector2 = Vector2(60, 465) |
| var vy: float = 0.0 |
| var platforms: Array[Rect2] = [] |
| var grounded: int = -2 |
| var clock: float = 0.0 |
| var carrying: bool = true |
| var lives: int = 3 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| player = Vector2(60, 465) |
| vy = 0 |
| clock = 0 |
| carrying = true |
| lives = 3 |
| grounded = -2 |
| outcome = "" |
| platforms = [Rect2(230, 430, 100, 16), Rect2(425, 360, 100, 16), Rect2(620, 430, 100, 16)] |
| func _physics_process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| clock += dt |
| for i in range(3): |
| var previous_x: float = platforms[i].position.x |
| platforms[i].position.x = 230 + i * 195 + sin(clock * 1.2 + i * 1.8) * 38 |
| if grounded == i: |
| player.x += platforms[i].position.x - previous_x |
| if Input.is_action_just_pressed("ui_accept") and grounded != -1: |
| vy = -445 |
| grounded = -1 |
| player.x = clampf(player.x + Input.get_axis("ui_left", "ui_right") * 235 * dt, 0, 935) |
| var old_bottom: float = player.y + 35 |
| vy += 900 * dt |
| player.y += vy * dt |
| grounded = -1 |
| var surfaces: Array[Rect2] = platforms.duplicate() |
| surfaces.append(Rect2(0, 500, 155, 30)) |
| surfaces.append(Rect2(815, 500, 145, 30)) |
| if vy >= 0: |
| for i in range(surfaces.size()): |
| var r: Rect2 = surfaces[i] |
| if old_bottom <= r.position.y + 3 and player.y + 35 >= r.position.y and player.x + 25 > r.position.x and player.x < r.end.x: |
| player.y = r.position.y - 35 |
| vy = 0 |
| grounded = i if i < 3 else -2 |
| if player.y > 650: |
| lives -= 1 |
| player = Vector2(60 if carrying else 875, 465) |
| vy = 0 |
| grounded = -2 |
| if lives == 0: |
| outcome = "Three falls. R: try the delivery again" |
| if carrying and player.x > 870 and grounded == -2: |
| carrying = false |
| if not carrying and player.x < 85 and grounded == -2: |
| outcome = "Delivered and returned safely! R: new route" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("SHUTTLE PLATFORMS", "Left / Right: move | Space: jump | Deliver the box at right, then return left | R: restart") |
| draw_rect(Rect2(0, 500, 155, 140), Color("334966")) |
| draw_rect(Rect2(815, 500, 145, 140), Color("334966")) |
| for p in platforms: |
| draw_rect(p, Color("5ef2d0")) |
| draw_rect(Rect2(player, Vector2(25, 35)), Color("79bbff")) |
| if carrying: |
| draw_rect(Rect2(player + Vector2(3, -20), Vector2(20, 20)), Color("ffcd6b")) |
| else: |
| draw_rect(Rect2(898, 472, 28, 28), Color("ffcd6b")) |
| text_at("HOME", Vector2(35, 555), 20) |
| text_at("DEPOT", Vector2(845, 555), 20) |
| text_at("Lives %d | %s" % [lives, "Carry box to depot" if carrying else "Box delivered - return HOME"], Vector2(230, 125)) |
| text_at(outcome, Vector2(260, 605), 24) |
| ''') |
| GAMES[31] = ("Driveway Plow", '''extends Node2D |
| const W: int = 10 |
| const H: int = 7 |
| const CELL: int = 56 |
| var snow: Dictionary = {} |
| var piles: Dictionary = {} |
| var player: Vector2i = Vector2i(4, 6) |
| var moves: int = 0 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| snow.clear() |
| piles.clear() |
| for y in range(1, 6): |
| piles[Vector2i(0, y)] = 0 |
| piles[Vector2i(9, y)] = 0 |
| for x in [2, 3, 6, 7]: |
| snow[Vector2i(x, y)] = true |
| player = Vector2i(4, 6) |
| moves = 0 |
| outcome = "" |
| func inside(p: Vector2i) -> bool: |
| return p.x >= 0 and p.y >= 0 and p.x < W and p.y < H |
| func step(direction: Vector2i) -> void: |
| if outcome != "": |
| return |
| var next: Vector2i = player + direction |
| if not inside(next) or piles.has(next): |
| return |
| if snow.has(next): |
| var chain: Array[Vector2i] = [] |
| var end: Vector2i = next |
| while snow.has(end): |
| chain.append(end) |
| end += direction |
| if not inside(end): |
| return |
| if (end.y == 0 or end.y == 6) and (end.x == 4 or end.x == 5): |
| outcome = "Snow blocked the garage exit corridor. R: retry" |
| return |
| for i in range(chain.size() - 1, -1, -1): |
| var dest: Vector2i = chain[i] + direction |
| snow.erase(chain[i]) |
| if piles.has(dest): |
| piles[dest] += 1 |
| else: |
| snow[dest] = true |
| player = next |
| moves += 1 |
| if snow.is_empty(): |
| outcome = "Every driveway tile cleared; exit remains open! R: restart" |
| func _input(event: InputEvent) -> void: |
| if event is InputEventKey and event.pressed and not event.echo: |
| if event.keycode == KEY_R: |
| reset() |
| elif event.keycode == KEY_LEFT: |
| step(Vector2i.LEFT) |
| elif event.keycode == KEY_RIGHT: |
| step(Vector2i.RIGHT) |
| elif event.keycode == KEY_UP: |
| step(Vector2i.UP) |
| elif event.keycode == KEY_DOWN: |
| step(Vector2i.DOWN) |
| queue_redraw() |
| func center(p: Vector2i) -> Vector2: |
| return Vector2(200, 155) + Vector2(p) * CELL + Vector2.ONE * 28 |
| func _draw() -> void: |
| backdrop("DRIVEWAY PLOW", "Tap arrows: move and push snow | Push into green side piles | Keep the yellow exit open | R: restart") |
| for y in range(H): |
| for x in range(W): |
| var p: Vector2i = Vector2i(x, y) |
| var color: Color = Color("28394e") |
| if piles.has(p): |
| color = Color("26785e") |
| elif (y == 0 or y == 6) and (x == 4 or x == 5): |
| color = Color("827035") |
| draw_rect(Rect2(center(p) - Vector2.ONE * 27, Vector2(54, 54)), color) |
| if snow.has(p): |
| draw_circle(center(p), 21, Color("d5ebff")) |
| if piles.has(p): |
| text_at(str(piles[p]), center(p) + Vector2(-6, 7), 19) |
| draw_rect(Rect2(center(player) - Vector2(17, 17), Vector2(34, 34)), Color("ff955b")) |
| text_at("Snow tiles left %d / 20 Moves %d" % [snow.size(), moves], Vector2(270, 585)) |
| text_at(outcome, Vector2(145, 625), 21) |
| ''') |
| GAMES[32] = ("Shepherd Gate", '''extends Node2D |
| var sheep: Array[Vector2] = [] |
| var secured: Array[bool] = [] |
| var shepherd: Vector2 = Vector2(160, 340) |
| var time_left: float = 90.0 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| sheep = [Vector2(240, 235), Vector2(360, 295), Vector2(270, 415), Vector2(410, 440), Vector2(460, 215)] |
| secured = [false, false, false, false, false] |
| shepherd = Vector2(160, 340) |
| time_left = 90 |
| outcome = "" |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| time_left -= dt |
| shepherd = get_global_mouse_position() |
| shepherd.x = clampf(shepherd.x, 35, 660) |
| shepherd.y = clampf(shepherd.y, 125, 575) |
| # The marked entrance is reserved for sheep: shepherd stays outside it. |
| if shepherd.x > 595 and shepherd.y > 265 and shepherd.y < 415: |
| shepherd.x = 595 |
| for i in range(sheep.size()): |
| if secured[i]: |
| continue |
| var velocity: Vector2 = Vector2.ZERO |
| var away: Vector2 = sheep[i] - shepherd |
| if away.length() < 145: |
| velocity += away.normalized() * (145 - away.length()) * 1.1 |
| for j in range(sheep.size()): |
| if i != j and not secured[j]: |
| var separation: Vector2 = sheep[i] - sheep[j] |
| if separation.length() < 38: |
| velocity += separation.normalized() * 35 |
| var next: Vector2 = sheep[i] + velocity.limit_length(110) * dt |
| next.y = clampf(next.y, 140, 555) |
| next.x = maxf(next.x, 50) |
| if next.x > 680 and (next.y < 285 or next.y > 395): |
| next.x = 680 |
| if next.x >= 690 and next.y >= 285 and next.y <= 395: |
| secured[i] = true |
| next = Vector2(750 + (i % 2) * 85, 230 + (i / 2) * 80) |
| sheep[i] = next |
| var count: int = 0 |
| for done in secured: |
| if done: |
| count += 1 |
| if count == sheep.size(): |
| outcome = "Every sheep penned; gate corridor clear! R: replay" |
| elif time_left <= 0: |
| outcome = "Time ran out. Approach from behind each sheep. R: retry" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("SHEPHERD GATE", "Mouse: shepherd repels nearby sheep | Herd them through the right-side gate | Keep corridor clear | R: restart") |
| draw_rect(Rect2(30, 120, 650, 465), Color("1a3b37")) |
| draw_rect(Rect2(700, 160, 220, 380), Color("285746")) |
| draw_rect(Rect2(595, 285, 105, 110), Color("746532")) |
| draw_line(Vector2(690, 120), Vector2(690, 278), Color("c1cfe8"), 8) |
| draw_line(Vector2(690, 402), Vector2(690, 585), Color("c1cfe8"), 8) |
| text_at("PEN", Vector2(775, 145)) |
| var count: int = 0 |
| for i in range(sheep.size()): |
| draw_circle(sheep[i], 16, Color.WHITE) |
| draw_circle(sheep[i] + Vector2(10, 0), 7, Color("68798b")) |
| if secured[i]: |
| count += 1 |
| draw_circle(shepherd, 15, Color("ff9568")) |
| draw_arc(shepherd, 145, 0, TAU, 48, Color(1, 0.7, 0.4, 0.18), 1) |
| text_at("Penned %d / 5 Time %d" % [count, ceili(maxf(time_left, 0))], Vector2(220, 610)) |
| text_at(outcome, Vector2(120, 108), 22) |
| ''') |
|
|
|
|
| def main(): |
| |
| wanted = {f"vg8b-teacher-v1-{i:03d}" for i in list(range(21, 33)) + list(range(65, 85))} |
| prompts = {} |
| with (ROOT / "data/teacher_prompts.jsonl").open() as handle: |
| for line in handle: |
| row = json.loads(line) |
| if row["id"] in wanted: |
| prompts[row["id"]] = row["instruction"] |
| if set(prompts) != wanted: |
| raise RuntimeError("Missing assigned training prompts") |
| rows, provenance = [], [] |
| for number, (title, source) in sorted(GAMES.items()): |
| identity = f"vg8b-teacher-v1-{number:03d}" |
| files = {"project.godot": PROJECT % title, "main.tscn": SCENE, "main.gd": source + HELPERS} |
| output = json.dumps({"files": files}, ensure_ascii=False, separators=(",", ":")) |
| parse_project(output) |
| rows.append({"instruction": prompts[identity], "output": output}) |
| provenance.append({"prompt_id": identity, "title": title, "project_sha256": project_sha256(files), |
| "output_sha256": hashlib.sha256(output.encode()).hexdigest(), |
| "gdscript_characters": len(files["main.gd"]), "static_contract_pass": True}) |
| output_path = ROOT / "data/codex_teacher_batch_b.jsonl" |
| temporary = output_path.with_suffix(".tmp") |
| temporary.write_text("".join(json.dumps(row, ensure_ascii=False) + "\n" for row in rows)) |
| temporary.replace(output_path) |
| report = {"authorship": "Original in-session Codex teacher authorship; not generated by the local 14B sampler.", |
| "source": "Independently implemented game mechanics responding to assigned training prompts 021–032 and 065–084.", |
| "license": "Apache-2.0", "assets": "Procedural Godot drawing and bundled default font only; no third-party game assets.", |
| "shared_boilerplate": "Canonical Godot project/scene and text drawing helpers follow the repository's original seeds.", |
| "blind_prompts_read": False, "engine_validation": "NOT RUN. Pending Linux import and full 60-second check; these are candidates, not admitted training data.", |
| "candidates_sha256": hashlib.sha256(output_path.read_bytes()).hexdigest(), "count": len(rows), "games": provenance} |
| (ROOT / "data/codex_teacher_batch_b_provenance.json").write_text(json.dumps(report, indent=2) + "\n") |
| print(json.dumps({"candidates": len(rows), "static_contract": "passed", "max_gdscript_characters": max(x["gdscript_characters"] for x in provenance), "engine_validation": "pending"})) |
|
|
|
|
|
|
| GAMES[65] = ("Landing Lines", '''extends Node2D |
| var planes: Array[Dictionary] = [] |
| var zones: Array[Vector2] = [Vector2(770, 210), Vector2(770, 480)] |
| var selected: int = -1 |
| var created: int = 0 |
| var landed: int = 0 |
| var spawn: float = 0 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| planes.clear() |
| selected = -1 |
| created = 0 |
| landed = 0 |
| spawn = 0 |
| outcome = "" |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and e.keycode == KEY_R: |
| reset() |
| if e is InputEventMouseButton and e.button_index == MOUSE_BUTTON_LEFT: |
| if e.pressed: |
| selected = -1 |
| for i in range(planes.size()): |
| if planes[i]["p"].distance_to(e.position) < 25: |
| selected = i |
| planes[i]["path"] = [] |
| else: |
| selected = -1 |
| if e is InputEventMouseMotion and selected >= 0 and selected < planes.size(): |
| var path: Array = planes[selected]["path"] |
| if path.is_empty() or path[-1].distance_to(e.position) > 18: |
| path.append(e.position) |
| func _process(dt: float) -> void: |
| if outcome == "": |
| spawn -= dt |
| if spawn <= 0 and created < 8: |
| planes.append({"p": Vector2(50, 170 + (created % 2) * 320), "zone": created % 2, "path": []}) |
| created += 1 |
| spawn = 5.5 |
| for i in range(planes.size() - 1, -1, -1): |
| var p: Dictionary = planes[i] |
| var path: Array = p["path"] |
| if not path.is_empty(): |
| p["p"] = p["p"].move_toward(path[0], 85 * dt) |
| if p["p"].distance_to(path[0]) < 2: |
| path.pop_front() |
| else: |
| p["p"] += Vector2(23 * dt, 0) |
| if p["p"].distance_to(zones[p["zone"]]) < 24: |
| planes.remove_at(i) |
| selected = -1 |
| landed += 1 |
| elif p["p"].x > 950 or p["p"].y < 90 or p["p"].y > 630: |
| outcome = "Plane left the airspace! R: retry" |
| for i in range(planes.size()): |
| for j in range(i): |
| if planes[i]["p"].distance_to(planes[j]["p"]) < 27: |
| outcome = "Loss of separation! R: retry" |
| if landed == 8: |
| outcome = "Eight safe landings! R: another shift" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("LANDING LINES", "Drag from a plane to draw its route | Match landing-zone color | Keep planes separated | R: restart") |
| for i in range(2): |
| draw_circle(zones[i], 38, Color("286c90") if i == 0 else Color("806631")) |
| text_at(str(i + 1), zones[i] + Vector2(-8, 9), 28) |
| for p in planes: |
| var previous: Vector2 = p["p"] |
| for point in p["path"]: |
| draw_line(previous, point, Color("526d88"), 2) |
| previous = point |
| draw_circle(p["p"], 12, Color("79d7ff") if p["zone"] == 0 else Color("ffcd6b")) |
| text_at("Landed %d / 8" % landed, Vector2(35, 610)) |
| text_at(outcome, Vector2(330, 610), 24) |
| ''') |
| GAMES[66] = ("Six Plot Farm", '''extends Node2D |
| var plants: Array[Dictionary] = [] |
| var water: int = 12 |
| var harvest: int = 0 |
| var wilted: int = 0 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| plants.clear() |
| for i in range(6): |
| plants.append({"stage": 0, "moisture": 0.0, "growth": 0.0}) |
| water = 12 |
| harvest = 0 |
| wilted = 0 |
| outcome = "" |
| func plot(i: int) -> Rect2: |
| return Rect2(170 + (i % 3) * 215, 175 + (i / 3) * 185, 185, 155) |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and e.keycode == KEY_R: |
| reset() |
| if outcome == "" and e is InputEventMouseButton and e.pressed and e.button_index == MOUSE_BUTTON_LEFT: |
| for i in range(6): |
| if plot(i).has_point(e.position): |
| var p: Dictionary = plants[i] |
| if p["stage"] == 0: |
| p["stage"] = 1 |
| p["moisture"] = 70.0 |
| elif p["stage"] == 2: |
| p["stage"] = 3 |
| harvest += 1 |
| elif p["stage"] == 1 and water > 0: |
| p["moisture"] = minf(100, p["moisture"] + 55) |
| water -= 1 |
| func _process(dt: float) -> void: |
| if outcome == "": |
| for p in plants: |
| if p["stage"] == 1: |
| p["moisture"] -= 8 * dt |
| p["growth"] += 6 * dt |
| if p["moisture"] <= 0: |
| p["stage"] = 4 |
| wilted += 1 |
| elif p["growth"] >= 100: |
| p["stage"] = 2 |
| if harvest == 6: |
| outcome = "All six crops harvested! R: replant" |
| elif wilted > 0: |
| outcome = "A plant wilted. R: restart the farm" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("SIX PLOT FARM", "Click empty plot: plant | Click growing crop: spend water | Click gold crop: harvest | R: restart") |
| for i in range(6): |
| var p: Dictionary = plants[i] |
| var r: Rect2 = plot(i) |
| draw_rect(r, Color("684b38")) |
| if p["stage"] == 1 or p["stage"] == 2: |
| draw_circle(r.get_center() - Vector2(0, 14), 15 + p["growth"] * 0.2, Color("ffcd6b") if p["stage"] == 2 else Color("5ed27b")) |
| draw_rect(Rect2(r.position + Vector2(10, 115), Vector2(p["moisture"] * 1.65, 12)), Color("79d7ff")) |
| text_at("Growth %d%%" % int(p["growth"]), r.position + Vector2(22, 149), 17) |
| else: |
| text_at(["PLANT", "", "", "HARVESTED", "WILTED"][p["stage"]], r.position + Vector2(23, 80), 20) |
| text_at("Water %d / 12 Harvest %d / 6" % [water, harvest], Vector2(300, 570)) |
| text_at(outcome, Vector2(250, 620), 24) |
| ''') |
| GAMES[67] = ("Three Barrier Bankshot", '''extends Node2D |
| var barriers: Array[Rect2] = [] |
| var ball: Vector2 = Vector2(125, 490) |
| var velocity: Vector2 = Vector2(210, -150) |
| var running: bool = false |
| var bounces: int = 0 |
| var horizontal: bool = true |
| var outcome: String = "" |
| var timer: float = 0 |
| func reset() -> void: |
| barriers.clear() |
| ball = Vector2(125, 490) |
| velocity = Vector2(210, -150) |
| running = false |
| bounces = 0 |
| timer = 0 |
| outcome = "" |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and not e.echo: |
| if e.keycode == KEY_R: |
| reset() |
| elif e.keycode == KEY_SPACE and barriers.size() == 3 and outcome == "": |
| running = true |
| if e is InputEventMouseButton and e.pressed and not running: |
| if e.button_index == MOUSE_BUTTON_RIGHT: |
| horizontal = not horizontal |
| elif e.button_index == MOUSE_BUTTON_LEFT and barriers.size() < 3 and e.position.y > 160: |
| var size: Vector2 = Vector2(120, 18) if horizontal else Vector2(18, 120) |
| var rect: Rect2 = Rect2(e.position - size / 2, size) |
| if not rect.grow(25).has_point(ball) and not rect.grow(35).has_point(Vector2(785, 425)): |
| barriers.append(rect) |
| func _process(dt: float) -> void: |
| if running and outcome == "": |
| timer += dt |
| var previous: Vector2 = ball |
| ball += velocity * dt |
| if ball.x < 55 or ball.x > 905: |
| velocity.x *= -1 |
| ball.x = clampf(ball.x, 55, 905) |
| bounces += 1 |
| if ball.y < 155 or ball.y > 565: |
| velocity.y *= -1 |
| ball.y = clampf(ball.y, 155, 565) |
| bounces += 1 |
| for r in barriers: |
| if r.grow(9).has_point(ball) and not r.grow(9).has_point(previous): |
| if previous.x < r.position.x - 9 or previous.x > r.end.x + 9: |
| velocity.x *= -1 |
| else: |
| velocity.y *= -1 |
| ball = previous |
| bounces += 1 |
| if ball.distance_to(Vector2(785, 425)) < 30: |
| outcome = "Target reached in %d bounces! R: rebuild" % bounces |
| elif bounces > 5 or timer > 25: |
| outcome = "Route failed. R: place a new layout" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("THREE BARRIER BANKSHOT", "Left click: place | Right click: rotate next barrier | Place three then Space: launch | R: restart") |
| draw_rect(Rect2(45, 145, 870, 430), Color("46617d"), false, 3) |
| draw_circle(Vector2(785, 425), 30, Color("287d60")) |
| for r in barriers: |
| draw_rect(r, Color("ffcd6b")) |
| draw_circle(ball, 9, Color.WHITE) |
| if not running: |
| draw_line(ball, ball + velocity.normalized() * 75, Color("79d7ff"), 3) |
| text_at("Barriers %d / 3 Bounces %d / 5 Next: %s" % [barriers.size(), bounces, "horizontal" if horizontal else "vertical"], Vector2(110, 122), 20) |
| text_at(outcome, Vector2(215, 618), 24) |
| ''') |
| GAMES[68] = ("Merge To 128", '''extends Node2D |
| var board: Array[int] = [] |
| var score: int = 0 |
| var outcome: String = "" |
| func _ready() -> void: |
| reset() |
| func reset() -> void: |
| board.clear() |
| board.resize(16) |
| board.fill(0) |
| score = 0 |
| outcome = "" |
| spawn() |
| spawn() |
| func spawn() -> void: |
| var empty: Array[int] = [] |
| for i in range(16): |
| if board[i] == 0: |
| empty.append(i) |
| if not empty.is_empty(): |
| board[empty[randi_range(0, empty.size() - 1)]] = 2 |
| func slide(direction: int) -> void: |
| if outcome != "": |
| return |
| var before: Array[int] = board.duplicate() |
| for line in range(4): |
| var ids: Array[int] = [] |
| for n in range(4): |
| var index: int = line * 4 + n |
| if direction == 1: |
| index = line * 4 + 3 - n |
| elif direction == 2: |
| index = n * 4 + line |
| elif direction == 3: |
| index = (3 - n) * 4 + line |
| ids.append(index) |
| var values: Array[int] = [] |
| for index in ids: |
| if board[index] > 0: |
| values.append(board[index]) |
| var merged: Array[int] = [] |
| var n: int = 0 |
| while n < values.size(): |
| if n + 1 < values.size() and values[n] == values[n + 1]: |
| merged.append(values[n] * 2) |
| score += values[n] * 2 |
| n += 2 |
| else: |
| merged.append(values[n]) |
| n += 1 |
| for i in range(4): |
| board[ids[i]] = merged[i] if i < merged.size() else 0 |
| if board != before: |
| spawn() |
| var possible: bool = board.has(0) |
| for y in range(4): |
| for x in range(4): |
| var i: int = y * 4 + x |
| if board[i] >= 128: |
| outcome = "128 reached! R: a new board" |
| if x < 3 and board[i] == board[i + 1]: |
| possible = true |
| if y < 3 and board[i] == board[i + 4]: |
| possible = true |
| if not possible and outcome == "": |
| outcome = "No legal moves. R: retry" |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and not e.echo: |
| if e.keycode == KEY_R: |
| reset() |
| elif e.keycode == KEY_LEFT: |
| slide(0) |
| elif e.keycode == KEY_RIGHT: |
| slide(1) |
| elif e.keycode == KEY_UP: |
| slide(2) |
| elif e.keycode == KEY_DOWN: |
| slide(3) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("MERGE TO 128", "Arrow keys: slide | Equal neighbors merge once per move | Reach 128 | R: restart") |
| for i in range(16): |
| var p: Vector2 = Vector2(270 + (i % 4) * 108, 120 + (i / 4) * 108) |
| draw_rect(Rect2(p, Vector2(100, 100)), Color("273b55") if board[i] == 0 else Color.from_hsv(log(float(board[i])) * 0.06, 0.55, 0.9)) |
| if board[i] > 0: |
| text_at(str(board[i]), p + Vector2(30, 61), 29) |
| text_at("Score %d" % score, Vector2(95, 160)) |
| text_at(outcome, Vector2(280, 606), 25) |
| ''') |
| GAMES[69] = ("Fragile Freight", '''extends Node2D |
| var cart: float = 110 |
| var speed: float = 0 |
| var cargo: float = 0 |
| var cargo_speed: float = 0 |
| var timer: float = 25 |
| var outcome: String = "" |
| func reset() -> void: |
| cart = 110 |
| speed = 0 |
| cargo = 0 |
| cargo_speed = 0 |
| timer = 25 |
| outcome = "" |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| timer -= dt |
| var acceleration: float = Input.get_axis("ui_left", "ui_right") * 95 - speed * 0.15 |
| speed = clampf(speed + acceleration * dt, -150, 150) |
| cart += speed * dt |
| cargo_speed += (-acceleration * 0.25 - cargo_speed * 0.85 - cargo * 0.2) * dt |
| cargo += cargo_speed * dt |
| if absf(cargo) > 65 or cart < 70: |
| outcome = "Cargo fell or cart left the road! R: retry" |
| elif cart >= 830 and absf(speed) < 28: |
| outcome = "Cargo delivered intact! R: drive again" |
| elif cart > 920 or timer <= 0: |
| outcome = "Missed the stopping zone! R: retry" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("FRAGILE FREIGHT", "Left / Right: accelerate or brake | Carry the loose ball into green zone and stop | R: restart") |
| draw_rect(Rect2(800, 370, 120, 150), Color("214f41")) |
| draw_line(Vector2(50, 500), Vector2(930, 500), Color("c1cfe8"), 5) |
| draw_rect(Rect2(cart - 70, 450, 140, 20), Color("79bbff")) |
| draw_circle(Vector2(cart - 45, 483), 16, Color("62758f")) |
| draw_circle(Vector2(cart + 45, 483), 16, Color("62758f")) |
| draw_circle(Vector2(cart + cargo, 432), 17, Color("ffcd6b")) |
| text_at("Speed %.0f Cargo offset %.0f Time %.1f" % [speed, cargo, maxf(timer, 0)], Vector2(240, 170)) |
| text_at("DESTINATION", Vector2(795, 355), 18) |
| text_at(outcome, Vector2(240, 590), 25) |
| ''') |
| GAMES[70] = ("One Thing Changed", '''extends Node2D |
| var objects: Array[Vector2] = [] |
| var changed: int = 0 |
| var stage: int = 0 |
| var clock: float = 0 |
| var solved: int = 0 |
| var mistakes: int = 0 |
| var outcome: String = "" |
| func _ready() -> void: |
| new_scene() |
| func new_scene() -> void: |
| objects.clear() |
| for i in range(6): |
| objects.append(Vector2(235 + (i % 3) * 230, 230 + (i / 3) * 210)) |
| changed = randi_range(0, 5) |
| stage = 0 |
| clock = 0 |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and e.keycode == KEY_R: |
| solved = 0 |
| mistakes = 0 |
| outcome = "" |
| new_scene() |
| if e is InputEventMouseButton and e.pressed and e.button_index == MOUSE_BUTTON_LEFT and stage == 2 and outcome == "": |
| if e.position.distance_to(objects[changed]) < 40: |
| solved += 1 |
| else: |
| mistakes += 1 |
| if solved == 5: |
| outcome = "Five changes spotted! R: play again" |
| elif mistakes == 3: |
| outcome = "Three misses. R: look more closely" |
| else: |
| new_scene() |
| func _process(dt: float) -> void: |
| if outcome == "": |
| clock += dt |
| if stage == 0 and clock > 2.7: |
| stage = 1 |
| clock = 0 |
| elif stage == 1 and clock > 0.7: |
| objects[changed].x += 65 if changed % 2 == 0 else -65 |
| stage = 2 |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("ONE THING CHANGED", "Memorize the scene | After the brief curtain, click the object that moved | R: restart") |
| text_at(["MEMORIZE", "CURTAIN", "WHICH OBJECT MOVED?"][stage], Vector2(330, 125), 25) |
| if stage != 1: |
| for i in range(objects.size()): |
| var color: Color = Color.from_hsv(i * 0.15, 0.65, 0.95) |
| if i % 2 == 0: |
| draw_circle(objects[i], 33, color) |
| else: |
| draw_rect(Rect2(objects[i] - Vector2.ONE * 31, Vector2.ONE * 62), color) |
| text_at(str(i + 1), objects[i] + Vector2(-7, 8), 25) |
| else: |
| draw_rect(Rect2(140, 160, 670, 360), Color("27344c")) |
| text_at("Found %d / 5 Misses %d / 3" % [solved, mistakes], Vector2(300, 565)) |
| text_at(outcome, Vector2(280, 615), 25) |
| ''') |
| GAMES[71] = ("Gentle Tension", '''extends Node2D |
| var angle: float = 0 |
| var sweet: float = 0.45 |
| var tension: float = 0 |
| var opened: float = 0 |
| var picks: int = 3 |
| var outcome: String = "" |
| func reset() -> void: |
| angle = 0 |
| sweet = randf_range(-1.0, 1.0) |
| tension = 0 |
| opened = 0 |
| picks = 3 |
| outcome = "" |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| angle = clampf(angle + Input.get_axis("ui_left", "ui_right") * dt, -1.2, 1.2) |
| if Input.is_action_pressed("ui_accept"): |
| tension = minf(1, tension + dt * 0.75) |
| if absf(angle - sweet) < 0.13: |
| opened += dt * tension * 0.6 |
| elif tension > 0.62: |
| picks -= 1 |
| tension = 0 |
| opened = 0 |
| else: |
| tension = maxf(0, tension - dt * 2.5) |
| if opened >= 1: |
| outcome = "Lock opened without force! R: another lock" |
| elif picks <= 0: |
| outcome = "All three picks broke. R: retry gently" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("GENTLE TENSION", "Left / Right: rotate pick | Hold Space gently to test and turn | Release to ease tension | R: restart") |
| draw_circle(Vector2(480, 345), 150, Color("52617a")) |
| draw_circle(Vector2(480, 345), 105, Color("24344c")) |
| var tip: Vector2 = Vector2(0, -160).rotated(angle) |
| draw_line(Vector2(480, 345), Vector2(480, 345) + tip, Color("ffcd6b"), 8) |
| draw_line(Vector2(480, 345), Vector2(480, 345) + Vector2(70, 0).rotated(opened * PI * 0.5), Color.WHITE, 12) |
| var near: bool = absf(angle - sweet) < 0.13 |
| text_at("The cylinder yields!" if near and tension > 0 else "Probe lightly; resistance means the angle is wrong.", Vector2(235, 145), 21) |
| draw_rect(Rect2(300, 530, tension * 360, 20), Color("ff6176") if tension > 0.6 and not near else Color("5ef2d0")) |
| text_at("Tension Picks %d Open %d%%" % [picks, int(opened * 100)], Vector2(290, 585)) |
| text_at(outcome, Vector2(250, 625), 23) |
| ''') |
| GAMES[72] = ("Paper Airflow", '''extends Node2D |
| var fans: Array[Dictionary] = [] |
| var plane: Vector2 = Vector2(125, 440) |
| var velocity: Vector2 = Vector2(65, 0) |
| var facing: int = 3 |
| var running: bool = false |
| var timer: float = 0 |
| var outcome: String = "" |
| var directions: Array[Vector2] = [Vector2.RIGHT, Vector2.DOWN, Vector2.LEFT, Vector2.UP] |
| func reset() -> void: |
| fans.clear() |
| plane = Vector2(125, 440) |
| velocity = Vector2(65, 0) |
| running = false |
| timer = 0 |
| outcome = "" |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and not e.echo: |
| if e.keycode == KEY_R: |
| reset() |
| elif e.keycode == KEY_SPACE and fans.size() == 2: |
| running = true |
| if e is InputEventMouseButton and e.pressed and not running: |
| if e.button_index == MOUSE_BUTTON_RIGHT: |
| facing = (facing + 1) % 4 |
| elif e.button_index == MOUSE_BUTTON_LEFT and fans.size() < 2 and e.position.y > 150: |
| fans.append({"p": e.position, "direction": facing}) |
| func _process(dt: float) -> void: |
| if running and outcome == "": |
| timer += dt |
| for fan in fans: |
| if plane.distance_to(fan["p"]) < 125: |
| velocity = velocity.move_toward(directions[fan["direction"]] * 95, 165 * dt) |
| plane += velocity * dt |
| if plane.distance_to(Vector2(790, 225)) < 35: |
| outcome = "Mail delivered by airflow! R: redesign" |
| elif plane.x < 30 or plane.x > 930 or plane.y < 125 or plane.y > 590 or timer > 18: |
| outcome = "Paper missed the mailbox. R: redesign fans" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("PAPER AIRFLOW", "Left click: place fan | Right click: rotate next fan | Place TWO then Space: launch | R: restart") |
| for fan in fans: |
| draw_arc(fan["p"], 125, 0, TAU, 48, Color("345068"), 2) |
| draw_circle(fan["p"], 20, Color("5ef2d0")) |
| draw_line(fan["p"], fan["p"] + directions[fan["direction"]] * 48, Color.WHITE, 5) |
| draw_rect(Rect2(760, 195, 60, 60), Color("ffcd6b")) |
| text_at("MAIL", Vector2(761, 185), 20) |
| draw_colored_polygon(PackedVector2Array([plane + Vector2(16, 0), plane + Vector2(-12, -9), plane + Vector2(-6, 0), plane + Vector2(-12, 9)]), Color.WHITE) |
| text_at("Fans %d / 2 Next direction: %s" % [fans.size(), ["RIGHT", "DOWN", "LEFT", "UP"][facing]], Vector2(270, 125), 20) |
| text_at(outcome, Vector2(230, 625), 25) |
| ''') |
| GAMES[73] = ("Marble Bend", '''extends Node2D |
| var chain: Array[int] = [0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2] |
| var progress: float = 0 |
| var next_color: int = 0 |
| var shot: Vector2 = Vector2.ZERO |
| var shot_velocity: Vector2 = Vector2.ZERO |
| var active: bool = false |
| var removed: int = 0 |
| var outcome: String = "" |
| var colors: Array[Color] = [Color("ff786e"), Color("79d7ff"), Color("ffcd6b")] |
| func reset() -> void: |
| chain = [0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2] |
| progress = 0 |
| next_color = 0 |
| active = false |
| removed = 0 |
| outcome = "" |
| func path(t: float) -> Vector2: |
| return Vector2(150 + t, 255 + sin(t / 130.0) * 70) |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and e.keycode == KEY_R: |
| reset() |
| if e is InputEventMouseButton and e.pressed and e.button_index == MOUSE_BUTTON_LEFT and not active and outcome == "": |
| shot = Vector2(480, 540) |
| shot_velocity = (e.position - shot).normalized() * 450 |
| active = true |
| func _process(dt: float) -> void: |
| if outcome == "": |
| progress += 7 * dt |
| if active: |
| shot += shot_velocity * dt |
| for i in range(chain.size()): |
| if shot.distance_to(path(progress + i * 31)) < 28: |
| chain.insert(i, next_color) |
| var left: int = i |
| var right: int = i |
| while left > 0 and chain[left - 1] == next_color: |
| left -= 1 |
| while right + 1 < chain.size() and chain[right + 1] == next_color: |
| right += 1 |
| if right - left + 1 >= 3: |
| removed += right - left + 1 |
| for j in range(right - left + 1): |
| chain.remove_at(left) |
| next_color = (next_color + 1) % 3 |
| active = false |
| break |
| if shot.y < 95 or shot.x < 10 or shot.x > 950: |
| active = false |
| if chain.is_empty(): |
| outcome = "Chain cleared! R: replay" |
| elif progress + (chain.size() - 1) * 31 > 680: |
| outcome = "Marbles reached the drain. R: retry" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("MARBLE BEND", "Click: launch the displayed marble toward the chain | Insert to make runs of three | R: restart") |
| for t in range(0, 680, 10): |
| draw_line(path(t), path(t + 10), Color("3c506a"), 4) |
| draw_circle(path(680), 26, Color("9e4259")) |
| for i in range(chain.size()): |
| draw_circle(path(progress + i * 31), 14, colors[chain[i]]) |
| draw_circle(Vector2(480, 540), 23, colors[next_color]) |
| if active: |
| draw_circle(shot, 13, colors[next_color]) |
| text_at("Removed %d Remaining %d" % [removed, chain.size()], Vector2(290, 125)) |
| text_at(outcome, Vector2(310, 610), 25) |
| ''') |
| GAMES[74] = ("Moon Window", '''extends Node2D |
| var angle: float = 0.0 |
| var target: float = 4.0 |
| var width: float = 0.8 |
| var wins: int = 0 |
| var misses: int = 0 |
| var pause: float = 0 |
| var outcome: String = "" |
| func reset() -> void: |
| angle = 0 |
| target = 4 |
| width = 0.8 |
| wins = 0 |
| misses = 0 |
| pause = 0 |
| outcome = "" |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and not e.echo: |
| if e.keycode == KEY_R: |
| reset() |
| elif e.keycode == KEY_SPACE and outcome == "" and pause <= 0: |
| var distance: float = absf(wrapf(angle - target, -PI, PI)) |
| if distance < (width + 0.28) * 0.5: |
| wins += 1 |
| width *= 0.77 |
| target = fposmod(target + 2.1, TAU) |
| else: |
| misses += 1 |
| pause = 0.45 |
| if wins == 6: |
| outcome = "Six lunar alignments! R: replay" |
| elif misses == 3: |
| outcome = "Three missed windows. R: retry" |
| func _process(dt: float) -> void: |
| if outcome == "": |
| pause -= dt |
| if pause <= 0: |
| angle = fposmod(angle + (1.5 + wins * 0.22) * dt, TAU) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("MOON WINDOW", "Space: stop the moving lit sector while it overlaps the fixed gold sector | R: restart") |
| draw_circle(Vector2(480, 340), 156, Color("22334d")) |
| draw_arc(Vector2(480, 340), 150, target - width / 2, target + width / 2, 40, Color("ffcd6b"), 24) |
| draw_arc(Vector2(480, 340), 150, angle - 0.14, angle + 0.14, 20, Color("79d7ff"), 18) |
| text_at("ALIGN", Vector2(431, 350), 26) |
| text_at("Aligned %d / 6 Missed %d / 3" % [wins, misses], Vector2(300, 545)) |
| text_at(outcome, Vector2(280, 610), 25) |
| ''') |
| GAMES[75] = ("Torch Return", '''extends Node2D |
| var player: Vector2i = Vector2i(0, 4) |
| var treasures: Array[Vector2i] = [Vector2i(3, 3), Vector2i(7, 6), Vector2i(10, 4)] |
| var torch: float = 90 |
| var outcome: String = "" |
| func reset() -> void: |
| player = Vector2i(0, 4) |
| treasures = [Vector2i(3, 3), Vector2i(7, 6), Vector2i(10, 4)] |
| torch = 90 |
| outcome = "" |
| func wall(p: Vector2i) -> bool: |
| return p.x < 0 or p.y < 0 or p.x >= 12 or p.y >= 9 or (p.x % 3 == 2 and p.y != 1 and p.y != 7) |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed: |
| if e.keycode == KEY_R: |
| reset() |
| var direction: Vector2i = Vector2i.ZERO |
| if e.keycode == KEY_LEFT: |
| direction = Vector2i.LEFT |
| elif e.keycode == KEY_RIGHT: |
| direction = Vector2i.RIGHT |
| elif e.keycode == KEY_UP: |
| direction = Vector2i.UP |
| elif e.keycode == KEY_DOWN: |
| direction = Vector2i.DOWN |
| if outcome == "" and not wall(player + direction): |
| player += direction |
| treasures.erase(player) |
| if treasures.is_empty() and player == Vector2i(0, 4): |
| outcome = "Three treasures brought home! R: explore again" |
| func _process(dt: float) -> void: |
| if outcome == "": |
| torch -= dt |
| if torch <= 0: |
| outcome = "Torch exhausted. R: try a shorter route" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("TORCH RETURN", "Arrows: explore the dark grid | Collect three treasures, then return to entrance | R: restart") |
| for y in range(9): |
| for x in range(12): |
| var p: Vector2i = Vector2i(x, y) |
| var r: Rect2 = Rect2(180 + x * 48, 135 + y * 48, 46, 46) |
| if Vector2(p - player).length() <= 2.5: |
| draw_rect(r, Color("52617a") if wall(p) else Color("293e55")) |
| if treasures.has(p): |
| draw_circle(r.get_center(), 12, Color("ffcd6b")) |
| if p == Vector2i(0, 4): |
| draw_rect(r.grow(-8), Color("5ef2d0"), false, 3) |
| else: |
| draw_rect(r, Color("0a101b")) |
| draw_circle(Vector2(203, 158) + Vector2(player) * 48, 12, Color.WHITE) |
| text_at("Treasures %d / 3 Torch %.0f" % [3 - treasures.size(), maxf(torch, 0)], Vector2(300, 605)) |
| text_at(outcome, Vector2(180, 115), 21) |
| ''') |
| GAMES[76] = ("Four Piston Passage", '''extends Node2D |
| var ball: Vector2 = Vector2(180, 480) |
| var velocity: Vector2 = Vector2.ZERO |
| var pressure: Array[float] = [0.0, 0.0, 0.0, 0.0] |
| var corridor: Array[Rect2] = [Rect2(130, 415, 285, 130), Rect2(295, 235, 120, 310), Rect2(295, 235, 365, 120), Rect2(540, 125, 120, 230), Rect2(540, 125, 285, 110)] |
| var hits: int = 0 |
| var cooldown: float = 0 |
| var outcome: String = "" |
| var directions: Array[Vector2] = [Vector2.LEFT, Vector2.RIGHT, Vector2.UP, Vector2.DOWN] |
| var actions: Array[String] = ["ui_left", "ui_right", "ui_up", "ui_down"] |
| func reset() -> void: |
| ball = Vector2(180, 480) |
| velocity = Vector2.ZERO |
| pressure = [0.0, 0.0, 0.0, 0.0] |
| hits = 0 |
| cooldown = 0 |
| outcome = "" |
| func safe(p: Vector2) -> bool: |
| for offset in [Vector2(-12, 0), Vector2(12, 0), Vector2(0, -12), Vector2(0, 12)]: |
| var ok: bool = false |
| for r in corridor: |
| if r.has_point(p + offset): |
| ok = true |
| if not ok: |
| return false |
| return true |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| cooldown -= dt |
| for i in range(4): |
| pressure[i] = move_toward(pressure[i], 1.0 if Input.is_action_pressed(actions[i]) else 0.0, dt * 3) |
| velocity += directions[i] * pressure[i] * 250 * dt |
| velocity *= exp(-3 * dt) |
| var next: Vector2 = ball + velocity * dt |
| if safe(next): |
| ball = next |
| else: |
| velocity *= -0.3 |
| if cooldown <= 0: |
| hits += 1 |
| cooldown = 0.7 |
| if ball.distance_to(Vector2(785, 180)) < 28: |
| outcome = "Ball delivered through all bends! R: replay" |
| elif hits >= 8: |
| outcome = "Eight pressure collisions. R: use gentler pulses" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("FOUR PISTON PASSAGE", "Hold arrows: independent directional pistons build pressure | Guide ball through the zigzag | R: restart") |
| for r in corridor: |
| draw_rect(r, Color("263e57")) |
| draw_circle(Vector2(785, 180), 28, Color("25855f")) |
| for i in range(4): |
| var origin: Vector2 = ball - directions[i] * (52 - pressure[i] * 20) |
| draw_line(origin - directions[i] * 22, origin, Color("ffcd6b"), 14) |
| draw_circle(ball, 12, Color.WHITE) |
| text_at("Wall strikes %d / 8" % hits, Vector2(60, 585)) |
| text_at(outcome, Vector2(260, 625), 23) |
| ''') |
| GAMES[77] = ("One Then Two", '''extends Node2D |
| var ball: Vector2 = Vector2(210, 430) |
| var velocity: Vector2 = Vector2.ZERO |
| var targets: Array[Vector2] = [Vector2(460, 300), Vector2(690, 330)] |
| var pockets: Array[Vector2] = [Vector2(110, 150), Vector2(850, 150), Vector2(110, 550), Vector2(850, 550)] |
| var order: int = 0 |
| var dragging: bool = false |
| var drag_start: Vector2 = Vector2.ZERO |
| var shooting: bool = false |
| var shots: int = 0 |
| var note: String = "Hit 1, then 2, then any corner pocket." |
| var outcome: String = "" |
| var contact: int = -1 |
| func reset_ball() -> void: |
| ball = Vector2(210, 430) |
| velocity = Vector2.ZERO |
| order = 0 |
| shooting = false |
| contact = -1 |
| func fail_shot(reason: String) -> void: |
| note = reason + " Balls reset." |
| reset_ball() |
| if shots >= 5: |
| outcome = "Five shots exhausted. R: retry" |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and e.keycode == KEY_R: |
| shots = 0 |
| outcome = "" |
| reset_ball() |
| if e is InputEventMouseButton and e.button_index == MOUSE_BUTTON_LEFT and outcome == "" and not shooting: |
| if e.pressed and e.position.distance_to(ball) < 30: |
| dragging = true |
| drag_start = e.position |
| elif not e.pressed and dragging: |
| dragging = false |
| velocity = (drag_start - e.position).limit_length(220) * 3 |
| if velocity.length() > 25: |
| shooting = true |
| shots += 1 |
| func _process(dt: float) -> void: |
| if shooting and outcome == "": |
| ball += velocity * dt |
| velocity *= exp(-0.16 * dt) |
| if ball.x < 120 or ball.x > 840: |
| velocity.x *= -1 |
| ball.x = clampf(ball.x, 120, 840) |
| if ball.y < 160 or ball.y > 540: |
| velocity.y *= -1 |
| ball.y = clampf(ball.y, 160, 540) |
| var touching: int = -1 |
| for i in range(2): |
| if ball.distance_to(targets[i]) < 28: |
| touching = i |
| if contact != i: |
| if i != order: |
| fail_shot("Wrong ball order!") |
| break |
| order += 1 |
| var normal: Vector2 = (ball - targets[i]).normalized() |
| velocity = velocity.bounce(normal) |
| ball = targets[i] + normal * 29 |
| contact = touching |
| for pocket in pockets: |
| if ball.distance_to(pocket) < 30: |
| if order == 2: |
| outcome = "Correct order and pocket! R: replay" |
| else: |
| fail_shot("Pocketed before both contacts!") |
| if shooting and velocity.length() < 20: |
| fail_shot("Shot stopped short.") |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("ONE THEN TWO", "Drag backward from cue ball, release to shoot | Hit numbered balls in order, then a pocket | R: restart") |
| draw_rect(Rect2(100, 140, 760, 420), Color("205945")) |
| for p in pockets: |
| draw_circle(p, 27, Color("101b26")) |
| for i in range(2): |
| draw_circle(targets[i], 16, Color("ffcd6b") if i == 0 else Color("ff786e")) |
| text_at(str(i + 1), targets[i] + Vector2(-6, 7), 20) |
| draw_circle(ball, 12, Color.WHITE) |
| if dragging: |
| draw_line(ball, ball + (drag_start - get_global_mouse_position()).limit_length(220), Color("79d7ff"), 3) |
| text_at("Contacts %d / 2 Shots %d / 5" % [order, shots], Vector2(300, 120), 20) |
| text_at(note if outcome == "" else outcome, Vector2(210, 612), 23) |
| ''') |
| GAMES[78] = ("Falling Symbols", '''extends Node2D |
| var symbols: Array[String] = ["+", "X", "O", "#"] |
| var target: Array[int] = [0, 2, 1, 3] |
| var rows: Array[Dictionary] = [] |
| var next: int = 0 |
| var completed: int = 0 |
| var misses: int = 0 |
| var spawn: float = 0 |
| var outcome: String = "" |
| func reset() -> void: |
| rows.clear() |
| next = 0 |
| completed = 0 |
| misses = 0 |
| spawn = 0 |
| outcome = "" |
| func cell(row: Dictionary, column: int) -> Rect2: |
| return Rect2(270 + column * 110, row["y"], 96, 46) |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and e.keycode == KEY_R: |
| reset() |
| if e is InputEventMouseButton and e.pressed and e.button_index == MOUSE_BUTTON_LEFT and outcome == "": |
| for row in rows: |
| for col in range(4): |
| if cell(row, col).has_point(e.position) and not row["used"].has(col): |
| if row["values"][col] == target[next]: |
| row["used"].append(col) |
| next += 1 |
| if next == 4: |
| completed += 1 |
| next = 0 |
| else: |
| misses += 1 |
| return |
| func _process(dt: float) -> void: |
| if outcome == "": |
| spawn -= dt |
| if spawn <= 0: |
| var values: Array[int] = [0, 1, 2, 3] |
| values.shuffle() |
| rows.append({"y": 175.0, "values": values, "used": []}) |
| spawn = 3 |
| for i in range(rows.size() - 1, -1, -1): |
| rows[i]["y"] += 40 * dt |
| if rows[i]["y"] > 550: |
| if rows[i]["used"].size() < 4: |
| misses += 1 |
| rows.remove_at(i) |
| if completed >= 6: |
| outcome = "Six symbol sequences completed! R: replay" |
| elif misses >= 5: |
| outcome = "Five mistakes or escaped rows. R: retry" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("FALLING SYMBOLS", "Read target left to right | Click the next required symbol in any falling row | R: restart") |
| for i in range(4): |
| draw_rect(Rect2(300 + i * 95, 100, 70, 50), Color("99763e") if i == next else Color("334966")) |
| text_at(symbols[target[i]], Vector2(322 + i * 95, 136), 30) |
| for row in rows: |
| for col in range(4): |
| draw_rect(cell(row, col), Color("203343") if row["used"].has(col) else Color("476587")) |
| if not row["used"].has(col): |
| text_at(symbols[row["values"][col]], cell(row, col).position + Vector2(37, 32), 27) |
| draw_line(Vector2(200, 597), Vector2(770, 597), Color("ff6176"), 3) |
| text_at("Sequences %d / 6 Misses %d / 5" % [completed, misses], Vector2(280, 625), 20) |
| text_at(outcome, Vector2(235, 575), 22) |
| ''') |
| GAMES[79] = ("Corner Runner", '''extends Node2D |
| var distance: float = 0 |
| var jump: float = 0 |
| var tokens: Array[bool] = [false, false, false, false] |
| var outcome: String = "" |
| var obstacles: Array[float] = [220.0, 760.0, 1150.0, 1660.0] |
| func reset() -> void: |
| distance = 0 |
| jump = 0 |
| tokens = [false, false, false, false] |
| outcome = "" |
| func point(t: float) -> Vector2: |
| t = fposmod(t, 1840) |
| if t < 600: |
| return Vector2(180 + t, 190) |
| if t < 920: |
| return Vector2(780, 190 + t - 600) |
| if t < 1520: |
| return Vector2(780 - (t - 920), 510) |
| return Vector2(180, 510 - (t - 1520)) |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and not e.echo: |
| if e.keycode == KEY_R: |
| reset() |
| elif e.keycode == KEY_SPACE and jump <= 0: |
| jump = 0.65 |
| func _process(dt: float) -> void: |
| if outcome == "": |
| distance += 175 * dt |
| jump = maxf(0, jump - dt) |
| var checkpoints: Array[float] = [0.0, 600.0, 920.0, 1520.0] |
| for i in range(4): |
| if absf(fposmod(distance - checkpoints[i] + 920, 1840) - 920) < 18: |
| tokens[i] = true |
| for obstacle in obstacles: |
| if absf(fposmod(distance - obstacle + 920, 1840) - 920) < 22 and jump < 0.1: |
| outcome = "Hit an obstacle! R: jump a little earlier" |
| if distance >= 1840 and not tokens.has(false): |
| outcome = "Four corner tokens and a clean lap! R: replay" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("CORNER RUNNER", "Automatic perimeter run | Space: jump inward over red obstacles | Collect four corner tokens | R: restart") |
| draw_rect(Rect2(180, 190, 600, 320), Color("52617a"), false, 7) |
| for t in obstacles: |
| draw_rect(Rect2(point(t) - Vector2.ONE * 15, Vector2.ONE * 30), Color("ff6176")) |
| var corners: Array[float] = [0.0, 600.0, 920.0, 1520.0] |
| for i in range(4): |
| if not tokens[i]: |
| draw_circle(point(corners[i]), 14, Color("ffcd6b")) |
| var p: Vector2 = point(distance) |
| if jump > 0: |
| p += (Vector2(480, 350) - p).normalized() * sin(jump / 0.65 * PI) * 75 |
| draw_rect(Rect2(p - Vector2.ONE * 11, Vector2.ONE * 22), Color("5ef2d0")) |
| text_at("Lap %d%% Tokens %d / 4" % [int(minf(distance / 1840, 1) * 100), tokens.count(true)], Vector2(315, 140)) |
| text_at(outcome, Vector2(220, 600), 24) |
| ''') |
| GAMES[80] = ("Drifting Radio", '''extends Node2D |
| var settings: Array[float] = [0.25, 0.25] |
| var target: Array[float] = [0.5, 0.65] |
| var selected: int = -1 |
| var clock: float = 0 |
| var stable: float = 0 |
| var outcome: String = "" |
| func reset() -> void: |
| settings = [0.25, 0.25] |
| clock = 0 |
| stable = 0 |
| outcome = "" |
| func slider(i: int) -> Rect2: |
| return Rect2(180, 430 + i * 90, 600, 35) |
| func adjust(p: Vector2) -> void: |
| if selected >= 0: |
| settings[selected] = clampf((p.x - 180) / 600, 0, 1) |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and e.keycode == KEY_R: |
| reset() |
| if e is InputEventMouseButton and e.button_index == MOUSE_BUTTON_LEFT: |
| if e.pressed: |
| for i in range(2): |
| if slider(i).grow(14).has_point(e.position): |
| selected = i |
| adjust(e.position) |
| else: |
| selected = -1 |
| if e is InputEventMouseMotion: |
| adjust(e.position) |
| func _process(dt: float) -> void: |
| if outcome == "": |
| clock += dt |
| target = [0.5 + sin(clock * 0.3) * 0.18, 0.5 + cos(clock * 0.19) * 0.15] |
| var error: float = absf(settings[0] - target[0]) + absf(settings[1] - target[1]) |
| stable = minf(8, stable + dt) if error < 0.09 else maxf(0, stable - dt * 2) |
| if stable >= 8: |
| outcome = "Signal locked for eight seconds! R: retune" |
| elif clock > 90: |
| outcome = "Transmission ended. R: retry" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("DRIFTING RADIO", "Drag FREQUENCY and PHASE sliders | Steady the waveform and track its drift for eight seconds | R: restart") |
| var error: float = absf(settings[0] - target[0]) + absf(settings[1] - target[1]) |
| var previous: Vector2 = Vector2(160, 280) |
| for i in range(101): |
| var x: float = i / 100.0 |
| var y: float = sin(x * 30 + clock * error * 12) * error * 150 + sin(x * 10 + settings[1] * TAU) * 15 |
| var point: Vector2 = Vector2(160 + x * 640, 280 + y) |
| if i > 0: |
| draw_line(previous, point, Color("5ef2d0") if error < 0.09 else Color("ff9568"), 3) |
| previous = point |
| for i in range(2): |
| draw_rect(slider(i), Color("334966")) |
| draw_circle(Vector2(180 + settings[i] * 600, 447 + i * 90), 17, Color("ffcd6b")) |
| var guidance: String = "raise" if settings[i] < target[i] - 0.03 else "lower" if settings[i] > target[i] + 0.03 else "near lock" |
| text_at(("FREQUENCY" if i == 0 else "PHASE") + " - " + guidance, Vector2(180, 416 + i * 90), 20) |
| text_at("Stable %.1f / 8 seconds" % stable, Vector2(340, 140)) |
| text_at(outcome, Vector2(255, 613), 23) |
| ''') |
| GAMES[81] = ("Three Plank Bridge", '''extends Node2D |
| var gaps: Array[int] = [3, 4, 5, 8, 9, 12, 13, 14] |
| var planks: Array[int] = [] |
| var x: float = 105 |
| var running: bool = false |
| var outcome: String = "" |
| func reset() -> void: |
| planks.clear() |
| x = 105 |
| running = false |
| outcome = "" |
| func supported(cell: int) -> bool: |
| if not gaps.has(cell): |
| return true |
| for start in planks: |
| if cell >= start and cell < start + 3: |
| return true |
| return false |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and not e.echo: |
| if e.keycode == KEY_R: |
| reset() |
| elif e.keycode == KEY_SPACE and outcome == "": |
| running = true |
| if e is InputEventMouseButton and e.pressed and not running and e.position.y > 270 and e.position.y < 520: |
| var cell: int = clampi(floori((e.position.x - 84) / 44), 0, 15) |
| if e.button_index == MOUSE_BUTTON_LEFT and planks.size() < 3: |
| planks.append(cell) |
| elif e.button_index == MOUSE_BUTTON_RIGHT: |
| for i in range(planks.size() - 1, -1, -1): |
| if cell >= planks[i] and cell < planks[i] + 3: |
| planks.remove_at(i) |
| break |
| func _process(dt: float) -> void: |
| if running and outcome == "": |
| x += 105 * dt |
| var cell: int = floori((x - 84) / 44) |
| if not supported(cell): |
| outcome = "Unsupported step! R: rebuild the bridge" |
| elif x >= 855: |
| outcome = "Bridge test passed within budget! R: rebuild" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("THREE PLANK BRIDGE", "Left click: place a three-tile plank starting there | Right click: remove | Space: test | R: restart") |
| for i in range(18): |
| var r: Rect2 = Rect2(84 + i * 44, 445, 44, 110) |
| if not gaps.has(i): |
| draw_rect(r, Color("46617d")) |
| else: |
| draw_rect(r, Color("142131")) |
| text_at(str(i), Vector2(97 + i * 44, 590), 16) |
| for start in planks: |
| draw_rect(Rect2(84 + start * 44, 433, 132, 12), Color("ffcd6b")) |
| draw_rect(Rect2(84 + start * 44, 433, 132, 12), Color("996b32"), false, 2) |
| draw_rect(Rect2(x - 10, 405, 20, 28), Color("5ef2d0")) |
| text_at("Budget: %d / 3 planks" % planks.size(), Vector2(335, 190), 25) |
| text_at("Cover every dark gap. Unsupported steps fail immediately.", Vector2(205, 250), 20) |
| text_at(outcome, Vector2(230, 625), 23) |
| ''') |
| GAMES[82] = ("Five Card Skirmish", '''extends Node2D |
| var hp: int = 12 |
| var enemy: int = 16 |
| var energy: int = 3 |
| var turn: int = 0 |
| var intent: int = 0 |
| var shield: int = 0 |
| var note: String = "Choose a card; the previewed enemy action resolves next." |
| var outcome: String = "" |
| var names: Array[String] = ["STRIKE", "HEAVY", "SHIELD", "HEAL", "CHARGE"] |
| var costs: Array[int] = [1, 2, 1, 2, 0] |
| func reset() -> void: |
| hp = 12 |
| enemy = 16 |
| energy = 3 |
| turn = 0 |
| intent = 0 |
| shield = 0 |
| outcome = "" |
| func card(i: int) -> Rect2: |
| return Rect2(50 + i * 174, 390, 160, 155) |
| func play(i: int) -> void: |
| if outcome != "": |
| return |
| if energy < costs[i]: |
| note = "Not enough energy. Use CHARGE." |
| return |
| energy -= costs[i] |
| shield = 0 |
| match i: |
| 0: enemy -= 3 |
| 1: enemy -= 6 |
| 2: shield = 5 |
| 3: hp = mini(12, hp + 5) |
| 4: energy = mini(6, energy + 3) |
| if enemy <= 0: |
| outcome = "Enemy defeated! R: a new skirmish" |
| return |
| if intent == 0: |
| hp -= maxi(0, 3 - shield) |
| note = "Enemy attacked for 3, reduced by this turn's shield." |
| elif intent == 1: |
| hp -= maxi(0, 5 - shield) |
| note = "Enemy used its previewed heavy attack." |
| else: |
| enemy = mini(16, enemy + 2) |
| note = "Enemy recovered 2 health." |
| turn += 1 |
| intent = turn % 3 |
| if hp <= 0: |
| outcome = "You were defeated. R: plan against the preview" |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed and not e.echo: |
| if e.keycode == KEY_R: |
| reset() |
| for i in range(5): |
| if e.keycode == KEY_1 + i: |
| play(i) |
| if e is InputEventMouseButton and e.pressed and e.button_index == MOUSE_BUTTON_LEFT: |
| for i in range(5): |
| if card(i).has_point(e.position): |
| play(i) |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("FIVE CARD SKIRMISH", "Click one of five cards or press 1–5 | Your action, then the previewed enemy turn | R: restart") |
| text_at("YOU: %d / 12 HP Energy %d / 6" % [hp, energy], Vector2(80, 165), 24) |
| text_at("ENEMY: %d / 16 HP" % enemy, Vector2(610, 165), 24) |
| text_at("NEXT ENEMY: " + ["Attack 3", "Heavy attack 5", "Recover 2 HP"][intent], Vector2(285, 245), 26, Color("ff9568")) |
| for i in range(5): |
| draw_rect(card(i), Color("3a526e")) |
| text_at(names[i], card(i).position + Vector2(14, 40), 22) |
| text_at("Cost %d" % costs[i], card(i).position + Vector2(17, 83), 20) |
| text_at(["3 damage", "6 damage", "Block 5", "Heal 5", "+3 energy"][i], card(i).position + Vector2(14, 125), 18) |
| text_at(note if outcome == "" else outcome, Vector2(125, 610), 23) |
| ''') |
| GAMES[83] = ("Color Cargo Train", '''extends Node2D |
| var train: Vector2i = Vector2i(1, 5) |
| var direction: Vector2i = Vector2i.RIGHT |
| var wagons: Dictionary = {Vector2i(3, 5): 0, Vector2i(6, 2): 1, Vector2i(9, 6): 2} |
| var cargo: Array[int] = [] |
| var target: Array[int] = [0, 1, 2] |
| var history: Array[Vector2i] = [] |
| var clock: float = 0 |
| var outcome: String = "" |
| var colors: Array[Color] = [Color("ff6176"), Color("79d7ff"), Color("ffcd6b")] |
| func reset() -> void: |
| train = Vector2i(1, 5) |
| direction = Vector2i.RIGHT |
| wagons = {Vector2i(3, 5): 0, Vector2i(6, 2): 1, Vector2i(9, 6): 2} |
| cargo.clear() |
| history.clear() |
| clock = 0 |
| outcome = "" |
| func _input(e: InputEvent) -> void: |
| if e is InputEventKey and e.pressed: |
| if e.keycode == KEY_R: |
| reset() |
| var next: Vector2i = direction |
| if e.keycode == KEY_LEFT: |
| next = Vector2i.LEFT |
| elif e.keycode == KEY_RIGHT: |
| next = Vector2i.RIGHT |
| elif e.keycode == KEY_UP: |
| next = Vector2i.UP |
| elif e.keycode == KEY_DOWN: |
| next = Vector2i.DOWN |
| if next != -direction: |
| direction = next |
| func _process(dt: float) -> void: |
| if outcome == "": |
| clock += dt |
| if clock >= 0.35: |
| clock = 0 |
| history.push_front(train) |
| if history.size() > 3: |
| history.pop_back() |
| train += direction |
| if train.x < 0 or train.x >= 12 or train.y < 0 or train.y >= 8: |
| outcome = "Train left the tracks! R: retry" |
| elif wagons.has(train): |
| cargo.append(wagons[train]) |
| wagons.erase(train) |
| if cargo[-1] != target[cargo.size() - 1]: |
| outcome = "Wrong wagon order! R: reroute" |
| if train == Vector2i(10, 1): |
| outcome = "Matching train arrived! R: replay" if cargo == target else "Station rejected an incomplete sequence. R: retry" |
| queue_redraw() |
| func point(p: Vector2i) -> Vector2: |
| return Vector2(215, 162) + Vector2(p) * 45 |
| func _draw() -> void: |
| backdrop("COLOR CARGO TRAIN", "Arrows: steer the moving train | Collect RED, BLUE, GOLD in order, then enter station S | R: restart") |
| for y in range(8): |
| for x in range(12): |
| draw_rect(Rect2(point(Vector2i(x, y)) - Vector2.ONE * 21, Vector2.ONE * 42), Color("26394e"), false, 1) |
| for p in wagons: |
| draw_rect(Rect2(point(p) - Vector2.ONE * 15, Vector2.ONE * 30), colors[wagons[p]]) |
| draw_rect(Rect2(point(Vector2i(10, 1)) - Vector2.ONE * 20, Vector2.ONE * 40), Color("31785a")) |
| text_at("S", point(Vector2i(10, 1)) + Vector2(-7, 8), 24) |
| for i in range(mini(cargo.size(), history.size())): |
| draw_rect(Rect2(point(history[i]) - Vector2.ONE * 13, Vector2.ONE * 26), colors[cargo[i]]) |
| draw_circle(point(train), 16, Color.WHITE) |
| text_at("Wagons %d / 3 TARGET: RED > BLUE > GOLD" % cargo.size(), Vector2(230, 555)) |
| text_at(outcome, Vector2(210, 610), 23) |
| ''') |
| GAMES[84] = ("Bubble Passage", '''extends Node2D |
| var bubble: Vector2 = Vector2(160, 570) |
| var air: float = 55 |
| var walls: Array[Rect2] = [Rect2(20, 455, 395, 25), Rect2(445, 455, 495, 25), Rect2(20, 340, 625, 25), Rect2(675, 340, 265, 25), Rect2(20, 225, 305, 25), Rect2(335, 225, 605, 25)] |
| var outcome: String = "" |
| var radius: float = 16 |
| func reset() -> void: |
| bubble = Vector2(160, 570) |
| air = 55 |
| outcome = "" |
| func _process(dt: float) -> void: |
| if Input.is_physical_key_pressed(KEY_R): |
| reset() |
| if outcome == "": |
| var shrink: bool = Input.is_action_pressed("ui_accept") |
| radius = 4.0 if shrink else 16.0 |
| air -= dt * (1.8 if shrink else 1.0) |
| var movement: Vector2 = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down") * 175 |
| var next: Vector2 = bubble + movement * dt |
| next.x = clampf(next.x, 25 + radius, 935 - radius) |
| next.y = minf(600 - radius, next.y) |
| var blocked: bool = false |
| for r in walls: |
| if r.grow(radius).has_point(next): |
| blocked = true |
| if not blocked: |
| bubble = next |
| if bubble.y < 130: |
| outcome = "Surface reached with air to spare! R: dive again" |
| elif air <= 0: |
| outcome = "Air exhausted. R: shrink only at narrow gates" |
| queue_redraw() |
| func _draw() -> void: |
| backdrop("BUBBLE PASSAGE", "Arrows: swim upward through the gates | Hold Space: shrink, using extra air | R: restart") |
| draw_rect(Rect2(20, 95, 920, 35), Color("276c86")) |
| text_at("SURFACE", Vector2(420, 120), 20) |
| for r in walls: |
| draw_rect(r, Color("46617d")) |
| draw_circle(bubble, radius, Color("79d7ff")) |
| draw_arc(bubble, radius, 0, TAU, 24, Color.WHITE, 2) |
| text_at("Air %.1f %s" % [maxf(air, 0), "SHRUNK" if radius < 10 else "NORMAL"], Vector2(30, 625), 22) |
| text_at(outcome, Vector2(320, 625), 22) |
| ''') |
|
|
| if __name__ == "__main__": |
| main() |
|
|
