spawnpoint-studio 0.1.0__py3-none-any.whl

spawnpoint/_data/godot/addons/spawn_point/runtime/camera_rig.gd

@@ -0,0 +1,71 @@
+class_name SPCameraRig
+extends Camera2D
+## Follows the player with smoothing and look-ahead; trauma-based screen shake.
+##
+## Shake follows the "trauma" model: offset = max_offset * trauma² * noise(t). Trauma decays
+## linearly, so small hits produce subtle jitter and big hits a strong, short shake.
+
+## Maximum shake offset in pixels at trauma 1.
+@export var max_shake_offset := Vector2(14, 10)
+## Maximum shake rotation in radians at trauma 1.
+@export var max_shake_rotation := 0.04
+## Trauma lost per second.
+@export var trauma_decay := 1.6
+## How far ahead of the player the camera looks, in pixels at full speed.
+@export var look_ahead := Vector2(48, 0)
+## Smoothing speed of the look-ahead offset.
+@export var look_ahead_speed := 3.0
+
+var trauma := 0.0
+var _noise := FastNoiseLite.new()
+var _t := 0.0
+var _look := Vector2.ZERO
+var _target: Node2D
+
+
+func _ready() -> void:
+	position_smoothing_enabled = true
+	if position_smoothing_speed <= 0.0:
+		position_smoothing_speed = 7.0
+	ignore_rotation = false
+	_noise.seed = randi()
+	_noise.frequency = 2.0
+	FX.register_camera(self)
+	make_current()
+	_snap_to_target.call_deferred()
+
+
+func _exit_tree() -> void:
+	FX.unregister_camera(self)
+
+
+func add_trauma(amount: float) -> void:
+	trauma = clampf(trauma + amount, 0.0, 1.0)
+
+
+func _snap_to_target() -> void:
+	_target = World.player()
+	if _target:
+		global_position = _target.global_position
+		reset_smoothing()
+
+
+func _process(delta: float) -> void:
+	if _target == null or not is_instance_valid(_target):
+		_target = World.player()
+	if _target:
+		var vel := Vector2.ZERO
+		if _target is CharacterBody2D:
+			vel = (_target as CharacterBody2D).velocity
+		var desired := Vector2(signf(vel.x) * look_ahead.x if absf(vel.x) > 20.0 else _look.x,
+				signf(vel.y) * look_ahead.y if absf(vel.y) > 20.0 else _look.y)
+		_look = _look.lerp(desired, clampf(look_ahead_speed * delta, 0.0, 1.0))
+		global_position = _target.global_position + _look
+
+	_t += delta
+	trauma = maxf(trauma - trauma_decay * delta, 0.0)
+	var s := trauma * trauma
+	offset = Vector2(
+			max_shake_offset.x * s * _noise.get_noise_2d(_t * 60.0, 0.0),
+			max_shake_offset.y * s * _noise.get_noise_2d(0.0, _t * 60.0))
+	rotation = max_shake_rotation * s * _noise.get_noise_2d(_t * 60.0, 100.0)

spawnpoint/_data/godot/addons/spawn_point/runtime/cockpit.gd

