gamedev

Plugin gamedev from marketplace greenblacked-ai in greenblacked/AI. Commands read from the repo's manifest — 2 days ago.

Skills (39)

• automated-playthrough

  Build a bot or scripted run that plays the game unattended in CI to find crashes, soft-locks and leaks. Starts with the smallest bot on the riskiest path, drives the game through the player input path rather than internal functions, records a seed with every run so failures replay, writes state, log

• economy-exploit-response

  Contain and repair a live duplication glitch, currency exploit or illegitimate item source as an ordered incident: switch off the narrowest path server-side, quantify from the transaction ledger rather than forum posts, classify accounts as originators, beneficiaries and innocent downstream holders,

• game-accessibility-pass

  Run a structured accessibility review of a game and fix what blocks players. Works by barrier type (vision, hearing, motor, cognitive, speech) against the Game Accessibility Guidelines tiers, one evidence table per area, cheap items first: subtitles on by default with size, background and speaker na

• game-assets

  Get art and audio into a game build without the build eating the disk, the memory or the download: keep lossless source out of the engine's import path, put large binaries behind Git LFS before the history is too big to migrate, choose per-platform texture compression (BC7, ASTC, ETC2) rather than s

• game-audio-event-spec

  Keep a game's sound events in one table that code, audio middleware and designers all read, so a trigger is never a guess. Writes the event table row by row — id, trigger, variants, bus, priority, max instances, voice-steal rule, ducking group, 2D or 3D — then runs a standard-library script that gre

• game-audio-mix

  Set up a game's audio mix so dialogue is intelligible, loudness is consistent across outputs and nothing clips, by measurement rather than by ear on one pair of monitors. Builds a bus hierarchy with player volume controls, voice priority with sidechain ducking that never pumps, integrated LUFS targe

• game-balance

  Tune a game's numbers against evidence rather than taste. Names what balanced means for this game before changing anything — near-equal win rates for a symmetric competitive game, a rising difficulty curve for a single-player one, a spread of viable builds for a roguelike — then instruments win rate

