asowneryt/gamejamgame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: resolve merge conflicts, keep test-branch rope physics

Browse Source 
The merge of main into test (fd39db8) was committed with conflict markers
still in the files, leaving rope_tether.gd and 3dlevel.tscn unparseable
while git reported a clean tree.

Both sides were competing full implementations of the tether rather than
overlapping edits, so every hunk had to go one way. Kept the test side:
elastic leash, kinematic tautening, haul drag and the mid-chain snap.
Dropped main's _constrain/_haul/_damp/_snap port and its tension_start,
pull_speed and snap_length exports. The two scene hunks followed from the
same choice, since the rope node's properties name exports that exist on
only one side.

Also drops rope_diag.gd, which came in with that commit and drives the
discarded API (can_snap, taut_margin).

Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
ASOwnerYT
2026-07-26 02:10:15 +12:00
co-authored by Claude Opus 5
parent fd39db872b
commit 9c99d5f3ce
4 changed files with 0 additions and 469 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/rope_tether.gd
-375
View File
@@ -42,7 +42,6 @@ var attach_end : PhysicsBody3D
## at all times and the leash is an explicit force instead.
@export var max_length := 20.0
<<<<<<< HEAD
## Leash spring: metres per second squared of pull per metre of stretch, plus
## damping on the separation speed. Applied as acceleration, so it behaves the
## same whether an endpoint is a CharacterBody3D or a RigidBody3D.
@@ -86,11 +85,6 @@ var attach_end : PhysicsBody3D
## winch, high values like the rope is weightless. Reeling out is not rate
## limited — see _reel.
@export var reel_speed := 6.0
=======
## How fast total length changes, in metres per second. Low values feel like a
## winch, high values like the rope is weightless.
@export var reel_speed := 8.0
>>>>>>> main
## Constrain segments to the X-Y plane (linear Z, angular X and Y).
@export var plane_lock_z := true
@@ -98,85 +92,10 @@ var attach_end : PhysicsBody3D
@export_flags_3d_physics var segment_collision_layer := 4
@export_flags_3d_physics var segment_collision_mask := 1
<<<<<<< HEAD
# Fraction of the endpoint gap the rope keeps in hand at minimum. `slack` is the
# resting sag; this is only the floor that keeps the chain off dead taut when
# slack is turned down to nothing.
const TAUT_MARGIN := 0.02
=======
# --- Pull / tension / snap ---------------------------------------------------
#
# Ported from the 2D Verlet rope. That rope integrated its own points, so it
# could resolve stretch by moving them directly; here the rope body is solved by
# the physics server, so only the *anchor* half of that logic carries over: the
# players get pulled, damped and finally launched. `max_length` is shared with
# the reel, which is exactly right — the reel stops paying out rope there, so
# that is the gap at which the rope runs out and starts pulling back.
## Note: the reference script's `reel_speed` is this — how fast the rope hauls
## the players together. Ours was already taken by the rope's own length change,
## so the anchor-pulling rate is `pull_speed`.
@export_group("Tension")
## Gap at which strain starts registering for visuals. Below max_length, so the
## rope reads as straining before it actually starts pulling.
@export var tension_start := 16.0
## Fraction of its nominal length the rope gives before it is genuinely straight,
## soaked up by compliant pin joints and the two end anchors.
##
## 0.12 is the measured sweet spot on a 6m/12-segment rope: sag at the moment
## pull engages falls from 0.73m at 0.02 to 0.41m here. Past ~0.18 it gets worse
## again — the extra span opens the joints further, which adds back the path
## length it was meant to take up. Retune if segment count or joint softness
## changes; those move the curve.
@export_range(0.0, 0.5, 0.005) var taut_margin := 0.12
## Metres per second the rope hauls the players together while over-stretched.
@export var pull_speed := 6.0
## How the pull is split. 0.5 moves both equally; 0.0 moves only attach_end.
@export_range(0.0, 1.0, 0.01) var pull_bias := 0.5
## Fraction of velocity-away-from-the-rope killed per tick while taut.
@export_range(0.0, 1.0, 0.01) var damping := 0.2
## Hard break distance, and how fast sustained over-stretch accumulates toward a
## break. The rope snaps on whichever arrives first.
@export var snap_length := 34.0
@export var snap_tension := 1.0
@export var tension_rise := 1.5
@export var tension_fall := 2.0
## Speed kicked into each player when the rope lets go.
@export var snap_impulse := 19.0
## Seconds the two dead halves dangle and fade before being freed.
@export var snap_fade := 0.6
## Off makes the rope an unbreakable leash: it still pulls, never snaps.
@export var can_snap := true
signal became_taut
signal became_slack
signal rope_snapped
signal tension_changed(amount)
## True while the gap exceeds max_length and the rope is actively hauling.
var taut := false
## True once the rope has broken. It stays broken until reset().
var snapped := false
## Accumulated over-stretch. Reaching snap_tension breaks the rope.
var tension := 0.0
## 0..1 strain for visuals and camera shake. Driven by whichever of raw distance
## or accumulated tension is further along.
var strain_amt := 0.0
var _emitted_strain := -1.0
var _break_time := 0.0
var _halves : Array[Path3D] = []
>>>>>>> main
# The base script zeroes `position` and bakes it into child positions, so keep
# our own copy to place the end joint we add.
@@ -212,7 +131,6 @@ func _ready() -> void:
func _physics_process(delta: float) -> void:
<<<<<<< HEAD
if _snapped:
# Nothing left to reel, tension or leash. Both halves just hang off their
# player, so all that is left is drawing them.
@@ -223,20 +141,11 @@ func _physics_process(delta: float) -> void:
_apply_elastic(delta)
_apply_tautness(delta)
_update_timer()
=======
if snapped:
_update_break(delta)
return
if dynamic_length:
_reel(delta)
_constrain(delta)
>>>>>>> main
# Base script redraws the CSG curve from the segment transforms and capsule
# heights, so it has to run after the resize.
super(delta)
<<<<<<< HEAD
func _on_snap_timer_timeout() -> void:
snap()
@@ -323,121 +232,10 @@ func _target_length() -> float:
# real error to correct and they push it right back off the line.
var effective_slack := lerpf(slack, TAUT_MARGIN, _taut_ramp())
return maxf(_endpoint_span() * (1.0 + effective_slack), min_length)
=======
## Pull the players together while the gap exceeds the rope, accumulate strain,
## and break the rope when it has taken too much.
func _constrain(delta: float) -> void:
if attach_start == null or attach_end == null:
return
var v := attach_end.global_position - attach_start.global_position
if plane_lock_z:
v.z = 0.0
var dist := v.length()
if dist < 0.001:
return
var stretch := dist - _taut_distance()
var now_taut := stretch > 0.0
if now_taut != taut:
taut = now_taut
if taut:
became_taut.emit()
else:
became_slack.emit()
# Tension only builds while genuinely over-stretched, and bleeds off the rest
# of the time, so a rope that is repeatedly yanked breaks but one held at a
# steady hard stretch does not break instantly.
if stretch > 0.0:
var s := clampf(stretch / maxf(snap_length - max_length, 0.001), 0.0, 1.0)
tension += tension_rise * s * delta
else:
tension = move_toward(tension, 0.0, tension_fall * delta)
var dist_strain := clampf(
(dist - tension_start) / maxf(snap_length - tension_start, 0.001), 0.0, 1.0)
strain_amt = maxf(dist_strain, tension / maxf(snap_tension, 0.001))
_emit_strain()
if now_taut:
var dir := v / dist
var pull := minf(stretch, pull_speed * delta)
_haul(attach_start, dir * pull * pull_bias)
_haul(attach_end, -dir * pull * (1.0 - pull_bias))
if damping > 0.0:
_damp(attach_start, -dir)
_damp(attach_end, dir)
if can_snap and (tension >= snap_tension or dist >= snap_length):
_snap()
# How far apart the rope can actually hold the players, which is *not* the
# length the reel commands. Pin joints are compliant: measured on the stock
# settings the interior joints open ~0.29m and the two end anchors another
# ~0.14m on a 6m rope, so the rope keeps roughly `taut_margin` in hand past its
# nominal length. Pulling at nominal starts hauling while the rope still droops.
#
# This deliberately does not measure the rope's live path. That was tried and it
# feeds back: compliant joints stretch to meet whatever the gap is, so measured
# reach chases the span, `stretch` never turns positive and the rope never pulls
# at all. The allowance has to be a value the current stretch cannot influence.
func _taut_distance() -> float:
return _rope_length * (1.0 + taut_margin)
func _emit_strain() -> void:
if absf(strain_amt - _emitted_strain) > 0.01:
_emitted_strain = strain_amt
tension_changed.emit(strain_amt)
# Position is moved rather than velocity added, matching the reference: the pull
# has to survive the player's own _physics_process, which rewrites velocity.x
# from input every tick and would swallow a velocity nudge.
func _haul(body: PhysicsBody3D, delta_pos: Vector3) -> void:
var rigid := body as RigidBody3D
if rigid != null:
rigid.apply_central_impulse(delta_pos / maxf(get_physics_process_delta_time(), 0.001))
else:
body.global_position += delta_pos
# Kill only the component of velocity heading away from the rope, so the rope
# resists being stretched without deadening movement along it.
func _damp(body: PhysicsBody3D, away: Vector3) -> void:
var character := body as CharacterBody3D
if character != null:
var along := character.velocity.dot(away)
if along > 0.0:
character.velocity -= away * along * damping
return
var rigid := body as RigidBody3D
if rigid != null:
var along := rigid.linear_velocity.dot(away)
if along > 0.0:
rigid.linear_velocity -= away * along * damping
## Length the rope wants to be for the current endpoint gap.
##
## Divided by the compliance allowance rather than set to the gap directly. The
## chain can reach `taut_margin` past whatever length it is told to be, so
## commanding exactly the gap leaves that surplus hanging as droop at every
## distance — which is what made the rope look slack however hard it was pulled.
## Commanding the gap *minus* the stretch it is going to gain means its real
## reach lands on the gap, and the rope hangs straight.
func _target_length() -> float:
if attach_start == null or attach_end == null:
return maxf(distance, min_length)
var span := attach_start.global_position.distance_to(attach_end.global_position)
return clampf(span / (1.0 + taut_margin), min_length, max_length)
>>>>>>> main
func _reel(delta: float) -> void:
var previous := _rope_length
<<<<<<< HEAD
var target := _target_length()
if target > _rope_length:
# Out is instant. Rate-limiting this direction is what lets the gap outrun
@@ -450,15 +248,6 @@ func _reel(delta: float) -> void:
# it is here so that a slack of 0 still cannot produce a chain shorter than the
# straight-line gap.
_rope_length = maxf(_rope_length, _endpoint_span() * (1.0 + TAUT_MARGIN))
=======
# Both directions are rate limited. Paying out instantly was what made the
# rope feel permanently slack: the commanded length would sit exactly on the
# gap, and since the chain can reach `taut_margin` beyond what it is told to
# be, that surplus had nowhere to go and hung as droop no matter how hard the
# players pulled. Trailing the gap instead means a pull faster than
# `reel_speed` eats the surplus and the rope comes up taut.
_rope_length = move_toward(_rope_length, _target_length(), reel_speed * delta)
>>>>>>> main
if absf(_rope_length - previous) > 0.0001:
_set_segment_length(_rope_length / float(number_of_segments))
@@ -744,173 +533,9 @@ func _wire_endpoints() -> void:
end_joint.set_param(PinJoint3D.PARAM_IMPULSE_CLAMP, max_impulse)
joints.append(end_joint)
<<<<<<< HEAD
func _update_timer() -> void:
var stretched = is_equal_approx(tension_ratio(), 1.0)
if stretched and $SnapTimer.is_stopped():
$SnapTimer.start()
elif !stretched:
$SnapTimer.stop()
=======
## Break the rope: kick the players apart and split the chain in two.
##
## The reference had to hand-integrate the two dead halves after a break. Here
## the halves are still pin-jointed rigid bodies with one loose end, so the
## physics server drapes them for free — all that is needed is to drop the
## middle joint and give each half its own tube to draw into.
func _snap() -> void:
var dir := attach_end.global_position - attach_start.global_position
if plane_lock_z:
dir.z = 0.0
dir = dir.normalized() if dir.length() > 0.001 else Vector3.RIGHT
_kick(attach_start, -dir * snap_impulse)
_kick(attach_end, dir * snap_impulse)
_split_chain()
snapped = true
taut = false
tension = 0.0
strain_amt = 0.0
_emit_strain()
rope_snapped.emit()
func _kick(body: PhysicsBody3D, impulse: Vector3) -> void:
var character := body as CharacterBody3D
if character != null:
character.velocity += impulse
return
var rigid := body as RigidBody3D
if rigid != null:
rigid.apply_central_impulse(impulse * rigid.mass)
# Free the middle joint so the chain parts, then hand each half its own path and
# tube. The single shared tube cannot be reused: its curve would still run
# through both halves and stretch a band of geometry across the break.
func _split_chain() -> void:
var mid := int(segments.size() / 2.0)
# joints[i] bridges segments[i-1] and segments[i], so joints[mid] is the one
# holding the two halves together.
if mid > 0 and mid < joints.size():
var seam := joints[mid]
joints.remove_at(mid)
seam.queue_free()
mesh.visible = false
_halves.clear()
_halves.append(_make_half(0, mid - 1))
_halves.append(_make_half(mid, segments.size() - 1))
_break_time = 0.0
_update_break(0.0)
# A Path3D + CSGPolygon3D pair covering segments[lo..hi], mirroring the settings
# of the main tube so the halves look like the rope they came from.
func _make_half(lo: int, hi: int) -> Path3D:
var path := Path3D.new()
path.top_level = true
path.curve = Curve3D.new()
path.set_meta("lo", lo)
path.set_meta("hi", hi)
add_child(path)
var tube := CSGPolygon3D.new()
tube.polygon = mesh.polygon
tube.mode = mesh.mode
tube.path_interval_type = mesh.path_interval_type
tube.path_interval = mesh.path_interval
tube.path_rotation = mesh.path_rotation
tube.path_local = mesh.path_local
tube.path_continuous_u = mesh.path_continuous_u
tube.path_joined = mesh.path_joined
tube.smooth_faces = mesh.smooth_faces
tube.calculate_tangents = mesh.calculate_tangents
# The rope material is an opaque resource shared with anything else using it,
# so the fade gets its own transparent copy rather than mutating the original.
if material != null:
var faded := material.duplicate() as StandardMaterial3D
if faded != null:
faded.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
tube.material = faded
path.add_child(tube)
# path_node resolves relative to the CSG node, so it can only be set once the
# tube is actually in the tree under the path.
tube.path_node = tube.get_path_to(path)
return path
func _update_break(delta: float) -> void:
_break_time += delta
var alpha := clampf(1.0 - _break_time / maxf(snap_fade, 0.001), 0.0, 1.0)
for path in _halves:
if not is_instance_valid(path):
continue
_trace_half(path)
var tube := path.get_child(0) as CSGPolygon3D
var mat := tube.material as StandardMaterial3D
if mat != null:
mat.albedo_color.a = alpha
if _break_time >= snap_fade:
_clear_rope()
# Same endpoint math the base script uses for the main curve: a capsule's +Y end
# is the one nearer the rope start, so the run is every segment's near end plus
# the far end of the last one.
func _trace_half(path: Path3D) -> void:
var lo : int = path.get_meta("lo")
var hi : int = path.get_meta("hi")
var c := path.curve
c.clear_points()
for i in range(lo, hi + 1):
var seg := segments[i]
var half_h : float = seg.get_child(0).shape.height * 0.5
c.add_point(seg.position + seg.transform.basis.y * half_h)
var last := segments[hi]
var last_half : float = last.get_child(0).shape.height * 0.5
c.add_point(last.position - last.transform.basis.y * last_half)
# Tear down every body, joint and tube the rope owns. A snapped rope should stop
# costing physics once it has finished falling.
func _clear_rope() -> void:
for path in _halves:
if is_instance_valid(path):
path.queue_free()
_halves.clear()
for joint in joints:
if is_instance_valid(joint):
joint.queue_free()
joints.clear()
for segment in segments:
if is_instance_valid(segment):
segment.queue_free()
segments.clear()
curve_points.clear()
## Rebuild the rope from scratch after a snap.
func reset() -> void:
_clear_rope()
snapped = false
taut = false
tension = 0.0
strain_amt = 0.0
_emitted_strain = -1.0
_break_time = 0.0
if mesh != null:
mesh.visible = true
# The base _ready() bakes `position` into the segments and then zeroes it, so
# the offset has to be put back before rebuilding or the new rope spawns at
# the parent's origin instead of the rope's.
position = _origin_offset
curve = Curve3D.new()
_fit_curve_to_endpoints()
super._ready()
_apply_plane_lock()
_wire_endpoints()
_rope_length = _target_length()
>>>>>>> main