@@ -0,0 +1,62 @@
+extends Node
+## Autoload "Cockpit": lets the Spawn Point web cockpit select entities in the running game.
+## Right-click an entity: it flashes, and on the web its type and node name are posted to the
+## parent page ({spawnpoint: "select", entity, node}). Harmless when not embedded.
+
+signal selected(entity: Node)
+
+## How far (px) a click may land from an entity and still select it — sprites are small.
+const PICK_RADIUS := 28.0
+
+
+func _ready() -> void:
+	process_mode = Node.PROCESS_MODE_ALWAYS
+
+
+func _unhandled_input(event: InputEvent) -> void:
+	var mb := event as InputEventMouseButton
+	if mb == null or not mb.pressed or mb.button_index != MOUSE_BUTTON_RIGHT:
+		return
+	if World.level == null or not is_instance_valid(World.level):
+		return
+	var e := entity_at(World.level.get_global_mouse_position())
+	if e:
+		select(e)
+		get_viewport().set_input_as_handled()
+
+
+## The entity at (or nearest to, within PICK_RADIUS) a world position, or null.
+func entity_at(world_pos: Vector2) -> Node2D:
+	var q := PhysicsPointQueryParameters2D.new()
+	q.position = world_pos
+	q.collide_with_areas = true
+	q.collide_with_bodies = true
+	for hit in World.level.get_world_2d().direct_space_state.intersect_point(q, 16):
+		var e := SP.entity_of(hit.collider) as Node2D
+		if e and e.is_in_group(SP.ENTITY_GROUP):
+			return e
+	var best: Node2D = null
+	var best_d := PICK_RADIUS
+	for n in get_tree().get_nodes_in_group(SP.ENTITY_GROUP):
+		var e := n as Node2D
+		if e == null or not e.visible:
+			continue
+		var d := e.global_position.distance_to(world_pos)
+		if d < best_d:
+			best_d = d
+			best = e
+	return best
+
+
+## Highlights [param e] and reports it to the cockpit page.
+func select(e: Node2D) -> void:
+	selected.emit(e)
+	var juice := SP.component(e, &"Juice")
+	if juice and juice.has_method(&"flash_white"):
+		juice.flash_white(0.35)
+	FX.burst(e.global_position, Color.WHITE, 10, 120.0, 0.3, 2.5, 0.0)
+	var core := SP.core(e)
+	var msg := JSON.stringify({"spawnpoint": "select", "entity": core.entity_type if core else String(e.name),
+			"node": String(e.name)})
+	if OS.has_feature("web"):
+		JavaScriptBridge.eval("window.parent && window.parent.postMessage(%s, '*')" % msg)

spawnpoint/_data/godot/addons/spawn_point/runtime/entity_core.gd

@@ -0,0 +1,98 @@
+class_name SPEntityCore
+extends Node
+## Core of every Spawn Point entity (always the child named "Entity").
+##
+## Registers the entity with [World], handles default death behaviour (players lose a life and
+## respawn, everything else is removed) and kills entities that fall out of the level.
+
+signal respawned
+
+## Entity type name from the game graph ("Player", "Slime", ...).
+@export var entity_type := ""
+## "player", "enemy" or "neutral".
+@export var team := SP.TEAM_NEUTRAL
+## True for the entity controlled by the player.
+@export var is_player := false
+## Seconds before a dead player respawns.
+@export var respawn_delay := 0.9
+
+var spawn_position := Vector2.ZERO
+var dead := false
+## Why the entity last died: "fall", the attacking entity's type (e.g. "Spikes"), or "unknown".
+## Empty while alive.
+var death_cause := ""
+
+
+func _enter_tree() -> void:
+	var e := get_parent()
+	e.add_to_group(SP.ENTITY_GROUP)
+	if entity_type != "":
+		e.add_to_group(StringName(entity_type))
+	if e.has_meta(&"sp_team"):
+		team = String(e.get_meta(&"sp_team"))
+	e.add_to_group(StringName("team_" + team))
+	if is_player:
+		e.add_to_group(SP.PLAYER_GROUP)
+
+
+func _ready() -> void:
+	var e := get_parent() as Node2D
+	spawn_position = e.global_position
+	var health := SP.component(e, &"Health") as HealthComponent
+	if health:
+		health.died.connect(_on_died)
+	World.register_entity(e)
+
+
+func _physics_process(_delta: float) -> void:
+	var e := get_parent() as Node2D
+	if not dead and e.global_position.y > World.kill_y:
+		death_cause = "fall"
+		var health := SP.component(e, &"Health") as HealthComponent
+		if health:
+			health.kill()
+		else:
+			_on_died()
+
+
+func _on_died() -> void:
+	if dead:
+		return
+	dead = true
+	var e := get_parent() as Node2D
+	if death_cause == "":
+		death_cause = _attacker_type(e)
+	if not is_player:
+		e.queue_free.call_deferred()
+		return
+	e.visible = false
+	e.set_deferred(&"process_mode", Node.PROCESS_MODE_DISABLED)
+	if GameState.player_died():
+		get_tree().create_timer(respawn_delay).timeout.connect(_respawn)
+
+
+func _respawn() -> void:
+	var e := get_parent() as Node2D
+	if not is_instance_valid(e):
+		return
+	e.global_position = spawn_position
+	if e is CharacterBody2D:
+		(e as CharacterBody2D).velocity = Vector2.ZERO
+	var health := SP.component(e, &"Health") as HealthComponent
+	if health:
+		health.reset()
+		health.grant_invincibility(1.5)
+	dead = false
+	death_cause = ""
+	e.visible = true
+	e.process_mode = Node.PROCESS_MODE_INHERIT
+	respawned.emit()
+
+
+func _attacker_type(e: Node) -> String:
+	var hb := SP.component(e, &"Hurtbox") as HurtboxComponent
+	if hb and is_instance_valid(hb.last_hit_by):
+		var c := SP.core(hb.last_hit_by)
+		if c and c.entity_type != "":
+			return c.entity_type
+	return "unknown"

