Put your game in front of players. Get paid when they play.

# Publish my game to KaoGames

Use the KaoGames MCP server (tools: get_publishing_guide, create_game, begin_upload, get_status, get_share_kit).

1. Call get_publishing_guide and check my game against it. Fix anything that would fail (the Kao SDK script, saves through Kao.get/Kao.set, blocked popups or fullscreen, sizing, relative paths). Show me what you changed.
2. Call list_my_games. If this game isn't listed yet, call create_game with a good title, a one-line tagline that sells it, up to 3 genres, the orientation, short controls, and phone_ready only if touch controls really work.
3. Make a production build and zip it with index.html at the top level (include a 16:9 thumb.png if there is one).
4. Call begin_upload and upload the zip with the command it returns.
5. Show me the automatic check results. If there are errors, fix them and upload again.
6. Call get_status and tell me where it stands. Once it's live, call get_share_kit and give me the link and post.

# Turn this artifact into a KaoGames game

I want to publish this artifact as a game on KaoGames (kaogames.com). Give me the whole game as ONE complete, self-contained HTML file that runs on its own in a browser.

## Rules
- One file: everything inline, starting with <!doctype html>. If it is a React artifact, include React from a CDN and compile it so it runs as plain HTML (no build step).
- Scripts from public CDNs (cdnjs, jsdelivr, unpkg) are fine; nothing that needs a server or an API key.
- Replace anything that only works inside Claude (window.claude, window.storage, artifact storage, asking Claude) with the Kao SDK: add <script src="https://kaogames.com/sdk/kao-1.1.0.js"></script>, start the game after Kao.init() resolves, call Kao.ready() once the first frame is drawn, and keep the save in one key with Kao.get('save', defaults) / Kao.set('save', value).
- No popups (window.open), forms, alert/confirm/prompt or its own fullscreen button: the KaoGames player blocks them.
- Fill whatever size it is given and handle resize. If it works with touch, make it play well upright on a phone too.

## When you're done
Give me the complete file in one code block, then list what you changed, and suggest a title, a one-line tagline and up to 3 genres for the listing.

# Make my hosted game linkable on KaoGames

My game is already online and I want to publish it on KaoGames (kaogames.com) by linking to it, so it shows inside their player in an iframe.

1. Find the address that is just the game (its own index.html), not a page with the game embedded in it.
2. Check my hosting config for X-Frame-Options or a Content-Security-Policy frame-ancestors rule. Remove X-Frame-Options, and if there is a CSP, change it to: frame-ancestors 'self' https://kaogames.com
3. Make sure the game fills whatever size it is given, handles resize, and doesn't use popups, forms or its own fullscreen button (the player blocks them).
4. Add the Kao SDK (<script src="https://kaogames.com/sdk/kao-1.1.0.js"></script>, start after Kao.init(), Kao.ready() on the first frame, saves through Kao.get/Kao.set) so loading and cloud saves work.
5. Tell me the exact address to paste into Link it, and what you changed.

# Add the Kao SDK to my HTML5 game

I'm publishing my HTML5 game on KaoGames (kaogames.com).

## The SDK
One script: <script src="https://kaogames.com/sdk/kao-1.1.0.js"></script>. It must load before my game's own code, and creates a global `Kao`:
- Kao.init(): a Promise that resolves when the player's save is ready. Start the game only after it resolves.
- Kao.progress(n): loading progress from 0 to 1, shown on the site's loading bar.
- Kao.ready(): call once the first frame is on screen. It hides the site's loading screen.
- Kao.fail(message): shows an error instead of an endless loading screen.
- Kao.get(key, fallback) and Kao.set(key, value): synchronous saves of any JSON value.

## What to do
1. Add the script tag to index.html before my game's scripts.
2. Wrap my game's startup in Kao.init().then(...).
3. If my game loads assets, report real progress with Kao.progress, and call Kao.ready() right after the first frame is drawn.

## Rules
Don't change gameplay. Show me every file you changed.

# Switch my game's saves to Kao cloud saves

My HTML5 game is going on KaoGames, which gives free cloud saves through the Kao SDK (loaded on the page as the global `Kao`). Replace my game's save system with it.

## How Kao saves work
- Read with Kao.get(key, fallback) and write with Kao.set(key, value). Both are synchronous and take any JSON value.
- Only read saves after Kao.init() has resolved.
- Saves sync as a whole and the newest copy wins, so keep everything that belongs together (progress, unlocks, settings) in ONE key, for example Kao.set('save', {...}).
- Keep the save under 64 KB as JSON. Save progress, never caches or assets.

## What to do
- Remove every direct use of localStorage, sessionStorage, IndexedDB and cookies for saving.
- If players may already have an old save, read it once on startup, copy it into Kao.set('save', ...), then use Kao from then on.

## When you're done
List every place the game saves and confirm each one now calls Kao.set.

# Fix what breaks in the KaoGames player

My HTML5 game will run on KaoGames inside a sandboxed iframe (sandbox="allow-scripts allow-same-origin allow-pointer-lock"). Find and fix anything that won't work there.

## Blocked in the player
- window.open, target="_blank" links, <form> submissions and anything that navigates top or parent. Remove them or replace them with in-game UI, and remove links to other sites.
- requestFullscreen. Remove fullscreen buttons; the site has its own.
- alert, confirm and prompt. Replace them with in-game UI.
- Any check that refuses to run inside an iframe. Remove it.

## Sizing and paths
- Fill whatever size the game is given and handle resizing. Desktop is usually a 16:9 area; phones are full-screen portrait. Use window.innerWidth/innerHeight, listen for resize, and avoid fixed page sizes and page scrollbars.
- Every asset path must be relative (./assets/x.png, not /assets/x.png or a full URL).

