spaceship/controllers/LaserController.gd

class_name LaserController
extends "res://controllers/AimedFleetAbilityController.gd"

const BEAM_COLOR := Color(0.3, 0.9, 1.0)
const TARGET_COLOR := Color(0.6, 0.95, 1.0)
const BEAM_HALF_WIDTH := 38.0
# The DRAWN beam is scaled from the hit width rather than tuned separately.
# The two were independent numbers and had drifted apart: the beam struck
# anything within 22 units of the line while its outer glow spanned about 11,
# so it killed things it visibly missed. NeonDraw's widest layer is 18px at
# scale 1, so this makes the glow span exactly what the beam hits.
const BEAM_WIDTH_SCALE := BEAM_HALF_WIDTH * 2.0 / 18.0
# #90: the beam was one flat line that blinked on at full length and faded.
# It now IGNITES - it runs out of the ship over the first slice of its life,
# holds white-hot, and falls away - which is the sabre look the report asked
# for and also the only part of the shot the eye can follow.
#
# Long enough for the extension to read as movement rather than as a
# stutter, still short enough to be gone before the 4s cooldown is up.
const FLASH_DURATION := 0.34
# The fraction of that life spent extending. The rest holds and decays.
const IGNITE_FRACTION := 0.3
# The white-hot rod down the middle of the coloured glow. Drawn INSIDE the
# beam's own width, never wider: the drawn beam is deliberately the same
# span as the hit test (see BEAM_WIDTH_SCALE above), and a halo painted past
# that would put the "it visibly missed" complaint back the other way round.
const CORE_SCALE := 0.42
const CORE_COLOR := Color(0.85, 0.99, 1.0)
# The leading cap, and the flare left at the emitter. Both are radii, both
# stay within the beam's half width so nothing suggests a wider reach.
const TIP_RADIUS := BEAM_HALF_WIDTH * 0.55
const MUZZLE_RADIUS := BEAM_HALF_WIDTH * 0.8
const ENERGY_PER_SHOT: int = 8
# By path, not by class name - see the note at the top of MuzzleSparkVFX.
const MUZZLE_SPARK = preload("res://vfx/MuzzleSparkVFX.gd")

var beams: Array = []
var last_hit_count: int = 0


func _button_path() -> NodePath: return "../UI/LaserButton"
func _status_path() -> NodePath: return "../UI/LaserStatus"
func _component_id() -> String: return "laser"
func _ammo_resource() -> String: return GameState.RESOURCE_ENERGY
func _ammo_cost() -> int: return ENERGY_PER_SHOT
func _aim_padding() -> float: return BEAM_HALF_WIDTH
func _has_effect_visuals() -> bool: return not beams.is_empty()


func _aim_max_range() -> float:
	# Falls back to the VESSEL DEFINITION's own beam_range, not to a copy of
	# the number. This used to hardcode 950.0 in both branches, which silently
	# became a lie the moment the definition's range changed - the aim line
	# would have been drawn to a different distance than the beam actually
	# reaches, and only in the cases where the fallback fires.
	var ship: Node2D = _next_ready_ship()
	if ship != null:
		var component: Node = ship.get_component(_component_id())
		if component != null:
			return component.beam_range
	return GameState.vessel_stat(GameState.VESSEL_LASER, "beam_range")


func _calculate_aim_target(drag: Vector2, origin: Vector2) -> Vector2:
	# A beam always reaches full range; dragging chooses its direction only.
	var direction: Vector2 = drag.normalized() if drag.length() > 0.001 else Vector2.UP
	return origin + direction * _aim_max_range()


func _consume_shot(component: Node) -> bool:
	return component.consume_shot()


func _perform_shot(ship: Node2D, component: Node) -> void:
	var direction: Vector2 = aim_target - _aim_origin()
	direction = direction.normalized() if direction.length() > 0.001 else Vector2.UP
	var beam_to: Vector2 = ship.global_position + direction * component.beam_range
	_strike(ship.global_position, beam_to, direction, int(component.damage))
	# #90: something happens at the hull, not just out in space. The ordinary
	# gun already does this (#87); the laser fired in complete silence at its
	# own end, which is most of why a shot read as a line appearing rather
	# than as a vessel firing.
	MUZZLE_SPARK.spawn(get_tree().root, ship.global_position, direction, BEAM_COLOR)


