Przejdź do treści
Biblioteka skilli
Programowanie · Testowanie

qa-game

/qa-game

Dodaje do gry w przeglądarce testy wizualnej regresji, weryfikacji rozgrywki i wydajności.

Repozytorium
game-creator ↗
Licencja
MIT
Ostatnia zmiana repozytorium
04.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 04.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Dodaje do gry w przeglądarce testy wizualnej regresji, weryfikacji rozgrywki i wydajności.

Wyzwalacze z opisu

add teststest my gameadd QAcheck for bugsadd visual regression tests

Argumenty

/qa-game [path-to-game]
Oryginalny opis (EN)

Add browser QA tests to a game — visual regression, gameplay verification, and performance. Use when the user says "add tests", "test my game", "add QA", "check for bugs", or "add visual regression tests". Do NOT use for manual playtesting or gameplay design.

Jak działa

  1. Instructions
  2. Example Usage
  3. Next Step
Sekcje z nagłówków SKILL.md, w oryginale · 132 linii, 922 słów
Podgląd SKILL.md
---
name: qa-game
description: Add browser QA tests to a game — visual regression, gameplay verification, and performance. Use when the user says "add tests", "test my game", "add QA", "check for bugs", or "add visual regression tests". Do NOT use for manual playtesting or gameplay design.
argument-hint: "[path-to-game]"
license: MIT
metadata:
  author: OpusGameLabs
  version: 1.3.0
  tags: [game, qa, testing, cdp, visual-regression]
---

# QA Game

Add automated browser QA testing (Chrome over the DevTools protocol, no npm dependency) to an existing game project. Tests verify your game boots, scenes work, scoring functions, and visuals haven't broken — like a safety net for your game.

## Instructions

Analyze the game at `$ARGUMENTS` (or the current directory if no path given).

First, load the game-qa skill to get the full testing patterns and fixtures.

### Step 1: Audit testability

- Read `package.json` to identify the engine and dev server port
- Read `vite.config.js` for the server port
- Read `src/main.js` to check if `window.__GAME__`, `window.__GAME_STATE__`, `window.__EVENT_BUS__` are exposed
- Read `src/core/GameState.js` to understand what state is available
- Read `src/core/EventBus.js` to understand what events exist
- Read `src/core/Constants.js` to understand game parameters (rates, speeds, durations, max values)
- Read all scene files to understand the game flow
- Read `design-brief.md` if it exists — it documents expected mechanics, magnitudes, and win/lose reachability

### Step 2: Setup browser tests

1. Copy the helpers from the plugin: `mkdir -p scripts && cp <plugin-root>/scripts/cdp.mjs <plugin-root>/scripts/browser-test.mjs scripts/` (needs Node 22+ or Bun and Google Chrome; no npm install), and add the `test`, `test:headed` and `test:update-snapshots` scripts from the `game-qa` skill to `package.json`
2. Create `browser.config.mjs` with the correct dev server port and webServer config
3. Expose `window.__GAME__`, `window.__GAME_STATE__`, `window.__EVENT_BUS__`, `window.__EVENTS__` in `src/main.js` if not already present
4. Create the test directory structure:
   ```
   tests/
   ├── e2e/
   │   ├── game.spec.js
   │   ├── visual.spec.js
   │   └── perf.spec.js
   ├── fixtures/
   │   └── game-test.js
   └── helpers/
       └── seed-random.js
   ```
5. Add npm scripts: `test`, `test:ui`, `test:headed`, `test:update-snapshots`

### Step 3: Generate tests

Write tests based on what the game actually does:

- **game.spec.js**: Boot test, scene transitions, input handling, scoring, game over, restart
- **visual.spec.js**: Screenshot regression for stable scenes (gameplay initial state, game over). Skip active gameplay screenshots — moving objects make them unstable.
- **perf.spec.js**: Load time budget, FPS during gameplay, canvas dimensions

Follow the game-qa skill patterns. Use `gamePage` fixture. Use `page.evaluate()` to read game state. Use `page.keyboard.press()` for input.

### Step 4: Design-intent tests

Add a `test.describe('Design Intent')` block to game.spec.js. These tests catch
mechanics that technically exist but are too weak to matter.

