spawnpoint-studio 0.1.0__py3-none-any.whl

spawnpoint/_data/godot/addons/spawn_point/components/collectible_component.gd

@@ -0,0 +1,58 @@
+class_name CollectibleComponent
+extends Node
+## A pickup (coin, gem, key...). Touching it adds [member score], emits [signal collected] and
+## removes it. The visual bobs gently so pickups read as "take me".
+
+const SP_NAME := "Collectible"
+const SP_HOSTS: Array[String] = ["Area2D"]
+const SP_REQUIRES: Array[String] = []
+const SP_CATEGORY := "core"
+
+## Emitted when collected; [param by] is the collecting entity.
+signal collected(by: Node)
+
+## Free-form kind, usable in rules ("coin", "key", "heart").
+@export var kind: String = "coin"
+## Score added on pickup (0 = none).
+@export_range(0, 100000) var score: int = 1
+## Health restored to the collector on pickup (0 = none).
+@export_range(0, 999) var heal: int = 0
+## Bobbing height in px (0 = static).
+@export_range(0.0, 32.0, 0.5) var bob_height: float = 3.0
+
+var _entity: Area2D
+var _t := 0.0
+var _taken := false
+var _base_y := 0.0
+
+
+func _ready() -> void:
+	_entity = get_parent() as Area2D
+	_entity.body_entered.connect(_on_body_entered)
+	_t = randf() * TAU
+	var visual := _entity.get_node_or_null(^"Visual") as Node2D
+	if visual:
+		_base_y = visual.position.y
+
+
+func _process(delta: float) -> void:
+	if bob_height <= 0.0:
+		return
+	_t += delta * 3.0
+	var visual := _entity.get_node_or_null(^"Visual") as Node2D
+	if visual:
+		visual.position.y = _base_y + sin(_t) * bob_height
+
+
+func _on_body_entered(body: Node) -> void:
+	if _taken or not body.is_in_group(SP.PLAYER_GROUP):
+		return
+	_taken = true
+	# Free first so rules reacting to these signals already see one pickup fewer in World.count().
+	_entity.queue_free()
+	if heal > 0:
+		var h := SP.component(body, &"Health") as HealthComponent
+		if h:
+			h.heal(heal)
+	collected.emit(body)
+	GameState.add_score(score)

spawnpoint/_data/godot/addons/spawn_point/components/gate_component.gd

@@ -0,0 +1,64 @@
+class_name GateComponent
+extends Node
+## A solid barrier that can be opened and closed by rules (doors, bridges, locked exits).
+
+const SP_NAME := "Gate"
+const SP_HOSTS: Array[String] = ["StaticBody2D"]
+const SP_REQUIRES: Array[String] = []
+const SP_CATEGORY := "core"
+
+## Emitted when the gate opens.
+signal opened
+## Emitted when the gate closes.
+signal closed
+
+## Start open.
+@export var starts_open := false
+
+var is_open := false
+var _entity: StaticBody2D
+
+
+func _ready() -> void:
+	_entity = get_parent() as StaticBody2D
+	_set_open(starts_open, false)
+
+
+## Opens the gate (no collision, faded visual).
+func open() -> void:
+	if not is_open:
+		_set_open(true, true)
+		opened.emit()
+
+
+## Closes the gate.
+func close() -> void:
+	if is_open:
+		_set_open(false, true)
+		closed.emit()
+
+
+## Opens if closed, closes if open.
+func toggle() -> void:
+	if is_open:
+		close()
+	else:
+		open()
+
+
+func _set_open(value: bool, animate: bool) -> void:
+	is_open = value
+	for cs in _entity.get_children():
+		if cs is CollisionShape2D or cs is CollisionPolygon2D:
+			cs.set_deferred(&"disabled", value)
+	var visual := _entity.get_node_or_null(^"Visual") as Node2D
+	if visual == null:
+		return
+	var alpha := 0.2 if value else 1.0
+	if animate:
+		var t := visual.create_tween().set_parallel(true)
+		t.tween_property(visual, ^"modulate:a", alpha, 0.25)
+		visual.scale = Vector2(1.15, 0.85) if value else Vector2(0.9, 1.1)
+		t.tween_property(visual, ^"scale", Vector2.ONE, 0.3).set_trans(Tween.TRANS_ELASTIC).set_ease(Tween.EASE_OUT)
+	else:
+		visual.modulate.a = alpha

spawnpoint/_data/godot/addons/spawn_point/components/health_component.gd

