feat(characters): rig anchors, and a lab that edits any tuning group

The weapon lab could tune how a character HOLDS a gun. It could not tune where
the gun sits in the hand, and that is a different question with a different
scope: a hold is per character and weapon, an anchor is a fact about the hand.

RigAnchors adds it. A hand bone's origin is the WRIST, not the palm, and how far
down the palm a grip should sit — and how the gun rolls in the fingers — depends
on how big that character's hand is and how the artist posed the thumb. It
cannot be derived, it differs per character, and it is small. So it is an offset
that defaults to identity, and identity means exactly what the code derived
before anchors existed: an untuned character is bit-for-bit unchanged.

Deliberately NOT a fixed rotation on the mount. There used to be one, and a bone
attachment is expressed in the BONE's axes, which no two rigs agree on — that
constant is why the hand mount points were wrong on every character. The derived
mount stays derived; the anchor is a nudge on top of it, and nothing here spells
a bone name.

The layering, the JSON round trip and the res://-then-user:// write are now
TuningStore, because none of that was ever specific to weapons and two copies of
it would mean two places for "an exported build's tuning pass is silently
discarded" to come back. WeaponHoldTuning is built on it with its file format
unchanged.

The lab is a rig lab now, and it grew three things:

  ANCHORS   a second knob group. It cost a spec table — everything in the lab is
            written against "which specs, which file, keyed on what" rather than
            twice against the two groups, so anchors got sliders, live preview,
            reset, save and clipboard for free. A third group is a third row in
            GROUPS.
  CLIP      audition one animation on its own. The four pose buttons are the
            states the game drives; watching a whole clip end to end is how you
            see where a retarget went wrong, and there was no way to do it.
  SURFACES  what the importer decided each surface IS, and a click to isolate a
            class. Isolating is how the decision gets CHECKED: click `hair` and
            anything else still standing was misclassified. Hidden by swapping
            in a transparent material rather than hiding the node, because a
            mesh is not one class — Miku's body, face and hair are three
            surfaces of one mesh.

And it takes the game's theme, applied to its own panel rather than only to the
Window, for the same reason the pause menu needed it: a CanvasLayer is not a
Control, so theme inheritance stops at one.

debug/rig_anchor_check.gd asserts the physical consequence rather than the
plumbing — an anchor system is easy to build so that the sliders move, the file
saves, the JSON round-trips and the gun does not budge. All six characters move
their weapon by exactly the offset asked for, measured in the attachment's frame
because a world-space delta on an animating skeleton is mostly the idle
animation, and all six return exactly to the derived mount when it is cleared.

Also fixes BoltRule, whose zigzag was self-intersecting: draw_colored_polygon
triangulates, and a crossing outline fails triangulation and draws nothing at
all except a console full of "Invalid polygon data". Same silhouette, walked as
a closed loop, with the ink edge as a polyline rather than a grown polygon —
growing a concave shape from its centroid reintroduces the crossing.

Co-Authored-By: Claude Opus 5 <[email protected]>

characters/skinned_player_model.gd

@@ -100,9 +100,12 @@ var is_holding_weapon: bool = false
 ## Which skin this is, so per-character hold tuning can be looked up. Set by
 ## whoever spawns the model; falls back to the GLB's basename.
 var skin_id: String = ""
-## Live hold overrides. Written by debug/weapon_lab.gd while tuning and by
+## Live hold overrides. Written by debug/rig_lab.gd while tuning and by
 ## set_weapon() from the saved table otherwise.
 var hold_tune: Dictionary = {}
+## Live anchor overrides — where the grip sits in the palm, and how the gun
+## rolls in the fingers. Same two sources as hold_tune. See RigAnchors.
+var anchors: Dictionary = {}
 
 # Animation blending: locomotion plays full-body through a Transition node;
 # gameplay one-shots (reload/throw/shoot/hit) play through an
@@ -907,20 +910,55 @@ func get_lean_debug() -> float:
 	return _cur_fwd
 
 
+## Every canonical clip this character resolved to something real.
+##
+## Canonical rather than raw, because the raw names differ per character — one
+## rig's "CrouchIdle" is another's "Crouch_Idle_Loop" — and the canonical name is
+## what the game asks for. For debug/rig_lab.gd's clip scrubber.
+func clip_names_debug() -> Array:
+	return _resolved_clips.keys()
+
+
+## Play one clip outright, ignoring the locomotion state machine. Lab only.
+func play_clip_debug(canonical: String) -> void:
+	_play_clip(canonical, true)
+
+
 ## Push a new hold tuning table in and re-seat the weapon with it.
 ##