spawnpoint/_data/godot/addons/spawn_point/runtime/fx.gd

@@ -0,0 +1,112 @@
+extends Node
+## Autoload "FX": global game-feel effects — hit-stop, screen shake, particle bursts, floating text.
+
+var _hitstop_token := 0
+var _cameras: Array[Node] = []
+
+
+func register_camera(cam: Node) -> void:
+	if cam not in _cameras:
+		_cameras.append(cam)
+
+
+func unregister_camera(cam: Node) -> void:
+	_cameras.erase(cam)
+
+
+## Freezes the game for [param seconds] ("hit-stop"). The most recent call decides when it ends.
+## Timed in engine time (not wall-clock), so it also works when the game runs faster than real
+## time (fixed-fps tests, high refresh rates).
+func hitstop(seconds: float) -> void:
+	if seconds <= 0.0 or not is_inside_tree():
+		return
+	_hitstop_token += 1
+	var token := _hitstop_token
+	Engine.time_scale = 0.0
+	await get_tree().create_timer(seconds, true, false, true).timeout
+	if token == _hitstop_token:
+		Engine.time_scale = 1.0
+
+
+## Adds trauma (0..1) to every active camera rig. Shake strength grows with trauma².
+func shake(amount: float) -> void:
+	for cam in _cameras:
+		if is_instance_valid(cam):
+			cam.add_trauma(amount)
+
+
+## One-shot particle burst at [param pos].
+func burst(pos: Vector2, color: Color, amount := 16, speed := 180.0, lifetime := 0.45, size := 4.0, gravity := 300.0) -> void:
+	var parent := _fx_parent()
+	if parent == null:
+		return
+	var p := CPUParticles2D.new()
+	p.one_shot = true
+	p.explosiveness = 0.95
+	p.amount = maxi(amount, 1)
+	p.lifetime = lifetime
+	p.direction = Vector2.UP
+	p.spread = 180.0
+	p.initial_velocity_min = speed * 0.4
+	p.initial_velocity_max = speed
+	p.gravity = Vector2(0, gravity)
+	p.damping_min = 40.0
+	p.damping_max = 80.0
+	p.scale_amount_min = size * 0.5
+	p.scale_amount_max = size
+	var curve := Curve.new()
+	curve.add_point(Vector2(0, 1))
+	curve.add_point(Vector2(1, 0))
+	p.scale_amount_curve = curve
+	p.color = color
+	p.position = pos
+	p.z_index = 10
+	parent.add_child(p)
+	p.emitting = true
+	p.finished.connect(p.queue_free)
+
+
+## Rising, fading text (e.g. "+1") at [param pos].
+func float_text(pos: Vector2, text: String, color := Color.WHITE) -> void:
+	var parent := _fx_parent()
+	if parent == null:
+		return
+	var label := Label.new()
+	label.text = text
+	label.add_theme_font_size_override(&"font_size", 18)
+	label.add_theme_color_override(&"font_color", color)
+	label.add_theme_color_override(&"font_outline_color", Color(0, 0, 0, 0.8))
+	label.add_theme_constant_override(&"outline_size", 4)
+	label.position = pos - Vector2(20, 24)
+	label.z_index = 20
+	parent.add_child(label)
+	var t := label.create_tween().set_parallel(true)
+	t.tween_property(label, ^"position:y", label.position.y - 28.0, 0.6).set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_CUBIC)
+	t.tween_property(label, ^"modulate:a", 0.0, 0.6).set_delay(0.25)
+	t.chain().tween_callback(label.queue_free)
+
+
+## Fading copy of [param visual] — used for dash after-images.
+func ghost(visual: Node2D, color := Color(1, 1, 1, 0.5)) -> void:
+	var parent := _fx_parent()
+	if parent == null or visual == null:
+		return
+	var copy := visual.duplicate(0) as Node2D
+	copy.material = null
+	for c in copy.find_children("*", "CanvasItem", true, false):
+		(c as CanvasItem).material = null
+	copy.modulate = color
+	copy.z_index = -1
+	parent.add_child(copy)
+	copy.global_transform = visual.global_transform
+	var t := copy.create_tween()
+	t.tween_property(copy, ^"modulate:a", 0.0, 0.25)
+	t.tween_callback(copy.queue_free)
+
+
+func _fx_parent() -> Node:
+	if not is_inside_tree():
+		return null
+	if World.level and is_instance_valid(World.level):
+		return World.level
+	return get_tree().current_scene

