More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Free-Text Game Actions & Settlement

    2

    Turn free-text player actions into validated game outcomes, with timeout and duplicate-submit handling.

    Free

    2 usesSecurity scanned

    Free-Text Game Actions & Settlement

    Example session with this skill installed

    Use $free-input-output to build an English browser demonstration called Crossing the Frozen Ridge, adapted from my fictional Aotai Crossing case.

    Let the player type an original action. Use the skill's controller for bounded waiting, validation, local fallback, one settlement per in-flight action, and invalidation after restart. A server-side model adapter may interpret the action and write the scene response; game rules must own resources and progression.

    Define Mara and Rowan with stable character cards. Mara has ordinary movement and one thermal wrap. Rowan knows only the visible scene and accepted shared events. Keep the latest two committed turns, up to eight scoped memories, a source-traceable summary, and a bounded estimated context budget. Restart must clear the current run's memories.

    Show careful movement, reuse of a spent thermal wrap, a question about an unseen secret route, offline fallback, and restart. Deliver a playable three-segment H5 prototype, readable English outcomes, actual screenshots, and verification notes. Clearly distinguish the live model run from deterministic fallback and from the reusable skill ZIP.

    • Read your context and instructions
    • Compiled the free-text game actions
    • Generated the document

    Crossing the Frozen Ridge — recorded browser demonstration

    Applied free-input-output's controller and workflow contracts in a separate English three-segment H5 prototype. The gallery shows the repaired browser interface and an actual recorded model-assisted session. The model interprets intent and writes scene text; the game owns inventory, costs and advancement.

    Screenshots from the recorded session

    A player-written action in the repaired English interface

    A live model result with rule-owned costs and progression

    Initial state

    Mara and Rowan begin at segment 1 with energy 76, warmth 76 and resolve 81. They share a rope and have one thermal wrap. Rowan knows the immediate visible scene and accepted shared events. There is no secret map or teleport ability.

    The complete recorded action sequence

    1. Edge-walking the ridge

    Player: I turn sideways and slide along the rock, using Rowan's rope to steady me.

    Scene: You press your side against the cold, unyielding rock, fingers finding purchase in the fissures. The rope pulls taut behind you as you shuffle sideways, keeping your weight centered over the firmer patches of snow to avoid the soft, treacherous drifts.

    Rowan: Keep your eyes on the rock, Mara. Don't look down.

    Settlement: careful; advance one segment; energy / warmth / resolve delta -7 / -4 / +2. Source: live model interpretation, followed by local rule checks.

    2. Warming frozen fingers

    Player: I use the only thermal wrap to warm my hands.

    Scene: You unfold the thermal wrap, its metallic lining crinkling sharply in the biting wind. You cup your numbing hands within the foil, feeling the trapped heat slowly seep back into your skin. The thin material offers a brief, necessary respite from the ridge's relentless chill. Its last stored heat fades into your gloves; the wrap is now spent.

    Rowan: Don't let it blow away, Mara. We need that heat later.

    Settlement: wrap; remain at the current segment; energy / warmth / resolve delta -2 / +12 / +1. Source: live model interpretation, followed by local rule checks.

    3. Your hand finds an empty pocket

    Player: I use the thermal wrap again.

    Scene: The thermal wrap has already been used. Remembering it does not put another one in your pack.

    Rowan: Don't look for what isn't there, Mara. Keep moving.

    Settlement: invalid; remain at the current segment; energy / warmth / resolve delta -2 / -2 / 0. Source: live model interpretation, followed by local rule checks.

    4. A question in the mist

    Player: I ask Rowan whether he knows a secret route to tomorrow's campsite.

    Scene: Rowan looks at you, his eyes tired and squinting against the blowing snow. He shakes his head slowly, gesturing to the featureless white expanse ahead. There are no shortcuts here, only the path we make one step at a time.

    Rowan: If there were a secret route, Mara, I think the mountain would have hidden it better.

    Settlement: talk; remain at the current segment; energy / warmth / resolve delta -1 / -2 / +1. Source: live model interpretation, followed by local rule checks.

    Accepted final state

    {
      "segment": 2,
      "stats": {
        "energy": 64,
        "warmth": 80,
        "resolve": 85
      },
      "inventory": {
        "thermalWrap": 0,
        "rope": 1
      },
      "committedActions": 4,
      "recentDialogueWindow": 2,
      "memoryLimit": 8,
      "acceptedMemoryFacts": [
        "Mara and Rowan crossed segment 1.",
        "Mara used the only thermal wrap.",
        "Mara stayed at segment 2 after invalid.",
        "Mara said: I ask Rowan whether he knows a secret route to tomorrow's campsite."
      ],
      "summaryThroughRevision": 2
    }
    

    Character and memory journal

    Character-card constraints and accepted run-scoped memories

    What the gallery demonstrates

    1. English cover and fictional setting.
    2. A player-written action in the input field.
    3. A live model response with rule-owned resource changes.
    4. Reusing the spent thermal wrap produces an empty-pocket outcome and no advance.
    5. Rowan stays within his visible-scene knowledge when asked about a future secret route.
    6. Character cards, accepted memories and recent dialogue are visible in the journal.

    Verification and use

    The 390×844 and 430×932 browser checks passed. Long dialogue is in the card's normal flow, with scrollable overflow and reachable controls. Single-use supplies, invalid shortcuts, local fallback, pause/resume, completion and replay were exercised. The final normalized H5 directory passed Admission and 29/29 independent Framework checks.

    The reusable skill ZIP includes the English instructions, controller, local examples and 18 controller tests. The gallery records a separately built application of those components. Its six settlement intents and fictional costs are project choices. Real model calls require a separately configured server adapter; no credentials or paid model access are delivered in the skill.

    The prototype's memory is scoped to one run, uses an estimated context budget, and clears on restart. It does not establish cross-session durable memory. Real iOS/Android Host behavior remains unverified. The screenshots are a recorded walkthrough; no public playable model endpoint is offered here.

    For your own game, supply the current state schema, legal costs, advancement rules, character cards, visibility policy, model endpoint and context/memory budget. Run the included controller examples and adapt the host-specific acceptance checks.

    1791862375002-y4bi.png

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Give players a third option: their own idea

    Players do not always want to choose from predefined buttons. This skill helps connect a player's typed action to a complete gameplay result: understandable feedback, legal resource changes, and progression when the game's rules allow it.

    Recorded browser demo: Crossing the Frozen Ridge

    See the six screenshots in this listing for an English H5 prototype built with this skill. The recorded session uses real model interpretation and rule-owned settlement: a careful move advances, a spent thermal wrap cannot be reused, and Rowan cannot reveal an unseen secret route. The journal shows character cards, recent accepted dialogue and scoped memories.

    The model-assisted prototype is a separate case application. The skill ZIP contains the reusable workflow and tested helpers. The screenshots provide a recorded walkthrough; a public playable model service is not bundled.

    What it helps you build

    • A clear boundary between model interpretation and game-state authority.
    • Validation of response structure and gameplay rules before settlement.
    • Readable outcomes for short, empty, noisy, or impossible actions.
    • Bounded waiting and a validated fallback when requests fail or time out.
    • One local settlement for an in-flight action, even when the player submits twice.
    • Invalidation of old responses after restart or a relevant state change.
    • Character-card constraints: stable identity and voice, actor capabilities, NPC knowledge visibility, and separation from mutable game state.
    • Context policies: a project-specific recent-dialogue window, token budget, summary provenance, and protected facts when pruning.
    • Memory policies: short-term versus durable facts, player/save/character scope, current-state priority, and idempotent updates after successful settlement.
    • An explicit degradation ladder under one total deadline, with optional bounded repair and no state change when even the fallback is invalid.

    Character, history, and memory constraints

    A typed claim cannot grant an ability, reveal a secret an NPC has not learned, or overwrite a character card. Current authoritative inventory, resources, relationships, and quest flags take precedence over old dialogue or retrieved memories.

    Choose the recent-turn window and token limits for the actual game and provider. A turn is one committed action and its accepted result; transport retries do not add game history. Summaries and retrieved memories carry sources and scope, and pruning keeps the current action, essential rules, character boundaries, and authoritative state.

    Record accepted memories only after a successful state commit. Ignore speculative candidates, invalid results, and late responses from a previous run. Define save/restart behavior and player/character visibility; indexing failures recover without replaying gameplay settlement.

    The package supplies English workflow contracts, a per-project decision template, and host acceptance scenarios for these features. It does not include a character database, token accountant, summarizer, retrieval backend, or persistent-memory engine. The included tests cover the controller and local example, not those host implementations.

    What is included

    • English SKILL.md, action contract, integration guide, and acceptance checklist.
    • Context and memory contract plus a configurable decision template for character cards, history budgets, memory scope, and degradation.
    • A JavaScript controller with injectable request, validation, timing, and commit callbacks.
    • Traversal result validation and the original Chinese-keyword fallback helper.
    • Original runnable integration example and 18 controller behavior tests.
    • Crossing the Frozen Ridge: an English case adapted from the earlier fictional H5 project Aotai Crossing, with a runnable nine-case demonstration.
    • MIT license and distribution change notes.

    The case

    A fictional mountain-crossing game offers two predefined responses and “I have my own idea.” A careful action can advance the player; rushing has a cost; stopping or attempting an impossible shortcut gives a complete result without granting unauthorized progress. Duplicate submissions, invalid responses, timeouts, and restart are also exercised.

    The bundled command-line demonstration uses deterministic local rules and simulated failures. That command-line example makes no model requests and requires no API key. It is an adaptation of the historical project, not a replay of a live model session or proof that this skill alone generated the original game.

    How to use it

    Ask a compatible agent to use free-input-output on your existing game. Supply the current state schema, legal actions, costs, progression rules, request endpoint, and desired waiting behavior. Request a design, an implementation, or verification of an existing flow.

    Run the bundled examples and tests with Node.js 18+:

    node examples/frozen-ridge-demo.cjs
    node --test tests/test-free-input.cjs
    

    Requirements and boundaries

    This package provides workflow instructions and tested JavaScript helpers. It does not bundle a game engine, model-provider backend, paid model access, or the complete historical H5 game. A real model integration requires the project's server-side adapter and separately configured credentials. Cross-client idempotency and persistent transactions belong to the host server.

    The entrypoint, guides, and new demonstration are in English. Original Chinese-keyword helpers and fixtures are retained for compatibility. Neither local classifier provides general language understanding.

    Open source

    Created and maintained by Whaocaii. Package license: MIT. Public base repository: https://github.com/Whaocaii/ai-game-skills

    This English distribution adds localized documentation and the case demonstration to the public base version; those additions have not yet been pushed to GitHub.

    The skill ZIP includes limited local keyword examples and simulated requests; its original traversal helper matches Chinese keywords. The screenshot gallery documents a separate live-model H5 application, with browser layout, single-use supplies, role boundaries, per-run memory and fallback checks. This is not a formal model-quality benchmark or real-device Host certification. The controller handles one local in-flight settlement; server/cross-client idempotency, authentication and persistent transactions belong to the host. The shown six intents, costs and three-segment story are project choices. Character-card storage, token accounting, summaries, retrieval and durable memory are workflow contracts and host responsibilities. The gallery prototype implements a bounded estimated context window and run-scoped memory, not cross-session memory. The skill ZIP does not bundle Framework, the H5 game, a public playable endpoint, provider credentials or paid model access.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Terminal / Shell, Read Files, and Write Files are appropriate when an agent integrates this skill into a project or runs its local tests. Limit writes to the user-authorized game workspace. The bundled examples make no network requests and require no environment credentials or external accounts. Browser access is conditional on requested UI verification. Network access and server-side environment variables are conditional on a separately authorized real-model integration; no specific provider is mandatory. Review permissions detected by Agensi after ZIP upload. Do not declare optional production services as mandatory for the offline demonstration.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    No. It includes workflow instructions, a controller, validation helpers, and local demonstrations. Connect a server-side model adapter for real language understanding.

    The entrypoint, guides, and new fictional-crossing demonstration are in English. Original Chinese-keyword helpers and fixtures are retained and clearly labeled.

    No. The game decides whether an action is legal and advances. Empty, unclear, or impossible input can receive a complete readable outcome without advancement.

    Yes. Inject your own validation, fallback, and commit callbacks. The three-stat crossing contract is an example, not a required game design.

    No. It handles one controller’s in-flight local settlement. Persistent resources and multiple clients need host-server idempotency and transactions.

    No. The package contains an English case adaptation and reproducible action-settlement example. The historical H5 game is not bundled.

    The package includes the author’s MIT license. Agensi separately applies its platform terms to acquisition and delivery; consult those terms for platform-specific conditions.

    Yes. Its English workflow contract separates stable identity, voice, capabilities, and knowledge from mutable state. A player claim cannot grant abilities or make an NPC know hidden facts. The host implements card storage, visibility checks, and relevant acceptance tests.

    Choose per-game turn and token budgets, summary triggers, and retrieval limits. Memories retain source events and player/save/character scope. Current state wins conflicts. Only committed events create accepted memories, and restart/load behavior is explicit. A policy template is included; storage and summarization are not implemented by the package.

    Use the configured ladder under one total deadline: primary interpretation, optional bounded repair or authorized alternative, validated local fallback, then a recoverable no-commit error if no legal fallback exists. Optional memory failure follows a declared project policy. Retries and indexing failures never replay gameplay settlement.

    New in Game Development