- Home
- Skills
- Game Development
- unity unreal godot game code debugger
More screenshots
Works with the AI Agents you already use
unity unreal godot game code debugger
Specialized game-engine debugger for Unity, Unreal, and Godot focusing on lifecycle, physics, and timing bugs.
$10.99
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 viatransform.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
- 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
SphereCollideron the projectile is not markedIs Triggerif 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
- Submit context by providing your engine, version, platform, and relevant code or blueprint logic.
- Receive classification as the agent maps the symptom to engine-specific categories like Lifecycle, Timing, or Input Focus.
- Execute instrumentation using the provided logging or breakpoint plan to gather missing evidence.
- 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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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
Permissions
Allowed Hosts
File Scopes
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