25 KI-Prompts, die jeder Spieleentwickler speichern sollte

Act as a senior Unity developer. Write a C# script named `SimplePlayerController.cs` for a first-person character controller.
It must meet these requirements:
1.  Use the `UnityEngine.CharacterController` component for movement. Do NOT use a Rigidbody.
2.  Include public float variables for `playerSpeed`, `jumpHeight`, and `gravityValue`.
3.  In the `Update()` method, read input from the standard "Horizontal" and "Vertical" axes.
4.  Calculate movement direction based on the camera's forward and right vectors.
5.  Handle jumping with the "Jump" button (Space bar). Apply gravity every frame.
6.  Include a simple mouse look implementation that rotates the player object horizontally and the camera object vertically. Create a public float for `mouseSensitivity`.
Add comments to explain the key sections.

Act as a Unity game programmer. Create a set of three C# scripts for a basic inventory system using ScriptableObjects.
1.  **`ItemData.cs`**: This should be a ScriptableObject. It needs fields for `itemName` (string), `itemIcon` (Sprite), and `itemDescription` (string).
2.  **`InventorySlot.cs`**: A simple class (not a MonoBehaviour) to hold an `ItemData` and an `amount` (int). This will be used inside the inventory list.
3.  **`InventorySystem.cs`**: This should be a MonoBehaviour. It needs a `public List<InventorySlot> inventory` to hold the items. Create public methods for `AddItem(ItemData item, int amount)` and `RemoveItem(ItemData item, int amount)`. The `AddItem` method should stack items if they already exist in the inventory.
Ensure all scripts are in the `MyGame.Inventory` namespace.

Act as a Unity C# developer. Write a script named `PrefabSpawner.cs` that spawns a given prefab at random positions within a defined area.
Requirements:
1.  A `public GameObject prefabToSpawn`.
2.  A `public int numberOfPrefabs`.
3.  A `public Vector3 spawnAreaSize` to define the bounds of a box where prefabs can spawn.
4.  A method `SpawnPrefabs()` that loops `numberOfPrefabs` times.
5.  Inside the loop, calculate a random `x`, `y`, and `z` position within the `spawnAreaSize` centered on the spawner's transform position.
6.  Use `Instantiate()` to create the prefab at the random position.
7.  Call `SpawnPrefabs()` in the `Start()` method.

Act as a senior Unity programmer. Create a C# script `HealthSystem.cs` for a player or enemy.
The script must:
1.  Use the `System` namespace for events.
2.  Define `public event Action<int, int> OnHealthChanged;` to broadcast health updates. The parameters are current health and max health.
3.  Define `public event Action OnDied;` to signal when health reaches zero.
4.  Have private integer fields for `_currentHealth` and `_maxHealth`. Create a public property `CurrentHealth` with a private setter.
5.  In the `Awake()` method, set `_currentHealth` to `_maxHealth`.
6.  Create a public method `TakeDamage(int damageAmount)`. This method should reduce health, clamp it at 0, and invoke the `OnHealthChanged` event. If health is 0, it should invoke the `OnDied` event.
7.  Create a public method `Heal(int healAmount)`. This should increase health, clamp it at `_maxHealth`, and invoke `OnHealthChanged`.

Act as a Unity C# programmer. Write a generic, reusable Singleton class named `Singleton.cs`.
Requirements:
1.  The class should be generic: `public class Singleton<T> : MonoBehaviour where T : Component`.
2.  It needs a `private static T _instance;` to hold the reference.
3.  It needs a `public static T Instance` property. The getter should be the public access point.
4.  In the `Instance` property's getter, check if `_instance` is null. If it is, find the object of type `T` in the scene and assign it. If it's still null, create a new GameObject and add the component `T` to it.
5.  In the `Awake()` method, handle the Singleton logic. If `_instance` is null, assign `this` to it. If `_instance` already exists and is not `this`, destroy the current GameObject to enforce the singleton pattern.
6.  Use `DontDestroyOnLoad(this.gameObject)` to make it persist across scenes.

Act as a Godot Engine developer. Write a GDScript for a 2D player controller.
The script should be attached to a `KinematicBody2D` node.
1.  Define exported variables for `speed`, `jump_strength`, and `gravity`.
2.  Use a `Vector2` variable named `velocity` to track the player's movement.
3.  In the `_physics_process(delta)` function:
a. Apply gravity to the `velocity.y`.
b. Get player input for "ui_left" and "ui_right" to set the horizontal velocity.
c. Handle jumping by checking for `is_on_floor()` and the "ui_up" action.
d. Use `move_and_slide(velocity, Vector2.UP)` to move the character.
Add comments explaining each part of the `_physics_process` function.

