Nicholas ButzkeandClaude Opus 5
c4bcbc7fd1
The reticle was five white ColorRects, pasted byte-identically into three
level runtime scripts. The vitals were two stock ProgressBars with a flat
colour override, inlined 1200 lines into the movement controller. The ammo
count — the number a shooter's player looks at most — was drawn by the LEVEL,
in a black rounded panel that shared nothing with the menus, and it had a
special case in it (`elif active_weapon is DoubleBarrelShotgun`) because that
weapon never declared a name or a capacity.
Everything that describes A PLAYER now belongs to ui/player_hud.gd, and a
level owns the level. The immediate symptom that fixed: the screen had two
ammo panels on it at once, in two different styles, overlapping in the corner.
What each piece now says, rather than merely shows:
ui/crosshair.gd one drawn reticle instead of five rectangles, so it can
BLOOM — open with speed, airtime and each shot, snap shut
on ADS. That is the accuracy readout of the whole game and
five ColorRects could not express it. Every stroke is
drawn twice, ink underneath, because a 2 px white line
disappears over pale concrete exactly when aim matters.
The hit confirmation is the same cross at 45 degrees, so
it lands where the eye already is.
ui/vital_bar.gd segmented, so remaining health can be COUNTED rather than
estimated, with a drain ghost that holds the old value for
a beat — the gap between fill and ghost is the size of the
hit, which a bar that merely gets shorter never tells you.
ui/ability_chip.gd dash and grapple as a wipe across a chip rather than a
tinted JPEG with a 12 px number under it. A shape changing
size is readable in peripheral vision; 12 px type is not.
chain meter promoted out of the debug panel. Movement is this game's
first stated pillar and chaining is its skill expression,
so the count is a score, not a diagnostic.
The numerals moved OFF the bars and beside them. Text centred on a two-tone
bar cannot be given a colour that beats both the fill and the trough — that is
the 2.4:1 debug/ui_contrast_check.gd measured on the old HUD — so this fixes it
at the source rather than leaning on an outline to rescue it.
debug/hud_layout_check.gd measures where every element actually lands, which is
how three real bugs were found rather than squinted at: `set_anchors_preset`
moves the anchors and LEAVES THE OFFSETS, so the reticle spanned the viewport
with a size of exactly (0,0) and drew itself in the top-left corner; a
PRESET_CENTER applied after the ring's own `_ready` undid its centring; and a
BOX CONTAINER's own `alignment` is what pushes content to an edge, not a
SHRINK_END flag on the box, whose minimum width depends on children that may be
hidden. The ammo card was hanging off the right edge of the screen because of
the last one.
DoubleBarrelShotgun now declares `weapon_name` and `max_shells` like every
other weapon, and the four inline `2`s are gone.
spawn smoke 0 failures, 11/11 movement tests, contrast 108/108, layout PASS.
Co-Authored-By: Claude Opus 5 <[email protected]>
255 lines
9.0 KiB
GDScript
255 lines
9.0 KiB
GDScript
extends Node3D
|
|
class_name LevelRuntime
|
|
|
|
var _player: CharacterBody3D
|
|
|
|
|
|
func _ready() -> void:
|
|
# Hide mouse
|
|
Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
|
|
|
|
# Maps that don't ship their own environment get the shared stylized one
|
|
# (sky gradient, sun+fill, glow, cel color grade, ambient bed).
|
|
if not has_node("WorldEnvironment"):
|
|
LevelEnvironment.add_to(self)
|
|
|
|
|
|
# Multiplayer Spawning
|
|
var spawner = MultiplayerSpawner.new()
|
|
spawner.name = "PlayerSpawner"
|
|
spawner.spawn_path = "." # Spawn directly as children of the level
|
|
spawner.spawn_function = _spawn_player
|
|
add_child(spawner)
|
|
|
|
var nm = get_node_or_null("/root/NetworkManager")
|
|
if nm and nm.multiplayer.is_server():
|
|
# Spawn existing players
|
|
for pid in nm.player_stats.keys():
|
|
spawner.spawn(pid)
|
|
|
|
# Spawn late joiners
|
|
nm.player_connected.connect(func(pid):
|
|
spawner.spawn(pid)
|
|
)
|
|
|
|
# Despawn on disconnect
|
|
nm.player_disconnected.connect(func(pid):
|
|
var p = get_node_or_null(str(pid))
|
|
if p:
|
|
p.queue_free()
|
|
)
|
|
|
|
|
|
# ── Spawning ──────────────────────────────────────────────────────────────────
|
|
|
|
func _get_dynamic_spawn_position() -> Vector3:
|
|
var spawn_nodes = get_tree().get_nodes_in_group("spawn_points")
|
|
if spawn_nodes.is_empty():
|
|
return Vector3(0, 10, 0)
|
|
|
|
var all_players = []
|
|
for p in get_tree().get_nodes_in_group("players"):
|
|
if is_instance_valid(p) and p is Node3D:
|
|
all_players.append(p)
|
|
|
|
if all_players.is_empty():
|
|
var pos = spawn_nodes.pick_random().global_position
|
|
pos += Vector3(randf_range(-1, 1), 0.5, randf_range(-1, 1))
|
|
return pos
|
|
|
|
var best_spawn = spawn_nodes[0].global_position
|
|
var max_min_dist = -1.0
|
|
|
|
for spawn_node in spawn_nodes:
|
|
var pos = spawn_node.global_position
|
|
var min_dist_to_player = 999999.0
|
|
for p in all_players:
|
|
var dist = pos.distance_to(p.global_position)
|
|
if dist < min_dist_to_player:
|
|
min_dist_to_player = dist
|
|
|
|
if min_dist_to_player > max_min_dist:
|
|
max_min_dist = min_dist_to_player
|
|
best_spawn = pos
|
|
|
|
# Add slight jitter to prevent exact stacking
|
|
best_spawn += Vector3(randf_range(-1, 1), 0.5, randf_range(-1, 1))
|
|
return best_spawn
|
|
|
|
func _spawn_player(pid: int) -> CharacterBody3D:
|
|
var player := CharacterBody3D.new()
|
|
player.name = str(pid)
|
|
player.set_multiplayer_authority(pid)
|
|
player.add_to_group("players")
|
|
|
|
# Dynamic Spawning
|
|
player.position = _get_dynamic_spawn_position()
|
|
|
|
# Server Synchronizer — host-owned gameplay state (health, kills, death)
|
|
var server_sync = MultiplayerSynchronizer.new()
|
|
server_sync.name = "ServerSynchronizer"
|
|
server_sync.set_multiplayer_authority(1) # Host always controls these
|
|
var server_rep_config = SceneReplicationConfig.new()
|
|
server_rep_config.add_property(":health")
|
|
server_rep_config.add_property(":shield")
|
|
server_rep_config.add_property(":is_dead")
|
|
server_sync.replication_config = server_rep_config
|
|
player.add_child(server_sync)
|
|
|
|
# Client Synchronizer — owner-simulated movement, aim, animation state.
|
|
# Movement is client-authoritative for instant response; remote peers
|
|
# interpolate synced_position/velocity (see PlayerMovementController).
|
|
var client_sync = MultiplayerSynchronizer.new()
|
|
client_sync.name = "MultiplayerSynchronizer"
|
|
client_sync.set_multiplayer_authority(pid)
|
|
var client_rep_config = SceneReplicationConfig.new()
|
|
client_rep_config.add_property(":synced_position")
|
|
client_rep_config.add_property(":synced_velocity")
|
|
client_rep_config.add_property(":rotation")
|
|
client_rep_config.add_property("HeadPivot:rotation")
|
|
client_rep_config.add_property(":synced_movement_state")
|
|
client_rep_config.add_property(":synced_movement_speed")
|
|
client_rep_config.add_property(":synced_is_crouching")
|
|
client_rep_config.add_property(":synced_is_ads")
|
|
client_rep_config.add_property(":synced_wall_side")
|
|
client_rep_config.add_property(":synced_is_dancing")
|
|
client_rep_config.add_property(":synced_grapple_point")
|
|
client_rep_config.add_property(":synced_is_grapple_shooting")
|
|
client_rep_config.add_property(":synced_skin_id")
|
|
client_rep_config.add_property(":synced_weapon_path")
|
|
client_rep_config.add_property(":synced_loadout_p1")
|
|
client_rep_config.add_property(":synced_loadout_p2")
|
|
client_rep_config.add_property(":synced_loadout_sp")
|
|
client_rep_config.add_property(":synced_loadout_melee")
|
|
client_rep_config.add_property(":synced_loadout_ready")
|
|
client_rep_config.add_property(":synced_action")
|
|
client_rep_config.add_property(":synced_action_seq")
|
|
client_rep_config.add_property(":synced_is_targeting")
|
|
client_rep_config.add_property(":synced_homing_target_pos")
|
|
client_sync.replication_config = client_rep_config
|
|
player.add_child(client_sync)
|
|
|
|
# Collision shape
|
|
var col_shape := CollisionShape3D.new()
|
|
col_shape.name = "CollisionShape3D"
|
|
var capsule := CapsuleShape3D.new()
|
|
capsule.radius = 0.4
|
|
capsule.height = 1.8
|
|
col_shape.shape = capsule
|
|
player.add_child(col_shape)
|
|
|
|
# Apply movement controller script
|
|
var mover_script = preload("res://movement/player_movement_controller.gd")
|
|
if mover_script:
|
|
player.set_script(mover_script)
|
|
|
|
# Humanoid Model for Player (Shadows only locally, visible to others)
|
|
var humanoid = load("res://characters/humanoid_model.gd").new()
|
|
humanoid.name = "HumanoidModel"
|
|
humanoid.color = Color(0.2, 0.4, 0.8) # Blueish for player
|
|
humanoid.shadows_only = (pid == multiplayer.get_unique_id())
|
|
humanoid.position = Vector3(0, -0.9, 0) # Offset from center to feet
|
|
player.add_child(humanoid)
|
|
|
|
# Movement State Machine
|
|
var sm := Node.new()
|
|
sm.name = "MovementStateMachine"
|
|
player.add_child(sm)
|
|
|
|
var sm_script = preload("res://movement/movement_state_machine.gd")
|
|
if sm_script:
|
|
sm.set_script(sm_script)
|
|
|
|
# Add all movement states
|
|
var state_scripts := {
|
|
"ground": "res://movement/states/state_ground.gd",
|
|
"air": "res://movement/states/state_air.gd",
|
|
"wall_run": "res://movement/states/state_wall_run.gd",
|
|
"wall_cling": "res://movement/states/state_wall_cling.gd",
|
|
"slide": "res://movement/states/state_slide.gd",
|
|
"dash": "res://movement/states/state_dash.gd",
|
|
}
|
|
for state_name in state_scripts:
|
|
var st := Node.new()
|
|
st.name = "state_" + state_name
|
|
sm.add_child(st)
|
|
var st_script = load(state_scripts[state_name])
|
|
if st_script:
|
|
st.set_script(st_script)
|
|
|
|
# FPS Camera Rig (HeadPivot → Camera3D)
|
|
var head_pivot := Node3D.new()
|
|
head_pivot.name = "HeadPivot"
|
|
head_pivot.position = Vector3(0, 0.7, 0) # Eye height
|
|
player.add_child(head_pivot)
|
|
|
|
var camera := Camera3D.new()
|
|
camera.name = "Camera3D"
|
|
camera.current = (pid == multiplayer.get_unique_id())
|
|
camera.fov = 90.0
|
|
head_pivot.add_child(camera)
|
|
|
|
# ── Weapon Setup ────────────────────────────────────────────────────────────
|
|
var wmanager_script = preload("res://weapons/weapon_manager.gd")
|
|
if wmanager_script:
|
|
var wman = wmanager_script.new()
|
|
wman.name = "WeaponManager"
|
|
wman.player = player
|
|
wman.camera = camera
|
|
camera.add_child(wman)
|
|
|
|
var rig_script = preload("res://characters/player/fps_camera_rig.gd")
|
|
if rig_script:
|
|
head_pivot.set_script(rig_script)
|
|
|
|
# Store original capsule height
|
|
sm.original_capsule_height = capsule.height
|
|
|
|
# ── Dependencies ────────────────────────────────────────────────────────
|
|
sm.player = player
|
|
sm.params = player.params
|
|
head_pivot.params = player.params
|
|
|
|
# Authority configuration
|
|
var is_local = (pid == multiplayer.get_unique_id())
|
|
if is_local:
|
|
_player = player
|
|
player.set_physics_process(true)
|
|
player.set_process(true)
|
|
sm.set_physics_process(true)
|
|
else:
|
|
player.set_physics_process(false)
|
|
player.set_process(true)
|
|
player.set_process_input(false)
|
|
sm.set_physics_process(false)
|
|
sm.set_process(false)
|
|
sm.set_process_input(false)
|
|
head_pivot.set_process_input(false)
|
|
head_pivot.set_process(false)
|
|
head_pivot.set_physics_process(false)
|
|
var wman = camera.get_node_or_null("WeaponManager")
|
|
if wman:
|
|
wman.set_process_input(false)
|
|
wman.set_process(false)
|
|
wman.set_physics_process(false)
|
|
wman.visible = false
|
|
var cv = wman.get("canvas_layer")
|
|
if cv:
|
|
cv.visible = false
|
|
|
|
return player
|
|
|
|
|
|
# ── HUD ───────────────────────────────────────────────────────────────
|
|
#
|
|
# There is no HUD here any more, and no _process to drive one.
|
|
#
|
|
# Reticle, vitals, ammo, ability cooldowns, the chain meter and the debug
|
|
# readout all belong to ui/player_hud.gd, spawned by the player itself. Every
|
|
# one of those describes A PLAYER, so a level that owns them has to reach down
|
|
# into that player's state machine and weapon manager every frame to fill them
|
|
# in — which is exactly what this did, from three byte-identical copies across
|
|
# the three level runtimes. The visible symptom was two ammo panels on screen at
|
|
# once, in two different styles, overlapping in the bottom-right corner.
|
|
#
|
|
# A level owns the level. |