spawnpoint/_data/godot/addons/spawn_point/runtime/game_state.gd

@@ -0,0 +1,111 @@
+extends Node
+## Autoload "GameState": score, lives, rule variables and the win/lose flow.
+
+signal score_changed(score: int)
+signal lives_changed(lives: int)
+signal var_changed(name: String, value: Variant)
+signal message_posted(text: String)
+## Emitted once per whole second of play time (survival goals, timed events).
+signal second_passed(seconds: int)
+signal game_won
+signal game_lost
+
+enum Phase { PLAYING, WON, LOST }
+
+var score := 0
+var lives := 3
+var start_lives := 3
+var time := 0.0
+var phase := Phase.PLAYING
+var vars := {}
+
+var _started := false
+
+
+## Called by the level on load. Resets everything on the first load and after restart().
+func begin_level(level_lives: int) -> void:
+	if _started:
+		phase = Phase.PLAYING
+		return
+	_started = true
+	start_lives = level_lives
+	score = 0
+	lives = level_lives
+	time = 0.0
+	vars.clear()
+	phase = Phase.PLAYING
+
+
+func _process(delta: float) -> void:
+	if phase == Phase.PLAYING:
+		var before := int(time)
+		time += delta
+		if int(time) > before:
+			second_passed.emit(int(time))
+
+
+func is_playing() -> bool:
+	return phase == Phase.PLAYING
+
+
+func add_score(amount: int) -> void:
+	if amount == 0:
+		return
+	score += amount
+	score_changed.emit(score)
+
+
+func set_var(var_name: String, value: Variant) -> void:
+	vars[var_name] = value
+	var_changed.emit(var_name, value)
+
+
+func add_var(var_name: String, delta: float) -> void:
+	set_var(var_name, get_var(var_name) + delta)
+
+
+func get_var(var_name: String) -> Variant:
+	return vars.get(var_name, 0)
+
+
+func message(text: String) -> void:
+	message_posted.emit(text)
+
+
+## The player lost a life. Returns true if the player may respawn.
+func player_died() -> bool:
+	if phase != Phase.PLAYING:
+		return false
+	lives = maxi(lives - 1, 0)
+	lives_changed.emit(lives)
+	if lives <= 0:
+		lose()
+		return false
+	return true
+
+
+func win() -> void:
+	if phase != Phase.PLAYING:
+		return
+	phase = Phase.WON
+	game_won.emit()
+
+
+func lose() -> void:
+	if phase != Phase.PLAYING:
+		return
+	phase = Phase.LOST
+	game_lost.emit()
+
+
+## Resets the run state without reloading the scene (used by tests and tools).
+func reset_run(level_lives := 3) -> void:
+	_started = false
+	begin_level(level_lives)
+
+
+## Full restart: score, lives and variables reset, level reloads.
+func restart() -> void:
+	_started = false
+	Engine.time_scale = 1.0
+	get_tree().reload_current_scene()

spawnpoint/_data/godot/addons/spawn_point/runtime/hud.gd

