15 Prompts for GameDev: Unity, Unreal Engine, Godot

Write a Unity C# script that toggles a boolean `isReady` every 2 seconds using a coroutine. The script should have a public method `TryAction()` that returns true only when `isReady` is true, and then sets `isReady` to false. Use `WaitForSeconds` for the cooldown.

using System.Collections;
using UnityEngine;

public class CooldownAction : MonoBehaviour
{
    private bool isReady = true;

    public bool TryAction()
    {
        if (isReady)
        {
            isReady = false;
            StartCoroutine(CooldownRoutine());
            return true;
        }
        return false;
    }

    private IEnumerator CooldownRoutine()
    {
        yield return new WaitForSeconds(2f);
        isReady = true;
    }
}

Write a Unity C# object pool class that manages a queue of GameObjects. It should have a `Get()` method that returns an inactive object from the queue (or instantiates a new one if empty), and a `Return(GameObject obj)` method that deactivates and enqueues the object. The pool should be initialized with a given prefab and initial size.

using System.Collections.Generic;
using UnityEngine;

public class BulletPool : MonoBehaviour
{
    [SerializeField] private GameObject bulletPrefab;
    [SerializeField] private int initialSize = 10;
    private Queue<GameObject> pool = new Queue<GameObject>();

    void Start()
    {
        for (int i = 0; i < initialSize; i++)
        {
            GameObject obj = Instantiate(bulletPrefab);
            obj.SetActive(false);
            pool.Enqueue(obj);
        }
    }

    public GameObject Get()
    {
        if (pool.Count == 0)
        {
            GameObject newObj = Instantiate(bulletPrefab);
            return newObj;
        }
        GameObject obj = pool.Dequeue();
        obj.SetActive(true);
        return obj;
    }

    public void Return(GameObject obj)
    {
        obj.SetActive(false);
        pool.Enqueue(obj);
    }
}

Write a Unity C# state machine for a player character. Create an abstract base class `PlayerState` with methods `Enter()`, `Update()`, and `Exit()`. Then create three concrete states: `IdleState`, `WalkState`, `JumpState`. The state machine should transition between states using a `TransitionTo(PlayerState newState)` method. Use a `PlayerController` class that holds references to the states and updates the current state each frame.

public abstract class PlayerState
{
    protected PlayerController controller;
    public PlayerState(PlayerController controller) => this.controller = controller;
    public abstract void Enter();
    public abstract void Update();
    public abstract void Exit();
}

public class IdleState : PlayerState
{
    public IdleState(PlayerController c) : base(c) { }
    public override void Enter() => Debug.Log("Enter Idle");
    public override void Update() { /* check input for walk/jump */ }
    public override void Exit() => Debug.Log("Exit Idle");
}
// Similar for WalkState and JumpState...

Write a Unity C# script that saves an integer `highScore` and a float `volume` to PlayerPrefs when the game quits, and loads them on start. Use `PlayerPrefs.SetFloat()` and `PlayerPrefs.GetFloat()` with default values. Also include a public method `ResetData()` that clears all saved data.

using UnityEngine;

public class DataManager : MonoBehaviour
{
    public int HighScore { get; private set; }
    public float Volume { get; private set; }

    void Awake()
    {
        HighScore = PlayerPrefs.GetInt("HighScore", 0);
        Volume = PlayerPrefs.GetFloat("Volume", 0.5f);
    }

    public void SaveHighScore(int score)
    {
        HighScore = score;
        PlayerPrefs.SetInt("HighScore", score);
        PlayerPrefs.Save();
    }

    public void ResetData()
    {
        PlayerPrefs.DeleteAll();
        HighScore = 0;
        Volume = 0.5f;
    }

    void OnApplicationQuit()
    {
        PlayerPrefs.Save();
    }
}

Write a Unity C# GameManager singleton. Use the classic pattern with a static instance property and `DontDestroyOnLoad()` in Awake(). Add a public integer `score` and a method `AddScore(int amount)`. Ensure that if another instance exists, it destroys itself.

using UnityEngine;

public class GameManager : MonoBehaviour
{
    private static GameManager _instance;
    public static GameManager Instance => _instance;

    public int Score { get; private set; }

    void Awake()
    {
        if (_instance != null && _instance != this)
        {
            Destroy(gameObject);
            return;
        }
        _instance = this;
        DontDestroyOnLoad(gameObject);
    }

    public void AddScore(int amount)
    {
        Score += amount;
        Debug.Log($"Score: {Score}");
    }
}

In an Unreal Engine Blueprint, create a custom event called `TakeDamage` with an input integer parameter `DamageAmount`. Inside the event, subtract `DamageAmount` from the `Health` integer variable, then print the new health to the screen using `Print String`. If health drops below 0, call `DestroyActor`.

In a First Person Character Blueprint, create a `Shoot` function that performs a line trace from the camera's location forward by 10,000 units. On hit, print the hit actor's name using `Print String` and apply a damage event to the hit actor if it implements the damage interface.

In a Blueprint Actor, create a Timeline that interpolates a float value from 0 to 1 over 2 seconds. Use this float to lerp the door's relative location from closed (0) to open (e.g., Y = 200). Use an `OnBeginOverlap` event to play the timeline forward, and a `Delay` node (3 seconds) to play it in reverse.

Create an AIController Blueprint that uses the AI Perception component with a Sight sense. Configure the sight radius to 1000 units and lose sight radius to 1200 units. On perception update, if the stimulus is `Dominant`, set a Blackboard key `TargetActor` to the sensed actor. If stimulus is `Lost`, clear the key.

In a User Widget Blueprint, create a progress bar that binds its percent to a character's health (e.g., Health / MaxHealth). Create a second binding for the bar's fill color: if health > 50%, return green; if between 25% and 50%, return yellow; if below 25%, return red. Use `Lerp (Linear Interpolation)` for smooth color transitions.

Write a GDScript for a `Coin` area that emits a `collected` signal when the player enters. In the player script, connect to the signal and increment a `coin_count` variable. In a HUD script, connect to the player's `coins_changed` signal to update the label.

# Coin.gd
extends Area2D
signal collected

func _on_body_entered(body):
    if body.is_in_group("player"):
        emit_signal("collected")
        queue_free()

Write a GDScript that creates a 2D array of 0s (floor) and 1s (wall), then uses a `TileMap` node to set cells based on the array. Use a simple random walk algorithm: start at center, move in random directions 100 steps, set floor tiles. Then surround all floor tiles with wall tiles.

extends TileMap

var floor_tile = Vector2i(0, 0)  # atlas coordinates
var wall_tile = Vector2i(1, 0)

func _ready():
    var grid = {}
    var pos = Vector2i(0, 0)
    for i in 100:
        grid[pos] = 0
        var dir = randi() % 4
        match dir:
            0: pos.x += 1
            1: pos.x -= 1
            2: pos.y += 1
            3: pos.y -= 1
    for cell in grid:
        set_cell(cell, 0, floor_tile)
    # Add wall border logic...

In a Godot 2D character, set up an AnimationTree with a StateMachine. Create three animations: idle, walk, run. Use a float parameter `speed` to blend between walk and run (0-1). Use a boolean parameter `is_moving` to transition between idle and walking. Write a script that updates these parameters based on player input.

func _process(delta):
    var input = Input.get_vector("left", "right", "up", "down")
    var moving = input.length() > 0.1
    $AnimationTree.set("parameters/is_moving", moving)
    $AnimationTree.set("parameters/speed", input.length())

Write a GDScript that uses `FileAccess` to save a dictionary containing player health, position (Vector2 as x/y), and an array of inventory item names to a file named "save.json". Loading reads the file and returns the dictionary. Use `JSON.stringify()` for saving and `JSON.parse_string()` for loading.

func save_game():
    var data = {
        "health": 100,
        "position": {"x": global_position.x, "y": global_position.y},
        "inventory": ["sword", "potion"]
    }
    var file = FileAccess.open("user://save.json", FileAccess.WRITE)
    file.store_string(JSON.stringify(data))
    file.close()

Write a Godot shader (visual or code) that takes a texture and an outline color. Use a fragment shader that checks the alpha of neighboring pixels (4-directional offset). If the current pixel is transparent but any neighbor is opaque, output the outline color. Otherwise, output the texture color.

shader_type canvas_item;

uniform vec4 outline_color : source_color = vec4(1.0, 0.0, 0.0, 1.0);
uniform float outline_size : hint_range(0, 10) = 1.0;

void fragment() {
    vec4 tex_color = texture(TEXTURE, UV);
    float alpha = tex_color.a;
    float outline_alpha = 0.0;
    for (int x = -1; x <= 1; x++) {
        for (int y = -1; y <= 1; y++) {
            vec2 offset = vec2(float(x), float(y)) * outline_size * TEXTURE_PIXEL_SIZE;
            float neighbor_alpha = texture(TEXTURE, UV + offset).a;
            if (neighbor_alpha > 0.5)
                outline_alpha = 1.0;
        }
    }
    if (alpha < 0.5 && outline_alpha > 0.5)
        COLOR = outline_color;
    else
        COLOR = tex_color;
}