henry/facsimile-wing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Set up framework for more advance pickup behaviours.

Browse source
This commit is contained in:
Henry Faber 2026-07-02 15:44:23 +01:00
parent a0df0be862
commit 935b61bd3b
16 changed files with 485 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

192
scripts/power_up_spawner.gd
View file

@ -9,18 +9,44 @@ class_name PowerUpSpawner extends Node2D
@onready var screensize: Vector2 = get_viewport().content_scale_size
@onready var spawn_timer: Timer = $SpawnTimer
# Optional behavior resources to assign randomly on spawn.
@export var pickup_behaviors: Array[PickupBehavior] = []
# All weapon resources to spawn as pickups.
# Populate in the editor with your weapon_shot resources.
@export var all_weapon_shots: Array[WeaponShot] = []
# Optional drift behaviors to assign randomly on spawn.
# Leave empty to use whatever is baked into the pickup scene.
@export var drift_behaviors: Array[PickupDriftBehavior] = []
# How long a pickup can linger off-screen before being cleaned up.
@export var offscreen_timeout: float = 5.0
# How long to wait after a pickup is collected before spawning the next one.
@export var cooldown_after_collection: float = 5.0
var _pickups_spawned: int = 0
var _pickups_remaining: int = 0
# Tracks active pickups so we can check off-screen timeouts.
var _active_pickups: Array[Area2D] = []
# Cooldown state for post-collection pause.
var _cooldown_timer: Timer
var _in_cooldown: bool = false
func _ready() -> void:
if spawn_timer == null:
return
spawn_timer.wait_time = spawn_interval
# Create a one-shot cooldown timer.
_cooldown_timer = Timer.new()
_cooldown_timer.one_shot = true
_cooldown_timer.timeout.connect(_on_cooldown_finished)
add_child(_cooldown_timer)
func _on_spawn_timer_timeout() -> void:
if test_mode:
@ -29,6 +55,12 @@ func _on_spawn_timer_timeout() -> void:
_spawn_normal_pickup()
func _on_cooldown_finished() -> void:
_in_cooldown = false
if spawn_timer != null and test_mode:
spawn_timer.start()
func _spawn_normal_pickup() -> void:
# Spawn a single random pickup at a position near the player.
if all_weapon_shots.is_empty():
@ -59,26 +91,51 @@ func _spawn_normal_pickup() -> void:
func _spawn_test_pickups() -> void:
for weapon: WeaponShot in all_weapon_shots:
if weapon == null or weapon.shot_name.is_empty():
continue
# In test mode: pick ONE random weapon and spawn a single pickup.
if all_weapon_shots.is_empty():
return
var pickup := _spawn_pickup(weapon)
if not is_instance_valid(pickup):
continue # skipped — no valid icon
var chosen_weapon: WeaponShot = all_weapon_shots[randi() % all_weapon_shots.size()]
if chosen_weapon == null or chosen_weapon.shot_name.is_empty():
return
# Random position within viewport, with edge padding.
var margin: float = 15.0
var pickup := _spawn_pickup(chosen_weapon)
if not is_instance_valid(pickup):
return
# Random position within viewport, with edge padding.
var margin: float = 15.0
if _should_randomize_origin(pickup):
# Randomize the perpendicular axis so pickups don't all start at one edge.
var drift := _get_pickup_drift(pickup)
if drift != null:
var offset := Vector2.ZERO
if drift.drift_along_x:
# Travels along X; randomize Y origin.
offset.x = randf_range(margin, screensize.x - margin)
offset.y = 0.0
else:
# Travels along Y; randomize X origin.
offset.x = 0.0
offset.y = randf_range(margin, screensize.y - margin)
pickup.position = offset
else:
pickup.position = Vector2(
randf_range(margin, screensize.x - margin),
randf_range(margin, screensize.y - margin)
)
else:
pickup.position = Vector2(
randf_range(margin, screensize.x - margin),
randf_range(margin, screensize.y - margin)
)
add_child(pickup)
_pickups_spawned += 1
_pickups_remaining = _pickups_spawned
add_child(pickup)
_active_pickups.append(pickup)
_pickups_spawned += 1
_pickups_remaining = _pickups_spawned
# Pause the timer while pickups are on screen; resume when all gone.
# Pause the timer while pickup is on screen; resume when gone or expired.
if spawn_timer != null:
spawn_timer.stop()
@ -92,12 +149,16 @@ func pickup_collected() -> void:
var wc: WeaponComponent = level.get_node_or_null("WeaponComponent")
if wc != null:
wc.test_mode = test_mode
# Decrement counter; resume timer once all pickups are gone.
_pickups_remaining = max(0, _pickups_remaining - 1)
if _pickups_remaining <= 0:
if spawn_timer != null:
spawn_timer.start()
_pickups_spawned = 0
# Remove from active list and start cooldown.
_active_pickups.clear()
if spawn_timer != null:
spawn_timer.stop()
_start_cooldown()
func _process(delta: float) -> void:
if test_mode:
_update_active_pickups(delta)
func _spawn_pickup(weapon: WeaponShot) -> Area2D:
@ -123,4 +184,99 @@ func _spawn_pickup(weapon: WeaponShot) -> Area2D:
icon.size = Vector2(16, 16)
pickup.add_child(icon)
# Assign a random behavior for visual variety.
_apply_random_behavior(pickup)
# Assign a random drift behavior for visual variety.
_apply_random_drift(pickup)
return pickup
func _cleanup_pickup(pickup: Area2D) -> void:
# Remove from active list if present.
for i in _active_pickups.size():
if _active_pickups[i] == pickup:
_active_pickups.remove_at(i)
break
pickup.queue_free()
# Trigger cooldown/respawn when a pickup drifts off-screen.
_start_cooldown()
func _update_active_pickups(_delta: float) -> void:
# Check each active pickup for off-screen timeout.
var viewport_rect := get_viewport_rect().size
var margin: float = 50.0 # how far off-screen counts as "gone"
var to_remove: Array[Area2D] = []
for pickup in _active_pickups:
if not is_instance_valid(pickup):
continue
# Simple off-screen check: outside viewport + margin.
if (pickup.position.x < -margin
or pickup.position.x > viewport_rect.x + margin
or pickup.position.y < -margin
or pickup.position.y > viewport_rect.y + margin):
to_remove.append(pickup)
for bad_pickup in to_remove:
_cleanup_pickup(bad_pickup)
func _start_cooldown() -> void:
if offscreen_timeout <= 0 or cooldown_after_collection <= 0:
return
_in_cooldown = true
_cooldown_timer.wait_time = cooldown_after_collection
_cooldown_timer.start()
func _apply_random_behavior(pickup: Area2D) -> void:
if pickup_behaviors.is_empty():
return
var controller := pickup.get_node_or_null("PickupBehaviorController")
if controller == null:
return
var chosen: PickupBehavior = pickup_behaviors[randi() % pickup_behaviors.size()].duplicate() as PickupBehavior
if chosen != null:
controller.behavior = chosen
func _apply_random_drift(pickup: Area2D) -> void:
# Randomly assign a drift behavior to the spawned pickup instance.
if drift_behaviors.is_empty():
return
var controller := pickup.get_node_or_null("PickupBehaviorController")
if controller == null:
return
var chosen: PickupDriftBehavior = drift_behaviors[randi() % drift_behaviors.size()].duplicate() as PickupDriftBehavior
if chosen == null:
return
# Randomize phase offset for per-instance variety.
chosen.phase_offset = randf_range(0.0, TAU)
# Randomize axis (horizontal vs vertical travel).
chosen.drift_along_x = randf() > 0.5
# Randomize direction (forward vs reverse).
chosen.reverse_direction = randf() > 0.5
# Randomize perpendicular origin.
chosen.randomize_origin = randf() > 0.5
# When randomizing origin, zero the phase so the wave starts at center (0 offset).
if chosen.randomize_origin:
chosen.phase_offset = 0.0
controller.drift_behavior = chosen
func _get_pickup_drift(pickup: Area2D) -> PickupDriftBehavior:
var controller := pickup.get_node_or_null("PickupBehaviorController")
if controller == null:
return null
return controller.drift_behavior
func _should_randomize_origin(pickup: Area2D) -> bool:
var drift := _get_pickup_drift(pickup)
return drift != null and drift.randomize_origin