Compose vessels from definitions and capabilities
This commit is contained in:
Loïc Wisniewski
parent
0504b24d8d
commit
14081ad230
39 changed files with 705 additions and 386 deletions
234
Ship.gd
234
Ship.gd
|
|
@ -2,224 +2,134 @@ extends Area2D
|
|||
|
||||
signal destroyed
|
||||
|
||||
# Deliberately faster than Fleet.cruise_speed: the fleet as a whole travels
|
||||
# at the cruise rate, and this headroom is what lets an individual ship
|
||||
# close on its formation slot - so a pivot mid-flight resolves quickly
|
||||
# instead of the ship having no speed budget left over for it.
|
||||
const VESSEL_DEFINITIONS = preload("res://VesselDefinitions.gd")
|
||||
|
||||
@export var max_speed: float = 460.0
|
||||
@export var acceleration: float = 450.0
|
||||
@export var rotation_speed: float = 8.0
|
||||
@export var arrive_radius: float = 6.0
|
||||
|
||||
@export var fire_range: float = 320.0
|
||||
@export var fire_cooldown: float = 0.5
|
||||
# How long to wait before looking for targets again after finding none.
|
||||
@export var idle_rescan_interval: float = 0.25
|
||||
@export var projectile_damage: int = 1
|
||||
|
||||
# Which kind of vessel this is (GameState.VESSEL_*). Drives both its
|
||||
# researched statistics and whether it carries a shield (#5).
|
||||
@export var vessel_type: String = "interceptor"
|
||||
|
||||
# --- shield (#5) ----------------------------------------------------------
|
||||
const SHIELD_COLOR: Color = Color(0.45, 0.8, 1.0)
|
||||
const SHIELD_RADIUS: float = 30.0
|
||||
|
||||
# A shield vessel survives a hit that would destroy any other ship, and is
|
||||
# then defenceless until it cycles back up. Personal, not a bubble: it
|
||||
# protects the vessel carrying it and nothing else.
|
||||
var shield_charges: int = 0
|
||||
var shield_recharge_left: float = 0.0
|
||||
var _shield_ring: Node2D = null
|
||||
|
||||
# Neon colours, assigned by Fleet on spawn so a scene can tint its fleet.
|
||||
# The lunar surface is a bright grey, where the default near-white core all
|
||||
# but vanishes - PlanetSurface.tscn passes a dark core there. See NeonDraw.
|
||||
var definition: Resource
|
||||
var glow_color: Color = Color(0.25, 0.85, 1.0)
|
||||
var core_color: Color = Color(1.0, 1.0, 1.0)
|
||||
|
||||
var core_color: Color = Color.WHITE
|
||||
var velocity: Vector2 = Vector2.ZERO
|
||||
# The fleet's own velocity, supplied by Fleet as CONTEXT rather than as a
|
||||
# facing command - the ship works out where to point from it.
|
||||
#
|
||||
# It is needed because `velocity` below is not the ship's true motion while
|
||||
# it is holding formation: the slot it chases sits inside arrive_radius, so
|
||||
# the ship snaps onto it and reports zero velocity even though it is being
|
||||
# carried along at cruise speed. Facing derived from `velocity` alone
|
||||
# therefore froze at whatever heading the ship last happened to travel.
|
||||
# Adding the two gives the ship's ACTUAL motion through the world, which is
|
||||
# the honest thing to point along in every case: it equals the fleet's
|
||||
# heading when station-keeping, the ship's own heading when manoeuvring
|
||||
# alone, and the true blend of both while strafing into a new slot.
|
||||
var fleet_velocity: Vector2 = Vector2.ZERO
|
||||
var move_target: Vector2
|
||||
var fire_timer: float = 0.0
|
||||
var projectile_scene: PackedScene = preload("res://Projectile.tscn")
|
||||
|
||||
# Compatibility accessors keep old saves/tests readable while shield state
|
||||
# itself belongs exclusively to the optional ShieldComponent.
|
||||
var shield_charges: int:
|
||||
get:
|
||||
var component: Node = get_component("shield")
|
||||
return component.charges if component != null else 0
|
||||
set(value):
|
||||
var component: Node = get_component("shield")
|
||||
if component != null:
|
||||
component.set_charges(value)
|
||||
|
||||
var shield_recharge_left: float:
|
||||
get:
|
||||
var component: Node = get_component("shield")
|
||||
return component.recharge_left if component != null else 0.0
|
||||
set(value):
|
||||
var component: Node = get_component("shield")
|
||||
if component != null:
|
||||
component.recharge_left = value
|
||||
|
||||
var projectile_damage: int:
|
||||
get:
|
||||
var component: Node = get_component("weapon")
|
||||
return component.projectile_damage if component != null else 0
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
move_target = position
|
||||
add_to_group("player_ships")
|
||||
area_entered.connect(_on_area_entered)
|
||||
if vessel_type == GameState.VESSEL_SHIELD:
|
||||
_build_shield_ring()
|
||||
shield_charges = GameState.shield_max_charges()
|
||||
definition = VESSEL_DEFINITIONS.get_definition(vessel_type)
|
||||
if definition == null:
|
||||
return
|
||||
glow_color = definition.glow_color
|
||||
for component_scene in definition.component_scenes:
|
||||
var component: Node = component_scene.instantiate()
|
||||
add_child(component)
|
||||
if component.has_method("setup"):
|
||||
component.setup()
|
||||
apply_vessel_stats()
|
||||
queue_redraw()
|
||||
|
||||
|
||||
func get_component(capability: String) -> Node:
|
||||
for child in get_children():
|
||||
if child.get("capability_id") == capability:
|
||||
return child
|
||||
return null
|
||||
|
||||
|
||||
func has_capability(capability: String) -> bool:
|
||||
return get_component(capability) != null
|
||||
|
||||
|
||||
func set_move_target(world_pos: Vector2) -> void:
|
||||
move_target = world_pos
|
||||
|
||||
|
||||
func apply_vessel_stats() -> void:
|
||||
# Read from GameState rather than baked in at spawn, so researching an
|
||||
# upgrade improves the ships already flying and not just the next one
|
||||
# built. Fleet calls this on every vessel when something is bought.
|
||||
max_speed = GameState.ship_max_speed(vessel_type)
|
||||
acceleration = GameState.ship_acceleration(vessel_type)
|
||||
fire_range = GameState.ship_fire_range(vessel_type)
|
||||
fire_cooldown = GameState.ship_fire_cooldown(vessel_type)
|
||||
projectile_damage = GameState.ship_damage(vessel_type)
|
||||
if vessel_type == GameState.VESSEL_SHIELD:
|
||||
# Topping up a live shield with researched capacity, without
|
||||
# refilling one that is currently down and cycling.
|
||||
var was_up: bool = shield_charges > 0
|
||||
shield_charges = GameState.shield_max_charges() if was_up else shield_charges
|
||||
_update_shield_visual()
|
||||
if definition == null:
|
||||
definition = VESSEL_DEFINITIONS.get_definition(vessel_type)
|
||||
if definition == null:
|
||||
return
|
||||
max_speed = GameState.vessel_stat(vessel_type, "max_speed")
|
||||
acceleration = GameState.vessel_stat(vessel_type, "acceleration")
|
||||
for child in get_children():
|
||||
if child.has_method("apply_stats"):
|
||||
child.apply_stats()
|
||||
|
||||
|
||||
func has_shield() -> bool:
|
||||
return vessel_type == GameState.VESSEL_SHIELD and shield_charges > 0
|
||||
|
||||
|
||||
func _update_shield_visual() -> void:
|
||||
if _shield_ring == null:
|
||||
return
|
||||
# visible only - per #10 the ring is rasterised once and never redrawn to
|
||||
# turn it on and off.
|
||||
_shield_ring.visible = has_shield()
|
||||
|
||||
|
||||
func _tick_shield(delta: float) -> void:
|
||||
if vessel_type != GameState.VESSEL_SHIELD:
|
||||
return
|
||||
if shield_charges >= GameState.shield_max_charges():
|
||||
return
|
||||
shield_recharge_left -= delta
|
||||
if shield_recharge_left <= 0.0:
|
||||
shield_charges += 1
|
||||
shield_recharge_left = GameState.shield_recharge_time()
|
||||
_update_shield_visual()
|
||||
var component: Node = get_component("shield")
|
||||
return component != null and component.is_active()
|
||||
|
||||
|
||||
func _physics_process(delta: float) -> void:
|
||||
_tick_shield(delta)
|
||||
for child in get_children():
|
||||
if child.has_method("tick"):
|
||||
child.tick(delta)
|
||||
|
||||
var to_target: Vector2 = move_target - position
|
||||
var distance: float = to_target.length()
|
||||
|
||||
if distance <= arrive_radius:
|
||||
# Snap and stop dead - prevents residual float-level jitter that
|
||||
# would otherwise keep nudging back and forth around the target.
|
||||
position = move_target
|
||||
velocity = Vector2.ZERO
|
||||
else:
|
||||
# Braking-distance formula: the fastest speed we can be going right
|
||||
# now and still be able to decelerate to 0 exactly at the target,
|
||||
# given our acceleration. Without this the ship approaches at full
|
||||
# speed, overshoots (stopping distance = max_speed^2 / (2*accel)),
|
||||
# and oscillates back and forth forever instead of settling.
|
||||
var braking_speed: float = sqrt(2.0 * acceleration * distance)
|
||||
var desired_speed: float = min(max_speed, braking_speed)
|
||||
var desired_velocity: Vector2 = to_target.normalized() * desired_speed
|
||||
velocity = velocity.move_toward(desired_velocity, acceleration * delta)
|
||||
position += velocity * delta
|
||||
|
||||
# One owner, one rule: face the way this ship is actually travelling.
|
||||
var motion: Vector2 = velocity + fleet_velocity
|
||||
if motion.length() > 8.0:
|
||||
var target_angle: float = motion.angle() + PI / 2.0
|
||||
rotation = lerp_angle(rotation, target_angle, rotation_speed * delta)
|
||||
|
||||
_update_weapon(delta)
|
||||
|
||||
|
||||
func _update_weapon(delta: float) -> void:
|
||||
fire_timer -= delta
|
||||
if fire_timer > 0.0:
|
||||
return
|
||||
|
||||
var target: Node2D = _find_nearest_enemy()
|
||||
if target == null:
|
||||
# Back off before scanning again. Without this, fire_timer stays at
|
||||
# or below zero and every ship queries the whole "enemies" group and
|
||||
# loops it on EVERY physics frame whenever nothing is in range -
|
||||
# which is most of the time.
|
||||
fire_timer = idle_rescan_interval
|
||||
return
|
||||
|
||||
fire_timer = fire_cooldown
|
||||
var proj: Node2D = projectile_scene.instantiate()
|
||||
proj.position = position
|
||||
proj.damage = projectile_damage
|
||||
get_tree().root.add_child(proj)
|
||||
proj.launch(target.position - position)
|
||||
|
||||
|
||||
func _find_nearest_enemy() -> Node2D:
|
||||
var enemies: Array = get_tree().get_nodes_in_group("enemies")
|
||||
var nearest: Node2D = null
|
||||
var best_dist: float = fire_range
|
||||
|
||||
for e in enemies:
|
||||
if not is_instance_valid(e):
|
||||
continue
|
||||
var d: float = position.distance_to(e.position)
|
||||
if d <= best_dist:
|
||||
best_dist = d
|
||||
nearest = e
|
||||
|
||||
return nearest
|
||||
|
||||
|
||||
func _on_area_entered(area: Area2D) -> void:
|
||||
if not (area.is_in_group("enemies") or area.is_in_group("asteroids")):
|
||||
return
|
||||
if has_shield():
|
||||
# Absorbed. The thing that hit it is still destroyed - a shield stops
|
||||
# the vessel dying, it does not make the rock harmless - but the
|
||||
# vessel survives and is defenceless until the shield cycles back.
|
||||
shield_charges -= 1
|
||||
shield_recharge_left = GameState.shield_recharge_time()
|
||||
_update_shield_visual()
|
||||
if area.is_in_group("asteroids") and is_instance_valid(area):
|
||||
area.queue_free()
|
||||
return
|
||||
for child in get_children():
|
||||
if child.has_method("absorb_hit") and child.absorb_hit():
|
||||
if area.is_in_group("asteroids") and is_instance_valid(area):
|
||||
area.queue_free()
|
||||
return
|
||||
ShipExplosionVFX.spawn(get_tree().root, position)
|
||||
destroyed.emit()
|
||||
queue_free()
|
||||
|
||||
|
||||
func _build_shield_ring() -> void:
|
||||
# Its own child, drawn once, toggled with `visible` (#10). A shield that
|
||||
# came and went by redrawing the ship would re-tessellate the hull every
|
||||
# time it cycled.
|
||||
_shield_ring = NeonPiece.create(self, Vector2.ZERO, SHIELD_COLOR)
|
||||
var points: PackedVector2Array = PackedVector2Array()
|
||||
for i in range(14):
|
||||
var a: float = (float(i) / 14.0) * TAU
|
||||
points.append(Vector2(cos(a), sin(a)) * SHIELD_RADIUS)
|
||||
_shield_ring.add_polygon(points, 0.7)
|
||||
_shield_ring.queue_redraw()
|
||||
_shield_ring.visible = false
|
||||
|
||||
|
||||
func _draw() -> void:
|
||||
var nose: Vector2 = Vector2(0, -22)
|
||||
var left: Vector2 = Vector2(-14, 16)
|
||||
var right: Vector2 = Vector2(14, 16)
|
||||
var points: PackedVector2Array = PackedVector2Array([nose, left, right])
|
||||
# Constant glow, drawn once. No pulse means nothing changes frame to
|
||||
# frame, so the ship never needs redrawing after _ready() - which also
|
||||
# removes four antialiased polyline rebuilds per ship per frame.
|
||||
var points: PackedVector2Array = definition.hull_points if definition != null else PackedVector2Array([
|
||||
Vector2(0, -22), Vector2(-14, 16), Vector2(14, 16),
|
||||
])
|
||||
NeonDraw.draw_glowing_polygon(self, points, glow_color, 1.0, core_color)
|
||||
|
|
|
|||
Loading…
Reference in a new issue