1. **Lose condition**: Detect deterministically whether the game has a lose state.
   Read `GameState.js` — if it has a `won`, `result`, or similar boolean/enum
   field, the game distinguishes win from loss. Also check `render_game_to_text()`
   in `main.js` — if it returns distinct outcome modes (e.g., `'win'` vs
   `'game_over'`), the game has a lose state.

   If a lose state exists: start the game, provide NO input, let it run to
   completion (use `page.waitForFunction` with the round duration from
   Constants.js). Assert the outcome is the losing one (e.g., `won === false`,
   `mode === 'game_over'`).

   **This assertion is non-negotiable.** Do NOT write a test that passes when the
   player wins by doing nothing. If the current game behavior is "player wins
   with no input," that is a bug — write the test to catch it.

2. **Opponent/AI pressure**: If an AI-driven mechanic exists (auto-climbing bar,
   enemy spawning, difficulty ramp), test that it produces substantial state
   changes. Run the game for half its duration without player input. Assert the
   opponent's state reaches at least 25% of its maximum. If `design-brief.md`
   exists, use its expected magnitudes for thresholds. Otherwise, derive from
   Constants.js: calculate `rate * duration` and assert it reaches meaningful
   levels.

3. **Win condition**: Test that active player input leads to a win. Provide rapid
   input throughout the round and assert the outcome is a win.

### Step 5: Entity interaction audit

Audit collision and interaction logic for asymmetries that would confuse a
first-time player.

If `design-brief.md` has an "Entity Interactions" section, use it as the
checklist. Otherwise, audit `GameScene.js` directly:

1. Find all collision handlers, overlap checks, or distance-based interactions
2. Map which entities interact with which others
3. Flag any visible moving entity that interacts with one side (player OR
   opponent) but not the other — add a `// QA FLAG: asymmetric interaction`
   comment in the test file noting the entity name and the asymmetry

This is a flag, not a hard fail. Some asymmetries are intentional (e.g.,
hazards that only affect the player). The flag ensures the asymmetry is a
conscious design choice, not an oversight.

### Step 6: Run and verify

1. Run `npm test` to execute all tests
2. If visual tests fail on first run, that's expected — generate baselines with `npm run test:update-snapshots`
3. Run again to verify all tests pass
4. Summarize results

### Step 7: Report

Tell the user in plain English:

- How many tests were created and what they check
- How to run them: `npm test` (headless), `npm run test:headed` (see the browser), `npm run test:update-snapshots` (accept new screenshots)
- "These tests are your safety net. Run them after making changes to make sure nothing broke."

## Example Usage

```
/qa-game examples/flappy-bird
```
Result: Copies the browser test helpers → creates 15 tests (boot, scene transitions, input, scoring, restart, game-over, visual regression, FPS, load time) → generates `tests/` directory with fixtures and helpers → all tests pass. Run `npm test` anytime after changes.

## Next Step

Tell the user:

> Your game now has automated tests! Finally, run `/game-creator:review-game` for a full architecture review — it checks your code structure, performance patterns, and gives you a score with specific improvement suggestions.
>
> **Pipeline progress:** ~~/viral-game~~ → ~~/design-game~~ → ~~/add-audio~~ → ~~/qa-game~~ → `/review-game`
>
> *(This is the `/viral-game` one-shot pipeline — not the `/make-game` multi-session, milestone-driven workflow.)*

Wersje

W bazie nie ma innych skilli o nazwie qa-game.

Migawka bazy z 13.11.2026 · wersja paczki 8c33256341c8 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100game-qa
    Pisze i uruchamia testy gier w przeglądarce przez protokół DevTools: testy regresji wizualnej, rozgrywki i wydajności.
  • 100add-feature
    Dodaje mechanikę do istniejącej gry w przeglądarce zgodnie z jej architekturą, np. power-up albo tablicę wyników.
  • 100gds-test-automate
    Generuje zautomatyzowane testy dla systemów rozgrywki w projekcie gry.
  • 100game-e2e-integration-qa
    Uruchamia w przeglądarce scenariusze Playwright, zrzuty ekranu i testy regresji całych przepływów po zmianach w grze.
  • 100gds-test-automate
    Generuje zautomatyzowane testy systemów rozgrywki w grach, by wykrywać regresje po każdej zmianie.
  • 100writing-visual-tests
    Dodaje testy regresji wizualnej, czyli zrzuty ekranu stron i paneli interfejsu Opik, z unikalnymi nazwami i maskowaniem.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.