-## For debug/weapon_lab.gd: the knobs that live on the pose layer take effect on
+## For debug/rig_lab.gd: the knobs that live on the pose layer take effect on
 ## the next frame, but weapon SIZE and the grip offset are baked into the
 ## attachment when the weapon is seated, so those need the weapon re-measured.
 func set_hold_tuning(t: Dictionary) -> void:
 	hold_tune = t
 	if _pose_mod:
 		_pose_mod.tune = t
-	if _weapon_attachment and _weapon_attachment.get_child_count() > 0:
-		var w := _weapon_attachment.get_child(0) as Node3D
-		if w:
-			w.transform = Transform3D.IDENTITY
-			_measure_weapon(w)
+	_reseat_weapon()
+
+
+## Push a new anchor table in and re-seat the weapon on it.
+##
+## Separate from set_hold_tuning because the two are separate questions with
+## separate scopes — a hold is per character AND weapon, an anchor is per
+## character — and the lab edits them on different screens.
+func set_anchors(a: Dictionary) -> void:
+	anchors = a
+	_reseat_weapon()
+
+
+## Re-apply the grip anchor and re-measure, after either table changed.
+##
+## `_measure_weapon` reads the weapon's transform to work out where its grip and
+## muzzle are, so the anchor has to be back in place BEFORE it runs — measuring
+## from identity and then offsetting would move the gun without moving the
+## points the hands are being solved onto.
+func _reseat_weapon() -> void:
+	if _weapon_attachment == null or _weapon_attachment.get_child_count() == 0:
+		return
+	var w := _weapon_attachment.get_child(0) as Node3D
+	if w:
+		w.transform = RigAnchors.grip_transform(anchors)
+		_measure_weapon(w)
 
 
 ## Whether the locomotion cycle is running backwards, which points the stride
@@ -955,10 +993,15 @@ func set_weapon(script_path: String) -> void:
 		return
 	# Per-character, per-weapon hold overrides, if any have been tuned. Empty is
 	# the normal case and means "use what the code derives".
+	var sid := skin_id if skin_id != "" else model_path.get_file().get_basename()
 	if hold_tune.is_empty():
-		var sid := skin_id if skin_id != "" else model_path.get_file().get_basename()
 		hold_tune = WeaponHoldTuning.resolve(WeaponHoldTuning.load_all(), sid,
 			script_path.get_file().get_basename())
+	# Anchors are per character, not per weapon — where a grip sits in a palm is
+	# a fact about the hand — so unlike hold_tune they are not re-read per gun
+	# unless the lab has pushed a live set in.
+	if anchors.is_empty():
+		anchors = RigAnchors.resolve(RigAnchors.load_all(), sid)
 
 	var script = load(script_path)
 	if not script:
@@ -992,7 +1035,13 @@ func set_weapon(script_path: String) -> void:
 		# rig, and the wrist then absorbs whatever that bone's roll happens to be.
 		# The grip is placed at the bone's origin below, so the gun sits IN the
 		# hand rather than at a fixed offset from a differently-oriented bone.
-		w.transform = Transform3D.IDENTITY
+		#
+		# ...with one adjustment on top: the character's own grip ANCHOR. A hand
+		# bone's origin is the wrist, not the palm, and how far down the palm a
+		# grip should sit is a fact about that character's hand — how big it is,
+		# how the fingers were modelled — which cannot be derived. It defaults to
+		# identity, so a character nobody has tuned behaves exactly as before.
+		w.transform = RigAnchors.grip_transform(anchors)
 		if _pose_mod:
 			_pose_mod.gun_fwd_hand = Vector3(0, 0, -1)
 			_pose_mod.gun_up_hand = Vector3(0, 1, 0)
@@ -1249,7 +1298,7 @@ class ShooterPoseModifier extends SkeletonModifier3D:
 	## "index.L" -> its bone names, knuckle to fingertip, from the same sidecar.
 	var fingers: Dictionary = {}
 	## Per-character hold overrides — see characters/weapon_hold_tuning.gd and
-	## debug/weapon_lab.gd. A dictionary rather than a field per knob so a new
+	## debug/rig_lab.gd. A dictionary rather than a field per knob so a new
 	## knob needs no plumbing: add it here, read it with _t/_tv, and the lab
 	## picks it up from the same table.
 	var tune: Dictionary = {}