Act as a Godot developer creating a global script. Write a GDScript for an autoloaded Singleton named `SceneTransition.gd`. This script will manage scene changes with a fade effect.
1.  The script should have a `change_scene(path)` function that takes a scene path as an argument.
2.  It requires a `ColorRect` and an `AnimationPlayer` node as children to work. Assume the `AnimationPlayer` has two animations: "fade_to_black" and "fade_to_normal".
3.  The `change_scene` function should:
a. Play the "fade_to_black" animation.
b. `yield` until the animation is finished.
c. Call `get_tree().change_scene(path)` to load the new scene.
d. `yield` for one frame to allow the new scene to load.
e. Play the "fade_to_normal" animation.
This script should be set up as an Autoload Singleton in the Godot Project Settings.

Act as a Godot GDScript expert. Provide two short GDScript examples demonstrating custom signals.
**Script 1: `Player.gd`**
1.  This script is for the player.
2.  Define a custom signal named `health_depleted`.
3.  Create a function `take_damage()`. When this function is called, it should `emit_signal("health_depleted")`.
4.  For demonstration, add a line to call `take_damage()` when the "ui_accept" input is pressed.
**Script 2: `GameUI.gd`**
1.  This script is for the main UI scene.
2.  In the `_ready()` function, get the player node (assume it's at `/root/Game/Player`).
3.  Connect the player's `health_depleted` signal to a new function in this script called `_on_Player_health_depleted`.
4.  The `_on_Player_health_depleted` function should print the message "Player health depleted! Game Over." to the console.

Act as a Godot game developer. Write a GDScript for a simple enemy AI using a state machine.
The script should be attached to a `KinematicBody2D` enemy.
1.  Use an `enum` to define the states: `PATROL`, `CHASE`.
2.  Create a `state` variable, defaulting to `PATROL`.
3.  In `_physics_process(delta)`, use a `match` statement to execute code based on the current `state`.
4.  **Patrol State:**
a. Move the enemy left or right.
b. Use a `RayCast2D` to detect walls or ledges. If a wall is detected, reverse direction.
c. Use an `Area2D` to detect the player. If the player enters the detection area, change the `state` to `CHASE`.
5.  **Chase State:**
a. Get the direction to the player.
b. Move towards the player.
c. If the player leaves the detection area, change the `state` back to `PATROL`.
Provide placeholders for the player detection logic.

Act as a Godot Engine specialist. Write a GDScript that procedurally generates a simple map using a `TileMap` node.
The script should be attached to a `TileMap` node.
1.  Export variables for `map_width`, `map_height`, `noise_scale`, and `tile_index_ground`.
2.  In the `_ready()` function, create a new `OpenSimplexNoise` object.
3.  Loop through every x and y coordinate from 0 to `map_width` and `map_height`.
4.  Inside the loop, get a noise value from the `OpenSimplexNoise` object using `get_noise_2d(x * noise_scale, y * noise_scale)`.
5.  If the noise value is above a certain threshold (e.g., 0.5), use `set_cell(x, y, tile_index_ground)` to place a ground tile.

Act as a world-building expert for a video game. I am creating a new faction for my open-world RPG, which has a "magitek" setting (magic fused with early industrial technology).
The faction is called the "Cogwork Scribes." Generate a detailed backstory for them, including:
1.  **Origin:** How and why were they founded?
2.  **Ideology:** What is their core belief or goal?
3.  **Structure:** How are they organized? (e.g., leaders, ranks)
4.  **Relationship with Magic & Technology:** How do they view the fusion of magic and tech? Are they innovators, traditionalists, or regulators?
5.  **Conflicts:** Who are their primary allies and enemies? What internal conflicts do they face?
Keep the tone serious and grounded. The output should be around 400 words.

Act as a narrative designer. Write a branching dialogue scene for a player character (PC) and a suspicious NPC guard named Marcus. The PC is trying to get past a gate Marcus is guarding.
The goal is to get past the gate. Provide three distinct paths:
1.  **Persuasion:** The PC tries to convince Marcus with a plausible lie.
2.  **Bribery:** The PC offers Marcus gold.
3.  **Intimidation:** The PC hints at a threat.
For each path, write Marcus's initial response and then two possible outcomes (success or failure) based on a follow-up choice. Format the output as a tree or nested list so the branches are clear.

Act as a quest designer for an action-adventure game. I need a side quest called "The Silent Bell."
The setting is a remote mountain monastery. The premise is that the monastery's giant bell, which wards off evil spirits, has stopped ringing.
Generate a quest outline with the following structure:
- **Quest Giver:** Brother Kael, the worried head monk.
- **The Hook:** What is the initial problem presented to the player?
- **Step 1: Investigation:** What does the player need to discover first? (e.g., the bell is physically intact but magically silenced).
- **Step 2: The Cause:** What is the source of the magical silence? (e.g., a rival cult has placed a "dampening stone" nearby).
- **Step 3: The Solution:** What must the player do to fix it? (e.g., find and destroy three power runes tethered to the dampening stone).
- **Step 4: Climax:** What happens when the player tries to destroy the final rune? (e.g., an ambush by the rival cult's leader).
- **Resolution & Reward:** The bell rings again, and Brother Kael gives the player a unique magical item.

Act as a narrative writer. I'm building a level that is an abandoned alchemist's laboratory in a steampunk city. The alchemist, Elias, was secretly trying to create a philosopher's stone but something went horribly wrong.
Write a series of three short journal entries from Elias's perspective that the player can find scattered around the lab. The entries should build suspense and tell the story of his failure without stating it directly.
- **Entry 1:** Full of hope and excitement, on the verge of a breakthrough.
- **Entry 2:** Paranoia and frustration are setting in. The process is unstable, and he mentions strange side effects.
- **Entry 3:** Despair and panic. The final entry, written moments before the disaster, describing the stone becoming volatile and something "unraveling.

Act as a senior game designer. I'm designing a 2D puzzle-platformer with the theme of "light and shadow." The player character is a small creature made of light.
Brainstorm five unique core mechanics based on this theme. For each mechanic, provide:
1.  **Name:** A clear, descriptive name (e.g., "Shadow Meld").
2.  **Description:** How does the mechanic work from the player's perspective?
3.  **Puzzle Example:** A simple puzzle that could only be solved using this mechanic.

Act as a game designer writing a Game Design Document (GDD). I need the section that describes the core gameplay loop for a survival-crafting game set on a hostile alien planet.
The document should be clear, professional, and use standard GDD formatting (headings, bullet points).
Cover the following phases of the loop:
1.  **EXPLORE:** Players venture out to find resources. What are the risks and goals?
2.  **SCAVENGE:** Players gather materials (e.g., alien flora, wreckage). How is this done?
3.  **RETURN:** Players must bring resources back to a safe base. What dangers do they face on the return trip?
4.  **CRAFT/BUILD:** Players use resources to craft tools, weapons, and base components. What is the crafting interface like?
5.  **SURVIVE:** How do the crafted items help the player survive the next cycle (e.g., hostile fauna, environmental hazards)?

Act as a level designer and environmental artist. Write a one-page description for a new level in a post-apocalyptic game. The level is called "The Sunken Library."
The description should evoke a strong mood and provide clear direction for an art team. Include details on:
- **Location:** A massive, pre-war public library that has partially collapsed into a flooded sinkhole.
- **Atmosphere:** What is the mood? (e.g., quiet, eerie, reverent). What are the key lighting and sound characteristics?
- **Key Areas:** Describe three distinct zones within the level (e.g., The Grand Rotunda, The Flooded Archives, The Rooftop Shanty Town).
- **Traversal:** How does the player navigate the space? (e.g., makeshift bridges, climbing collapsed bookshelves, diving through flooded sections).
- **Points of Interest:** What unique landmarks or storytelling elements exist? (e.g., a protected room with pristine books, a skeleton of a survivor who made a last stand).

Act as a UX writer and game designer. Write the tutorial text for a new ability in a fast-paced action game. The ability is called "Phase Dash," and it lets the player teleport a short distance, passing through enemies and projectiles.
The text should be delivered via non-intrusive UI pop-ups. Write three short, clear, and concise tutorial messages:
1.  **Introduction:** Appears when the player first unlocks the ability. Explains the basic command (e.g., "Press [RB] to Phase Dash").
2.  **Contextual Use (Offensive):** Appears when the player is facing a shielded enemy for the first time. Suggests using the dash to get behind them (e.g., "Dash through shielded foes to strike their weak point.").
3.  **Contextual Use (Defensive):** Appears when the player is targeted by a powerful projectile. Suggests using the dash to avoid it (e.g., "Time your dash to phase through incoming attacks.").

Generate a pixel art sprite sheet for a video game character.
**Subject:** A goblin rogue. He is small, wiry, and wears a dark leather hood and cloak. He wields two small daggers.
**Style:** 16-bit, high-contrast, fantasy, style of classic JRPGs like Chrono Trigger. Saturated color palette.
**Layout:** A 4x4 grid sprite sheet on a neutral grey background.
**Animations:**
- Row 1: Idle animation (4 frames)
- Row 2: Walk cycle (4 frames)
- Row 3: Attack animation (4 frames, a quick two-dagger slash)
- Row 4: Damage/hit reaction (4 frames)
Ensure each frame is distinct and clearly shows the intended motion.

Generate a set of seamless PBR texture maps for a sci-fi spaceship floor panel.
**Description:** A square metal panel, dark grey with hexagonal patterns and subtle glowing orange emissive lines. It should look worn and used, with minor scratches and scuffs, but not heavily damaged.
**Style:** Gritty, industrial sci-fi, realistic.
**Maps to Generate:**
- Albedo (Base Color)
- Normal Map (DirectX format)
- Roughness Map
- Metallic Map
- Emissive Map
The output should be 4K resolution.

Generate high-quality concept art for a fantasy creature called a "Glimmerwood Stag."
**Description:** A large, majestic stag. Its body is made of ancient, moss-covered wood. Its antlers are crystalline, pulsing with a soft, blue internal light. Its eyes glow with the same blue light. It is a guardian of an ancient forest.
**Composition:** The stag is standing in a clearing at night, illuminated by moonlight filtering through the canopy. Fireflies are floating around it.
**Style:** Highly detailed, photorealistic, cinematic lighting, fantasy illustration, style of Greg Rutkowski and Loish.
**Mood:** Serene, magical, powerful, mysterious.

Generate a low-poly 3D model of a stylized treasure chest, ready for a game engine.
**Description:** A classic wooden treasure chest with iron bindings and a simple lock. The style should be chunky and stylized, suitable for a fantasy mobile game.
**Technical Specs:**
- **Poly Count:** Under 800 triangles.
- **Format:** GLB file.
- **Textures:** A single, hand-painted style 1024x1024 color map. No PBR materials needed. The texture should be baked into the model.
- **Details:** The lid should be a separate object, with its pivot point correctly placed at the hinge for easy opening in-engine.

Act as a QA lead for a game studio. I need a test plan for a new feature: a photo mode in our open-world adventure game.
Generate a test plan in a markdown table format. The columns should be: `Test Case ID`, `Component`, `Test Description`, `Expected Result`, and `Priority (Low/Med/High)`.
Cover the following components:
- **UI/UX:** Entering and exiting photo mode, navigating the UI.
- **Camera Controls:** Free camera movement (pan, tilt, dolly, truck), field of view, roll.
- **Filters & Effects:** Applying color filters, depth of field, vignette.
- **Character Controls:** Hiding the player character, changing poses.
- **Edge Cases:** Using photo mode during combat, in cinematics, while swimming, on a mount.

Act as a QA analyst. I have three player-submitted bug reports. For each report, classify its priority and suggest a potential cause.
**Report 1:** "Sometimes when I sell items to the vendor really fast, my game crashes to desktop. It happened twice last night."
**Report 2:** "The texture on the 'Iron Shield' looks all stretched and weird on one side. It's just a visual thing but it looks bad."
**Report 3:** "I got stuck in a wall in the Crystal Caverns level behind a rock and had to reload my save to get out."
Provide your analysis in this format for each report:
- **Summary:**
- **Priority:** (Blocker / Critical / Major / Minor / Trivial)
- **Likely Component:** (e.g., UI, Art Asset, Collision/Physics, AI)
- **Suggested Next Step:** (e.g., "Attempt to reproduce with rapid inventory actions," "Check the UV map for the Iron Shield model.")

Act as a Unity developer with expertise in test-driven development. I have a `HealthSystem.cs` script with a method `TakeDamage(int damage)`.
Write a simple C# unit test script for this method using the `NUnit.Framework` and `UnityEngine.TestTools`. The test should verify that the character's health is correctly reduced after taking damage.
The test script should:
1.  Be named `HealthSystemTests.cs`.
2.  Include a test method `TakeDamage_ReducesHealth_Correctly()`.
3.  Inside the test, create a new GameObject and add the `HealthSystem` component to it.
4.  Set the initial health to 100.
5.  Call the `TakeDamage(10)` method.
6.  Use `Assert.AreEqual(90, healthSystem.CurrentHealth)` to verify the result.