Asteroids can be shot apart for the ore inside them

Asteroids were pure hazard: the only thing one could ever do was cost you a
ship. They now take damage like anything else and break open, dropping ore the
fleet can fly over and collect - the one resource reachable in open space
without conquering anything, and something for the new fire stick to do out
there.

Two ways to destroy one, deliberately not equivalent. Shot apart yields the
ore; flown into does not - the rock shatters against a hull rather than being
mined, and a ship or a shield charge has just been spent on it. Without that
split a shield vessel could farm asteroids by ramming them.

Asteroid.take_damage() matches Enemy's contract exactly, so every weapon that
already knew how to hurt an enemy hurts an asteroid through the same branch
rather than a second special case: bolts, the laser sweep, and the gas bomb's
blast all pick both groups up together.

Dropped ore carries the asteroid's own drift, so it reads as debris rather
than as a spawned pickup, and it expires after a minute. Rock grew an optional
lifetime for that, defaulting to 0 (never) so hand-placed surface rocks are
unchanged - a planet surface is bounded and authored, open space is not, and a
field shot up and abandoned would otherwise leak nodes for the session. Rock's
header note that asteroids and rocks are never on screen together is no longer
true and now says so; the hexagon-versus-lump shape language matters more now
that they sit side by side, not less.

Five weapon tests silenced the asteroid field but never cleared what it had
already placed. That was harmless while asteroids were untouchable and is not
any more - two of them assert exact hit counts, and a drifting rock in the
beam would have made those fail intermittently.

Suite 111/111.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Asteroid.gd

@@ -1,7 +1,30 @@
 extends Area2D
 
+# A drifting rock that can be shot apart for the ore inside it.
+#
+# Asteroids used to be pure hazard: they could only ever cost you a ship. Now
+# they are also the one resource you can reach without conquering anything,
+# which is what the fleet's guns are for out in open space.
+#
+# Two ways to destroy one, and they are deliberately NOT the same:
+#   - shot apart, which yields the ore
+#   - flown into, which does not. The rock shatters against a hull instead of
+#     being mined, and you have just lost a ship (or a shield charge) for it.
+#     Without that split, a shield vessel could farm asteroids by ramming.
+
+const ROCK_SCENE: PackedScene = preload("res://Rock.tscn")
+# Shots needed to crack one open. Low enough that a single vessel clears one
+# in a couple of bursts, high enough that a stray shot in passing does not.
+const HIT_POINTS: int = 2
+# How long the dropped ore survives if nobody comes for it. Surface rocks live
+# forever because a planet surface is bounded and hand-authored; open space is
+# not, and an asteroid field shot up and left behind would otherwise leak
+# nodes for the rest of the session.
+const DROP_LIFETIME: float = 60.0
+
 var velocity: Vector2 = Vector2.ZERO
 var rotation_speed: float = 0.0
+var hp: int = HIT_POINTS
 
 var shape_points: PackedVector2Array = PackedVector2Array()
 
@@ -30,10 +53,41 @@ func _process(delta: float) -> void:
 	rotation += rotation_speed * delta
 
 
+# Same contract as Enemy.take_damage, so every weapon that already knows how
+# to hurt an enemy can hurt an asteroid without learning a second protocol.
+func take_damage(amount: int) -> bool:
+	hp -= maxi(amount, 1)
+	if hp > 0:
+		return false
+	shatter(true)
+	return true
+
+
+func shatter(drop_ore: bool) -> void:
+	AsteroidExplosionVFX.spawn(get_tree().root, position)
+	if drop_ore:
+		_drop_ore()
+	queue_free()
+
+
+func _drop_ore() -> void:
+	var rock: Node2D = ROCK_SCENE.instantiate()
+	rock.build_shape(randi())
+	rock.position = position
+	rock.lifetime = DROP_LIFETIME
+	# Inherits the asteroid's drift, so the ore carries on along the path the
+	# rock it came from was already travelling instead of stopping dead in
+	# space - which reads as debris rather than as a spawned pickup.
+	rock.velocity = velocity
+	# Deferred: this runs from inside an area_entered signal, where the
+	# physics server is mid-flush and refuses a direct add_child.
+	get_parent().add_child.call_deferred(rock)
+
+
 func _on_area_entered(area: Area2D) -> void:
 	if area.is_in_group("player_ships"):
