Introduction
Game development is a multidisciplinary craft that blends programming, art, design, and storytelling. Whether you are prototyping a new mechanic, debugging a complex shader, or optimizing a level for performance, the right prompt can save hours of trial and error. This article provides a curated collection of 10 ready-to-use prompts tailored to the three major engines: Unity (C#), Unreal Engine (Blueprints/C++), and Godot (GDScript). Each prompt is designed to be copy-pasted directly into your AI assistant (like ChatGPT, Claude, or Gemini) to get actionable, engine-specific answers. We also share real-world usage examples and expert tips to help you integrate these prompts into your daily workflow.
Why Use Prompts in Game Development?
Modern AI tools can generate code snippets, explain complex engine features, and even suggest architectural patterns. However, the quality of the output depends heavily on how you frame the question. A vague prompt like "write a movement script" yields a generic answer, while a specific prompt like "write a C# script for Unity that implements wall-running using raycasts and a configurable stamina system" gives you production-ready code. The prompts below follow best practices from official documentation and community forums (e.g., Unity Learn, Unreal Engine Documentation, Godot Docs) to ensure accuracy and relevance.
1. Unity C#: Player Movement with Physics
Prompt:
Write a Unity C# script for a 3D character controller that uses Rigidbody physics for movement. Include:
- WASD input relative to camera direction
- Jump with ground check using a LayerMask
- Configurable walk speed, run speed, and jump force
- Smooth acceleration and deceleration
- Use FixedUpdate for physics
Explanation: This prompt covers a fundamental need — responsive player movement. It explicitly asks for Rigidbody (not CharacterController) to leverage physics interactions like collisions and forces. The request for camera-relative input ensures the character moves forward relative to where the camera faces, which is standard in third-person games. The ground check via LayerMask prevents the character from jumping in mid-air. Using FixedUpdate is crucial because physics calculations should not depend on frame rate.
Usage Example: Paste the prompt into an AI assistant. The output will be a PlayerMovement.cs script with public variables for speed and jump force. You can then attach it to your player GameObject and assign the camera reference and ground layer. The script will handle input, apply forces, and clamp velocity for smooth movement. Many developers at ASI Biont have used similar prompts to rapidly prototype movement systems — learn more about integrating AI with Unity workflows at asibiont.com/courses.
2. Unreal Engine: Blueprint for Interactable Door
Prompt:
Create an Unreal Engine Blueprint for an interactable door that:
- Opens with a smooth rotation when the player presses 'E' within a sphere collision
- Closes automatically after 3 seconds
- Plays an open and close sound
- Has a configurable open angle (default 90 degrees)
- Uses Timeline node for smooth animation
Explanation: This prompt targets Unreal's visual scripting language. It specifies core requirements: interaction via collision, timed auto-close, audio feedback, and parameterized behavior. The Timeline node is the recommended way to animate values over time (like rotation). The prompt avoids vague terms like "make a door" and instead lists concrete features, which helps the AI generate a structured Blueprint with comments.
Usage Example: The AI will describe the Blueprint nodes: a Sphere Collision component, an Input Action for 'E', a Timeline that drives a Lerp (Rotator) node, and a Delay node for the 3-second close. You can recreate this in your Unreal Editor by dragging the described nodes. This approach is faster than searching through tutorials and gives you a customized solution.
3. Godot: 2D Top-Down Movement with Animation
Prompt:
Write a GDScript for Godot 4 that implements top-down 2D movement for a CharacterBody2D:
- Use Input.get_axis for horizontal and vertical
- Normalize diagonal movement to prevent faster speed
- Change animation state (idle, walk) using an AnimationTree
- Speed variable exposed in inspector
- Use _physics_process(delta)
Explanation: Godot's CharacterBody2D is the standard for kinematic movement. The prompt asks for Input.get_axis (the modern input system) and normalization — a common pitfall where diagonal movement becomes faster. Including AnimationTree ensures the character's sprite changes based on movement state. Exposing the speed variable in the inspector via @export makes it easy to tweak without code changes.
Usage Example: The AI will generate a script with _physics_process, move_and_slide(), and a function to update animation parameters. You can attach it to your player scene, configure the input map (e.g., "left", "right", "up", "down"), and link the AnimationTree. This is a complete player controller ready for a 2D RPG or adventure game.
4. Unity C#: Object Pooling for Bullets
Prompt:
Write a Unity C# object pooler for bullets that:
- Pre-instantiates a configurable number of bullet GameObjects at start
- Provides a GetBullet() method that returns a disabled bullet from the pool
- Provides a ReturnBullet(GameObject) method that disables and re-pools it
- Works with any prefab (generic)
- Is a singleton for easy access
Explanation: Object pooling is essential for performance in games with many projectiles (shooters, tower defense). This prompt asks for a generic singleton pool that avoids costly Instantiate/Destroy calls during gameplay. The generic approach means you can reuse the same pooler for bullets, enemies, or particles by just changing the prefab.
Usage Example: The AI outputs a ObjectPooler.cs script. You create an empty GameObject in your scene, attach the script, assign the bullet prefab and pool size (e.g., 20). Then in your shooting script, call ObjectPooler.Instance.GetBullet() to obtain a bullet, and ObjectPooler.Instance.ReturnBullet(bullet) when it hits something. This dramatically reduces garbage collection and frame spikes.
5. Unreal Engine C++: Custom AI Perception Component
Prompt:
Write an Unreal Engine C++ class that extends UAIPerceptionComponent to:
- Detect sight and hearing stimuli
- Store the last known stimulus location in a Blackboard
- Only react to stimuli from a specific team (via GameplayTags)
- Expose sight radius and hearing range as editable properties
Explanation: AI perception is complex. This prompt narrows it down to two senses (sight and hearing), uses Blackboard (the standard way to share data between Behavior Trees), and adds team filtering via GameplayTags — a powerful tagging system introduced in recent Unreal versions. The request for editable properties ensures designers can tweak values without touching C++.
Usage Example: The AI provides a header and implementation file. You create a new class derived from UAIPerceptionComponent, override OnTargetPerceptionUpdated, and add UPROPERTY(EditAnywhere) for radius values. Then assign this component to your AI character. The AI will automatically update the Blackboard with the last known enemy location, which your Behavior Tree can use to patrol or chase.
6. Godot: TileMap Auto-Tiling for Procedural Levels
Prompt:
Create a GDScript for Godot 4 that generates a 2D dungeon level using TileMap and auto-tiling:
- Use a seeded random number generator
- Place walls around the perimeter
- Randomly place floor tiles with 70% probability
- Ensure connectivity (no isolated rooms) using BFS flood fill
- Use a custom tile set with terrains for auto-tiling
Explanation: Procedural generation is a popular technique for roguelikes and sandbox games. This prompt includes specific algorithms (BFS for connectivity) and tile set configuration (terrains). The seeded RNG allows reproducible levels — useful for debugging or sharing seeds. Auto-tiling automatically picks the correct tile (e.g., wall corner, straight wall) based on neighbors.
Usage Example: The AI outputs a script that you attach to a Node2D with a TileMap. It first fills the entire area with walls, then carves out floor tiles randomly, ensuring connectivity. After generation, it calls TileMap.set_cells_terrain_connect() to apply auto-tiling. The result is a fully connected dungeon with visually correct walls — ready for player spawning and enemy placement.
7. Unity C#: Save/Load System with JSON
Prompt:
Write a Unity C# save/load system that:
- Saves player inventory (list of item IDs and quantities) to a JSON file in Application.persistentDataPath
- Loads the data back into a ScriptableObject-based inventory
- Handles missing file gracefully (returns default inventory)
- Uses async methods to avoid frame drops
- Supports encryption (AES) with a configurable key
Explanation: Persistence is crucial for any game with progress. This prompt asks for JSON (human-readable and easy to debug) stored in the persistent data path (cross-platform). Using ScriptableObject for inventory data is a Unity best practice. Async saving prevents UI freezes. Encryption is added for leaderboards or sensitive data.
Usage Example: The AI generates a SaveManager class with SaveGame() and LoadGame() methods. You call SaveManager.SaveGame(inventoryData) after the player picks up an item. If the file is missing, LoadGame() returns the default inventory from a ScriptableObject. The encryption is optional — you can toggle it via a boolean. This system can be extended to save positions, settings, or game state.
8. Unreal Engine: Niagara Particle System for Explosion
Prompt:
Design a Niagara system in Unreal Engine for an explosion that:
- Spawns 100 particles in a sphere radius of 2 meters
- Particles are small cubes that fade from orange to black over 0.5 seconds
- Each particle has random initial velocity (magnitude 5-10) and random rotation
- On collision with a surface, spawn a decal (optional)
- Use GPU sprites for performance
Explanation: Niagara is Unreal's advanced particle system. This prompt is specific: it defines particle count, shape (sphere), size, color, lifetime, and behavior on collision. Requesting GPU sprites ensures high performance even with many particles. The decal spawning adds visual polish.
Usage Example: In the Niagara Editor, you create a new system from scratch. The AI describes the module stack: Add "Spawn Burst Instantaneous" for 100 particles, "Shape Location" with sphere radius 200 (Unreal units), "Color" module with gradient from orange to black, "Scale Color" to fade alpha, "Velocity" module with random range 500-1000, and "Collision" module to spawn a decal. The result is a reusable explosion effect that you can trigger from Blueprints or C++.
9. Godot: Health System with Damage Numbers
Prompt:
Write a GDScript for Godot 4 that implements a health system for a player:
- Max health, current health, and invincibility timer
- TakeDamage(damage, knockback_direction) method
- Emit a signal when health reaches zero
- Display floating damage numbers using a Label with a Tween animation
- Use @export_group for inspector organization
Explanation: Health is a core mechanic. The prompt includes signals (Godot's event system) for loose coupling. Floating damage numbers are a common UI element; using a Tween node animates the label upward and fades it out. @export_group organizes the inspector variables (health, invincibility time) into collapsible groups for cleaner UI.
Usage Example: The AI outputs a Health.gd script attached to the player. You call health_component.TakeDamage(10, Vector2.UP) when an enemy hits. The script reduces health, starts an invincibility timer (e.g., 0.5 seconds), and instantiates a floating label scene. When health reaches zero, it emits a died signal that your game manager can listen to for game over logic.
10. Cross-Engine: Shader Graph for Dissolve Effect
Prompt:
Explain how to create a dissolve shader effect in [Unity/Unreal/Godot] that:
- Uses a noise texture to create organic edges
- Has a configurable threshold slider from 0 (invisible) to 1 (fully visible)
- Adds an emissive glow along the edge during dissolve
- Works with both opaque and transparent materials
- Provide the node graph or code steps
Explanation: This prompt is engine-agnostic but asks for platform-specific implementation. The dissolve effect is popular for death animations, teleportation, or revealing hidden objects. The prompt requests a noise-based edge (more natural than a simple gradient), a slider for animation, and edge glow for visual impact. The mention of opaque/transparent ensures compatibility with different render pipelines.
Usage Example: For Unity URP, the AI describes a Shader Graph with a Step node comparing the noise value to the threshold, a Fresnel Effect node for edge glow, and a Transparency mask. For Unreal, it describes a Material with a Noise node, Scalar Parameter for threshold, and Emissive Color connected to the edge. For Godot, it provides a shader_type canvas_item code snippet. This prompt works best when you specify the engine and render pipeline (e.g., "Unity URP").
Expert Tips for Using Prompts Effectively
- Specify the version: Always mention the engine version (e.g., "Unity 6000.0", "Unreal Engine 5.5", "Godot 4.3") to get up-to-date syntax and API calls. Many deprecated features exist across versions.
- Include constraints: Add performance requirements ("optimize for mobile") or platform targets ("works on console") to avoid generic solutions.
- Request comments: Ask for code comments explaining each block. This helps you understand and modify the logic later.
- Iterate: The first output is rarely perfect. Refine by asking for changes ("change the movement to use AddForce instead") or additional features ("add a cooldown to the ability").
- Verify against docs: AI can hallucinate non-existent methods. Cross-check key functions with official documentation (e.g., Unity Scripting API, Unreal Engine Documentation, Godot Docs).
Conclusion
Prompts are a powerful tool in a game developer's arsenal. By being specific about the engine, desired features, and constraints, you can generate code, Blueprints, and shaders that are production-ready and save hours of manual work. The 10 prompts above cover fundamental systems — movement, interaction, AI, performance, and effects — across Unity, Unreal Engine, and Godot. Start by copying one into your favorite AI assistant, adapt the output to your project, and iterate. As you become more comfortable crafting prompts, you'll find yourself prototyping faster and solving problems more creatively. Happy developing!
Comments