@@ -0,0 +1,83 @@
+class_name HealthComponent
+extends Node
+## Hit points with brief invincibility after each hit.
+## When health reaches zero the entity dies (players respawn while lives remain).
+
+const SP_NAME := "Health"
+const SP_HOSTS: Array[String] = []
+const SP_REQUIRES: Array[String] = []
+const SP_CATEGORY := "core"
+
+## Emitted after taking damage that was not blocked.
+signal damaged(amount: int)
+## Emitted after healing.
+signal healed(amount: int)
+## Emitted once when health reaches zero.
+signal died
+
+## Maximum (and starting) hit points.
+@export_range(1, 999) var max_health: int = 3
+## Seconds of invincibility after being hit (prevents instant multi-hits).
+@export_range(0.0, 5.0, 0.01) var invincibility_time: float = 0.6
+
+var current: int
+var _invincible_left := 0.0
+
+
+func _ready() -> void:
+	current = max_health
+
+
+func _physics_process(delta: float) -> void:
+	if _invincible_left > 0.0:
+		_invincible_left -= delta
+
+
+## Deals [param amount] damage unless invincible or dead.
+func damage(amount: int) -> void:
+	if amount <= 0 or is_dead() or is_invincible():
+		return
+	current = maxi(current - amount, 0)
+	_invincible_left = invincibility_time
+	damaged.emit(amount)
+	if current == 0:
+		died.emit()
+
+
+## Restores up to [param amount] hit points.
+func heal(amount: int) -> void:
+	if amount <= 0 or is_dead():
+		return
+	var before := current
+	current = mini(current + amount, max_health)
+	if current > before:
+		healed.emit(current - before)
+
+
+## Kills the entity immediately, ignoring invincibility.
+func kill() -> void:
+	if is_dead():
+		return
+	current = 0
+	died.emit()
+
+
+## Restores full health.
+func reset() -> void:
+	current = max_health
+	_invincible_left = 0.0
+
+
+## Makes the entity invincible for [param seconds].
+func grant_invincibility(seconds: float) -> void:
+	_invincible_left = maxf(_invincible_left, seconds)
+
+
+## True while hits are ignored.
+func is_invincible() -> bool:
+	return _invincible_left > 0.0
+
+
+## True when health is zero.
+func is_dead() -> bool:
+	return current <= 0

spawnpoint/_data/godot/addons/spawn_point/components/hitbox_component.gd

@@ -0,0 +1,50 @@
+class_name HitboxComponent
+extends Area2D
+## Deals damage to hurtboxes of the opposing team on contact (enemy bodies, bullets, spikes).
+
+const SP_NAME := "Hitbox"
+const SP_HOSTS: Array[String] = []
+const SP_REQUIRES: Array[String] = []
+const SP_INTERNAL: Array[String] = ["refresh_team"]
+const SP_CATEGORY := "core"
+
+## Emitted when this hitbox damages [param target] (the entity that was hit).
+signal hit(target: Node)
+
+## Damage per hit.
+@export_range(0, 999) var damage: int = 1
+## Push applied to the victim, in pixels/second.
+@export_range(0.0, 2000.0, 1.0) var knockback: float = 260.0
+## Hitbox size relative to the entity shape.
+@export_range(0.1, 2.0, 0.05) var size_scale: float = 1.0
+## Neutral hitboxes (traps) hurt both teams.
+@export var hurts_own_team := false
+
+var _entity: Node2D
+
+
+func _ready() -> void:
+	_entity = SP.entity_of(get_parent()) as Node2D
+	monitorable = false
+	monitoring = true
+	collision_layer = 0
+	refresh_team()
+
+
+## Re-reads the entity team (call after changing it at runtime).
+func refresh_team() -> void:
+	var team := SP.team_of(_entity)
+	collision_mask = SP.opposing_hurtbox_mask(team)
+	if hurts_own_team:
+		collision_mask |= SP.hurtbox_layer(team)
+
+
+func _physics_process(_delta: float) -> void:
+	# Polling overlaps (instead of area_entered) keeps damaging a victim that stays inside us
+	# once its invincibility ends.
+	for area in get_overlapping_areas():
+		var hb := area as HurtboxComponent
+		if hb == null or SP.entity_of(hb) == _entity:
+			continue
+		if hb.take_hit(damage, global_position, knockback, _entity):
+			hit.emit(SP.entity_of(hb))

spawnpoint/_data/godot/addons/spawn_point/components/hurtbox_component.gd