@@ -0,0 +1,155 @@
+class_name SPHud
+extends CanvasLayer
+## Score, lives, player health, toast messages and the win / game-over overlay.
+## Press R at any time (or Enter after the game ends) to restart.
+
+const TEXT_COLOR := Color("#fff1e8")
+const ACCENT := Color("#ffec27")
+const DANGER := Color("#ff004d")
+
+var _score: Label
+var _lives: Label
+var _hearts: HBoxContainer
+var _toast: Label
+var _overlay: Control
+var _overlay_title: Label
+var _toast_tween: Tween
+var _shown_health := -1
+
+
+func _ready() -> void:
+	layer = 10
+	process_mode = Node.PROCESS_MODE_ALWAYS
+	_build()
+	GameState.score_changed.connect(_on_score)
+	GameState.lives_changed.connect(_on_lives)
+	GameState.message_posted.connect(show_message)
+	GameState.game_won.connect(_show_overlay.bind("YOU WIN!", ACCENT))
+	GameState.game_lost.connect(_show_overlay.bind("GAME OVER", DANGER))
+	_on_score(GameState.score)
+	_on_lives(GameState.lives)
+
+
+func _process(_delta: float) -> void:
+	var p := World.player()
+	var h: HealthComponent = SP.component(p, &"Health") as HealthComponent if p else null
+	var cur: int = h.current if h else -1
+	if cur != _shown_health:
+		_shown_health = cur
+		_refresh_hearts(h)
+
+
+func _unhandled_input(event: InputEvent) -> void:
+	if event is InputEventKey and event.pressed and not event.echo:
+		var key := (event as InputEventKey).keycode
+		if key == KEY_R or (not GameState.is_playing() and key in [KEY_ENTER, KEY_KP_ENTER, KEY_SPACE]):
+			GameState.restart()
+
+
+func show_message(text: String) -> void:
+	_toast.text = text
+	_toast.modulate.a = 1.0
+	_toast.scale = Vector2(1.3, 1.3)
+	if _toast_tween:
+		_toast_tween.kill()
+	_toast_tween = _toast.create_tween()
+	_toast_tween.tween_property(_toast, ^"scale", Vector2.ONE, 0.25).set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)
+	_toast_tween.tween_interval(1.4)
+	_toast_tween.tween_property(_toast, ^"modulate:a", 0.0, 0.5)
+
+
+func _on_score(score: int) -> void:
+	_score.text = "SCORE %d" % score
+	_score.pivot_offset = _score.size * 0.5
+	var t := _score.create_tween()
+	_score.scale = Vector2(1.25, 1.25)
+	t.tween_property(_score, ^"scale", Vector2.ONE, 0.2).set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)
+
+
+func _on_lives(lives: int) -> void:
+	_lives.text = "LIVES %d" % lives
+
+
+func _refresh_hearts(h: HealthComponent) -> void:
+	for c in _hearts.get_children():
+		c.queue_free()
+	if h == null:
+		return
+	for i in h.max_health:
+		var r := ColorRect.new()
+		r.custom_minimum_size = Vector2(14, 14)
+		r.color = DANGER if i < h.current else Color(1, 1, 1, 0.15)
+		_hearts.add_child(r)
+
+
+func _show_overlay(title: String, color: Color) -> void:
+	_overlay_title.text = title
+	_overlay_title.add_theme_color_override(&"font_color", color)
+	_overlay.visible = true
+	_overlay.modulate.a = 0.0
+	_overlay.create_tween().tween_property(_overlay, ^"modulate:a", 1.0, 0.35)
+
+
+func _label(size: int, color := TEXT_COLOR) -> Label:
+	var l := Label.new()
+	l.add_theme_font_size_override(&"font_size", size)
+	l.add_theme_color_override(&"font_color", color)
+	l.add_theme_color_override(&"font_outline_color", Color(0, 0, 0, 0.85))
+	l.add_theme_constant_override(&"outline_size", maxi(size / 5, 3))
+	return l
+
+
+func _build() -> void:
+	var root := Control.new()
+	root.set_anchors_preset(Control.PRESET_FULL_RECT)
+	root.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	add_child(root)
+
+	var top := HBoxContainer.new()
+	top.set_anchors_preset(Control.PRESET_TOP_WIDE)
+	top.offset_left = 16
+	top.offset_right = -16
+	top.offset_top = 10
+	top.add_theme_constant_override(&"separation", 24)
+	root.add_child(top)
+	_score = _label(26, ACCENT)
+	top.add_child(_score)
+	_hearts = HBoxContainer.new()
+	_hearts.size_flags_vertical = Control.SIZE_SHRINK_CENTER
+	_hearts.add_theme_constant_override(&"separation", 4)
+	_hearts.alignment = BoxContainer.ALIGNMENT_CENTER
+	top.add_child(_hearts)
+	var spacer := Control.new()
+	spacer.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	top.add_child(spacer)
+	_lives = _label(22)
+	top.add_child(_lives)
+
+	_toast = _label(34)
+	_toast.set_anchors_preset(Control.PRESET_CENTER_TOP)
+	_toast.offset_top = 70
+	_toast.offset_left = -300
+	_toast.offset_right = 300
+	_toast.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	_toast.pivot_offset = Vector2(300, 20)
+	_toast.modulate.a = 0.0
+	root.add_child(_toast)
+
+	_overlay = ColorRect.new()
+	(_overlay as ColorRect).color = Color(0, 0, 0, 0.55)
+	_overlay.set_anchors_preset(Control.PRESET_FULL_RECT)
+	_overlay.visible = false
+	root.add_child(_overlay)
+	var box := VBoxContainer.new()
+	box.set_anchors_preset(Control.PRESET_CENTER)
+	box.grow_horizontal = Control.GROW_DIRECTION_BOTH
+	box.grow_vertical = Control.GROW_DIRECTION_BOTH
+	box.alignment = BoxContainer.ALIGNMENT_CENTER
+	_overlay.add_child(box)
+	_overlay_title = _label(64)
+	_overlay_title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	box.add_child(_overlay_title)
+	var hint := _label(22)
+	hint.text = "Press R to play again"
+	hint.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	box.add_child(hint)

