spaceship/controllers/LaserController.gd

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

# The player's end of the laser: the button, the aim, the fleet's magazine.
# The SHOT itself is a LaserBeamEffect in the world (see that file) - it was
# lifted out of here so a garrisoned laser vessel could fire the same beam
# from a different trigger without this controller being involved at all.
#
# What is left here is everything that is genuinely about the player firing:
# where they aimed, what it costs the fleet hold, and the guide line drawn
# while they aim it.

const BEAM_EFFECT = preload("res://vfx/LaserBeamEffect.gd")
# #201: the beam borrows the fire stick's aim helper, so it is loaded here
# for its static assist rather than for anything a laser hull carries.
const WEAPON_COMPONENT = preload("res://vessels/VesselWeaponComponent.gd")
const BEAM_COLOR := BEAM_EFFECT.BEAM_COLOR
const TARGET_COLOR := Color(0.6, 0.95, 1.0)
const BEAM_HALF_WIDTH := BEAM_EFFECT.BEAM_HALF_WIDTH
const FLASH_DURATION := BEAM_EFFECT.FLASH_DURATION
const ENERGY_PER_SHOT: int = VesselLaserComponent.ENERGY_PER_SHOT

# The beams this controller has fired and that are still alive. Kept so the
# fleet's own shots can be reasoned about - "is anything still on screen" for
# the redraw, and the tests' view of what a shot did - without this becoming
# the owner of them again.
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 _assisted_target(origin, origin + direction * _aim_max_range())


# The mouse path (#80) names a world point directly instead of dragging one
# into existence. It has a real cursor, so it is assisted from that rather
# than from a virtual one at the end of the beam - otherwise the crosshair
# would be the only aim in the game the helper does not touch.
func fire_at(world_target: Vector2) -> bool:
	return super(_assisted_target(_aim_origin(), world_target))


# #201: ordinary fire's aim helper, applied to the beam. It answers with a
# PLACE, not a heading - the same thing the fire stick resolves and every
# hull then converges on - so a drag that ends near an enemy, or merely
# inside the assist cone, passes through that enemy instead of a few degrees
# past it. The beam still runs on to its full range from there.
func _assisted_target(origin: Vector2, point: Vector2) -> Vector2:
	return WEAPON_COMPONENT.assisted_point(get_tree(), origin, point,
		_aim_max_range())


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


func _perform_shot(ship: Node2D, component: Node) -> void:
	# The cooldown was already spent by _consume_shot() above, so this fires
	# the effect directly rather than going through fire_ability() and
	# spending it twice.
	# Aimed from the HULL, not from the fleet centre. aim_target is a place
	# now that the assist can move it onto an enemy (#201), and ordinary fire
	# converges on such a place by letting each hull find its own heading to
	# it - a shared heading measured at the centroid would walk this beam off
	# the very target the assist just picked, by the ship's formation offset.
	var direction: Vector2 = aim_target - ship.global_position
	direction = direction.normalized() if direction.length() > 0.001 else Vector2.UP
	var effect: Node2D = BEAM_EFFECT.fire(get_tree().root, ship.global_position,
		direction, component.beam_range, int(component.damage))
	beams.append(effect)
	last_hit_count = int(effect.hit_count)


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


func _advance_effects(_delta: float) -> void:
	# The effects animate and free themselves; this only forgets the ones that
	# have gone.
	beams = beams.filter(func(beam): return is_instance_valid(beam))


func beam_extension(beam: Node2D) -> float:
	return beam.extension()


func beam_tip(beam: Node2D) -> Vector2:
	return beam.tip()


func _draw() -> void:
	# Only the aim guide. Each beam draws itself, in its own node.
	if aiming:
		NeonDraw.draw_glowing_line(self, _aim_origin(), aim_target,
			TARGET_COLOR, 0.7, 0.6)