More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    gameplay script engineer

    1

    Professional gameplay engineering for Godot and Unity focusing on decoupled architecture and data-driven systems.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    gameplay script engineer

    gameplay script engineer

    Example session with this skill installed

    I need a basic enemy AI for my Godot 4 top-down shooter. It needs to patrol between points and chase the player when they get close. Use a state machine and Resources for the stats.

    • Read your context and instructions
    • Compiled the gameplay script engineer

    I have implemented a decoupled FSM for the enemy AI using Godot 4 GDScript. The system uses a EnemyStats Resource for tuning and signals for player detection to avoid direct node dependencies.

    Enemy AI System (Godot 4)

    
    # enemy_stats.gd
    extends Resource
    class_name EnemyStats
    
    @export var move_speed: float = 200.0
    @export var detection_radius: float = 400.0
    @export var patrol_wait_time: float = 2.0
    
    # enemy_controller.gd
    extends CharacterBody2D
    
    enum State { PATROL, CHASE, IDLE }
    var current_state: State = State.IDLE
    
    @export var stats: EnemyStats
    @export var patrol_points: Array[Node2D]
    var target_point_index: int = 0
    var player: CharacterBody2D = null
    
    func _physics_process(delta: float) -> void:
        match current_state:
            State.IDLE:
                _handle_idle(delta)
            State.PATROL:
                _handle_patrol(delta)
            State.CHASE:
                _handle_chase(delta)
    
    func _handle_patrol(delta: float) -> void:
        if patrol_points.is_empty(): return
        var target = patrol_points[target_point_index].global_position
        var direction = global_position.direction_to(target)
        velocity = direction * stats.move_speed
        
        if global_position.distance_to(target) < 10.0:
            _cycle_patrol_point()
        move_and_slide()
    
    func _on_detection_area_body_entered(body: Node2D) -> void:
        if body.is_in_group("player"):
            player = body
            current_state = State.CHASE
    
    func _on_detection_area_body_exited(body: Node2D) -> void:
        if body == player:
            player = null
            current_state = State.PATROL
    

    Next steps

    1. Create a new EnemyStats Resource in the inspector and assign it to the stats slot.
    2. Attach a Area2D to the enemy with a CollisionShape2D for the detection radius and wire the signals.
    3. Add Node2D markers to the patrol_points array to define the movement path.

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

    About this skill

    Game development code quickly turns into an unmaintainable mess of direct references and magic numbers. This skill provides senior gameplay engineering for Godot 4 and Unity 6, delivering decoupled, data-driven systems that survive the transition from prototype to production.

    What it does

    • Architectural Design implements state machines, event buses, and service patterns to keep systems decoupled.
    • System Implementation builds movement, enemy AI, combat, inventory, and save/load logic.
    • Performance Optimization enforces object pooling and allocation-free logic in hot paths to prevent frame drops.
    • Data Management separates logic from values using Resources or ScriptableObjects for designer-friendly tuning.
    • Save-Safe Versioning ensures persistence systems include version migration to prevent breaking player saves.

    How it works

    1. Intake defining the engine, project scale, and the technical contract for the requested system.
    2. Architecture Selection choosing patterns like FSMs for AI or signals for cross-system communication.
    3. Implementation writing GDScript or C# code following strict engine-specific idioms and physics rules.
    4. Game-Feel Pass adding editor-exposed tuning variables, screen shake hooks, and pause state handling.

    Frameworks & tools

    Specialized for Godot 4 (GDScript) and Unity 6 (C#). It utilizes engine-native features like Signals, Autoloads, ScriptableObjects, and the latest physics APIs.

    Why this beats prompting it yourself

    Generic AI often produces "game jam code" with tight coupling and hardcoded paths that break when you move a node. This skill enforces production-grade standards, ensuring every script has one responsibility and every save file is versioned for long-term stability.

    Use cases

    • Building a state-machine based enemy AI that handles patrol, chase, and attack behaviors.
    • Creating a robust inventory system where item data is stored in external resources.
    • Wiring complex UI HUDs to gameplay events without direct scene references.
    • Implementing a versioned save/load system that doesn't crash after a game update.

    Known limitations

    Does not support older engine versions like Unity 5 or Godot 3. Does not provide 3D models, textures, or audio files. Requires an existing project structure to match architectural patterns.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Game Development.

    Supports Godot 4.x and Unity 6 only. Focuses on gameplay logic; does not generate art, shaders, or audio assets. Existing project patterns take precedence over new architectures.

    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 buying a skill.

    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 9 days ago

    Permissions

    Read Files
    Write Files
    Network Access
    Listed9 days ago

    What's inside

    Frequently Asked Questions

    This skill specializes in professional-grade GDScript (Godot 4) and C# (Unity 6), delivering decoupled code that uses event buses and state machines rather than the fragile, hardcoded references typical of standard AI outputs.

    Yes, it is specifically built for Godot 4 and Unity 6; please note that it does not support legacy versions like Godot 3 or Unity 5 due to significant changes in physics APIs and internal architecture.

    The skill includes the architectural logic, system implementation, and a game-feel pass with editor-exposed variables, but it does not provide visual or audio assets like 3D models or sound effects.

    Absolutely—one of the core features is the implementation of versioned save/load systems that allow you to update your game's data structures without corrupting existing player save files.

    The skill works best when provided with your existing project structure and technical requirements, allowing it to generate code that integrates seamlessly into your specific architectural patterns.

    It prioritizes production-ready performance by enforcing object pooling and allocation-free logic in 'hot paths,' ensuring your gameplay systems remain smooth even during intense action.

    New in Game Development