spawnpoint/_data/godot/addons/spawn_point/runtime/level.gd

@@ -0,0 +1,19 @@
+class_name SPLevel
+extends Node2D
+## Root of a generated level. Configures [World] and [GameState] before entities load.
+
+## "platformer" or "topdown".
+@export var genre := "platformer"
+## Lives at the start of a run.
+@export var lives := 3
+## Tile size in pixels.
+@export var tile_size := 32
+## Level bounds in pixels.
+@export var bounds := Rect2(0, 0, 960, 540)
+
+
+func _enter_tree() -> void:
+	var kill_y := bounds.end.y + tile_size * 4.0 if genre == "platformer" else INF
+	World.begin_level(self, kill_y)
+	GameState.begin_level(lives)
+	Engine.time_scale = 1.0

spawnpoint/_data/godot/addons/spawn_point/runtime/sfx.gd

@@ -0,0 +1,58 @@
+extends Node
+## Autoload "Sfx": pooled one-shot sound playback with pitch variation.
+## Sounds are loaded from res://sfx/<name>.wav (generated by the compiler).
+
+const SFX_PATH := "res://sfx/%s.wav"
+const VOICES := 12
+
+var _players: Array[AudioStreamPlayer] = []
+var _next := 0
+var _streams := {}
+var _combo := {}  # name -> {"until": msec, "step": int}
+
+
+func _ready() -> void:
+	process_mode = Node.PROCESS_MODE_ALWAYS
+	for i in VOICES:
+		var p := AudioStreamPlayer.new()
+		add_child(p)
+		_players.append(p)
+
+
+## Plays sound [param sound_name]. [param pitch_variance] randomizes pitch by ±that fraction.
+func play(sound_name: String, pitch_variance := 0.08, volume_db := 0.0, pitch := 1.0) -> void:
+	var stream := _stream(sound_name)
+	if stream == null:
+		return
+	var p := _players[_next]
+	_next = (_next + 1) % _players.size()
+	p.stream = stream
+	p.volume_db = volume_db
+	p.pitch_scale = maxf(0.05, pitch * (1.0 + randf_range(-pitch_variance, pitch_variance)))
+	p.play()
+
+
+## Like play(), but each call within [param window] seconds of the previous one is a semitone
+## higher (coin pickup chains).
+func play_combo(sound_name: String, window := 0.8, max_steps := 12) -> void:
+	var now := Time.get_ticks_msec()
+	var c: Dictionary = _combo.get(sound_name, {"until": 0, "step": -1})
+	c.step = mini(c.step + 1, max_steps) if now < c.until else 0
+	c.until = now + int(window * 1000.0)
+	_combo[sound_name] = c
+	play(sound_name, 0.0, 0.0, pow(2.0, c.step / 12.0))
+
+
+func has_sound(sound_name: String) -> bool:
+	return _stream(sound_name) != null
+
+
+func _stream(sound_name: String) -> AudioStream:
+	if sound_name.is_empty():
+		return null
+	if _streams.has(sound_name):
+		return _streams[sound_name]
+	var path := SFX_PATH % sound_name
+	var s: AudioStream = load(path) if ResourceLoader.exists(path) else null
+	_streams[sound_name] = s
+	return s