spawnpoint-studio 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,121 @@
+class_name SP
+## Static helpers shared by every Spawn Point component.
+##
+## Conventions:
+## - An entity is a physics body (CharacterBody2D / StaticBody2D / Area2D) whose direct child
+##   named "Entity" is an [SPEntityCore].
+## - Components are direct children of the entity, named by their short name ("Health", ...).
+
+# Physics layer bits (1-based layer N == bit 1 << (N - 1)).
+const LAYER_WORLD := 1 << 0
+const LAYER_PLAYER := 1 << 1
+const LAYER_ENEMY := 1 << 2
+const LAYER_PLAYER_HURTBOX := 1 << 3
+const LAYER_ENEMY_HURTBOX := 1 << 4
+const LAYER_PICKUP := 1 << 5
+
+const TEAM_PLAYER := "player"
+const TEAM_ENEMY := "enemy"
+const TEAM_NEUTRAL := "neutral"
+
+const ENTITY_GROUP := &"sp_entity"
+const PLAYER_GROUP := &"player"
+
+
+## Returns the entity root owning [param node] (or [param node] itself), or null.
+static func entity_of(node: Node) -> Node:
+	var n := node
+	while n != null:
+		if n.is_in_group(ENTITY_GROUP) or n.has_node(^"Entity"):
+			return n
+		n = n.get_parent()
+	return null
+
+
+## Returns the entity's core node, or null.
+static func core(entity: Node) -> SPEntityCore:
+	if entity == null:
+		return null
+	return entity.get_node_or_null(^"Entity") as SPEntityCore
+
+
+## Returns the component named [param short_name] on [param entity], or null.
+static func component(entity: Node, short_name: StringName) -> Node:
+	if entity == null:
+		return null
+	return entity.get_node_or_null(NodePath(String(short_name)))
+
+
+## Returns the movement component (platformer or top-down) of [param entity], or null.
+static func movement(entity: Node) -> Node:
+	var m := component(entity, &"PlatformerMovement")
+	if m == null:
+		m = component(entity, &"TopDownMovement")
+	return m
+
+
+## Team of [param entity]: "player", "enemy" or "neutral".
+static func team_of(entity: Node) -> String:
+	if entity == null:
+		return TEAM_NEUTRAL
+	if entity.has_meta(&"sp_team"):
+		return String(entity.get_meta(&"sp_team"))
+	var c := core(entity)
+	return c.team if c else TEAM_NEUTRAL
+
+
+## Hurtbox layer bit for a team.
+static func hurtbox_layer(team: String) -> int:
+	match team:
+		TEAM_PLAYER:
+			return LAYER_PLAYER_HURTBOX
+		TEAM_ENEMY:
+			return LAYER_ENEMY_HURTBOX
+	return 0
+
+
+## Layer bits of hurtboxes that a hitbox of [param team] should damage.
+static func opposing_hurtbox_mask(team: String) -> int:
+	match team:
+		TEAM_PLAYER:
+			return LAYER_ENEMY_HURTBOX
+		TEAM_ENEMY:
+			return LAYER_PLAYER_HURTBOX
+	return LAYER_PLAYER_HURTBOX | LAYER_ENEMY_HURTBOX
+
+
+## Half extents of the entity's body (from builder metadata or its collision shape).
+static func half_size(entity: Node) -> Vector2:
+	if entity.has_meta(&"sp_half_size"):
+		return entity.get_meta(&"sp_half_size")
+	var cs := entity.get_node_or_null(^"CollisionShape2D") as CollisionShape2D
+	if cs and cs.shape:
+		return cs.shape.get_rect().size * 0.5
+	return Vector2(8, 8)
+
+
+## Main color of the entity's visual (sprite's dominant color or placeholder color).
+static func color_of(entity: Node) -> Color:
+	var visual := entity.get_node_or_null(^"Visual")
+	if visual and visual.has_meta(&"sp_color"):
+		return visual.get_meta(&"sp_color")
+	var shape := entity.get_node_or_null(^"Visual/Shape") as Polygon2D
+	return shape.color if shape else Color.WHITE
+
+
+## True when the entity is drawn with a sprite (flip to face) instead of a placeholder shape.
+static func has_sprite(entity: Node) -> bool:
+	return entity.has_node(^"Visual/Shape/Sprite")
+
+
+## Turns the entity's visual toward [param dir]: sprites flip horizontally, placeholder shapes
+## rotate (top-down) — side-view pixel art must never be rotated.
+static func face(entity: Node, dir: Vector2, allow_rotation: bool, weight := 0.5) -> void:
+	var shape := entity.get_node_or_null(^"Visual/Shape") as Node2D
+	if shape == null or dir.length() < 0.01:
+		return
+	if has_sprite(entity) or not allow_rotation:
+		if absf(dir.x) > 0.05:
+			shape.scale.x = 1.0 if dir.x > 0.0 else -1.0
+	else:
+		shape.rotation = lerp_angle(shape.rotation, dir.angle(), weight)

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