func _next_ready_laser_ship() -> Node2D:
	return _next_ready_ship()


func _advance_effects(delta: float) -> void:
	for i in range(beams.size() - 1, -1, -1):
		var beam: Dictionary = beams[i]
		beam.time = maxf(float(beam.time) - delta, 0.0)
		if float(beam.time) <= 0.0:
			beams.remove_at(i)


func _strike(from: Vector2, to: Vector2, direction: Vector2, damage: int) -> void:
	# The damage below is dealt HERE, in full, along the whole beam, at the
	# instant of the shot. The extension in _draw is the picture of that, not
	# a travelling projectile - a beam that had to arrive would be a change
	# to how the weapon plays, which #90 did not ask for.
	beams.append({
		"from": from, "to": to, "time": FLASH_DURATION,
		# Per beam, so two lasers firing together do not flicker in lockstep.
		"phase": randf() * TAU,
	})
	last_hit_count = 0
	var range_along: float = from.distance_to(to)
	# 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
		var along: float = to_enemy.dot(direction)
		if along < 0.0 or along > range_along:
			continue
		var perpendicular: float = (to_enemy - direction * along).length()
		if perpendicular <= BEAM_HALF_WIDTH:
			enemy.take_damage(damage)
			last_hit_count += 1


# How far along its length a beam is currently drawn. Cubic ease-out, so it
# leaves the ship fast and settles into full reach rather than crawling.
# Public because it is the whole of #90's "it comes out of the ship" and is
# worth asserting on directly.
func beam_extension(beam: Dictionary) -> float:
	var progress: float = 1.0 - float(beam.time) / FLASH_DURATION
	var out: float = clampf(progress / IGNITE_FRACTION, 0.0, 1.0)
	return 1.0 - pow(1.0 - out, 3.0)


func beam_tip(beam: Dictionary) -> Vector2:
	return Vector2(beam.from).lerp(Vector2(beam.to), beam_extension(beam))


func _draw() -> void:
	if aiming:
		NeonDraw.draw_glowing_line(self, _aim_origin(), aim_target,
			TARGET_COLOR, 0.7, 0.6)
	for beam in beams:
		var progress: float = 1.0 - float(beam.time) / FLASH_DURATION
		# Full brightness while it extends, then away. Squared so it holds
		# its light and drops at the end, instead of dimming from the first
		# frame the way a plain linear fade did.
		var decay: float = clampf((progress - IGNITE_FRACTION) / (1.0 - IGNITE_FRACTION), 0.0, 1.0)
		var alpha: float = 1.0 - decay * decay
		# A live blade hums. Small enough to be texture rather than a blink.
		var flicker: float = 1.0 + 0.09 * sin(float(beam.time) * 70.0 + float(beam.phase))
		var tip: Vector2 = beam_tip(beam)
		var from: Vector2 = beam.from

		NeonDraw.draw_glowing_line(self, from, tip, BEAM_COLOR, alpha,
			BEAM_WIDTH_SCALE * flicker * (1.0 - decay * 0.45))
		# The white-hot rod, over the same span at a fraction of the width.
		# This is where the extra light comes from: brighter through the
		# middle, not broader across.
		NeonDraw.draw_glowing_line(self, from, tip, CORE_COLOR, alpha,
			BEAM_WIDTH_SCALE * CORE_SCALE * flicker)
		# The leading cap, brightest while the blade is still running out.
		var cap: float = TIP_RADIUS * (0.7 + 0.3 * (1.0 - decay)) * flicker
		NeonDraw.draw_glowing_circle(self, tip, cap, CORE_COLOR, alpha)
		# And the flare left at the emitter, which fades faster than the
		# beam so the hull does not keep glowing after the shot is over.
		var muzzle: float = MUZZLE_RADIUS * (1.0 - progress)
		if muzzle > 1.0:
			NeonDraw.draw_glowing_circle(self, from, muzzle, CORE_COLOR,
				alpha * (1.0 - progress))