spawnpoint-studio 0.1.0__py3-none-any.whl

spawnpoint/_data/examples/pixel_arena.json

@@ -0,0 +1,242 @@
+{
+  "spawnpoint": 1,
+  "name": "Pixel Arena",
+  "genre": "topdown",
+  "settings": {
+    "tile_size": 32,
+    "lives": 3,
+    "seed": 21,
+    "zoom": 1.5
+  },
+  "entities": {
+    "Player": {
+      "components": {
+        "TopDownMovement": {
+          "max_speed": 250,
+          "dash_speed": 720
+        },
+        "PlayerInput": {},
+        "Aim": {
+          "mode": "mouse"
+        },
+        "Weapon": {
+          "projectile": "Bullet",
+          "fire_rate": 9,
+          "spread_deg": 5
+        },
+        "Health": {
+          "max_health": 5,
+          "invincibility_time": 0.8
+        },
+        "Hurtbox": {}
+      },
+      "sprite": {
+        "generate": {
+          "kind": "hero",
+          "color": "#29adff",
+          "features": [
+            "helmet"
+          ]
+        }
+      }
+    },
+    "Bullet": {
+      "body": "area",
+      "components": {
+        "Projectile": {
+          "speed": 760,
+          "lifetime": 1.0
+        },
+        "Hitbox": {
+          "damage": 1,
+          "knockback": 160
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "bullet",
+          "color": "#fff1e8"
+        }
+      }
+    },
+    "Chaser": {
+      "components": {
+        "TopDownMovement": {
+          "max_speed": 130
+        },
+        "ChaseAI": {
+          "detect_radius": 380
+        },
+        "Health": {
+          "max_health": 2,
+          "invincibility_time": 0.05
+        },
+        "Hurtbox": {
+          "size_scale": 1.0
+        },
+        "Hitbox": {
+          "damage": 1,
+          "knockback": 300
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "bug",
+          "color": "#ff004d"
+        }
+      }
+    },
+    "Shooter": {
+      "team": "enemy",
+      "components": {
+        "TopDownMovement": {
+          "max_speed": 90
+        },
+        "ChaseAI": {
+          "detect_radius": 420,
+          "keep_distance": 220,
+          "fire_range": 380
+        },
+        "Weapon": {
+          "projectile": "EnemyBullet",
+          "fire_rate": 1.3,
+          "spread_deg": 8,
+          "muzzle_distance": 22
+        },
+        "Health": {
+          "max_health": 3,
+          "invincibility_time": 0.05
+        },
+        "Hurtbox": {
+          "size_scale": 1.0
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "robot",
+          "color": "#ff77a8"
+        }
+      }
+    },
+    "EnemyBullet": {
+      "body": "area",
+      "team": "enemy",
+      "components": {
+        "Projectile": {
+          "speed": 300,
+          "lifetime": 3.0
+        },
+        "Hitbox": {
+          "damage": 1,
+          "knockback": 200
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "bullet",
+          "color": "#ff77a8"
+        }
+      }
+    },
+    "Portal": {
+      "body": "area",
+      "components": {
+        "Spawner": {
+          "entity": "Chaser",
+          "interval": 4.0,
+          "start_delay": 3.0,
+          "max_alive": 3,
+          "total": 6
+        }
+      },
+      "juice": "none",
+      "sprite": {
+        "generate": {
+          "kind": "portal",
+          "color": "#83769c"
+        }
+      }
+    },
+    "HealthPack": {
+      "body": "area",
+      "components": {
+        "Collectible": {
+          "kind": "heart",
+          "score": 0,
+          "heal": 2
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "heart",
+          "color": "#00e436"
+        }
+      }
+    }
+  },
+  "level": {
+    "map": [
+      "########################################",
+      "#......................................#",
+      "#..O...................................#",
+      "#...................X..................#",
+      "#....Z............####............Z....#",
+      "#......................................#",
+      "#.......##....................##.......#",
+      "#.......##....................##.......#",
+      "#...................+..................#",
+      "#......................................#",
+      "#......................................#",
+      "#...#..............................#...#",
+      "#...#.......X.......P.......X......#...#",
+      "#...#..............................#...#",
+      "#......................................#",
+      "#......................................#",
+      "#.......##..........+.........##.......#",
+      "#.......##....................##.......#",
+      "#......................................#",
+      "#....Z............####............Z....#",
+      "#......................................#",
+      "#...................................O..#",
+      "#......................................#",
+      "########################################"
+    ],
+    "legend": {
+      "#": "solid",
+      "P": "Player",
+      "Z": "Chaser",
+      "X": "Shooter",
+      "O": "Portal",
+      "+": "HealthPack"
+    }
+  },
+  "rules": [
+    {
+      "on": "Game.ready",
+      "do": [
+        "message('Score 200 to clear the arena!')"
+      ]
+    },
+    {
+      "on": "Chaser.died",
+      "do": [
+        "add_score(10)"
+      ]
+    },
+    {
+      "on": "Shooter.died",
+      "do": [
+        "add_score(25)",
+        "shake(0.3)"
+      ]
+    },
+    {
+      "on": "GameState.score_changed",
+      "if": "score >= 200",
+      "do": [
+        "message('Arena cleared!')",
+        "win()"
+      ]
+    }
+  ]
+}

