Celeste momentum platforming skill for AI agents

npx -y summer-engine@latest skills install celeste-momentum-platforming --agent claude-code

Player (CharacterBody2D)
├── CollisionShape2D          # compact rectangle; Celeste probes at 2–6 px, so shape must be tight
├── WallProbeLeft (Area2D)    # or use move_and_collide probes at WallJumpCheckDist
├── WallProbeRight (Area2D)
├── StateMachine (ref in script)
└── (AnimatedSprite2D / hair, particles optional)

World
├── TileMapLayer (static solids)
├── OneWayPlatforms (TileMapLayer or StaticBody2D with one-way collision)
└── JumpThru zones

extends CharacterBody2D

# === Tuning table (values from Celeste Player.cs; rescale px if needed) ===
const GRAVITY := 900.0
const MAX_FALL := 160.0
const HALF_GRAV_THRESHOLD := 40.0
const FAST_MAX_FALL := 240.0
const FAST_MAX_ACCEL := 300.0
const MAX_RUN := 90.0
const RUN_ACCEL := 1000.0
const RUN_REDUCE := 400.0
const AIR_MULT := 0.65
const JUMP_GRACE_TIME := 0.1
const JUMP_SPEED := -105.0
const JUMP_H_BOOST := 40.0
const VAR_JUMP_TIME := 0.2
const UPWARD_CORNER_CORRECTION := 4
const WALL_SPEED_RETENTION_TIME := 0.06
const WALL_JUMP_CHECK_DIST := 3
const WALL_JUMP_FORCE_TIME := 0.16
const WALL_JUMP_H_SPEED := MAX_RUN + JUMP_H_BOOST  # 130
const DASH_SPEED := 240.0
const DASH_TIME := 0.15
const END_DASH_SPEED := 160.0
const END_DASH_UP_MULT := 0.75
const DASH_COOLDOWN := 0.2
const DASH_CORNER_CORRECTION := 4
const CLIMB_MAX_STAMINA := 110.0
const CLIMB_UP_COST := 100.0 / 2.2
const CLIMB_STILL_COST := 100.0 / 10.0
const CLIMB_JUMP_COST := 110.0 / 4.0
const CLIMB_UP_SPEED := -45.0
const CLIMB_DOWN_SPEED := 80.0
const CLIMB_SLIP_SPEED := 30.0
const CLIMB_CHECK_DIST := 2

enum St { NORMAL, CLIMB, DASH, SWIM, BOOST, RED_DASH, HIT_SQUASH, LAUNCH, PICKUP, DREAM_DASH }

var state: int = St.NORMAL
var var_jump_timer: float = 0.0
var jump_grace_timer: float = 0.0        # coyote time
var dash_cooldown_timer: float = 0.0
var dash_timer: float = 0.0
var dash_dir: Vector2 = Vector2.ZERO
var wall_jump_force_timer: float = 0.0
var wall_speed_retention_timer: float = 0.0
var stamina: float = CLIMB_MAX_STAMINA

func _physics_process(delta: float) -> void:
    match state:
        St.NORMAL: _normal_update(delta)
        St.DASH:   _dash_update(delta)
        St.CLIMB:  _climb_update(delta)
        # ... remaining states
    move_and_slide()

func _normal_update(delta: float) -> void:
    # --- Gravity with apex float and fast-fall ---
    var max_fall := MAX_FALL
    if Input.is_action_pressed("ui_down") and not is_on_floor():
        max_fall = FAST_MAX_FALL
    var grav := GRAVITY
    if absf(velocity.y) < HALF_GRAV_THRESHOLD and velocity.y < 0.0:
        grav *= 0.5
    velocity.y = minf(velocity.y + grav * delta, max_fall)

    # --- Run acceleration, reduced in air ---
    var input_x := Input.get_axis("ui_left", "ui_right")
    var accel := RUN_ACCEL if is_on_floor() else RUN_ACCEL * AIR_MULT
    if input_x != 0.0:
        velocity.x = move_toward(velocity.x, input_x * MAX_RUN, accel * delta)
    else:
        velocity.x = move_toward(velocity.x, 0.0, RUN_REDUCE * delta)

    # --- Coyote time bookkeeping ---
    if is_on_floor():
        jump_grace_timer = JUMP_GRACE_TIME
    else:
        jump_grace_timer -= delta

    # --- Jump with variable height ---
    if Input.is_action_just_pressed("ui_accept") and jump_grace_timer > 0.0:
        velocity.y = JUMP_SPEED
        velocity.x += signf(input_x) * JUMP_H_BOOST if input_x != 0.0 else 0.0
        var_jump_timer = VAR_JUMP_TIME
        jump_grace_timer = 0.0
    if var_jump_timer > 0.0 and Input.is_action_pressed("ui_accept"):
        var_jump_timer -= delta
        # hold sustains upward velocity; release cuts it
    elif var_jump_timer > 0.0:
        var_jump_timer = 0.0
        if velocity.y < 0.0:
            velocity.y *= 0.5  # jump cut on release (standard platformer pattern)

    # --- Wall probe and wall jump ---
    var wall_dir := _probe_wall()  # raycast WALL_JUMP_CHECK_DIST px each side
    if wall_dir != 0 and Input.is_action_just_pressed("ui_accept"):
        velocity.x = -wall_dir * WALL_JUMP_H_SPEED
        wall_jump_force_timer = WALL_JUMP_FORCE_TIME
        velocity.y = JUMP_SPEED
        var_jump_timer = VAR_JUMP_TIME

    if wall_jump_force_timer > 0.0:
        wall_jump_force_timer -= delta  # lock horizontal input during forced push

    # --- Dash entry ---
    if dash_cooldown_timer <= 0.0 and Input.is_action_just_pressed("dash"):
        state = St.DASH
        dash_dir = _aim_direction()  # 8-way from input axes
        dash_timer = DASH_TIME
        dash_cooldown_timer = DASH_COOLDOWN
        velocity = dash_dir * DASH_SPEED

func _dash_update(delta: float) -> void:
    dash_timer -= delta
    velocity = dash_dir * DASH_SPEED  # no gravity during dash
    if dash_timer <= 0.0 or _collided_during_dash():
        state = St.NORMAL
        # Residual speed: keep EndDashSpeed, reduced for upward dashes
        var residual := END_DASH_SPEED
        if dash_dir.y < 0.0:
            residual *= END_DASH_UP_MULT
        velocity = dash_dir.normalized() * minf(velocity.length(), residual)

func _climb_update(delta: float) -> void:
    var input_y := Input.get_axis("ui_up", "ui_down")
    if input_y < 0.0:
        velocity.y = CLIMB_UP_SPEED
        stamina -= CLIMB_UP_COST * delta
    elif input_y > 0.0:
        velocity.y = CLIMB_DOWN_SPEED
    else:
        velocity.y = minf(velocity.y + GRAVITY * delta * 0.1, CLIMB_SLIP_SPEED)
        stamina -= CLIMB_STILL_COST * delta
    velocity.x = 0.0
    if stamina <= 0.0 or not _touching_wall():
        state = St.NORMAL
    if Input.is_action_just_pressed("ui_accept"):
        stamina -= CLIMB_JUMP_COST
        state = St.NORMAL
        velocity.y = JUMP_SPEED

func _probe_wall() -> int:
    # Space-aware probe: returns -1 (wall left), 1 (wall right), 0 (none)
    # Use move_and_collide or a WALL_JUMP_CHECK_DIST raycast against solids.
    return 0