@@ -0,0 +1,48 @@
+class_name HurtboxComponent
+extends Area2D
+## The area where this entity can be hit. Forwards damage to Health and pushes the entity back.
+
+const SP_NAME := "Hurtbox"
+const SP_HOSTS: Array[String] = []
+const SP_REQUIRES: Array[String] = ["Health"]
+const SP_INTERNAL: Array[String] = ["take_hit"]
+const SP_CATEGORY := "core"
+
+## Emitted when a hit lands (after invincibility checks).
+signal hurt(amount: int)
+
+## Hurtbox size relative to the entity shape. Below 1 is more forgiving for the player.
+@export_range(0.1, 2.0, 0.05) var size_scale: float = 0.85
+## Multiplies knockback received.
+@export_range(0.0, 5.0, 0.05) var knockback_scale: float = 1.0
+
+## The entity whose hit landed last (attribution for death causes and playtest telemetry).
+var last_hit_by: Node
+
+var _entity: Node2D
+
+
+func _ready() -> void:
+	_entity = SP.entity_of(get_parent()) as Node2D
+	monitoring = false
+	monitorable = true
+	collision_mask = 0
+	collision_layer = SP.hurtbox_layer(SP.team_of(_entity))
+
+
+## Applies a hit from [param source] coming from [param from_position]. Returns true if damage
+## was dealt.
+func take_hit(amount: int, from_position: Vector2, knockback: float, source: Node = null) -> bool:
+	var health := SP.component(_entity, &"Health") as HealthComponent
+	if health == null or health.is_dead() or health.is_invincible():
+		return false
+	last_hit_by = source
+	health.damage(amount)
+	hurt.emit(amount)
+	var mv := SP.movement(_entity)
+	if mv and knockback > 0.0 and mv.has_method(&"apply_knockback"):
+		var dir := (_entity.global_position - from_position).normalized()
+		if dir == Vector2.ZERO:
+			dir = Vector2.UP
+		mv.apply_knockback(dir * knockback * knockback_scale)
+	return true

spawnpoint/_data/godot/addons/spawn_point/components/juice_component.gd