-		AsteroidExplosionVFX.spawn(get_tree().root, position)
+		# No ore: see the note at the top of this file.
-		queue_free()
+		shatter(false)
 
 
 func _draw() -> void:

GasBombController.gd

@@ -85,7 +85,10 @@ func _advance_effects(delta: float) -> void:
 func _explode(at: Vector2) -> void:
 	explosions.append({"position": at, "time": 0.8})
 	last_hit_count = 0
-	for enemy in get_tree().get_nodes_in_group("enemies"):
+	# Asteroids too - a blast that clears everything around it but leaves the
+	# rocks untouched would need explaining, and they take damage the same way.
+	for enemy in get_tree().get_nodes_in_group("enemies") \
+			+ get_tree().get_nodes_in_group("asteroids"):
 		if is_instance_valid(enemy) and enemy is Node2D \
 				and enemy.global_position.distance_to(at) <= AOE_RADIUS:
 			enemy.take_damage(DAMAGE)

LaserController.gd

@@ -73,7 +73,11 @@ func _strike(from: Vector2, to: Vector2, direction: Vector2, damage: int) -> voi
 	beams.append({"from": from, "to": to, "time": FLASH_DURATION})
 	last_hit_count = 0
 	var range_along: float = from.distance_to(to)
-	for enemy in get_tree().get_nodes_in_group("enemies"):
+	# Asteroids share the enemies' take_damage() contract, so the beam sweeps
+	# both groups in one pass. Shooting a path clear through a field is a
+	# perfectly good use of a laser, and the ore it leaves behind is the point.
+	for enemy in get_tree().get_nodes_in_group("enemies") \
+			+ get_tree().get_nodes_in_group("asteroids"):
 		if not is_instance_valid(enemy) or not (enemy is Node2D):
 			continue
 		var to_enemy: Vector2 = enemy.global_position - from

Projectile.gd

@@ -34,7 +34,9 @@ func _physics_process(delta: float) -> void:
 
 
 func _on_area_entered(area: Area2D) -> void:
-	if area.is_in_group("enemies"):
+	# Asteroids answer take_damage() exactly as enemies do, so both are hit by
+	# the same branch rather than by a second special case.
+	if area.is_in_group("enemies") or area.is_in_group("asteroids"):
 		area.take_damage(damage)
 		queue_free()
 

Rock.gd

@@ -4,11 +4,11 @@ extends Area2D
 # up by flying any ship over it; the fleet doesn't need to stop.
 #
 # Deliberately drawn as a PERFECT HEXAGON rather than the irregular lumpy
-# polygon Asteroid.gd uses. The two are never on screen
+# polygon Asteroid.gd uses. The two now DO appear together - shooting an
-# together (asteroids are space-only, rocks surface-only), so the player
+# asteroid drops one of these right next to its neighbours - which makes the
-# can only tell "collect this" from "this hurts" by learned shape language:
+# shape language matter more than when they were kept apart by scene: jagged
-# irregular and jagged reads as a natural hazard, regular and faceted reads
+# and irregular reads as a natural hazard, regular and faceted reads as
-# as something valuable and meant to be picked up.
+# something valuable and meant to be picked up.
 #
 # It also drifts toward a nearby ship (see _physics_process). Nothing
 # harmful moves helpfully toward you, so the pull doubles as a readability
@@ -16,6 +16,13 @@ extends Area2D
 
 signal collected
 
+# Seconds before an uncollected rock disappears. 0 means never, which is what
+# hand-placed surface rocks use - a planet surface is bounded and authored, so
+# nothing accumulates. Ore dropped by a shot asteroid sets a real lifetime,
+# because open space is unbounded and a field shot up and left behind would
+# otherwise leak nodes for the rest of the session.
+@export var lifetime: float = 0.0
+
 @export var attract_radius: float = 220.0
 @export var attract_speed: float = 260.0
 @export var attract_accel: float = 420.0
