@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/claude/skills/world-and-story/references/world-kit.md

@@ -0,0 +1,154 @@
+# A world from a kit: scatter, landmarks, the route
+
+Working code, checked in a scratch scaffold on pixi.js 8.21 and three 0.170 (captured and profiled
+at 844×390). Take what helps; change the numbers to the place.
+
+## The kit
+
+Six to twelve pieces in one style carry a whole area. Ways to get them:
+
+| Piece | Tool | Note |
+|---|---|---|
+| 2D props (rock, bush, lamp, crate, fence) | `generate_sprite`, one call per piece with the same style words | a style lock keeps them one family (skill `fp:art`) |
+| A state variant (lamp lit/unlit, bridge broken/mended) | `edit_image` on the accepted sprite | the same drawing changed, so the swap reads as the world changing |
+| Ground and paths | `generate_image` texture or strip (`funtools gen texture`) | seamless tiles under the scatter; the scatter hides the grid |
+| Characters that move | `generate_spritesheet` | idle and walk from one base |
+| 3D props | code-built (below), `generate_3d_model`, or `find_material` type `model` (Poly Haven, CC0) | instance anything placed more than a few times |
+| Sky | `generate_skybox`, or a Poly Haven HDRI via `get_material` | the sky sets the time of day and the palette |
+| A set with a plan | `build_level` (skill `fp:3d`) | interiors, a village square, anything with doors |
+
+## Scatter by rule
+
+Seeded dart-throwing with spacing: denser at the edges, sparse in the open, a clear route and a
+ring around each landmark, jittered scale, flip and tint. Engine-free.
+
+```ts
+// Dress a place from a kit: seeded, spaced, denser at the edges, the path kept clear.
+// Engine-free: it returns placements; Pixi or Three draws them.
+
+export interface Piece { name: string; radius: number; weight: number; zones?: Zone[] }
+export type Zone = 'edge' | 'field' | 'path-side' | 'landmark';
+export interface Placement { piece: string; x: number; y: number; scale: number; flip: boolean; tint: number; zone: Zone }
+export interface Area {
+  w: number; h: number;
+  /** The walkable route as points; pieces keep `clear` away from it, `path-side` pieces hug it. */
+  path: Array<[number, number]>; clear: number;
+  /** Landmarks already placed (a tower, a tree): scatter leaves a ring around each. */
+  landmarks: Array<{ x: number; y: number; r: number }>;
+}
+
+export function rng(seed: number) {
+  return () => { seed = (seed + 0x6d2b79f5) | 0; let t = Math.imul(seed ^ (seed >>> 15), 1 | seed); t ^= t + Math.imul(t ^ (t >>> 7), 61 | t); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
+}
+
+const distToPath = (x: number, y: number, path: Area['path']) => {
+  let best = Infinity;
+  for (let i = 1; i < path.length; i++) {
+    const [ax, ay] = path[i - 1], [bx, by] = path[i], dx = bx - ax, dy = by - ay;
+    const k = Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy || 1)));
+    best = Math.min(best, Math.hypot(x - ax - k * dx, y - ay - k * dy));
+  }
+  return best;
+};
+
+/** Where a point sits: near an edge, beside the path, or in the open field. */
+function zoneOf(x: number, y: number, a: Area): Zone | null {
+  const d = distToPath(x, y, a.path);
+  if (d < a.clear) return null;                                  // the route stays readable
+  if (a.landmarks.some((l) => Math.hypot(x - l.x, y - l.y) < l.r)) return null; // landmarks breathe
+  if (d < a.clear * 1.8) return 'path-side';
+  const edge = Math.min(x, y, a.w - x, a.h - y);
+  return edge < Math.min(a.w, a.h) * 0.14 ? 'edge' : 'field';
+}
+
+/** Dart-throwing with spacing: `tries` candidates, each kept only if no neighbour is closer than the sum of radii. */
+export function scatter(kit: Piece[], a: Area, seed: number, tries = 1500, density: Record<Zone, number> = { edge: 1, 'path-side': 0.6, field: 0.25, landmark: 0 }): Placement[] {
+  const r = rng(seed), out: Placement[] = [], total = kit.reduce((s, p) => s + p.weight, 0);
+  for (let i = 0; i < tries; i++) {
+    const x = r() * a.w, y = r() * a.h, zone = zoneOf(x, y, a);
+    if (!zone || r() > density[zone]) continue;
+    let pick = r() * total, piece = kit[0];
+    for (const p of kit) { pick -= p.weight; if (pick <= 0) { piece = p; break; } }
+    if (piece.zones && !piece.zones.includes(zone)) continue;
+    const scale = 0.8 + r() * 0.45;
+    if (out.some((o) => Math.hypot(o.x - x, o.y - y) < (kit.find((k) => k.name === o.piece)!.radius * o.scale + piece.radius * scale) * 0.9)) continue;
+    const warm = Math.round(235 + r() * 20);                     // a small tint jitter breaks the copy-paste look
+    out.push({ piece: piece.name, x, y, scale, flip: r() < 0.5, tint: (warm << 16) | (Math.round(240 + r() * 15) << 8) | 235, zone });
+  }
+  return out.sort((p, q) => p.y - q.y);                          // back to front for a 2D side or top view
+}
+```
+
+Pixi: draw the placements back to front (they come sorted by y), with the flip and tint.
+
+```ts
+for (const p of scatter(KIT, { w, h, path, clear: 30, landmarks: [tower] }, 42)) {
+  const s = new Sprite({ texture: kitTextures[p.piece], anchor: { x: 0.5, y: 1 } });
+  s.position.set(p.x, p.y); s.scale.set(p.flip ? -p.scale : p.scale, p.scale); s.tint = p.tint;
+  world.addChild(s);
+}
+```
+
+Measured in the lab: about 280 pieces on an 844×390 view drew in 3 draw calls (Pixi batches
+sprites and graphics that share a texture), JS work under 0.5 ms a frame. Put every kit piece on
+one atlas (`npx @funpixel/tools optimize pack-atlas`) so they keep batching.
+
+Three: one `InstancedMesh` per piece kind, so a few hundred props cost a few draw calls.
+
+```ts
+/** Scatter on the XZ plane (area units = metres), one draw call per piece kind. */
+export function dressGround(scene: THREE.Scene, size: number, path: Array<[number, number]>, landmark: THREE.Vector3, seed: number) {
+  const toArea = (x: number, z: number): [number, number] => [x + size / 2, z + size / 2];
+  const placed = scatter(KIT, { w: size, h: size, path: path.map(([x, z]) => toArea(x, z)), clear: 1.6, landmarks: [{ x: landmark.x + size / 2, y: landmark.z + size / 2, r: 4 }] }, seed, 4000);
+  const m = new THREE.Matrix4(), q = new THREE.Quaternion();
+  for (const piece of KIT) {
+    const mine = placed.filter((p) => p.piece === piece.name);
+    const [geo, mat] = GEO[piece.name];
+    const mesh = new THREE.InstancedMesh(geo, mat, mine.length);
+    mesh.name = 'kit-' + piece.name;
+    mine.forEach((p, i) => {
+      q.setFromAxisAngle(new THREE.Vector3(0, 1, 0), (p.x * 13.7) % (Math.PI * 2));
+      mesh.setMatrixAt(i, m.compose(new THREE.Vector3(p.x - size / 2, 0, p.y - size / 2), q, new THREE.Vector3(p.scale, p.scale, p.scale)));
+      mesh.setColorAt(i, new THREE.Color(p.tint));
+    });
+    scene.add(mesh);
+  }
+  return placed.length;
+}
+```
+
+Measured in the lab: 621 instances across the kit and trees, 16 draw calls, 17,640 triangles.
+
+## Landmarks and the route
+
+- One landmark tall enough to see from most of the map, with its own silhouette and light (a
+  tower, a great tree). Place it first; the scatter leaves room around it.
+- The route is the brightest, least cluttered band. In 2D a path texture or a stroked spline
+  (`Graphics.stroke({ width, cap: 'round', join: 'round' })`); in 3D a lighter ground strip.
+- Two or three districts, each with one colour and one material: the orchard is warm and round,
+  the quarry grey and angular. A player should know where they are from one frame.
+- Depth in 2D: two or three parallax layers (far hills move at 0.2–0.4 of the camera, near props
+  at 1.0), the far ones lighter and bluer; in 3D, fog in the sky's colour (skill `fp:art`).
+
+## Contact and life
+
+- A soft shadow under anything standing on the ground (a blurred dark ellipse in 2D; a blob
+  texture or a shadow map in 3D) glues it to the place.
+- Small ambient motion sells a place: grass sway (a sine on rotation with a per-piece phase),
+  drifting particles (pollen, fireflies, dust), water shimmer, smoke. Keep it low contrast so the
+  player and threats stay the clearest things on screen. Respect `prefers-reduced-motion`.
+- Wildlife that reacts (birds that lift off as you pass) is cheap and reads as a living world.
+
+## A minimap, cheaply
+
+A round mask over a small render of the world's layout: in 2D, draw the route and landmarks into a
+`Graphics` in a corner at 1/20 scale with the player as an arrow; in 3D, a top-down orthographic
+camera into a small `WebGLRenderTarget` shown on a plane, or a 2D canvas that draws the same
+positions. Keep it off the thumbs' zones (skill `fp:mobile-ui`).
+
+## Checking a place
+
+- Capture the play view at phone size and ask: can I see the landmark, the route and the goal?
+- `npx @funpixel/tools look --read` for whether the player and threats stand out from the ground.
+- `npx @funpixel/tools profile --views playing` before and after dressing; the draw calls and
+  object count say what the kit costs.