@@ -0,0 +1,219 @@
+class_name JuiceComponent
+extends Node
+## Game feel for one entity. Wires itself to whatever sibling components exist and adds
+## feedback: squash & stretch on jump/land, white flash + shake + hit-stop when hurt,
+## after-images on dash, particle bursts on death and pickup, recoil shake and sounds.
+## Attached automatically to every entity unless the game disables juice.
+
+const SP_NAME := "Juice"
+const SP_HOSTS: Array[String] = []
+const SP_REQUIRES: Array[String] = []
+const SP_CATEGORY := "juice"
+
+const FLASH_SHADER := preload("res://addons/spawn_point/shaders/flash.gdshader")
+
+## Squash & stretch on jump, land and hit.
+@export var squash := true
+## Squash strength (0.3 = 30% deformation).
+@export_range(0.0, 0.8, 0.01) var squash_amount: float = 0.28
+## Flash white when damaged.
+@export var flash := true
+## Screen shake when this entity is hurt (0..1 trauma).
+@export_range(0.0, 1.0, 0.01) var shake_on_hurt: float = 0.35
+## Screen shake when this entity dies.
+@export_range(0.0, 1.0, 0.01) var shake_on_death: float = 0.45
+## Screen shake when this entity fires.
+@export_range(0.0, 1.0, 0.01) var shake_on_fire: float = 0.06
+## Hit-stop (freeze frame) seconds when hurt.
+@export_range(0.0, 0.3, 0.005) var hitstop_on_hurt: float = 0.06
+## Hit-stop seconds when killed.
+@export_range(0.0, 0.3, 0.005) var hitstop_on_death: float = 0.04
+## Particle effects (death burst, landing dust, pickup sparkle).
+@export var particles := true
+## After-images while dashing.
+@export var dash_trail := true
+## Turn the visual to face the movement direction.
+@export var face_movement := true
+## Play sound effects.
+@export var sounds := true
+## Random pitch variation for sounds (0.1 = ±10%).
+@export_range(0.0, 0.5, 0.01) var pitch_variance: float = 0.1
+## Sound played on jump.
+@export var sound_jump: String = "jump"
+## Sound played on a hard landing.
+@export var sound_land: String = "land"
+## Sound played when damaged.
+@export var sound_hurt: String = "hurt"
+## Sound played on death.
+@export var sound_death: String = "explosion"
+## Sound played when the Weapon fires.
+@export var sound_fire: String = "shoot"
+## Sound played when collected (pitch rises on quick chains).
+@export var sound_collect: String = "coin"
+## Sound played on dash.
+@export var sound_dash: String = "dash"
+
+var _entity: Node2D
+var _visual: Node2D
+var _shape: Node2D
+var _mat: ShaderMaterial
+var _squash_tween: Tween
+var _flash_tween: Tween
+var _ghost_timer := 0.0
+var _ghost_accum := 0.0
+var _base_scale := Vector2.ONE
+
+
+func _ready() -> void:
+	_entity = SP.entity_of(get_parent()) as Node2D
+	_visual = _entity.get_node_or_null(^"Visual") as Node2D
+	_shape = _entity.get_node_or_null(^"Visual/Shape") as Node2D
+	if _visual:
+		_base_scale = _visual.scale
+		if flash:
+			_mat = ShaderMaterial.new()
+			_mat.shader = FLASH_SHADER
+			_visual.material = _mat
+			for ci in _visual.find_children("*", "CanvasItem", true, false):
+				(ci as CanvasItem).material = _mat
+	_wire.call_deferred()
+
+
+func _wire() -> void:
+	var mv := SP.movement(_entity)
+	if mv:
+		if mv.has_signal(&"jumped"):
+			mv.jumped.connect(_on_jumped)
+		if mv.has_signal(&"landed"):
+			mv.landed.connect(_on_landed)
+		if mv.has_signal(&"dashed"):
+			mv.dashed.connect(_on_dashed)
+	var health := SP.component(_entity, &"Health") as HealthComponent
+	if health:
+		health.damaged.connect(_on_damaged)
+		health.died.connect(_on_died)
+	var weapon := SP.component(_entity, &"Weapon") as WeaponComponent
+	if weapon:
+		weapon.fired.connect(_on_fired)
+	var collectible := SP.component(_entity, &"Collectible") as CollectibleComponent
+	if collectible:
+		collectible.collected.connect(_on_collected)
+	var projectile := SP.component(_entity, &"Projectile") as ProjectileComponent
+	if projectile:
+		projectile.expired.connect(_on_projectile_expired)
+	var stomp := SP.component(_entity, &"Stomp") as StompComponent
+	if stomp:
+		stomp.stomped.connect(_on_stomped)
+	var gate := SP.component(_entity, &"Gate") as GateComponent
+	if gate:
+		gate.opened.connect(_play.bind("powerup"))
+
+
+func _process(delta: float) -> void:
+	if _ghost_timer > 0.0:
+		_ghost_timer -= delta
+		_ghost_accum += delta
+		if _ghost_accum >= 0.03:
+			_ghost_accum = 0.0
+			FX.ghost(_visual, Color(1, 1, 1, 0.45))
+	if not face_movement or _shape == null:
+		return
+	var mv := SP.movement(_entity)
+	if mv is PlatformerMovementComponent:
+		SP.face(_entity, Vector2((mv as PlatformerMovementComponent).facing, 0), false)
+	elif mv is TopDownMovementComponent and SP.component(_entity, &"Aim") == null:
+		SP.face(_entity, (mv as TopDownMovementComponent).facing_dir, true, clampf(delta * 14.0, 0.0, 1.0))
+
+
+## Squash (x wider, y shorter) when [param amount] > 0, stretch when < 0, then spring back.
+func squash_stretch(amount: float, duration := 0.22) -> void:
+	if not squash or _visual == null:
+		return
+	if _squash_tween:
+		_squash_tween.kill()
+	_visual.scale = _base_scale * Vector2(1.0 + amount, 1.0 - amount)
+	_squash_tween = _visual.create_tween()
+	_squash_tween.tween_property(_visual, ^"scale", _base_scale, duration).set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)
+
+
+## Flashes the visual white for [param duration] seconds.
+func flash_white(duration := 0.12) -> void:
+	if _mat == null:
+		return
+	if _flash_tween:
+		_flash_tween.kill()
+	_mat.set_shader_parameter(&"flash", 1.0)
+	_flash_tween = _visual.create_tween()
+	_flash_tween.tween_method(func(v: float) -> void: _mat.set_shader_parameter(&"flash", v), 1.0, 0.0, duration)
+
+
+func _on_jumped() -> void:
+	squash_stretch(-squash_amount)
+	_play(sound_jump)
+
+
+func _on_landed(impact_speed: float) -> void:
+	var k := clampf(impact_speed / 900.0, 0.2, 1.0)
+	squash_stretch(squash_amount * k)
+	if particles and impact_speed > 250.0:
+		var feet := _entity.global_position + Vector2(0, SP.half_size(_entity).y)
+		FX.burst(feet, Color(1, 1, 1, 0.55), int(6 + 8 * k), 90.0 * k + 40.0, 0.35, 3.0, -60.0)
+	if impact_speed > 250.0:
+		_play(sound_land, -6.0)
+
+
+func _on_dashed() -> void:
+	if dash_trail:
+		_ghost_timer = 0.15
+	squash_stretch(-squash_amount * 0.6, 0.15)
+	_play(sound_dash)
+
+
+func _on_damaged(_amount: int) -> void:
+	if flash:
+		flash_white()
+	squash_stretch(squash_amount * 0.8, 0.18)
+	FX.shake(shake_on_hurt)
+	FX.hitstop(hitstop_on_hurt)
+	_play(sound_hurt)
+
+
+func _on_died() -> void:
+	if particles:
+		FX.burst(_entity.global_position, SP.color_of(_entity), 28, 260.0, 0.6, 5.0)
+		FX.burst(_entity.global_position, Color.WHITE, 10, 160.0, 0.3, 3.0)
+	FX.shake(shake_on_death)
+	FX.hitstop(hitstop_on_death)
+	_play(sound_death)
+
+
+func _on_fired() -> void:
+	FX.shake(shake_on_fire)
+	squash_stretch(squash_amount * 0.3, 0.1)
+	_play(sound_fire)
+
+
+func _on_collected(_by: Node) -> void:
+	if particles:
+		FX.burst(_entity.global_position, SP.color_of(_entity), 12, 150.0, 0.4, 3.0, 0.0)
+	var c := SP.component(_entity, &"Collectible") as CollectibleComponent
+	if c and c.score > 0:
+		FX.float_text(_entity.global_position, "+%d" % c.score, SP.color_of(_entity))
+	if sounds:
+		Sfx.play_combo(sound_collect)
+
+
+func _on_projectile_expired() -> void:
+	if particles:
+		FX.burst(_entity.global_position, SP.color_of(_entity), 5, 90.0, 0.2, 2.5, 0.0)
+
+
+func _on_stomped(_target: Node) -> void:
+	squash_stretch(-squash_amount)
+	FX.shake(0.25)
+	_play(sound_jump, 0.0, 1.25)
+
+
+func _play(sound_name: String, volume_db := 0.0, pitch := 1.0) -> void:
+	if sounds:
+		Sfx.play(sound_name, pitch_variance, volume_db, pitch)