@@ -24,6 +31,7 @@ var shape_points: PackedVector2Array = PackedVector2Array()
 var facet_points: PackedVector2Array = PackedVector2Array()
 var size_scale: float = 1.0
 var velocity: Vector2 = Vector2.ZERO
+var age: float = 0.0
 
 
 func _ready() -> void:
@@ -56,6 +64,12 @@ func build_shape(shape_seed: int) -> void:
 func _physics_process(delta: float) -> void:
 	# Drift toward the closest ship inside attract_radius. No redraw here:
 	# position is a transform property and the crystal's shape is fixed.
+	if lifetime > 0.0:
+		age += delta
+		if age >= lifetime:
+			queue_free()
+			return
+
 	var target: Node2D = _nearest_ship()
 	if target == null:
 		velocity = velocity.move_toward(Vector2.ZERO, attract_accel * delta)

tests/test_asteroid_mining.gd

@@ -0,0 +1,166 @@
+extends SceneTree
+
+# Headless gameplay test: run with
+#   godot --headless -s res://tests/test_asteroid_mining.gd
+# Asteroids used to be pure hazard - the only thing one could ever do was cost
+# you a ship. They can now be shot apart for the ore inside, which is the one
+# resource reachable in open space without conquering anything.
+#
+# Covers:
+#   A. an asteroid survives a hit it should survive, so "destructible" does
+#      not mean "evaporates on contact with anything"
+#   B. enough fire destroys it and leaves ore behind
+#   C. the ore is fetchable - flying a ship over it loads the fleet's hold,
+#      which is the whole point of dropping it
+#   D. ramming destroys the asteroid but yields NOTHING. Without that split a
+#      shield vessel could farm asteroids by flying into them
+#   E. dropped ore expires if nobody collects it, so a field that gets shot up
+#      and abandoned cannot leak nodes for the rest of the session; a
+#      hand-placed surface rock still lives forever
+
+var game_state: Node
+var main: Node
+var fleet: Node
+var asteroid: Node2D
+var stage: int = 0
+var elapsed: float = 0.0
+var hold_before: int = 0
+
+
+func _initialize() -> void:
+	game_state = root.get_node("GameState")
+	game_state.buildings.clear()
+	game_state.extractors.clear()
+	game_state.reset_progression()
+	main = load("res://Main.tscn").instantiate()
+	root.add_child(main)
+	current_scene = main
+	fleet = main.get_node("Fleet")
+
+
+func _spawn_asteroid(at: Vector2) -> Node2D:
+	var rock: Node2D = load("res://Asteroid.tscn").instantiate()
+	rock.position = at
+	main.add_child(rock)
+	return rock
+
+
+func _clear_sky() -> void:
+	for node in get_nodes_in_group("asteroids") + get_nodes_in_group("rocks") \
+			+ get_nodes_in_group("enemies") + get_nodes_in_group("player_projectiles"):
+		if is_instance_valid(node):
+			node.free()
+
+
+func _process(delta: float) -> bool:
+	elapsed += delta
+	match stage:
+		0:
+			if elapsed < 0.3:
+				return false
+			main.get_node("EnemySpawner").set_process(false)
+			main.get_node("AsteroidField").set_process(false)
+			_clear_sky()
+			fleet.spawn_ships(1, Vector2.ZERO, PackedStringArray([GameState.VESSEL_INTERCEPTOR]))
+
+			# --- A/B. it takes real damage, then breaks -------------------
+			asteroid = _spawn_asteroid(Vector2(4000.0, 0.0))
+			var hit_points: int = int(asteroid.hp)
+			if hit_points < 2:
+				return _fail("an asteroid dies to a single point of damage, so there is nothing to survive")
+			for i in range(hit_points - 1):
+				asteroid.take_damage(1)
+			if not is_instance_valid(asteroid) or asteroid.is_queued_for_deletion():
+				return _fail("the asteroid broke after %d of its %d hit points" % [hit_points - 1, hit_points])
+			print("asteroid survived %d of %d hit points" % [hit_points - 1, hit_points])
+
+			asteroid.take_damage(1)
+			if is_instance_valid(asteroid) and not asteroid.is_queued_for_deletion():
+				return _fail("the asteroid survived its full %d hit points" % hit_points)
+			stage = 1
+			elapsed = 0.0
+			return false
+		1:
+			# The drop is deferred - it is created from inside a signal, where
+			# the physics server refuses a direct add_child.
+			if elapsed < 0.2:
+				return false
+			var dropped: Array = get_nodes_in_group("rocks")
+			if dropped.is_empty():
+				return _fail("destroying an asteroid left no ore behind")
+			print("destroyed asteroid dropped %d ore node(s)" % dropped.size())
+
+			# --- C. the ore is fetchable ---------------------------------
+			hold_before = game_state.fleet_resource(GameState.RESOURCE_ORE)
+			var ship: Node2D = fleet.ships[0]
+			# Placed just clear of the ship rather than on top of it, so the
+			# rock's own drift has to bring it in - that pull is how a player
+			# actually collects one.
+			dropped[0].position = ship.global_position + Vector2(80.0, 0.0)
+			stage = 2
+			elapsed = 0.0
+			return false
+		2:
+			if elapsed < 1.5:
+				return false
+			var gained: int = game_state.fleet_resource(GameState.RESOURCE_ORE) - hold_before
+			if gained <= 0:
+				return _fail("flying over the dropped ore put nothing in the hold")
+			print("dropped ore collected into the fleet hold (+%d)" % gained)
+
+			# --- D. ramming yields nothing -------------------------------
+			_clear_sky()
+			hold_before = game_state.fleet_resource(GameState.RESOURCE_ORE)
+			asteroid = _spawn_asteroid(fleet.ships[0].global_position)
+			stage = 3
+			elapsed = 0.0
+			return false
+		3:
+			if elapsed < 0.5:
+				return false
+			if is_instance_valid(asteroid) and not asteroid.is_queued_for_deletion():
+				return _fail("an asteroid dropped onto a ship did not shatter against it")
+			if not get_nodes_in_group("rocks").is_empty():
+				return _fail("ramming an asteroid yielded ore - a shield vessel could farm them that way")
+			if game_state.fleet_resource(GameState.RESOURCE_ORE) != hold_before:
+				return _fail("ramming an asteroid changed the hold")
+			print("ramming shattered the asteroid and yielded nothing")
+
+			# --- E. abandoned ore expires, authored ore does not ----------
+			_clear_sky()
+			var abandoned: Node2D = load("res://Rock.tscn").instantiate()
+			abandoned.build_shape(1)
+			abandoned.lifetime = 0.4
+			# Far from every ship, or it would be collected rather than expire.
+			abandoned.position = fleet.get_centroid() + Vector2(9000.0, 0.0)
+			main.add_child(abandoned)
+			var authored: Node2D = load("res://Rock.tscn").instantiate()
+			authored.build_shape(2)
+			authored.position = fleet.get_centroid() + Vector2(9600.0, 0.0)
+			main.add_child(authored)
+			if authored.lifetime != 0.0:
+				return _fail("a plain rock has a lifetime of %.1f - surface rocks must live forever" % authored.lifetime)
+			stage = 4
+			elapsed = 0.0
+			return false
+		4:
+			if elapsed < 1.0:
+				return false
+			var survivors: Array = get_nodes_in_group("rocks")
+			var names: Array = []
+			for rock in survivors:
+				names.append(rock.name)
+			if survivors.size() != 1:
+				return _fail("expected only the authored rock to remain, found %d: %s" % [survivors.size(), str(names)])
+			print("abandoned ore expired; the rock with no lifetime is still there")
+
+			print("TEST_ASTEROID_MINING: PASS")
+			quit(0)
+			return true
+	return false
+
+
+func _fail(message: String) -> bool:
+	print("TEST_ASTEROID_MINING: FAIL (%s)" % message)
+	quit(1)
+	return true

