Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Game Developer Specialist

    1

    Build a bounded gameplay feature in your existing project, preserving rules across code, scenes and saves, with reproducible checks and a clear handoff.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Game Developer Specialist

    Game Developer Specialist

    Example session with this skill installed

    Implement this engine-neutral Python rule fixture as complete copyable code; no filesystem or execution tools are available here. World starts with score=0 and collected=set(). pickup(id) accepts a nonempty string, adds one point only on the first collection of that stable ID, and returns True only when it awards. checkpoint() returns an independent snapshot. restore(snapshot) must validate everything before replacing state: score is a nonnegative integer, collected is a list of unique nonempty strings, and score equals its length. Reject invalid snapshots without changing the world. Include source-level checks and an honest receipt. Do not invent scene integration or executed test results.

    • Read your context and instructions
    • Compiled the game developer specialist

    Illustrative preview: this representative editorial result is not a recorded runtime session.

    task_id: PICKUP-DEV-1
    artifact_id: PICKUP-RULE-FIXTURE
    version: 1
    status: COMPLETE_LOCAL
    producer / recipient: game developer / fixture owner
    objective / scope: Supply complete Python source and check source for the closed rule fixture; execution and game integration are outside this delivered scope.
    inputs_and_sources: The request's score, stable-ID, snapshot and validation rules.
    confirmed_decisions: Successful first collection awards one point; duplicate collection awards none; restoration validates before mutation.
    recommendations_and_pending: Run the checks in the chosen Python environment; actual engine/scene integration needs a separate authorized project context.
    criteria: PICK-1 first award, PICK-2 duplicate denial, SAVE-1 independent snapshot, SAVE-2 atomic validated restore
    next_action: Fixture owner runs the supplied check source and records source/harness hashes and raw output.

    Complete source, not executed:

    class World:
        def __init__(self):
            self.score = 0
            self.collected = set()
    
        def pickup(self, pickup_id):
            if not isinstance(pickup_id, str) or not pickup_id:
                raise ValueError('pickup id must be a nonempty string')
            if pickup_id in self.collected:
                return False
            self.collected.add(pickup_id)
            self.score += 1
            return True
    
        def checkpoint(self):
            return {'score': self.score, 'collected': sorted(self.collected)}
    
        def restore(self, snapshot):
            if not isinstance(snapshot, dict):
                raise ValueError('snapshot must be a mapping')
            score = snapshot.get('score')
            ids = snapshot.get('collected')
            if type(score) is not int or score < 0:
                raise ValueError('invalid score')
            if not isinstance(ids, list):
                raise ValueError('invalid collected list')
            if any(not isinstance(x, str) or not x for x in ids):
                raise ValueError('invalid pickup id')
            validated = set(ids)
            if len(validated) != len(ids) or score != len(validated):
                raise ValueError('inconsistent snapshot')
            self.score, self.collected = score, validated
    

    Separate check source, not executed:

    w = World()
    assert w.pickup('A') is True
    assert w.pickup('A') is False and w.score == 1
    saved = w.checkpoint()
    saved['collected'].append('external')
    assert w.collected == {'A'}
    saved = w.checkpoint()
    assert w.pickup('B') is True
    w.restore(saved)
    assert w.score == 1 and w.pickup('A') is False
    before = w.checkpoint()
    for invalid in [None, {'score': True, 'collected': ['A']},
                    {'score': 2, 'collected': ['A', 'A']},
                    {'score': 1, 'collected': ['']},
                    {'score': 9, 'collected': ['A']}]:
        try:
            w.restore(invalid)
        except ValueError:
            pass
        else:
            raise AssertionError('invalid snapshot accepted')
        assert w.checkpoint() == before
    

    Implementation receipt
    Binding: These supplied source blocks only; no repository commit, file hash, Python version or executed harness binding was obtained.
    Behavior: The authoritative collected set guards the award; checkpoint creates a fresh list; restore builds a validated temporary set before assignment.
    Integration: No scene, collision, audio, animation or save-file I/O was requested or inspected.
    Checks: PENDING; the assertions are planned writer self-checks. No command ran and no PASS or exit code is claimed.
    Limits: This is rule-fixture source, not a playable engine build or independent acceptance. Production file formats, capacity limits and engine integration require their own project contract.

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

    About this skill

    Take the feature all the way into the project.

    Game Developer Specialist guides your coding assistant through a bounded gameplay implementation or defect fix, from the accepted behavior to the actual changes and checks. It is useful when another isolated snippet would leave input, scene setup or save behavior for you to reconcile later.

    The method inspects the current project, preserves settled rules and implements the smallest sufficient change using its conventions. It pays attention to one-shot input, simulation timing, state ownership, repeated events, scene connections and valid save restoration. Relevant asset, audio and animation hooks are part of the integration problem when your feature needs them.

    You receive

    • The authorized source, configuration, scene or asset changes your available tools can produce.
    • Relevant checks against the accepted behavior, including failure and boundary cases.
    • Run instructions, the change rationale and a clear account of what still needs integration or review.

    For example, implement a pickup that awards once per stable item ID and restores consistently from a checkpoint. The method keeps cosmetic effects from issuing another reward and validates saved state before replacing the live world.

    Provide the requested behavior, project access, engine/version and constraints. The standalone method and reference are included. You supply AI access and development tools. Actual project changes require file access; engine and build checks require the appropriate environment. When those tools are absent, the specialist can deliver complete source/check artifacts with the remaining integration steps.

    Implementation depends on available project and file tools. Engine integration, exported builds and target-device behavior require their actual environments. Writer checks do not replace independent acceptance, and no engine, asset pack or AI access is included.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Requires

    Python

    Permissions

    Read Files
    Write Files

    Reading the installed skill and supplied project materials is required for file-based use. Terminal or write access, where declared, is conditional on the requested execution or implementation mode and the buyer's authorization. Planning can use supplied text without those tools. Optional research uses only browsing/network access authorized by the buyer. No credential, environment-variable or account access is mandatory.

    Listed1 month ago
    Updated1 month ago

    What's inside

    Frequently Asked Questions

    Yes. It produces the authorized implementation and relevant source, scene or configuration changes when your assistant has project tools. Text-only use can deliver complete copyable source and checks.

    The feature or defect, settled behavior, existing project, engine/version and constraints. Include relevant source or reproduction details so the change fits the actual game.

    It runs relevant checks when your assistant can access that engine and project. Otherwise, it provides the available source checks and exact pending integration steps.

    No. The independent method and reference are included. The same underlying method also belongs to Game Squad Agent Skills; architecture and QA roles are optional collaborators.

    An illustrative Python rule implementation and separate check source. It demonstrates the deliverable structure; it is not a recorded model session or playable engine build.

    Yes. The method may be used for personal or commercial projects. Keep the purchased instructions private under Agensi's personal, non-transferable source license; review generated code for your project.

    New in APIs & Backend