spawnpoint/_data/godot/addons/spawn_point/components/patrol_ai_component.gd

@@ -0,0 +1,63 @@
+class_name PatrolAIComponent
+extends Node
+## Platformer enemy brain: walks back and forth, turning at walls and (optionally) ledges.
+## Can hop periodically.
+
+const SP_NAME := "PatrolAI"
+const SP_HOSTS: Array[String] = ["CharacterBody2D"]
+const SP_REQUIRES: Array[String] = ["PlatformerMovement"]
+const SP_CATEGORY := "controller"
+
+## Initial walking direction.
+@export_enum("left", "right") var start_direction: String = "left"
+## Turn around instead of walking off ledges.
+@export var turn_at_ledges := true
+## Fraction of the movement max_speed to walk at.
+@export_range(0.0, 1.0, 0.05) var speed_scale: float = 1.0
+## Seconds between hops (0 = never hop).
+@export_range(0.0, 30.0, 0.1) var jump_interval: float = 0.0
+
+## Current direction: -1 left, 1 right.
+var direction := -1
+
+var _body: CharacterBody2D
+var _turn_cooldown := 0.0
+var _jump_timer := 0.0
+
+
+func _ready() -> void:
+	_body = get_parent() as CharacterBody2D
+	direction = 1 if start_direction == "right" else -1
+	_jump_timer = jump_interval
+	process_physics_priority = -10
+
+
+func _physics_process(delta: float) -> void:
+	var mv := SP.component(_body, &"PlatformerMovement") as PlatformerMovementComponent
+	if mv == null:
+		return
+	_turn_cooldown -= delta
+	if _turn_cooldown <= 0.0:
+		if _body.is_on_wall() and signf(_body.get_wall_normal().x) == -direction:
+			_turn()
+		elif turn_at_ledges and _body.is_on_floor() and not _ground_ahead():
+			_turn()
+	mv.move_vector = Vector2(direction * speed_scale, 0)
+	if jump_interval > 0.0:
+		_jump_timer -= delta
+		mv.jump_held = true
+		if _jump_timer <= 0.0 and _body.is_on_floor():
+			_jump_timer = jump_interval
+			mv.request_jump()
+
+
+func _turn() -> void:
+	direction = -direction
+	_turn_cooldown = 0.2
+
+
+func _ground_ahead() -> bool:
+	var half := SP.half_size(_body)
+	var from := _body.global_position + Vector2(direction * (half.x + 2.0), 0)
+	var q := PhysicsRayQueryParameters2D.create(from, from + Vector2(0, half.y + 12.0), SP.LAYER_WORLD, [_body.get_rid()])
+	return not _body.get_world_2d().direct_space_state.intersect_ray(q).is_empty()