tests/test_gas_bomber.gd

@@ -91,6 +91,14 @@ func _process(delta: float) -> bool:
 				return false
 			main.get_node("EnemySpawner").set_process(false)
 			main.get_node("AsteroidField").set_process(false)
+			# Asteroids are shootable now, and the laser and the bomb both
+			# sweep them alongside enemies - so whatever the field already
+			# spawned would be counted as a hit. Silencing the spawner is not
+			# enough; what it placed before that has to go too. Same
+			# clean-slate idiom as test_ship_lab.gd.
+			for hazard in get_nodes_in_group("asteroids"):
+				if is_instance_valid(hazard):
+					hazard.free()
 			if main.get_node("UI/GasBombButton").visible:
 				return _fail_now("bomb control appeared without a Gas Bomber")
 			fleet.spawn_ships(2, Vector2.ZERO, PackedStringArray([

tests/test_gas_bomber_ammo.gd

@@ -57,6 +57,14 @@ func _process(delta: float) -> bool:
 				return false
 			main.get_node("EnemySpawner").set_process(false)
 			main.get_node("AsteroidField").set_process(false)
+			# Asteroids are shootable now, and the laser and the bomb both
+			# sweep them alongside enemies - so whatever the field already
+			# spawned would be counted as a hit. Silencing the spawner is not
+			# enough; what it placed before that has to go too. Same
+			# clean-slate idiom as test_ship_lab.gd.
+			for hazard in get_nodes_in_group("asteroids"):
+				if is_instance_valid(hazard):
+					hazard.free()
 			# An interceptor rides along purely for its "cargo" capability
 			# (#56): a fleet made only of a gas bomber has zero cargo
 			# capacity, which would silently clamp every fleet_gas_cargo

tests/test_gas_bomber_cooldowns.gd

@@ -26,6 +26,11 @@ func _process(delta: float) -> bool:
 		return false
 	main.get_node("EnemySpawner").set_process(false)
 	main.get_node("AsteroidField").set_process(false)
+	# Asteroids take damage now, so anything the field already placed
+	# would soak a bomb meant for the enemies under test.
+	for hazard in get_nodes_in_group("asteroids"):
+		if is_instance_valid(hazard):
+			hazard.free()
 	fleet.spawn_ships(2, Vector2.ZERO, PackedStringArray([
 		GameState.VESSEL_GAS_BOMBER, GameState.VESSEL_GAS_BOMBER]))
 	skill._process(0.0)

tests/test_laser_ammo.gd

@@ -56,6 +56,14 @@ func _process(delta: float) -> bool:
 				return false
 			main.get_node("EnemySpawner").set_process(false)
 			main.get_node("AsteroidField").set_process(false)
+			# Asteroids are shootable now, and the laser and the bomb both
+			# sweep them alongside enemies - so whatever the field already
+			# spawned would be counted as a hit. Silencing the spawner is not
+			# enough; what it placed before that has to go too. Same
+			# clean-slate idiom as test_ship_lab.gd.
+			for hazard in get_nodes_in_group("asteroids"):
+				if is_instance_valid(hazard):
+					hazard.free()
 			# An interceptor rides along purely for its "cargo" capability
 			# (#56): a fleet made only of a laser ship has zero cargo
 			# capacity, which would silently clamp every fleet energy

tests/test_laser_vessel.gd

@@ -68,6 +68,14 @@ func _process(delta: float) -> bool:
 				return false
 			main.get_node("EnemySpawner").set_process(false)
 			main.get_node("AsteroidField").set_process(false)
+			# Asteroids are shootable now, and the laser and the bomb both
+			# sweep them alongside enemies - so whatever the field already
+			# spawned would be counted as a hit. Silencing the spawner is not
+			# enough; what it placed before that has to go too. Same
+			# clean-slate idiom as test_ship_lab.gd.
+			for hazard in get_nodes_in_group("asteroids"):
+				if is_instance_valid(hazard):
+					hazard.free()
 
 			# --- A. absent, then appears -------------------------------------
 			if main.get_node("UI/LaserButton").visible: