15 KiB
15 KiB
allowed_tools
| allowed_tools | ||||
|---|---|---|---|---|
|
Create common scene templates for 2D games, including characters, enemies, levels, and more.
Process
- Ask the user what type of scene they want to create:
Use AskUserQuestion with the following options:
Question: "What type of scene would you like to create?" Header: "Scene Type" Multi-select: false Options:
- 2D Player Character: Platformer character with movement and collision
- 2D Enemy: Basic enemy with AI placeholder
- 2D Level: Level scene with tilemap and camera
- 2D Projectile: Bullet/projectile with movement
- Collectible: Coin/item pickup
- Interactable Object: Chest, door, switch, etc.
Question 2: "Where should the scene be created?" Header: "Location" Multi-select: false Options:
- scenes/characters/: For player and NPCs
- scenes/enemies/: For enemy characters
- scenes/levels/: For level scenes
- scenes/objects/: For items and interactables
- Custom path: I'll specify the path
-
If Custom path selected, ask for the specific path and scene name
-
Create the appropriate template based on selection
2D Player Character Template
Create scene with:
CharacterBody2D (root)
├── Sprite2D (sprite)
├── CollisionShape2D (collision)
├── AnimationPlayer (animation_player)
└── Camera2D (camera)
Node details:
- CharacterBody2D: motion_mode = MOTION_MODE_GROUNDED
- Sprite2D: centered = true, texture = placeholder (32x32 white rect)
- CollisionShape2D: shape = RectangleShape2D (16x32)
- Camera2D: enabled = true, position_smoothing_enabled = true
Create accompanying script:
extends CharacterBody2D
# Movement parameters
@export var speed: float = 200.0
@export var jump_velocity: float = -400.0
@export var acceleration: float = 800.0
@export var friction: float = 1000.0
# Get the gravity from the project settings
var gravity = ProjectSettings.get_setting("physics/2d/default_gravity")
@onready var sprite = $Sprite2D
@onready var animation_player = $AnimationPlayer
func _physics_process(delta):
# Add gravity
if not is_on_floor():
velocity.y += gravity * delta
# Handle jump
if Input.is_action_just_pressed("ui_accept") and is_on_floor():
velocity.y = jump_velocity
# Get input direction
var direction = Input.get_axis("ui_left", "ui_right")
# Apply movement
if direction != 0:
velocity.x = move_toward(velocity.x, direction * speed, acceleration * delta)
# Flip sprite based on direction
sprite.flip_h = direction < 0
else:
# Apply friction when no input
velocity.x = move_toward(velocity.x, 0, friction * delta)
move_and_slide()
# Animation logic (requires animations to be set up)
_update_animation()
func _update_animation():
if not animation_player:
return
# TODO: Create animations in AnimationPlayer:
# - "idle": Standing still
# - "run": Running
# - "jump": Jumping up
# - "fall": Falling down
# Example animation logic:
# if not is_on_floor():
# if velocity.y < 0:
# animation_player.play("jump")
# else:
# animation_player.play("fall")
# elif abs(velocity.x) > 10:
# animation_player.play("run")
# else:
# animation_player.play("idle")
pass
2D Enemy Template
Create scene with:
CharacterBody2D (root)
├── Sprite2D (sprite)
├── CollisionShape2D (collision)
├── Area2D (detection_area)
│ └── CollisionShape2D (detection_collision)
├── AnimationPlayer (animation_player)
└── Timer (patrol_timer)
Node details:
- CharacterBody2D: motion_mode = MOTION_MODE_GROUNDED
- Sprite2D: centered = true, modulate = Color(1, 0.5, 0.5) (reddish tint)
- CollisionShape2D: shape = RectangleShape2D (16x24)
- Area2D/CollisionShape2D: shape = CircleShape2D (radius = 100) for player detection
- Timer: wait_time = 2.0, one_shot = false
Create accompanying script:
extends CharacterBody2D
enum State { IDLE, PATROL, CHASE, ATTACK }
# Movement parameters
@export var patrol_speed: float = 50.0
@export var chase_speed: float = 150.0
@export var detection_range: float = 100.0
@export var attack_range: float = 30.0
@export var health: int = 100
var current_state: State = State.IDLE
var player: Node2D = null
var patrol_direction: int = 1
var gravity = ProjectSettings.get_setting("physics/2d/default_gravity")
@onready var sprite = $Sprite2D
@onready var detection_area = $detection_area
@onready var patrol_timer = $patrol_timer
func _ready():
# Connect area signals for player detection
detection_area.body_entered.connect(_on_detection_area_entered)
detection_area.body_exited.connect(_on_detection_area_exited)
# Connect patrol timer
patrol_timer.timeout.connect(_on_patrol_timer_timeout)
patrol_timer.start()
current_state = State.PATROL
func _physics_process(delta):
# Apply gravity
if not is_on_floor():
velocity.y += gravity * delta
# State machine
match current_state:
State.IDLE:
velocity.x = 0
State.PATROL:
velocity.x = patrol_direction * patrol_speed
sprite.flip_h = patrol_direction < 0
# Turn around at ledges or walls
if is_on_wall() or not _check_floor_ahead():
patrol_direction *= -1
State.CHASE:
if player:
var direction = sign(player.global_position.x - global_position.x)
velocity.x = direction * chase_speed
sprite.flip_h = direction < 0
# Check if close enough to attack
var distance = global_position.distance_to(player.global_position)
if distance < attack_range:
current_state = State.ATTACK
else:
current_state = State.PATROL
State.ATTACK:
velocity.x = 0
# TODO: Implement attack logic
# For now, just return to chase after a moment
await get_tree().create_timer(0.5).timeout
current_state = State.CHASE
move_and_slide()
func _check_floor_ahead() -> bool:
# Raycast to check if there's floor ahead
var space_state = get_world_2d().direct_space_state
var query = PhysicsRayQueryParameters2D.create(
global_position,
global_position + Vector2(patrol_direction * 20, 30)
)
var result = space_state.intersect_ray(query)
return result.size() > 0
func _on_detection_area_entered(body):
if body.is_in_group("player"):
player = body
current_state = State.CHASE
func _on_detection_area_exited(body):
if body == player:
player = null
current_state = State.PATROL
func _on_patrol_timer_timeout():
if current_state == State.IDLE or current_state == State.PATROL:
patrol_direction *= -1
func take_damage(amount: int):
health -= amount
# TODO: Add damage flash/animation
if health <= 0:
die()
func die():
# TODO: Add death animation
queue_free()
2D Level Template
Create scene with:
Node2D (root)
├── TileMap (tilemap)
├── Node2D (spawn_points)
│ └── Marker2D (player_spawn)
├── Node2D (enemies)
├── Node2D (collectibles)
├── ParallaxBackground (background)
│ └── ParallaxLayer (layer1)
│ └── Sprite2D (bg_sprite)
└── Camera2D (camera)
Node details:
- TileMap: tile_set = null (needs to be set by user), layer 0 = "Ground", layer 1 = "Walls"
- Camera2D: enabled = true, limit_left = 0, limit_top = 0
Create accompanying script:
extends Node2D
@onready var tilemap = $TileMap
@onready var player_spawn = $spawn_points/player_spawn
@onready var camera = $Camera2D
# Preload player scene
const PLAYER_SCENE = preload("res://scenes/characters/player.tscn")
func _ready():
# Spawn player
spawn_player()
# Set camera limits based on level bounds
_setup_camera_limits()
func spawn_player():
# Instance and add player
var player = PLAYER_SCENE.instantiate()
player.global_position = player_spawn.global_position
add_child(player)
# Make camera follow player
camera.enabled = false # Disable level camera
# Player should have its own camera
func _setup_camera_limits():
# Get tilemap bounds
var used_rect = tilemap.get_used_rect()
var tile_size = tilemap.tile_set.tile_size if tilemap.tile_set else Vector2(16, 16)
# Set camera limits to level bounds
camera.limit_left = used_rect.position.x * tile_size.x
camera.limit_top = used_rect.position.y * tile_size.y
camera.limit_right = used_rect.end.x * tile_size.x
camera.limit_bottom = used_rect.end.y * tile_size.y
# Helper function to spawn enemies at runtime
func spawn_enemy(enemy_scene: PackedScene, position: Vector2):
var enemy = enemy_scene.instantiate()
enemy.global_position = position
$enemies.add_child(enemy)
# Helper function to spawn collectibles
func spawn_collectible(collectible_scene: PackedScene, position: Vector2):
var collectible = collectible_scene.instantiate()
collectible.global_position = position
$collectibles.add_child(collectible)
2D Projectile Template
Create scene with:
Area2D (root)
├── Sprite2D (sprite)
├── CollisionShape2D (collision)
└── Timer (lifetime_timer)
Node details:
- Sprite2D: centered = true, modulate = Color(1, 1, 0) (yellow)
- CollisionShape2D: shape = CircleShape2D (radius = 4)
- Timer: wait_time = 5.0, one_shot = true, autostart = true
Create accompanying script:
extends Area2D
@export var speed: float = 300.0
@export var damage: int = 10
@export var lifetime: float = 5.0
var direction: Vector2 = Vector2.RIGHT
@onready var sprite = $Sprite2D
@onready var lifetime_timer = $lifetime_timer
func _ready():
# Connect signals
body_entered.connect(_on_body_entered)
area_entered.connect(_on_area_entered)
lifetime_timer.timeout.connect(_on_lifetime_timeout)
# Set lifetime
lifetime_timer.wait_time = lifetime
func _physics_process(delta):
# Move in direction
position += direction.normalized() * speed * delta
func set_direction(new_direction: Vector2):
direction = new_direction.normalized()
# Rotate sprite to face direction
rotation = direction.angle()
func _on_body_entered(body):
# Hit something solid
if body.has_method("take_damage"):
body.take_damage(damage)
# Create hit effect
_create_hit_effect()
queue_free()
func _on_area_entered(area):
# Hit another area (enemy hitbox, etc.)
if area.get_parent().has_method("take_damage"):
area.get_parent().take_damage(damage)
# Create hit effect
_create_hit_effect()
queue_free()
func _on_lifetime_timeout():
# Despawn after lifetime expires
queue_free()
func _create_hit_effect():
# TODO: Spawn particle effect or animation
pass
Collectible Template
Create scene with:
Area2D (root)
├── Sprite2D (sprite)
├── CollisionShape2D (collision)
├── AnimationPlayer (animation_player)
└── AudioStreamPlayer2D (pickup_sound)
Node details:
- Sprite2D: centered = true, modulate = Color(1, 0.8, 0) (gold color)
- CollisionShape2D: shape = CircleShape2D (radius = 8)
Create accompanying script:
extends Area2D
@export var collect_value: int = 1
@export var float_amplitude: float = 5.0
@export var float_speed: float = 2.0
var start_y: float
var time: float = 0.0
@onready var sprite = $Sprite2D
@onready var animation_player = $AnimationPlayer
@onready var pickup_sound = $pickup_sound
func _ready():
# Connect collection signal
body_entered.connect(_on_body_entered)
# Store starting position for floating animation
start_y = position.y
# Random offset for variety
time = randf() * TAU
func _process(delta):
# Floating animation
time += delta * float_speed
position.y = start_y + sin(time) * float_amplitude
# Rotate for visual interest
sprite.rotation += delta * 2.0
func _on_body_entered(body):
if body.is_in_group("player"):
# Notify player of collection
if body.has_method("collect_item"):
body.collect_item(collect_value)
# Play pickup sound
if pickup_sound and pickup_sound.stream:
# Play sound then destroy
pickup_sound.play()
# Hide visuals but keep node alive for sound
sprite.visible = false
$CollisionShape2D.set_deferred("disabled", true)
await pickup_sound.finished
queue_free()
Interactable Object Template
Create scene with:
StaticBody2D (root)
├── Sprite2D (sprite)
├── CollisionShape2D (collision)
├── Area2D (interaction_area)
│ └── CollisionShape2D (interaction_collision)
└── Label (prompt_label)
Node details:
- Sprite2D: centered = true
- CollisionShape2D: shape = RectangleShape2D (32x32)
- Area2D/CollisionShape2D: shape = RectangleShape2D (48x48) for interaction detection
- Label: text = "Press E", horizontal_alignment = CENTER, visible = false
Create accompanying script:
extends StaticBody2D
signal interacted
@export var interaction_text: String = "Press E"
@export var can_interact_multiple_times: bool = false
var player_nearby: bool = false
var has_been_used: bool = false
@onready var sprite = $Sprite2D
@onready var interaction_area = $interaction_area
@onready var prompt_label = $prompt_label
func _ready():
# Connect area signals
interaction_area.body_entered.connect(_on_interaction_area_entered)
interaction_area.body_exited.connect(_on_interaction_area_exited)
# Set prompt text
prompt_label.text = interaction_text
# Position prompt above object
prompt_label.position.y = -40
func _process(_delta):
if player_nearby and Input.is_action_just_pressed("ui_accept"):
if not has_been_used or can_interact_multiple_times:
_interact()
func _on_interaction_area_entered(body):
if body.is_in_group("player"):
player_nearby = true
# Show prompt if not used or can use multiple times
if not has_been_used or can_interact_multiple_times:
prompt_label.visible = true
func _on_interaction_area_exited(body):
if body.is_in_group("player"):
player_nearby = false
prompt_label.visible = false
func _interact():
# Mark as used
has_been_used = true
# Hide prompt if can't be used again
if not can_interact_multiple_times:
prompt_label.visible = false
# Emit signal for other systems to respond
interacted.emit()
# TODO: Implement specific interaction logic
# Examples:
# - Open a door
# - Play an animation
# - Give an item
# - Show dialogue
# - Toggle a mechanism
print("Interacted with ", name)
After Creating Scene
After creating the selected scene:
-
Inform the user of the files created:
- Scene file location
- Script file location
-
Provide customization tips:
- "The [scene name] has been created at [path]"
- "To customize this scene:"
- Replace the placeholder sprite with your own artwork
- Adjust the exported variables in the Inspector
- Add animations in the AnimationPlayer
- [Template-specific tips]
-
Provide usage instructions:
- For characters: "Add this to your level by dragging into the scene or instantiating in code"
- For levels: "Set this as your main scene in Project Settings or change to it with get_tree().change_scene_to_file()"
- For projectiles: "Instance this in your player/enemy script when firing"
- For collectibles/interactables: "Place these in your level scene as children"
-
Offer next steps:
- "Would you like me to:"
- Create related scenes (e.g., "create a projectile for this character?")
- Add more features (e.g., "add a dash ability?", "add more enemy states?")
- Set up animations (if AnimationPlayer exists)
- Create a test level to try it out
- "Would you like me to:"