More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    unity unreal godot game code debugger

    2

    Specialized game-engine debugger for Unity, Unreal, and Godot focusing on lifecycle, physics, and timing bugs.

    $10.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    unity unreal godot game code debugger

    unity unreal godot game code debugger

    Example session with this skill installed

    My Unity projectile sometimes passes through enemies without triggering a collision. It moves using transform.position in Update and has a Rigidbody and SphereCollider.

    • Read your context and instructions
    • Compiled the unity unreal godot

    The projectile is likely "tunneling" because it moves too fast for the discrete physics step, combined with a conflict between manual Transform mutation and the Rigidbody's simulation.

    Debugging Diagnosis: Projectile Tunneling

    Bug Classification: GCD-009 TRANSFORM_PHYSICS_CONFLICT / GCD-007 PHYSICS_TIMING
    Severity: HIGH

    Lifecycle & Physics Map

    • Input/Logic: Update() moves the transform manually via transform.position += ...
    • Physics Step: FixedUpdate() runs at a discrete interval (e.g., 0.02s).

    The Conflict: By teleporting the transform in Update, the physics engine may never see the projectile overlap the enemy's collider if the "step" jump is larger than the enemy's bounding box.

    Ranked Hypotheses

    1. Transform/Physics Conflict (HIGH): Manual transform updates bypass the Rigidbody's sweep tests.

    Discrete Collision Detection (MEDIUM): Projectile velocity exceeds the width of the target collider per physics frame.
    3. Layer Matrix Mismatch (LOW): The projectile and enemy layers are not set to collide.

    Targeted Fix

    // 1. Move logic to FixedUpdate
    // 2. Use Rigidbody.MovePosition or velocity instead of transform.position
    // 3. Set Collision Detection to Continuous
    
    public class Projectile : MonoBehaviour 
    {
        [SerializeField] private float speed = 50f;
        private Rigidbody rb;
    
        void Awake() 
        {
            rb = GetComponent<Rigidbody>();
            // Essential for fast-moving small objects
            rb.collisionDetectionMode = CollisionDetectionMode.Continuous;
        }
    
        void FixedUpdate() 
        {
            Vector3 moveOffset = transform.forward * speed * Time.fixedDeltaTime;
            rb.MovePosition(rb.position + moveOffset);
        }
    }
    

    Next Steps

    • Verify the SphereCollider on the projectile is not marked Is Trigger if you expect a physics impact.
    • Check

    Project Settings > Physics to ensure the collision layers for "Projectile" and "Enemy" are checked in the matrix.

    • Test at a lower Time.timeScale (e.g., 0.1) to visually confirm the collision occurs.

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

    About this skill

    Game logic bugs are rarely about a single line of code. They are usually failures in lifecycle timing, physics authority, or object ownership that generic AI assistants miss. This skill provides engine-aware diagnosis for Unity, Unreal Engine, and Godot to find exactly why your game state is desyncing or crashing.

    What it does

    • Engine-aware diagnosis analyzes code through the lens of specific engine lifecycles like FixedUpdate, BeginPlay, or _physics_process.
    • Ranked root-cause hypotheses provides multiple potential causes labeled by confidence levels (HIGH, MEDIUM, LOW) based on evidence.
    • Diagnostic instrumentation generates targeted logging plans to capture frame numbers, instance IDs, and physics states.
    • Reproduction strategy creates minimal test cases to isolate bugs from complex project dependencies.
    • Regression prevention delivers specific test matrices to ensure fixes hold across scene reloads, builds, and varying frame rates.

    How it works

    1. Submit context by providing your engine, version, platform, and relevant code or blueprint logic.
    2. Receive classification as the agent maps the symptom to engine-specific categories like Lifecycle, Timing, or Input Focus.
    3. Execute instrumentation using the provided logging or breakpoint plan to gather missing evidence.
    4. Apply fix based on the targeted solution and verification checklist.

    Frameworks & tools

    Supports Unity (C#), Unreal Engine (C++, Blueprints), and Godot (GDScript, C#). It understands engine-specific systems including Unity Addressables, Unreal Enhanced Input, and Godot SceneTrees.

    Why this beats prompting it yourself

    Generic LLMs often suggest a "null check" which only hides the bug. This skill identifies why the reference is null by analyzing scene transitions and initialization order. It stops you from fighting the engine and helps you work with its internal loops.

    Use cases

    • Debugging physics jitter caused by transform mutation fighting the physics solver.
    • Fixing input actions that fire twice or stop working after a scene transition.
    • Resolving coroutine or async failures when objects are destroyed during waits.
    • Identifying why saved data loads correctly but is overwritten by default values a frame later.

    Known limitations

    Cannot prove runtime behavior without supplied logs or instrumentation results. Requires server/client authority context for networking bugs. Blueprint analysis depends on provided screenshots.

    The agent can diagnose code and architecture from supplied source, logs, screenshots, stack traces, project configuration, and reproduction details, but it cannot directly observe runtime state unless that state is exposed through connected tools, logs, project files, instrumentation, or user-provided evidence.

    Some bugs may depend on:

    Exact Engine Version
    Package Version
    Plugin Version
    Operating System
    Graphics Backend
    Physics Settings
    Frame Rate
    Build Configuration
    Hardware
    Input Device
    Network Conditions

    and may therefore require reproduction inside the actual project.

    Blueprint screenshots can hide:

    Default Values
    Collapsed Graphs
    Execution Paths
    Runtime References
    Component Configuration
    Instance Overrides

    so screenshots alone may not always establish the root cause.

    Unity Inspector state and Godot scene-tree configuration may also contain critical values that are not visible in code.

    Networked Unreal problems cannot be diagnosed reliably without knowing:

    Authority
    Ownership
    RPC Direction
    Replication State
    Server / Client Context

    Save/load bugs may require the actual serialized data or schema history.

    Build-only failures may require packaged/exported logs.

    Performance problems require profiling evidence; source inspection alone cannot reliably establish the dominant runtime bottleneck.

    A theoretically correct code change can still cause project-specific side effects.

    Every fix should therefore be tested against:

    Original Reproduction
    Scene Reload
    Object Respawn
    Pause / Resume
    Relevant Frame Rates
    Target Build
    Relevant Platforms

    when applicable.

    The skill does not replace actual engine execution, automated testing, profiling, or playtesting.

    Its strongest role is to turn vague game-engine symptoms into:

    Ranked Hypotheses
    Provable Diagnostic Steps
    Root-Cause Fixes
    Regression Tests
    Engine-Specific Verification

    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

    Google Drive
    GitHub
    Notion
    Dropbox
    Linear
    OpenAI

    Permissions

    Write Files
    Browser
    Read Files

    Allowed Hosts

    drive.googleapis.com
    api.github.com
    api.notion.com
    api.dropboxapi.com
    api.linear.app
    api.openai.com

    File Scopes

    **/*.cs
    **/*.cpp
    **/*.cc
    **/*.cxx
    **/*.h
    **/*.hpp
    **/*.gd
    **/*.gdscript
    **/*.json
    **/*.jsonl
    **/*.yaml
    **/*.yml
    **/*.xml
    **/*.ini
    **/*.cfg
    **/*.config
    **/*.txt
    **/*.md
    **/*.log
    **/*.csv
    **/*.tsv
    **/*.asset
    **/*.meta
    **/*.prefab
    **/*.unity
    **/*.asmdef
    **/*.uproject
    **/*.uplugin
    **/*.Build.cs
    **/*.Target.cs
    **/*.godot
    **/*.tscn
    **/*.tres
    **/*.res
    **/*.png
    **/*.jpg
    **/*.jpeg
    **/*.webp
    **/unity/**
    **/unreal/**
    **/unreal-engine/**
    **/godot/**
    **/assets/**
    **/Assets/**
    **/scripts/**
    **/Scripts/**
    **/source/**
    **/Source/**
    **/code/**
    **/game/**
    **/gameplay/**
    **/controllers/**
    **/player/**
    **/characters/**
    **/actors/**
    **/components/**
    **/blueprints/**
    **/Blueprints/**
    **/prefabs/**
    **/Prefabs/**
    **/scenes/**
    **/Scenes/**
    **/levels/**
    **/Levels/**
    **/nodes/**
    **/resources/**
    **/Resources/**
    **/input/**
    **/Input/**
    **/physics/**
    **/Physics/**
    **/collision/**
    **/spawning/**
    **/pooling/**
    **/async/**
    **/coroutines/**
    **/timers/**
    **/state-machines/**
    **/animation/**
    **/save/**
    **/saves/**
    **/save-system/**
    **/serialization/**
    **/network/**
    **/multiplayer/**
    **/replication/**
    **/logs/**
    **/crash-logs/**
    **/debug/**
    **/profiling/**
    **/tests/**
    **/playtests/**
    **/bugs/**
    **/bug-reports/**
    **/docs/**
    **/documentation/**
    **/output/**

    Use Read Files to inspect authorized: Source Code Project Configuration Scene Files Unity Prefabs Godot Scenes Unreal Configuration Logs Stack Traces Crash Reports Save Data Serialization Definitions Bug Reports Playtest Reports Technical Documentation Use Write Files only when the user requests creation or modification of derived artifacts such as: Patched Code Diagnostic Logging Regression Tests Debug Reports Reproduction Projects Architecture Notes Save Migration Logic Test Plans Bug Documentation Use Browser when current authoritative documentation is required for: Unity Version-Specific APIs Unreal Engine Version-Specific Behavior Godot Version-Specific Behavior Plugin Documentation Package Documentation Breaking Changes Known Engine Issues Recommended connected services: GitHub: Highly relevant for inspecting repositories, branches, commits, pull requests, issue history, code changes, regressions, and project architecture. Google Drive: Useful for project archives, exported logs, screenshots, design documents, crash reports, test reports, and shared debugging artifacts. Dropbox: Useful for large project snapshots, builds, logs, videos, screenshots, and exported engine files. Notion: Useful for technical documentation, gameplay architecture, bug databases, reproduction procedures, state diagrams, and debugging notes. Linear: Useful for issue tracking, regression history, reproduction steps, severity, ownership, and verification status. OpenAI: Relevant for code analysis, debugging, reasoning, refactoring, test generation, and technical documentation workflows. Always establish, when possible: Engine Engine Version Language Target Platform Expected Behavior Actual Behavior Reproduction Steps Relevant Code Scene / World Context Recent Changes Logs Do not assume the line that throws the exception is the root cause. Always consider: Lifecycle Timing Ownership Scene Lifetime Frame Rate Physics Tick Event Subscription Input Context Async Lifetime For required dependencies: Do not hide initialization errors with generic null guards. For physics: Do not recommend Transform-based movement for physics-controlled objects without understanding the intended movement authority. For asynchronous operations: Check whether the operation can outlive: GameObject Actor Node Scene World State For pooled objects: Always consider reset completeness. For build-only bugs: Compare: Editor Standalone Packaged / Exported Build Target Platform For Unreal multiplayer: Identify: Server Owning Client Remote Client Authority Ownership RPC Direction before diagnosing shared-state problems. For Blueprint screenshots: Be explicit when hidden pin values, collapsed graphs, unshown branches, or runtime instance values prevent definitive diagnosis. For performance problems: Prefer profiling evidence over speculation. The objective is: Prove the root cause → Apply the smallest correct fix → Verify it → Prevent regression

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill specializes in engine-specific lifecycle and state bugs, such as physics jitter or execution order conflicts, which generic AI often misses by only looking at syntax rather than runtime logic.

    It is compatible with Unity (C#), Unreal Engine (C++ and Blueprints), and Godot (GDScript and C#), covering modern versions and core systems like Addressables and SceneTrees.

    You will receive the specialized agent skill profile, a set of diagnostic instrumentation templates for targeted logging, and a verification checklist for regression testing.

    Yes, the agent provides engine-specific instrumentation plans that tell you exactly what to log—such as frame numbers or instance IDs—to gather the evidence needed for a fix.

    While it can diagnose logic in multiplayer contexts, you must provide the specific server/client authority context and relevant network logs for it to identify synchronization issues.

    Simply import the skill into your preferred AI agent platform and provide your engine version and platform details to begin the diagnostic workflow.

    New in Game Development