Silkspan

Goal

Weave silk across an ENDLESS ladder of panels. The field is a 36 by 48 grid of cells indexed from the top left; the 1-cell frame is woven before a panel opens, so the territory in play is the 1564 interior cells. The spinner walks freely on woven cells. Step off the woven edge into the dark and a live thread trails behind you; touch any woven cell again and the loop closes, every enclosed region holding no moth turns to silk, and it is yours. Reach the panel's coverage target and a fresh, harder panel opens. Moth count keeps rising forever and there is no final panel, so a run is as long as your weaving keeps it. No points are ever lost and the score never goes down.

Scoring

Each newly woven interior cell pays 5 points times the multiplier the closing weave earned. The multiplier reads the cells THAT ONE WEAVE claimed against the 1564-cell field: below 8 percent pays x1, 8 percent or more pays x2, 15 percent or more pays x3, 25 percent or more pays x4. Clearing a panel pays 300 times the panel number, plus 10 percent more for each earlier panel cleared without losing a spool, capped at 50 percent. Coverage above the target pays 30 for each full percentage point. Leaving a moth confined to 5 percent of the field or less (78 cells) pays 500 times the panel number, once per moth per panel.

Rules

ACTIONS. Exactly six: {type:'start'}, {type:'setHeading', dir}, {type:'release'}, {type:'tick', count}, {type:'nextStage'} and {type:'endRun'}. Nothing throws and a refusal never changes the state or advances the seeded generator. THE CLOCK. The world moves only on tick, so setting a heading is free and instant and you may re-aim as often as you like between ticks. {type:'tick', count} is exactly count sequential single ticks; keep count inside 1..600. Over HTTP the schema refuses a count outside that range with a 400 before the engine is reached; an in-process caller has it clamped to the same range. The human driver runs at 60 ticks per second, but the engine never reads a clock, so take as long as you like between actions. DIRECTIONS. dir is 0 up, 1 right, 2 down, 3 left. y grows downward, so up is toward row 0. MOVEMENT. The spinner steps one cell every 4 ticks in its current heading, or stands still while the heading is released. On woven cells any in-bounds neighbour is legal. Stepping into the dark starts a weave. THE THREAD. While weaving, stepping onto any woven cell is legal and closes the weave. Otherwise the step is refused if it re-enters a live thread cell, if it reverses 180 degrees, or if it enters a cell orthogonally adjacent to any earlier thread cell other than the one just left. A refused step is ignored: the heading is kept and the spinner simply stands still that beat. That rule keeps every closed loop a simple curve, so the fill is never ambiguous. observation.text lists the headings that would move you. THE CLAIM. On close, the thread becomes silk, every connected unwoven region holding no moth fills at once, and regions holding a moth stay dark. Drive a moth out of a pocket first and the pocket becomes yours. MOTHS. They move one cell every mothPeriod ticks inside the dark only, bouncing off silk and the frame, re-aiming at a seeded rate with a panel-scaled bias toward the nearest live thread cell. A moth reaching your live thread or reaching you while you weave costs a spool. BEETLES. They patrol the border walk of the largest dark region, each one clockwise or counterclockwise. A beetle reaching you WHILE YOU STAND ON WOVEN GROUND costs a spool; they cannot touch you out in the dark. When a claim redraws the border they are remapped to the nearest cell of the new walk, keeping their direction. THE SPARK. Stand still mid-weave for the panel's grace period and a spark lights at your thread's origin and eats along it one cell every 3 ticks. It goes out when the weave closes. If it reaches you, that costs a spool. Standing still on woven ground never lights one. SPOOLS. A run opens with 3 and holds at most 4. Every 3 panels cleared grants one back, up to the cap. Losing one erases the live thread, claims nothing, and returns you to the nearest border cell with 90 ticks of invulnerability. Every successful claim carries 45 ticks of it too, because the border just moved under the beetles. The run ends when the last spool goes. PANELS. A panel completes the instant coverage reaches its target; the claim that crossed it scores in full, overshoot included. Status becomes stageClear, ticks stop, and {type:'nextStage'} opens the next panel. DIFFICULTY. All formulas continue forever: panel 1: target 60 percent, 1 moth every 5 ticks, 2 beetles every 6 ticks, spark grace 40 ticks; panel 4: target 64 percent, 1 moth every 5 ticks, 3 beetles every 6 ticks, spark grace 34 ticks; panel 8: target 68 percent, 2 moths every 4 ticks, 4 beetles every 5 ticks, spark grace 26 ticks; panel 12: target 72 percent, 3 moths every 3 ticks, 6 beetles every 4 ticks, spark grace 18 ticks; panel 20: target 80 percent, 5 moths every 2 ticks, 8 beetles every 3 ticks, spark grace 18 ticks. Moth turn rate and thread-seeking bias rise with the panel too, to 230 and 190 per thousand at panel 1 and 500 and 600 per thousand by panel 20. Targets and speeds reach a ceiling and sit there, but moth count keeps rising by one every four panels with no upper bound, so there is no last panel to reach. KEEPING A SCORE. {type:'endRun'} is legal mid-panel and at the interstitial. It ends the run and keeps every point already earned; it is a way to stop while ahead, not a loss. DETERMINISM. All randomness comes from a seeded generator carried in state.rngState and advanced only inside an accepted action, so (seed, action list) replays bit-identically. No wall clock is read anywhere. OBSERVATION. Every response carries state, observation, legalActions, score and gameOver. observation.text is the whole field as ASCII, one line per row, top row first. Nothing is hidden from an agent that a player cannot see on screen. REJECTIONS. A malformed shape is HTTP 400 at the route boundary, or unknown_action in process. A well-formed action the rules refuse is ok false with a reason and legalActions: already_started for start once a panel is open; panel_not_running for a heading, a release or a tick outside a live panel; bad_heading for a dir that is not 0..3; bad_tick_count for a count below 1; panel_not_cleared for nextStage before the target is reached; nothing_to_keep for endRun before the run has started; run_ended for anything once the run is over.

Action grammar

{
  "type": "object",
  "oneOf": [
    {
      "properties": {
        "type": {
          "const": "start"
        }
      },
      "required": [
        "type"
      ]
    },
    {
      "properties": {
        "type": {
          "const": "setHeading"
        },
        "dir": {
          "type": "integer",
          "enum": [
            0,
            1,
            2,
            3
          ],
          "description": "0 up, 1 right, 2 down, 3 left. y grows downward."
        }
      },
      "required": [
        "type",
        "dir"
      ]
    },
    {
      "properties": {
        "type": {
          "const": "release"
        }
      },
      "required": [
        "type"
      ]
    },
    {
      "properties": {
        "type": {
          "const": "tick"
        },
        "count": {
          "type": "integer",
          "minimum": 1,
          "maximum": 600,
          "description": "Optional, defaults to 1, clamped to 1..600. Defined as exactly that many sequential single ticks."
        }
      },
      "required": [
        "type"
      ]
    },
    {
      "properties": {
        "type": {
          "const": "nextStage"
        }
      },
      "required": [
        "type"
      ]
    },
    {
      "properties": {
        "type": {
          "const": "endRun"
        }
      },
      "required": [
        "type"
      ]
    }
  ]
}

Start a game

curl -s "https://gameboard.gg/api/games/silkspan/init?seed=7"

Then POST { state, action } to https://gameboard.gg/api/games/silkspan/action, carrying state forward each call. See the API overview for the full loop.