## When you're done
List each problem with its file and line, then fix them.

# Make my HTML5 game playable on phones

On KaoGames, games that work on phones get far more players.

## Controls
- Add touch controls for everything that needs a keyboard or mouse (on-screen buttons, taps or swipes, whatever suits the game). Show them only on touch devices.
- Use pointer events so mouse and touch share one code path.
- Stop the page scrolling or zooming during play (touch-action: none on the game canvas).

## Layout
- Work on a portrait phone screen as well as a landscape desktop one, and handle rotation and resizing.
- Make tap targets at least 44px and keep text readable at phone size.

## Speed
Cap the device pixel ratio at 2 and avoid huge textures.

## When you're done
Tell me how to test it in a desktop browser with device emulation.

# Set up my Unity WebGL game for KaoGames

Set up my Unity WebGL game for KaoGames (kaogames.com), with cloud saves and a real loading bar.

## 1. Add the save plugin
Download these two files into my project:
- https://kaogames.com/sdk/unity/KaoPlayerPrefs.cs into Assets/ (anywhere, but not inside a folder with its own .asmdef)
- https://kaogames.com/sdk/unity/KaoPrefs.jslib into Assets/Plugins/WebGL/
KaoPlayerPrefs.cs defines a global PlayerPrefs class, so existing PlayerPrefs calls become cloud saves on KaoGames with no code changes, and behave as normal everywhere else. Check that no script writes UnityEngine.PlayerPrefs in full; if any do, change them to just PlayerPrefs.

## 2. Edit the WebGL template
In my WebGL template's index.html (make a custom template under Assets/WebGLTemplates/ if I use a built-in one):
- Add <script src="https://kaogames.com/sdk/kao-1.1.0.js"></script> before the Unity loader script.
- Call createUnityInstance only after Kao.init() resolves.
- In createUnityInstance's progress callback, call Kao.progress(progress).
- When the instance is created, call Kao.ready(). If it fails, call Kao.fail(message).

## 3. Player Settings
Publishing Settings: Compression Format Brotli (or Gzip), Decompression Fallback off. KaoGames serves compressed files with the right headers.

## 4. Fit the page
Make the canvas fill the page and follow window resizes, instead of a fixed size. Remove Application.OpenURL and fullscreen toggles; the site has its own fullscreen button.

## 5. Build and zip
Build, then zip the contents of the build folder so index.html is at the top of the zip (limits: 30 MB zipped, 80 MB unpacked).

# Package my HTML5 game for upload to KaoGames

## Requirements
- A .zip with index.html at the top level, not inside a folder.
- At most 30 MB zipped, 80 MB unpacked and 1,500 files. Under 15 MB unpacked loads much faster on phones.
- Relative paths for every asset.
- Optional: a 16:9 picture named thumb.png, thumb.jpg or thumb.webp at the top level (1280x720 is ideal). It becomes the game's picture in Discover.

## What to do
- Make a production build: minified, no source maps, no test or dev files.
- Remove unused assets, and compress images where it won't visibly hurt quality.
- Give me the exact commands to create the zip on my computer.

## When you're done
List the zip's top-level contents so I can check index.html is at the root.

# Make a thumbnail for my game from its own assets

My game is going on KaoGames (kaogames.com). Make it a striking thumbnail using the game's own art.

## Step 1: Look at what I have
Go through my project's assets (sprites, textures, 3D models, backgrounds, logos, fonts, colour palette) and the game's code, and tell me what the game is about and what its most exciting moment is. Then pitch three thumbnail ideas in one line each, and ask me to pick one.

## Step 2: Build it
Write something that composes the image from my actual asset files, so I can re-run it whenever the art changes:
- For a 2D game: an HTML page with a canvas (or a small Node or Python script) that layers a background, my main character or object large, and an effect or two, then saves a PNG.
- For a 3D game: a small three.js scene that loads my models, frames a dramatic camera angle and saves a PNG.

## Rules
- 1280 × 720 (16:9), saved as thumb.png, under about 400 KB.
- KaoGames crops thumbnails to 4:3 and to a wide 21:8, so keep the subject and any title inside the centre 960 × 480.
- One big subject filling a third of the frame or more, strong contrast, and a moment of action rather than a menu.
- If there's a title, two or three words, bold, with an outline, readable when the whole image is 150 px wide.
- No small text or interface elements. Only use assets from my project. Don't invent features the game doesn't have.

## When you're done
Show me the result, explain how to re-run it, and remind me to put thumb.png at the top level of my upload zip.

# Check my game before I upload it to KaoGames

For each item answer pass, fail or not sure, with the file and line for every fail.

## Checklist
1. index.html is at the top of the build, and every asset path is relative.
2. The Kao SDK (https://kaogames.com/sdk/kao-1.1.0.js) loads before the game code, the game starts inside Kao.init().then(...), and Kao.ready() is called once something is on screen.
3. Saves use only Kao.get/Kao.set, in one key, under 64 KB. No localStorage, sessionStorage, IndexedDB or cookies.
4. No window.open, target="_blank", forms, alert/confirm/prompt, requestFullscreen, or top/parent navigation.
5. The game fills its container and handles resizing, in landscape and portrait.
6. Touch controls work, if the game is meant to be playable on phones.
7. The build is at most 30 MB zipped and 80 MB unpacked (ideally under 15 MB), with no source maps or dev files.
8. No errors in the console on startup.

## When you're done
Finish with the three most important fixes.