spawnpoint/_data/examples/pixel_hopper.json

@@ -0,0 +1,221 @@
+{
+  "spawnpoint": 1,
+  "name": "Pixel Hopper",
+  "genre": "platformer",
+  "settings": {
+    "tile_size": 32,
+    "lives": 3,
+    "seed": 7,
+    "zoom": 1.5
+  },
+  "entities": {
+    "Player": {
+      "components": {
+        "PlatformerMovement": {
+          "air_jumps": 1,
+          "dash_speed": 620
+        },
+        "PlayerInput": {},
+        "Health": {
+          "max_health": 3
+        },
+        "Hurtbox": {},
+        "Stomp": {}
+      },
+      "sprite": {
+        "generate": {
+          "kind": "hero",
+          "color": "#29adff",
+          "features": [
+            "mask"
+          ]
+        }
+      }
+    },
+    "Slime": {
+      "components": {
+        "PlatformerMovement": {
+          "max_speed": 60
+        },
+        "PatrolAI": {},
+        "Health": {
+          "max_health": 1
+        },
+        "Hurtbox": {
+          "size_scale": 1.0
+        },
+        "Hitbox": {
+          "damage": 1
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "slime",
+          "color": "#ff004d"
+        }
+      }
+    },
+    "Frog": {
+      "team": "enemy",
+      "components": {
+        "PlatformerMovement": {
+          "max_speed": 90,
+          "jump_velocity": 480
+        },
+        "PatrolAI": {
+          "jump_interval": 1.4
+        },
+        "Health": {
+          "max_health": 2
+        },
+        "Hurtbox": {
+          "size_scale": 1.0
+        },
+        "Hitbox": {
+          "damage": 1
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "hopper",
+          "color": "#00e436"
+        }
+      }
+    },
+    "Spikes": {
+      "body": "area",
+      "team": "enemy",
+      "components": {
+        "Hitbox": {
+          "damage": 1,
+          "knockback": 420
+        }
+      },
+      "juice": "none",
+      "sprite": {
+        "generate": {
+          "kind": "spikes",
+          "color": "#c2c3c7"
+        }
+      }
+    },
+    "Coin": {
+      "body": "area",
+      "components": {
+        "Collectible": {
+          "score": 1
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "coin",
+          "color": "#ffec27"
+        }
+      }
+    },
+    "Heart": {
+      "body": "area",
+      "components": {
+        "Collectible": {
+          "kind": "heart",
+          "score": 0,
+          "heal": 1
+        }
+      },
+      "sprite": {
+        "generate": {
+          "kind": "heart",
+          "color": "#ff77a8"
+        }
+      }
+    },
+    "Door": {
+      "body": "static",
+      "components": {
+        "Gate": {}
+      },
+      "sprite": {
+        "generate": {
+          "kind": "door",
+          "color": "#ab5236"
+        }
+      }
+    },
+    "Exit": {
+      "body": "area",
+      "components": {
+        "TriggerZone": {}
+      },
+      "sprite": {
+        "generate": {
+          "kind": "exit",
+          "color": "#00e436"
+        }
+      }
+    }
+  },
+  "level": {
+    "map": [
+      "....................................................",
+      "....................................................",
+      "....................................................",
+      "....................................................",
+      "............................................C.......",
+      "............CC.............................===......",
+      "...........====.....................................",
+      ".............................CC........CC...........",
+      ".......CC...............C...====......====..........",
+      "......====.........C................................",
+      ".......................###..........................",
+      "..P............S.......###.S...^^...CS....F.H...D.E.",
+      "##################...############..#################",
+      "##################...############..#################"
+    ],
+    "legend": {
+      "#": "solid",
+      "=": "oneway",
+      "P": "Player",
+      "S": "Slime",
+      "F": "Frog",
+      "^": "Spikes",
+      "C": "Coin",
+      "H": "Heart",
+      "D": "Door",
+      "E": "Exit"
+    }
+  },
+  "rules": [
+    {
+      "on": "Game.ready",
+      "do": [
+        "message('Collect every coin to open the door!')"
+      ]
+    },
+    {
+      "on": "Coin.collected",
+      "if": "count('Coin') == 0",
+      "do": [
+        "Door.open()",
+        "message('The door is open!')"
+      ]
+    },
+    {
+      "on": "Slime.died",
+      "do": [
+        "add_score(5)"
+      ]
+    },
+    {
+      "on": "Frog.died",
+      "do": [
+        "add_score(10)"
+      ]
+    },
+    {
+      "on": "Exit.triggered",
+      "do": [
+        "win()"
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,63 @@
+class_name AimComponent
+extends Node
+## Points the entity's Weapon (and visual) at the mouse, the nearest enemy, or the movement
+## direction.
+
+const SP_NAME := "Aim"
+const SP_HOSTS: Array[String] = []
+const SP_REQUIRES: Array[String] = ["Weapon"]
+const SP_INTERNAL: Array[String] = ["aim_direction"]
+const SP_CATEGORY := "controller"
+
+## "mouse", "nearest_enemy" or "movement".
+@export_enum("mouse", "nearest_enemy", "movement") var mode: String = "mouse"
+## Rotate the visual to face the aim direction (top-down games).
+@export var rotate_visual := true
+## Max distance for nearest_enemy targeting (px).
+@export_range(0.0, 5000.0, 1.0) var max_range: float = 600.0
+
+var _entity: Node2D
+
+
+func _ready() -> void:
+	_entity = SP.entity_of(get_parent()) as Node2D
+	process_physics_priority = -5
+
+
+func _physics_process(_delta: float) -> void:
+	var dir := aim_direction()
+	var weapon := SP.component(_entity, &"Weapon") as WeaponComponent
+	if weapon:
+		weapon.aim_direction = dir
+	if rotate_visual and dir != Vector2.ZERO:
+		SP.face(_entity, dir, true)
+
+
+## Current aim direction (normalized, or zero if there is nothing to aim at).
+func aim_direction() -> Vector2:
+	match mode:
+		"mouse":
+			var vp := _entity.get_viewport()
+			if vp:
+				return (_entity.get_global_mouse_position() - _entity.global_position).normalized()
+		"nearest_enemy":
+			var best: Node2D = null
+			var best_d := max_range
+			var my_team := SP.team_of(_entity)
+			for e in _entity.get_tree().get_nodes_in_group(SP.ENTITY_GROUP):
+				var n := e as Node2D
+				if n == null or n == _entity or SP.team_of(n) == my_team or SP.team_of(n) == SP.TEAM_NEUTRAL:
+					continue
+				if SP.component(n, &"Hurtbox") == null:
+					continue
+				var d := n.global_position.distance_to(_entity.global_position)
+				if d < best_d:
+					best_d = d
+					best = n
+			if best:
+				return (best.global_position - _entity.global_position).normalized()
+		"movement":
+			var mv := SP.movement(_entity)
+			if mv is TopDownMovementComponent:
+				return (mv as TopDownMovementComponent).facing_dir
+	return Vector2.ZERO

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

@@ -0,0 +1,66 @@
+class_name AnimatorComponent
+extends Node
+## Plays the entity sprite's animations from what the entity is doing: idle, run, jump, fall and
+## hurt. Run speed follows movement speed. Attached automatically to entities that have a sprite.
+
+const SP_NAME := "Animator"
+const SP_HOSTS: Array[String] = []
+const SP_REQUIRES: Array[String] = []
+const SP_CATEGORY := "juice"
+
+## Seconds the hurt animation is shown after taking damage.
+@export_range(0.0, 2.0, 0.01) var hurt_time: float = 0.25
+## Speed (px/s) above which the entity counts as moving.
+@export_range(0.0, 200.0, 1.0) var move_threshold: float = 15.0
+
+## Animation currently requested (may fall back to "idle" if the sprite lacks it).
+var state := "idle"
+
+var _entity: Node2D
+var _sprite: AnimatedSprite2D
+var _hurt_left := 0.0
+
+
+func _ready() -> void:
+	_entity = SP.entity_of(get_parent()) as Node2D
+	_sprite = _entity.get_node_or_null(^"Visual/Shape/Sprite") as AnimatedSprite2D
+	var health := SP.component(_entity, &"Health") as HealthComponent
+	if health:
+		health.damaged.connect(func(_a: int) -> void: _hurt_left = hurt_time)
+
+
+func _process(delta: float) -> void:
+	if _sprite == null:
+		return
+	_hurt_left -= delta
+	state = pick_state()
+	var anim := state if _sprite.sprite_frames.has_animation(state) else &"idle"
+	if _sprite.animation != anim or not _sprite.is_playing():
+		_sprite.play(anim)
+	if state == "run":
+		var mv := SP.movement(_entity)
+		var top: float = mv.max_speed if mv else 200.0
+		_sprite.speed_scale = clampf(_speed() / maxf(top, 1.0) * 1.2, 0.5, 1.6)
+	else:
+		_sprite.speed_scale = 1.0
+
+
+## The state the entity is in right now.
+func pick_state() -> String:
+	if _hurt_left > 0.0:
+		return "hurt"
+	var body := _entity as CharacterBody2D
+	if body == null:
+		return "idle"
+	if SP.movement(_entity) is PlatformerMovementComponent and not body.is_on_floor():
+		return "jump" if body.velocity.y < 0.0 else "fall"
+	return "run" if _speed() > move_threshold else "idle"
+
+
+func _speed() -> float:
+	var body := _entity as CharacterBody2D
+	if body == null:
+		return 0.0
+	if SP.movement(_entity) is PlatformerMovementComponent:
+		return absf(body.velocity.x)
+	return body.velocity.length()

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

@@ -0,0 +1,107 @@
+class_name ChaseAIComponent
+extends Node
+## Enemy brain: wanders until the player comes close, then chases (and shoots, if the entity
+## has a Weapon and a clear line of sight). Works top-down; in platformers it only moves
+## horizontally.
+
+const SP_NAME := "ChaseAI"
+const SP_HOSTS: Array[String] = ["CharacterBody2D"]
+const SP_REQUIRES: Array[String] = []
+const SP_CATEGORY := "controller"
+
+enum State { WANDER, CHASE }
+
+## Distance at which the player is noticed (px).
+@export_range(0.0, 5000.0, 1.0) var detect_radius: float = 300.0
+## Distance at which the chase is abandoned (px).
+@export_range(0.0, 5000.0, 1.0) var lose_radius: float = 480.0
+## Stop approaching inside this distance (ranged enemies keep their distance).
+@export_range(0.0, 2000.0, 1.0) var keep_distance: float = 0.0
+## Weapon fires when the player is within this distance (px).
+@export_range(0.0, 5000.0, 1.0) var fire_range: float = 380.0
+## Wander around while idle.
+@export var wander := true
+## Fraction of max speed used while wandering.
+@export_range(0.0, 1.0, 0.05) var wander_speed: float = 0.35
+## Require an unobstructed line to the player to chase/shoot.
+@export var needs_line_of_sight := true
+
+var state := State.WANDER
+
+var _body: CharacterBody2D
+var _wander_dir := Vector2.ZERO
+var _wander_timer := 0.0
+
+
+func _ready() -> void:
+	_body = get_parent() as CharacterBody2D
+	process_physics_priority = -10
+
+
+func _physics_process(delta: float) -> void:
+	var mv := SP.movement(_body)
+	var weapon := SP.component(_body, &"Weapon") as WeaponComponent
+	var player := World.player()
+	var to_player := Vector2.ZERO
+	var dist := INF
+	if player and player.visible and GameState.is_playing():
+		to_player = player.global_position - _body.global_position
+		dist = to_player.length()
+
+	match state:
+		State.WANDER:
+			if dist < detect_radius and _can_see(player):
+				state = State.CHASE
+		State.CHASE:
+			if dist > lose_radius or player == null or not player.visible:
+				state = State.WANDER
+
+	var desired := Vector2.ZERO
+	if state == State.CHASE:
+		if dist > keep_distance:
+			desired = to_player.normalized()
+		elif keep_distance > 0.0 and dist < keep_distance * 0.7:
+			desired = -to_player.normalized()
+	elif wander:
+		_wander_timer -= delta
+		if _wander_timer <= 0.0:
+			_wander_timer = randf_range(1.0, 2.5)
+			_wander_dir = Vector2.ZERO if randf() < 0.3 else Vector2.from_angle(randf() * TAU)
+		desired = _wander_dir * wander_speed
+	desired += _separation()
+
+	if mv is PlatformerMovementComponent:
+		mv.move_vector = Vector2(signf(desired.x) if absf(desired.x) > 0.1 else 0.0, 0)
+	elif mv:
+		mv.move_vector = desired.limit_length(1.0)
+
+	if weapon:
+		var shooting := state == State.CHASE and dist <= fire_range and _can_see(player)
+		weapon.trigger_held = shooting
+		if shooting:
+			weapon.aim_direction = to_player.normalized()
+
+
+func _can_see(target: Node2D) -> bool:
+	if target == null:
+		return false
+	if not needs_line_of_sight:
+		return true
+	var q := PhysicsRayQueryParameters2D.create(_body.global_position, target.global_position, SP.LAYER_WORLD, [_body.get_rid()])
+	return _body.get_world_2d().direct_space_state.intersect_ray(q).is_empty()
+
+
+# Keeps a crowd of chasers from collapsing into one blob.
+func _separation() -> Vector2:
+	var push := Vector2.ZERO
+	var half := SP.half_size(_body)
+	var radius := maxf(half.x, half.y) * 2.5
+	for other in World.instances(StringName(SP.core(_body).entity_type)):
+		var o := other as Node2D
+		if o == _body:
+			continue
+		var d := _body.global_position - o.global_position
+		var l := d.length()
+		if l > 0.01 and l < radius:
+			push += d / l * (1.0 - l / radius)
+	return push