- Home
- Skills
- Game Development
- gameplay script engineer
More screenshots
Works with the AI Agents you already use
gameplay script engineer
Professional gameplay engineering for Godot and Unity focusing on decoupled architecture and data-driven systems.
$5
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
- Create a new
EnemyStatsResource in the inspector and assign it to thestatsslot. - Attach a
Area2Dto the enemy with aCollisionShape2Dfor the detection radius and wire the signals. - Add
Node2Dmarkers to thepatrol_pointsarray 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
- Intake defining the engine, project scale, and the technical contract for the requested system.
- Architecture Selection choosing patterns like FSMs for AI or signals for cross-system communication.
- Implementation writing GDScript or C# code following strict engine-specific idioms and physics rules.
- 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.
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
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 9 days ago