Refactor grapple rope physics for improved realism and control

Enhances player swinging mechanics by precisely managing position and tangential velocity when the rope is at maximum length and anchored to terrain. This ensures smooth movement along the tethered arc.

Improves how maximum rope length is enforced during hook flight and when attached to objects, deferring to physics constraints for a more natural tethering effect rather than abruptly stopping the hook.

Refines the initialization of rope segment positions and their historical states for both the player and hook ends. This leads to more accurate initial rope deployment and better response to movement.

Standardizes the number of physics iterations for consistent simulation quality and simplifies rope rendering by always drawing segments.

Additionally, adjusts the shift-scroll speed for finer rope length control and modifies target acquisition to better handle complex, multi-part objects.

Author: OpenTools-run

Data/Base.rte/Devices/Tools/GrappleGun/Grapple.lua

@@ -55,7 +55,7 @@ function Create(self)
     self.currentSegments = self.minSegments -- Current number of segments
 
     -- Mousewheel control variables
-    self.shiftScrollSpeed = 8.0 -- Faster rope control with Shift+Mousewheel
+    self.shiftScrollSpeed = 1.0 -- Faster rope control with Shift+Mousewheel
 
     --ESTABLISH LINE
     self.apx = {}
@@ -74,8 +74,8 @@ function Create(self)
         self.lastY[i] = py
     end
 
-    self.lastX[self.minSegments] = px - self.Vel.X
-    self.lastY[self.minSegments] = py - self.Vel.Y
+    -- self.lastX[self.minSegments] = px - self.Vel.X -- This will be set after parent is found and hook Vel is determined
+    -- self.lastY[self.minSegments] = py - self.Vel.Y
     self.currentSegments = self.minSegments -- Start with minimum segments
     --slots 0 and currentSegments are ANCHOR POINTS
 
@@ -92,7 +92,20 @@ function Create(self)
                     self.parent = ToACrab(self.parent)
                 end
 
+                -- Initialize player anchor point (segment 0) based on parent's state
+                self.apx[0] = self.parent.Pos.X
+                self.apy[0] = self.parent.Pos.Y
+                self.lastX[0] = self.parent.Pos.X - self.parent.Vel.X 
+                self.lastY[0] = self.parent.Pos.Y - self.parent.Vel.Y
+
                 self.Vel = self.parent.Vel + Vector(self.fireVel, 0):RadRotate(self.parent:GetAimAngle(true)) -- Changed: Use full parent velocity
+                
+                -- Now that hook's self.Vel is set, initialize its lastX/Y for initial trajectory for the hook end
+                -- Note: self.currentSegments is self.minSegments at this point.
+                self.lastX[self.currentSegments] = px - self.Vel.X 
+                self.lastY[self.currentSegments] = py - self.Vel.Y
+
+
                 self.parentGun:RemoveNumberValue("GrappleMode")
                 for part in self.parent.Attachables do
                     local radcheck = SceneMan:ShortestDistance(self.parent.Pos, part.Pos, self.mapWrapsX).Magnitude + part.Radius
@@ -132,32 +145,27 @@ function Update(self)
 				if self.actionMode == 1 then
 					-- Immediately update rope length based on actual hook position
 					self.lineVec = SceneMan:ShortestDistance(self.parent.Pos, self.Pos, self.mapWrapsX)
-					self.lineLength = self.lineVec.Magnitude
-					self.currentLineLength = self.lineLength
-					
-					-- Check if we've reached the maximum shooting distance during flight
+					self.lineLength = self.lineVec.Magnitude -- Actual current distance
+
+					-- Determine currentLineLength and limitReached status based on maxShootDistance
 					if self.lineLength >= self.maxShootDistance then
-						-- Stop the claw at max shooting distance but keep it in flight mode
-						local maxShootVec = self.lineVec:SetMagnitude(self.maxShootDistance)
-						self.Pos = self.parent.Pos + maxShootVec
-						self.Vel = Vector(0, 0) -- Stop the claw
-						self.currentLineLength = self.maxShootDistance
+						if not self.limitReached then -- Play sound only on the frame it first reaches the limit
+							self.clickSound:Play(self.parent.Pos)
+						end
+						self.currentLineLength = self.maxShootDistance -- Cap the effective rope length for physics
 						self.limitReached = true