@@ -0,0 +1,130 @@
+extends Node
+## Autoload "World": entity registry, spawning and rule signal bindings.
+
+const ENTITY_SCENE_PATH := "res://entities/%s.tscn"
+
+var level: Node2D
+## Entities below this y are killed (platformers). INF disables.
+var kill_y := INF
+
+var _bindings: Array[Dictionary] = []
+var _scene_cache := {}
+
+
+## Called by the level root when it enters the tree, before any entity registers.
+func begin_level(level_root: Node2D, level_kill_y: float) -> void:
+	level = level_root
+	kill_y = level_kill_y
+	_bindings.clear()
+
+
+## Called by every [SPEntityCore] when its entity is ready.
+func register_entity(entity: Node) -> void:
+	for b in _bindings:
+		_apply_binding(b, entity)
+
+
+## Connects [param callable] to [param signal_name] of component [param component_name] on every
+## current and future instance of [param entity_type]. The emitting entity is appended as the
+## last argument.
+func bind_signal(entity_type: StringName, component_name: StringName, signal_name: StringName, callable: Callable) -> void:
+	var b := {"type": entity_type, "component": component_name, "signal": signal_name, "callable": callable}
+	_bindings.append(b)
+	for e in instances(entity_type):
+		_apply_binding(b, e)
+
+
+func _apply_binding(b: Dictionary, entity: Node) -> void:
+	if not entity.is_in_group(b.type):
+		return
+	var src: Object = SP.component(entity, b.component) if b.component != &"" else entity
+	if src == null or not src.has_signal(b.signal):
+		push_error("Spawn Point: %s has no signal %s.%s" % [b.type, b.component, b.signal])
+		return
+	var bound: Callable = b.callable.bind(entity)
+	if not src.is_connected(b.signal, bound):
+		src.connect(b.signal, bound)
+
+
+## All live instances of an entity type.
+func instances(entity_type: StringName) -> Array[Node]:
+	var out: Array[Node] = []
+	if not is_inside_tree():
+		return out
+	for n in get_tree().get_nodes_in_group(entity_type):
+		if n.is_queued_for_deletion() or not n.is_in_group(SP.ENTITY_GROUP):
+			continue
+		var c := SP.core(n)
+		if c and c.dead:
+			continue  # Dying this frame: rules reacting to "died" must not count it.
+		out.append(n)
+	return out
+
+
+func count(entity_type: StringName) -> int:
+	return instances(entity_type).size()
+
+
+func player() -> Node2D:
+	var players := get_tree().get_nodes_in_group(SP.PLAYER_GROUP)
+	return players[0] as Node2D if players.size() > 0 else null
+
+
+## Instantiates entity [param entity_type] at [param pos]. [param meta] is applied as node
+## metadata before the node enters the tree (e.g. {"sp_team": "enemy"}).
+func spawn(entity_type: String, pos: Vector2, meta := {}) -> Node2D:
+	var scene: PackedScene = _scene_cache.get(entity_type)
+	if scene == null:
+		var path := ENTITY_SCENE_PATH % entity_type
+		if not ResourceLoader.exists(path):
+			push_error("Spawn Point: unknown entity '%s'" % entity_type)
+			return null
+		scene = load(path)
+		_scene_cache[entity_type] = scene
+	var node := scene.instantiate() as Node2D
+	for k in meta:
+		node.set_meta(k, meta[k])
+	node.position = pos
+	var parent: Node = level.get_node_or_null(^"Entities") if level else null
+	if parent == null:
+		parent = level if level else get_tree().current_scene
+	parent.add_child(node)
+	return node
+
+
+## Spawns at tile coordinates (cell center).
+func spawn_at_tile(entity_type: String, tx: int, ty: int) -> Node2D:
+	var ts: float = level.get(&"tile_size") if level else 32.0
+	return spawn(entity_type, Vector2((tx + 0.5) * ts, (ty + 0.5) * ts))
+
+
+## Removes an entity from the game (no death effects).
+func destroy(entity: Node) -> void:
+	if entity and is_instance_valid(entity) and not entity.is_queued_for_deletion():
+		if entity.is_in_group(SP.PLAYER_GROUP):
+			var h := SP.component(entity, &"Health") as HealthComponent
+			if h:
+				h.kill()
+				return
+		entity.queue_free()
+
+
+func destroy_all(entity_type: StringName) -> void:
+	for e in instances(entity_type):
+		destroy(e)
+
+
+## Calls [param method] on component [param component_name] (or the entity root if empty) of
+## every instance of [param entity_type].
+func call_all(entity_type: StringName, component_name: StringName, method: StringName, args: Array = []) -> void:
+	for e in instances(entity_type):
+		call_on(e, component_name, method, args)
+
+
+func call_on(entity: Node, component_name: StringName, method: StringName, args: Array = []) -> Variant:
+	if entity == null or not is_instance_valid(entity):
+		return null
+	var target: Object = SP.component(entity, component_name) if component_name != &"" else entity
+	if target == null:
+		return null
+	return target.callv(method, args)

spawnpoint/_data/godot/addons/spawn_point/shaders/flash.gdshader

@@ -0,0 +1,9 @@
+shader_type canvas_item;
+
+// 0 = normal color, 1 = solid flash color (hit feedback).
+uniform float flash : hint_range(0.0, 1.0) = 0.0;
+uniform vec4 flash_color : source_color = vec4(1.0);
+
+void fragment() {
+	COLOR.rgb = mix(COLOR.rgb, flash_color.rgb, flash);
+}

spawnpoint/_data/godot/addons/spawn_point/shaders/floor_grid.gdshader

@@ -0,0 +1,13 @@
+shader_type canvas_item;
+
+// Subtle checkerboard floor for top-down levels, in world-space tiles.
+uniform float tile_size = 32.0;
+uniform vec4 color_a : source_color = vec4(0.12, 0.13, 0.2, 1.0);
+uniform vec4 color_b : source_color = vec4(0.14, 0.15, 0.23, 1.0);
+uniform vec2 size = vec2(1024.0, 1024.0);
+
+void fragment() {
+	vec2 cell = floor(UV * size / tile_size);
+	float checker = mod(cell.x + cell.y, 2.0);
+	COLOR = mix(color_a, color_b, checker);
+}