• game-bug-triage

  Write game bugs down so they can be reproduced, and rank them so a release decision can be made. Gives every bug one record of build id, platform and hardware, save file or its hash, RNG seed, input log or replay, and measured repro rate — then assigns a severity from a fixed S1 to S4 scale (S1 is a

• game-builder

  Design and build a playable game scaled to the brief — a one-file browser prototype, a Phaser jam entry, a finished game in Godot, Unity or whatever is in use — or review one that exists and fix what makes it unfun, slow or unmaintainable. Building picks the lightest engine, offers concept direction

• game-certification

  Get a game through platform certification and store submission — the one-time review gate before players see it. Works backwards from the release date to a content lock, sorts the remaining work by whether it can fail cert rather than by visibility, and tests the behaviours nobody plays: suspend and

• game-compat-matrix

  Choose the hardware and driver combinations a game must be tested on, from the installed base rather than from what the studio owns, and triage bugs that occur only on some GPUs or devices. Ranks GPU families, drivers, OS versions and RAM tiers by share and crash rate, selects a covering set small e

• game-design-doc

  Turn a game idea or a design chat into an implementation-ready game feature specification the whole team can build from, designers to QA. Writes out of scope before scope, marks every statement as a confirmed decision, assumption, recommendation or open question, keeps must, should and may distinct,

• game-desync-forensics

  Find the first frame and the subsystem where two peers of a lockstep or rollback game diverge, from a failed hash check or a bug report. Makes the failure replayable (per-peer input log, match seed, build id, a headless single-process replay), replaces one whole-state hash with a per-subsystem hash

• game-economy-flow

  Model a game's economy before launch as data: every currency and tradeable item written as sources and sinks per hour for each player archetype (new, engaged, grinder or whale), kept in a flow sheet that a script reads rather than a spreadsheet nobody reruns. Gates the design on three checks: no cur

• game-greenlight

  Turn a game concept into a chosen idea before any design document exists. Writes a one-page pitch (fantasy, target player, three comparables, why now), reads feasibility against team, time, money, platform and technical risk, and builds a risk register naming the one assumption most likely to sink i

• game-hud-menu-spec

  Write a per-screen spec for a game's HUD and menus, then prove a gamepad can drive every screen. Ranks each piece of information by when the player needs it (always, in a moment of danger, on demand), fixes the safe area, and checks legibility at the smallest supported display and the largest text s

• game-input-mapping

  Build an input layer where gameplay reads named actions, never physical keys: contexts that switch on and off, bindings as data with player overrides kept apart from defaults, a rebind screen that swaps instead of stealing, glyphs that follow the last-used device the frame it changes, radial deadzon

• game-level-design

  Lay out a game level as a space: fix the player metrics — standing and crouching height, step height, jump height and distance, sprint speed, cover height, door width, and the blockout grid — then derive every dimension from them, step the grid down from massing to detail, sort each segment into exp

• game-live-ops

  Run a game after launch: a content and season calendar planned ahead rather than assembled week to week, events with a stated purpose, and economy tuning scheduled with guardrails — this decides what changes and when; any single number still goes through game-balance's evidence procedure. Chooses KP

• game-load-times

  Cut boot and level load times and streaming hitches, measured on the slowest storage the game supports with the OS file cache cleared. Breaks a load into a phase timeline (read, decompress, deserialise, instantiate, GPU upload, initialisation scripts, shader warm-up) on cold and warm runs, so the ra

• game-localisation

  Take a game from one language to many without shipping broken text. Moves every player-facing string into keyed tables with a translator note and a length limit from day one, pseudo-localises early to expose hard-coded and clipped text, handles plurals and gender with ICU MessageFormat rather than c

• game-memory-budget

  Set and enforce per-system memory budgets and find leaks and fragmentation on memory-constrained targets. Writes the platform ceiling less the OS reserve as one budget table in the repository, measures peak (not average) memory in a release build on the real target at fixed checkpoints, runs a twent

• game-narrative-graph-check

  Verify a branching dialogue or quest graph as data before content lock. Exports the graph to a plain node and edge list, then runs a standard-library checker that reports node id and reason for unreachable nodes, dead ends not marked as endings, flags read before any path sets them, equality conditi

• game-netcode

  Choose and implement a multiplayer networking model that survives real latency and dishonest clients. Picks the authority model first from genre and player count — server-authoritative, client-authoritative, deterministic lockstep or rollback — then builds client-side prediction, server reconciliati

• game-patch-size

  Keep post-launch patches and DLC downloads small by making builds deterministic and chunking content so a change touches few bytes. Measures the real download between builds on the staging channel, requires two builds from one commit to be byte-identical, removes drift (timestamps, file ordering, re

• game-performance

  Make a game hold a frame budget on the hardware it ships to. Convert the target frame rate into a millisecond budget, capture frame times from a real build on the target device, judge the 1% low and the 99th percentile rather than an average, prove whether the frame is CPU-bound or GPU-bound before

• game-pillars

  Set three to five design pillars for a game and use them to decide what gets built. Writes each pillar as a sentence that forces a choice between two good things, ties it to a named feature it excludes, tests that a reasonable team could disagree with it, then stress-tests the next five candidate fe

• game-playtest

  Run a game playtest so it ends in decisions rather than opinions: write one question per session tied to a design goal, recruit the target player instead of friends, observe in silence and record behaviour (deaths, quits, time to first success) before asking, choose think-aloud or retrospective narr

• game-save-system

  Design, version and repair a game's save files so player progress survives every future patch. Names the compatibility promise first — how many builds back a save has to load, and what happens outside that window — then picks the format from the promise rather than the other way round, version-tags

• game-server-rollout

  Deploy a new dedicated game server build without killing live matches or stranding players on mismatched versions. Treats the fleet as long-lived sessions, not requests: fixes the version contract first (handshake protocol version, pool keyed by build, an N and N-1 window or a forced update), drains

• handheld-pc-readiness

  Make a PC game work well on Steam Deck and similar handheld PCs, treating Valve's current Deck Verified criteria (input, display, seamlessness, system support) as the spec. Tests on the actual device, not a 1280x800 window, through Proton from a clean install, measures a sustained 30-minute session

• loot-odds-verification

  Prove that drop rates, gacha pulls, crate odds and pity timers do what the design and any published odds say. Verifies three layers separately: the table (exact per-item probability and expected value, including conditional tables, modifiers and pity), the code (ten million or more headless draws th

• matchmaking-tuning

  Tune how a multiplayer game groups players, trading queue time against match quality. States the target as two numbers first (median and p95 queue time per tier, and a quality metric such as predicted win probability of 0.4 to 0.6), checks real population by region, hour, platform and party size bef

• mod-support-design

  Decide whether and how to let players mod a game, then write the commitment down: support level (tolerated, data mods, scripted), a small versioned API the studio dogfoods, a manifest with dependencies and load-order hints, a sandboxed trust model, deterministic load order with safe mode, multiplaye

• npc-behaviour-debugging

  Find out why a computer-controlled character is stuck, stupid or twitchy from recorded decisions instead of guessing. Builds a per-agent debug view (goal, state, last transitions with reasons, believed perception facts, path), reproduces with a pinned seed and a recorded scenario, classifies the fau

• physics-glitch-triage

  Diagnose and fix physics glitches by classifying the symptom first: tunnelling (fast thin object, small collider, large step), jitter (mixed simulation and render timing, platform parenting), exploding or unstable stacks (spawn overlap, extreme mass ratios, solver iterations, scaled bodies), launch

• procgen-seed-testing

  Validate procedurally generated levels, worlds or loot by treating the generator as a function from seed to content and sweeping many seeds. Makes it pure and byte-reproducible across platforms with the generator version in the seed string, encodes hard validity invariants as code run over at least

• scene-merge-conflicts

  Stop teams losing work to conflicts in scenes, prefabs, blueprints and other binary or structured assets. Classifies each asset type as mergeable text, structured but fragile (Unity YAML, Godot tscn) or opaque binary (Unreal uasset and umap), locks opaque binary from day one with read-only checkout,

• shader-compile-stutter

  Eliminate hitches caused by shaders, pipeline state objects and materials compiling the first time they appear. Confirms the pattern first (one-off spike per effect, render or driver thread, gone on a second pass with a warm cache), then clears caches and logs every frame over twice the budget with

Slash commands (2)

• /gamedev:game-data-check

  Check game data tables (JSON or CSV) under a path for ids referenced but never defined, duplicate ids, values outside their declared ranges and rows nothing references, and report file, row and reason with a pass and fail count. Read-only; drop-rate maths and balance are other skills' work.

• /gamedev:level

  Run a level or feature from idea to reviewable through the gamedev skills in order — spec the scope, lay out the space against fixed player metrics, grey-box the loop in it, tune the curve, measure the frame cost on the target device, then size what it adds to the build — with a gate between each st

Subagents (2)

• frame-capture-reader

  Read a profiler capture, frame trace or performance log from a game — a Unity Profiler export, an Unreal Insights trace, a RenderDoc capture summary, a perf record, a console platform capture — and return whether the frame is CPU-bound or GPU-bound with the evidence for the call, the hot frames and

• tuning-literal-reader

  Read a game's gameplay code and return a table of the numeric literals that behave like tuning values — damage, speeds, cooldowns, costs, drop weights, timers, ranges — plus per-frame arithmetic that is missing a delta-time factor, each classed move-to-data, structural constant or unsure, with file

Similar plugins