-						-- Keep actionMode = 1 (flight) so it can still detect collisions
-						self.clickSound:Play(self.parent.Pos)
+						-- By not setting self.Pos or self.Vel directly, we let RopePhysics.applyRopeConstraints
+						-- handle the "binding" at maxShootDistance, creating a tethered effect.
+					else
+						self.currentLineLength = self.lineLength -- Rope is shorter than max, so its length is the actual distance
+						self.limitReached = false
 					end
 
 					-- Update rope anchor points directly for flight mode
 					self.apx[0] = self.parent.Pos.X
 					self.apy[0] = self.parent.Pos.Y
 					self.apx[self.currentSegments] = self.Pos.X
 					self.apy[self.currentSegments] = self.Pos.Y
-					
-					-- Set all lastX/lastY positions to prevent velocity inheritance from previous mode
-					for i = 0, self.currentSegments do
-						self.lastX[i] = self.apx[i]
-						self.lastY[i] = self.apy[i]
-					end
 				end
 
 				-- Calculate optimal number of segments based on rope length using our module function
@@ -194,22 +202,28 @@ function Update(self)
 
 				-- Special handling for attached targets (MO grabbing)
 				if self.actionMode == 3 and self.target and self.target.ID ~= rte.NoMOID then
-					local target = self.target
-					if target.ID ~= target.RootID then
-						local mo = target:GetRootParent()
-						if mo.ID ~= rte.NoMOID and IsAttachable(target) then
-							target = mo
+					local effective_target = self.target -- Start with the direct hit object
+
+					-- If the direct hit target is part of a larger entity (e.g., a limb of an actor),
+					-- try to use its root parent as the effective target, provided the root is "attachable".
+					if self.target.ID ~= self.target.RootID then
+						local root_parent = self.target:GetRootParent()
+						-- Check if root_parent is valid and if it's considered attachable
+						if root_parent and root_parent.ID ~= rte.NoMOID and IsAttachable(root_parent) then
+							effective_target = root_parent -- Use the attachable root parent
+						-- Else, if root_parent is not attachable (or doesn't exist),
+						-- we continue using the original self.target as effective_target.
 						end
 					end
 
-					-- Update hook position to follow the target
-					self.Pos = target.Pos
-					self.apx[self.currentSegments] = target.Pos.X
-					self.apy[self.currentSegments] = target.Pos.Y
+					-- Update hook position to follow the 'effective_target'
+					self.Pos = effective_target.Pos
+					self.apx[self.currentSegments] = effective_target.Pos.X
+					self.apy[self.currentSegments] = effective_target.Pos.Y
 
-					-- Apply target velocity to the hook anchor for physics continuity
-					self.lastX[self.currentSegments] = self.apx[self.currentSegments] - target.Vel.X
-					self.lastY[self.currentSegments] = self.apy[self.currentSegments] - target.Vel.Y
+					-- Apply 'effective_target' velocity to the hook anchor for physics continuity
+					self.lastX[self.currentSegments] = self.apx[self.currentSegments] - effective_target.Vel.X
+					self.lastY[self.currentSegments] = self.apy[self.currentSegments] - effective_target.Vel.Y
 				else
 					-- Update hook position from rope physics when not attached to MO
 					if self.actionMode > 1 then -- Hook is stuck to terrain
@@ -253,6 +267,21 @@ function Update(self)
 					if self.actionMode > 1 then  -- Only reset limit flag when attached, not during flight
 						self.limitReached = false
 					end
+					
+					-- Update rope anchor points
+                    -- Player end (anchor 0)
+                    self.apx[0] = self.parent.Pos.X
+                    self.apy[0] = self.parent.Pos.Y
+                    -- Set lastX/Y for the player anchor to reflect its movement.
+                    -- This makes the rope correctly inherit player\'s motion at the anchor point.
+                    self.lastX[0] = self.parent.Pos.X - self.parent.Vel.X 
+                    self.lastY[0] = self.parent.Pos.Y - self.parent.Vel.Y 
+
+                    -- Hook end (anchor currentSegments)
+					self.apx[self.currentSegments] = self.Pos.X
+					self.apy[self.currentSegments] = self.Pos.Y
+					-- lastX/Y for the hook end are implicitly handled by the Verlet integration
+                    -- as we are no longer resetting them in a loop for actionMode == 1.
 				end
 
 				if self.parentGun and self.parentGun.ID ~= rte.NoMOID then

Data/Base.rte/Devices/Tools/GrappleGun/Scripts/RopePhysics.lua

@@ -107,13 +107,14 @@ end
 -- @return     The number of physics iterations to use for this rope
 function RopePhysics.optimizePhysicsIterations(self)
     -- Base iteration count - balance between performance and physics accuracy
-    if self.currentSegments < 15 and self.currentLineLength < 150 then
-        return 36 -- More iterations for shorter, more active ropes (higher accuracy)
-    elseif self.currentSegments > 30 or self.currentLineLength > 300 then
-        return 9 -- Fewer iterations for very long ropes to save performance
-    end
-    
-    return 18 -- Default for medium-length ropes
+    -- if self.currentSegments < 15 and self.currentLineLength < 150 then
+    --     return 36 -- More iterations for shorter, more active ropes (higher accuracy)
+    -- elseif self.currentSegments > 30 or self.currentLineLength > 300 then
+    --     return 9 -- Fewer iterations for very long ropes to save performance
+    -- end
+    -- 
+    -- return 18 -- Default for medium-length ropes
+    return 32 -- User request: Set all iterations to 32
 end
 
 -- Resize the rope segments (add/remove/reposition)
@@ -331,103 +332,78 @@ function RopePhysics.applyRopeConstraints(grappleInstance, currentTotalCableLeng
 
     if not grappleInstance.parent then return false end
 
-    -- Use the centrally controlled rope length as the maximum constraint
     local maxRopeLength = grappleInstance.currentLineLength or grappleInstance.maxLineLength
 
-    -- FIRST: Enforce rigid maximum distance constraint through rope physics only
-    -- Pure Verlet implementation - no direct player position manipulation
-    local playerPos = grappleInstance.parent.Pos
+    local playerPos = grappleInstance.parent.Pos 
     local hookPos = Vector(grappleInstance.apx[segments], grappleInstance.apy[segments])
-    local ropeVector = SceneMan:ShortestDistance(playerPos, hookPos, grappleInstance.mapWrapsX)
-    local totalRopeDistance = ropeVector.Magnitude
 
-    -- Update anchor positions for constraint calculations
+    -- Ensure player anchor point is up-to-date for constraint calculations
     grappleInstance.apx[0] = playerPos.X
     grappleInstance.apy[0] = playerPos.Y
 
-    -- GLOBAL CONSTRAINT: Handle rope length constraints smoothly
+    local ropeVector = SceneMan:ShortestDistance(playerPos, hookPos, grappleInstance.mapWrapsX)
+    local totalRopeDistance = ropeVector.Magnitude
+
+    -- GLOBAL CONSTRAINT: Handle rope length limits
     if totalRopeDistance > maxRopeLength then
         local excessDistance = totalRopeDistance - maxRopeLength
-        local constraintDirection = ropeVector:SetMagnitude(1)
-        
-        -- Check if hook is anchored (attached to terrain or MO)
-        -- if grappleInstance.actionMode >= 2 then  -- Original condition
-        if grappleInstance.actionMode == 2 then -- Changed: Actor anchored to claw only in mode 2
-            -- Hook is anchored - apply PROPER SWINGING CONSTRAINT
-            -- This allows free tangential movement (swinging) while constraining radial movement
+        local constraintDirection = ropeVector:SetMagnitude(1) -- Vector from player to hook
+
+        if grappleInstance.actionMode == 2 then -- Hook is anchored to terrain; player swings.
+            -- Player is overstretched. Correct position and velocity for a rigid swing.
 
-            local currentVelocity = grappleInstance.parent.Vel
+            -- 1. Correct Player Position: Snap player precisely to the maxRopeLength arc.
+            local vec_from_hook_to_player = playerPos - hookPos -- Vector from hook to current player position
+            grappleInstance.parent.Pos = hookPos + vec_from_hook_to_player:SetMagnitude(maxRopeLength)
+
+            -- Update player's rope anchor point and local playerPos variable to reflect the correction.
+            grappleInstance.apx[0] = grappleInstance.parent.Pos.X
+            grappleInstance.apy[0] = grappleInstance.parent.Pos.Y
+            playerPos = grappleInstance.parent.Pos 
+
+            -- 2. Correct Player Velocity: Make it purely tangential to the swing arc.
+            local currentVel = grappleInstance.parent.Vel
+            -- Define rope direction from the *newly corrected* player position to the hook.
+            local ropeDirFromPlayerToHook = (hookPos - playerPos):SetMagnitude(1) 
 
-            -- Calculate velocity component toward/away from hook
-            -- constraintDirection points FROM player TO hook
-            local radialVelocity = currentVelocity:Dot(constraintDirection)
+            local radialVelScalar = currentVel:Dot(ropeDirFromPlayerToHook)
+            -- radialVelScalar is the component of currentVel along the rope direction (player to hook).
+            -- If > 0, moving towards hook. If < 0, moving away from hook.
+            -- For a rigid tether at max length, all velocity along the rope axis should be nullified.
+            local radialVelocityVector = ropeDirFromPlayerToHook * radialVelScalar
+            local tangentialVelocity = currentVel - radialVelocityVector
 
-            -- Only constrain the radial component if moving away from hook (stretching rope)
-            if radialVelocity < 0 then
-                -- Player is moving away from hook - remove ONLY the radial component
-                -- Keep all tangential velocity for swinging motion
-                local radialVelocityVector = constraintDirection * radialVelocity
-                local tangentialVelocity = currentVelocity - radialVelocityVector
-                
-                -- Set velocity to pure tangential motion (perfect swinging)
-                grappleInstance.parent.Vel = tangentialVelocity
-                
-                -- Set tension for physics feedback
-                grappleInstance.ropeTensionForce = -radialVelocity * 0.5
-                grappleInstance.ropeTensionDirection = constraintDirection
+            grappleInstance.parent.Vel = tangentialVelocity
+
+            -- Tension feedback: Indicate that the rope resisted outward motion.
+            -- resisted_outgoing_speed will be positive if player was moving away from hook.
+            local resisted_outgoing_speed = -radialVelScalar 
+            if resisted_outgoing_speed > 0.01 then 
+                grappleInstance.ropeTensionForce = resisted_outgoing_speed * 0.5 -- Magnitude based on resisted speed
+                grappleInstance.ropeTensionDirection = ropeDirFromPlayerToHook -- Force on player is towards hook
             else
-                -- Player is moving toward hook or tangentially - no constraint needed
-                -- This allows free movement inward and pure swinging motion
                 grappleInstance.ropeTensionForce = nil
                 grappleInstance.ropeTensionDirection = nil
             end
-            
-            -- CRITICAL: Also enforce position constraint to prevent gradual stretching
-            -- After constraining velocity, ensure player doesn't drift beyond max rope length
-            if totalRopeDistance > maxRopeLength then
-                local correctionDistance = totalRopeDistance - maxRopeLength
-                local correctionVector = constraintDirection * correctionDistance
-                
-                -- Move player back to exact rope radius (smooth correction)
-                local correctionStrength = 0.8 -- Strong but not instant correction
-                grappleInstance.parent.Pos = grappleInstance.parent.Pos + correctionVector * correctionStrength
-                
-                -- Update rope anchor to match corrected player position
-                grappleInstance.apx[0] = grappleInstance.parent.Pos.X
-                grappleInstance.apy[0] = grappleInstance.parent.Pos.Y
-            end
-        elseif grappleInstance.actionMode == 1 then -- Added: Claw anchored to actor in mode 1
-            -- Hook is in flight, anchor it to the player
-            local correctionVector = constraintDirection * excessDistance
-            -- Move the player instead of the hook
-            grappleInstance.parent.Pos = grappleInstance.parent.Pos + correctionVector
-            -- Update rope anchor to match corrected player position
-            grappleInstance.apx[0] = grappleInstance.parent.Pos.X
-            grappleInstance.apy[0] = grappleInstance.parent.Pos.Y
-
-            -- Clear any tension forces since rope is not under tension
-            grappleInstance.ropeTensionForce = nil
-            grappleInstance.ropeTensionDirection = nil
 
-            -- Recalculate after constraint
-            playerPos = grappleInstance.parent.Pos -- update playerPos for subsequent calculations
-            ropeVector = SceneMan:ShortestDistance(playerPos, hookPos, grappleInstance.mapWrapsX)
-            totalRopeDistance = ropeVector.Magnitude
-        else
-            -- Hook is in flight - we can move it to maintain rope length (default case)
-            local correctionVector = constraintDirection * excessDistance
-            grappleInstance.apx[segments] = grappleInstance.apx[segments] - correctionVector.X
+        else -- Handles actionMode == 1 (hook flying), actionMode == 3 (hook on MO), and any other defaults.
+             -- In these cases, the player is the anchor, and the hook end of the rope is corrected.
+            local correctionVector = constraintDirection * excessDistance -- constraintDirection is player -> hook
+            
+            -- Move hook segment towards player
+            grappleInstance.apx[segments] = grappleInstance.apx[segments] - correctionVector.X 
             grappleInstance.apy[segments] = grappleInstance.apy[segments] - correctionVector.Y
 
-            -- Clear any tension forces since rope is not under tension
-            grappleInstance.ropeTensionForce = nil
+            grappleInstance.ropeTensionForce = nil 
             grappleInstance.ropeTensionDirection = nil
 
-            -- Recalculate after constraint
-            hookPos = Vector(grappleInstance.apx[segments], grappleInstance.apy[segments])
-            ropeVector = SceneMan:ShortestDistance(playerPos, hookPos, grappleInstance.mapWrapsX)
-            totalRopeDistance = ropeVector.Magnitude
+            hookPos = Vector(grappleInstance.apx[segments], grappleInstance.apy[segments]) -- Update hookPos for subsequent segment constraints
         end
+        
+        -- After any correction, update totalRopeDistance for the segment constraint part
+        -- This ensures the segment distribution logic uses the corrected overall length.
+        ropeVector = SceneMan:ShortestDistance(playerPos, hookPos, grappleInstance.mapWrapsX)
+        totalRopeDistance = ropeVector.Magnitude 
     else
         -- Rope is not at maximum length - clear tension forces
         grappleInstance.ropeTensionForce = nil

Data/Base.rte/Devices/Tools/GrappleGun/Scripts/RopeRenderer.lua

@@ -36,17 +36,9 @@ end
 
 -- Draw the complete rope with debug information
 function RopeRenderer.drawRope(grappleInstance, player)
-    -- If we're in flight mode, draw a simple direct line
-    if grappleInstance.actionMode == 1 then
-        -- Draw a direct line from player to hook for visibility during flight
-        if grappleInstance.parent then
-            PrimitiveMan:DrawLinePrimitive(player, grappleInstance.parent.Pos, grappleInstance.Pos, 97)
-        end
-    else
-        -- Draw regular rope segments with physics
-        for i = 0, grappleInstance.currentSegments - 1 do
-            RopeRenderer.drawSegment(grappleInstance, i, i + 1, player)
-        end
+    -- Always draw regular rope segments with physics, regardless of actionMode
+    for i = 0, grappleInstance.currentSegments - 1 do
+        RopeRenderer.drawSegment(grappleInstance, i, i + 1, player)
     end
 
     -- Always draw debug information when player is controlling