package/plugins/codex/.codex-plugin/plugin.json

@@ -0,0 +1,27 @@
+{
+  "name": "fp",
+  "version": "0.1.0",
+  "description": "Use Funpixel asset tools, game skills and optional studio workflows in your agent. Build, verify and publish browser games with advisory hooks and project-controlled review.",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Funpixel",
+    "url": "https://funpixel.ai"
+  },
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "Funpixel GDK",
+    "shortDescription": "Build, verify and publish browser games",
+    "longDescription": "Game authoring, Blender assets, blind play and critique using the shared Funpixel GDK.",
+    "developerName": "Funpixel",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Read",
+      "Write"
+    ],
+    "websiteURL": "https://funpixel.ai",
+    "defaultPrompt": [
+      "Build one playable mobile game level with the Funpixel GDK."
+    ]
+  }
+}

package/plugins/codex/.mcp.json

@@ -0,0 +1,7 @@
+{
+  "mcpServers": {
+    "funpixel": {
+      "url": "https://api.funpixel.ai/mcp"
+    }
+  }
+}

package/plugins/codex/AGENTS.md

@@ -0,0 +1,135 @@
+<!-- funpixel-gdk:brief -->
+# Game development with the Funpixel toolkit
+
+Start with the creator's goal. An asset repair stays an asset repair; a new game gets the path
+below. The creator and host agent own scope, style and workflow. Recipes here and in the
+skills are defaults, not boundaries: keep locked choices, explore open ones, find another way when
+no recipe fits.
+
+Assets work in any engine; build, preview and publish target browser games (Pixi 8 or Three.js,
+Preact, the SDK).
+
+## The shelf
+
+Skills hold what great looks like, with numbers; each loads in one call (Skill tool or `SKILL.md`):
+- starting, planning or reshaping a game, the GDD: `funpixel-gdd`; code, the SDK, multiplayer:
+  `funpixel-game-spine`; rules, levels, balance, depth and replay: `funpixel-game-logic`
+- the look, 2D art, light and effects: `funpixel-art`; 3D models, the bench and levels: `funpixel-3d`
+- feel and payoffs: `funpixel-game-feel`; a place with a story: `funpixel-world-and-story`; sound
+  and music: `funpixel-audio`; phone HUD, touch: `funpixel-mobile-ui`
+- proving it plays, the panel and blind player: `funpixel-verify`; dev log: `funpixel-feedback`;
+  publish, trailer, store shots, playable ads: `funpixel-publish`; a store: `funpixel-store`;
+  Unity: `funpixel-unity-game`
+
+The session start names the few this game needs. Local hooks advise (`funpixel.json` `gdk.gate`:
+`"block"` or `"off"`; `FUNPIXEL_GDK_GATE`); no setting changes publishing's own checks.
+
+## The path
+
+For a complete game, the path our best games took: you are the person's copilot, not an autopilot.
+A plan made with them is a contract, target frames show what done looks like, and every round
+closes the gap between the two. The locked plan
+is the job; how you build it is yours. Why, tool and signal per step:
+`funpixel-gdd/references/the-path.md`.
+
+Start each session from `npx @funpixel/tools flow`: the owner's notes first (they outrank an
+agent's claim), then the one next step. After every step, a short status in the chat with a
+capture of the build: the owner watches and steers.
+
+1. **Brief back, one screen, one question.** A short brief (title, kind, verb, world, length,
+   failing, look, platforms), your calls in a line each, then one question: is it right? Decide
+   the rest and say it: their ask outranks a standing request.
+2. **First look, then a first playable.** The key art and the hero's reference sheet, shown in
+   the chat for the owner to steer. Then a playable built from them with real assets (the hero,
+   the place in the key art's light, title, music, the verb's sounds), sized by the game (short:
+   about 1 minute; long: 3 to 5), judged against the key art. They play: potential, or not.
+3. **Plan the whole game around it** (skill `funpixel-gdd`): the genre's best, pillars, story,
+   levels and maps, fun and wow moments, screens and HUD, a numbers contract with named tests,
+   the rest of the first look (target frames), the asset list with its price.
+4. **Lock** (`flow ask`): the owner's "looks good, let's build" (price shown; not a cap). It
+   stands until they say otherwise; a new direction is a new GDD version locked again; a
+   departure goes in "Where the build moved", with why.
+5. **Sim first** (`sim`, `test`), then **build with the assets as they land** in `public/assets/`,
+   each judged under the game's light. The slice: one verb, a win and a loss, progress, keys and
+   touch, `check` exits 0.
+6. **Each round, the look-dev loop**: capture at the target moments, set each beside its target
+   (`compare --target`), fix the biggest difference, then play it (`play`, `playtest`). Repeat
+   until each beat is close. Matching the targets is the job, never a style choice: only the owner
+   relaxes a target.
+7. **Extend** chapter by chapter (each to its targets, then the owner's yes); fold a new
+   request into the pillars first.
+8. **Finish when the person plays it and says yes.** Green means stop. When verify passes and the
+   goal is met, stop editing. No renames, restyles or polish nobody asked for; they break what
+   worked and hide which change did what.
+Hand back what plays now (keys and touch), what is out on purpose, the next two or three steps,
+and every stand-in. File the dev log with `report_feedback` before you finish.
+
+## A funtools scaffold
+
+A folder `funtools init` made is a finished frame around a demo round (`init --bare`: none). Replace
+the demo with your game (`rules.ts`, `session.ts`, `game.ts`, `feel.ts`, `hud.tsx`, `screens.tsx`,
+`look.json`, a check per mechanic in `funpixel.json`); keep the frame, host integration and checks.
+
+## Silent failures
+
+- dt is in seconds and clamped: `dt = Math.min(dt, 0.1)`. A background tab hands you one huge
+  frame and everything tunnels. Pixi: `ticker.deltaMS / 1000`, never `deltaTime`.
+- Resize with `setupGameResize((w, h) => …)` from `@funpixel/sdk`, never a `resize` listener or
+  `resizeTo: window`: those miss iframe resizes. It fires once at the call, so create the renderer
+  first.
+- Audio: one `new AudioEngine({ iosPatch: false })` from `@funpixel/sdk/audio`; connect every
+  source to `audio.master` and call `audio.unlock()` from the first click, pointerup or keydown.
+  `iosPatch: false` lets the iPhone ringer switch mute the game; pass `true`
+  only when sound is the game (rhythm, music). Keep an existing game's choice.
+- Pointer handlers use `addEventListener`. Assigning `onpointerdown = …` twice kills the first
+  control without an error.
+- Three: GLBs need `DRACOLoader`, `KTX2Loader` and the meshopt decoder with same-origin decoder
+  paths, an environment map (they render flat grey without one), and `mixer.update(dt)` every frame.
+- Pixi: every display object gets a `.label`; `window.__PIXI_APP__ = app` after `app.init()`.
+- Room codes, share codes and seeds carry `data-funpixel-selectable` (else they cannot be copied).
+- `@funpixel/sdk` is pinned exactly (`"0.7.0"`). Import the root only for `setupGameResize`;
+  everything else from a subpath. Multiplayer is `Room.autoJoin(getGameKey(), …)`, never a raw
+  WebSocket (skill `funpixel-game-spine`).
+- A performance fix changes how a frame is made (pooling, atlases, instancing), never what it shows.
+- Assets arrive as expiring URLs: `npx @funpixel/tools job <id> --wait --out public/assets/<file>`;
+  never base64 in code.
+- Hosts may refuse chains, loops, `sed -i`, heredocs and outside paths: use the edit tool, one
+  command per call (`doctor --host`); keep captures in `design/shots/`.
+
+## Red flags: thoughts before broken games
+
+- "It compiles, so it works." Verify it; a runtime crash builds green.
+- "I'll cast it to make the error go away." Look the name up (skill `funpixel-game-spine`); `as any` and
+  `?.` compile code that does nothing.
+- "The class exists, so the feature exists." Trace it from boot, the loop or an input handler, and
+  give it a check.
+- "The shapes will do for now." They won't: make the planned asset. A shape is only a fallback
+  until it lands; name every one still in the game at hand-back.
+- "The Play button surely works." Press it (skill `funpixel-verify`, front door).
+
+## Spending
+
+Scope, time and spend are the creator's: never shrink an agreed game to save them. The locked plan
+is the go-ahead for its assets: make them (pass `confirm_cost`); before each paid call say the
+route and its cost in one line. No budget unless the owner sets a cap. Out of credits is a pause: say so;
+they top up and you go on. Long jobs return an id: collect
+with `get_job`. Never end a session (headless `-p` too) while a background job, subagent
+or recording runs: a session that ends does not come back. Do the work in the session.
+
+## Hosted and local
+
+The Funpixel MCP does the paid and hosted work; `funtools` runs locally and free. When the MCP is
+not connected, use the local column and say which steps you could not do.
+
+| Job | MCP tool | Local (`npx @funpixel/tools …`) |
+|---|---|---|
+| New game | `create_game`, only with no local files (`init` mints the id) | `init` |
+| Build and preview | `build`, `preview` | `npm run build`, `dev` |
+| Check it plays | `probe`, `screenshot` (`click` presses Play) | `verify`, `verify --watch`, `verify --front-door` |
+| Look at a state | `capture_view`, `audit_screens`, `inspect_scene` | `capture` (`--all`: every view), `audit-screens`, `scene` |
+| Critic panel, blind player | `review`, `play` | `playtest`: `critic`, `player` agent seats |
+| Images, sprites, sheets | `generate_image`, `generate_sprite`, `edit_image`, `generate_spritesheet` | `gen image\|sprite\|edit\|sheet`, `assets gen` |
+| Sound and music | `generate_sound`, `generate_music` | `gen sound`, `gen music` |
+| 3D models | `generate_3d_model`, then the bench tools (skill `funpixel-3d`) | `gen model3d`, `model …` (`--local` on your Blender) |
+| Publish | `publish_game` | `publish` (needs `funtools login`) |
+| Dev log and feedback | `report_feedback` | lines in `.funtools/devlog.jsonl` |

package/plugins/codex/LICENSE

@@ -0,0 +1,115 @@
+Funpixel GDK and funtools (@funpixel/tools)
+
+Required Notice: Copyright 2026 Funpixel (https://funpixel.ai)
+
+These files are licensed under the PolyForm Shield License 1.0.0, below, together with the
+additional permission that follows.
+
+## Additional Permission: Making Games
+
+In addition to the permissions in the license below, the licensor grants you permission to use the
+software, and to make changes and new works based on it, to make, test, publish, sell and run your
+own games and other playable works, whether or not you charge for them. The games you make are yours:
+this license does not reach a game's own code, art, sound, text or other content, or what you earn
+from it, and a game you make is not a product that competes with the licensor's, wherever you
+publish it.
+
+This permission does not cover providing the software, or a product or service based on it, that
+lets others make games (a game-making tool, kit, platform or service). That remains subject to the
+Noncompete section of the license below.
+
+The parts of this package under other licenses keep them: see NOTICE (the bundled devtools, MIT)
+and bench/LICENSE (the Blender bench scripts, GPL-3.0-or-later) where present, and
+THIRD_PARTY_NOTICES.md for the GDK.
+
+---
+
+# PolyForm Shield License 1.0.0
+
+<https://polyformproject.org/licenses/shield/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose.  However, you may only distribute the software according to [Distribution License](#distribution-license) and make changes or new works based on the software according to [Changes and New Works License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license to distribute copies of the software.  Your license to distribute covers distributing the software with changes and new works permitted by [Changes and New Works License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above, as well as copies of any plain-text lines beginning with `Required Notice:` that the licensor provided with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to make changes and new works based on the software for any permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.
+
+## Noncompete
+
+Any purpose is a permitted purpose, except for providing any product that competes with the software or any product the licensor or any of its affiliates provides using the software.
+
+## Competition
+
+Goods and services compete even when they provide functionality through different kinds of interfaces or for different technical platforms.  Applications can compete with services, libraries with plugins, frameworks with development tools, and so on, even if they're written in different programming languages or for different computer architectures.  Goods and services compete even when provided free of charge.  If you market a product as a practical substitute for the software or another product, it definitely competes.
+
+## New Products
+
+If you are using the software to provide a product that does not compete, but the licensor or any of its affiliates brings your product into competition by providing a new version of the software or another product using the software, you may continue using versions of the software available under these terms beforehand to provide your competing product, but not any later versions.
+
+## Discontinued Products
+
+You may begin using the software to compete with a product or service that the licensor or any of its affiliates has stopped providing, unless the licensor includes a plain-text line beginning with `Licensor Line of Business:` with the software that mentions that line of business.  For example:
+
+> Licensor Line of Business: YoyodyneCMS Content Management System (http://example.com/cms)
+
+## Sales of Business
+
+If the licensor or any of its affiliates sells a line of business developing the software or using the software to provide a product, the buyer can also enforce [Noncompete](#noncompete) for that product.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else.  These terms do not imply any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice.  Otherwise, all your licenses end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.
+
+A **product** can be a good or service, or a combination of them.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all its affiliates.
+
+**Affiliates** means the other organizations than an organization has control over, is under the control of, or is under common control with.
+
+**Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.

package/plugins/codex/README.md

@@ -0,0 +1,17 @@
+# Funpixel GDK for Codex
+
+Use Funpixel asset tools, game skills and optional studio workflows in your agent. Build, verify and publish browser games with advisory hooks and project-controlled review.
+
+Enable fp from your marketplace, then review its hooks with `/hooks`. A new chat picks up the installed skills.
+
+Needs funtools: `npm i -g @funpixel/tools` (the kit's CLI; `npx @funpixel/tools …` works too). Then start a game with `$fp-new` "<the game in one line>": the agent briefs it back, makes the key art and a first playable you steer in the chat, plans the whole game around it with you, and builds it round after round with the game open beside the chat.
+
+Commands: `$fp-first-look`, `$fp-flow`, `$fp-lanes`, `$fp-mobile-qa`, `$fp-new`, `$fp-playtest`, `$fp-publish`, `$fp-smoke-build`, `$fp-verify`. Studio workflow: `$fp-studio`. Eight specialist role skills (the seven seats and the lane runner) mirror the Claude package; Codex's SubagentStop records blind critic verdicts.
+
+The portable MCP descriptor carries only the URL. Configure authentication through the host's MCP settings: in `~/.codex/config.toml`, `bearer_token_env_var = "FUNPIXEL_API_KEY"` under `[mcp_servers.funpixel]`. If hosted authentication is unavailable, use the documented funtools fallback; package installation does not prove hosted access.
+
+Copy `AGENTS.md` into a game that has none (`funtools init` writes one). The shared brief and Codex workflow are also injected by SessionStart.
+
+See `skills/fp-studio/SKILL.md` for the exact review evidence format. A real clean-host game run remains the acceptance test.
+
+This folder is built from Funpixel's source and published as is: changes made here are replaced by the next release.

package/plugins/codex/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,75 @@
+# Third-party notices
+
+The Funpixel GDK adapts material from two MIT-licensed projects. Where a skill, agent or rule
+adapts one of them, it says so in a credit line. Everything else is Funpixel's own.
+
+One further source informed the GDK as ideas only, and none of its text is used: PixelLab
+(proprietary).
+
+## scenario-labs/skills (v0.47.0)
+
+Adapted: the skill house style (trigger line, worked example, common mistakes, length cap) and its
+lint; the refine-loop discipline (rubric first, one variable per round, round cap); reference and
+consistency handling; sprite-sheet grid and alignment recipes; audio prompt grammar; the
+"name the reflex" method for variety; and (from 0.48.0's critique rubrics) the critique order
+"numbers first, then eyes; a passing number never excuses a visual failure", used by the critic
+agent and the panel brief that ships with funtools (`panel/brief.md`); the identity-library flow
+(an accepted anchor, then a named collection drawn from it) and the model-comparison method (one
+input, a budget first, the same framing, measured before judged), in `funpixel-art`
+`references/cast.md` and `funpixel-3d` `references/bake-off.md`, and funtools'
+`cast` and `assets` bake-off.
+
+```
+MIT License
+
+Copyright (c) 2026 Scenario
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## Claude Code Game Studios (Donchitos)
+
+Adapted: the studio roles as agents (art director, audio director, QA lead, level designer), the
+session-start context and gap detection hooks, asset-spec and playtest-report practice, the HUD's
+information tiers and element budget (`funpixel-mobile-ui`), and "never two new mechanics in one
+encounter" (`funpixel-game-logic`, the level designer).
+
+```
+MIT License
+
+Copyright (c) 2026 Donchitos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```