ryan
6a1359f244
- Introduced `stickman_prop_interactor.gd` to manage prop interactions. - Created `phase_11_prop_interactions.md` detailing the design and implementation of prop pickup, drop, and throw mechanics. - Defined interaction states, action lifecycles, and event triggers for prop handling. - Specified constraints for throw actions, including target positioning and velocity calculations. - Established acceptance criteria for prop interactions and lifecycle management.
1105 lines
46 KiB
GDScript
1105 lines
46 KiB
GDScript
class_name StickmanPropInteractor
|
|
extends Node
|
|
## Owns one-stickman/one-hand prop interaction state during Sandbox PLAY.
|
|
|
|
const ANCHOR_DATA := preload("res://scripts/prop_anchor_data.gd")
|
|
|
|
enum Hand { LEFT, RIGHT }
|
|
enum Phase { IDLE, APPROACHING, REACHING, PICKUP_RECOVERING, HELD, THROWING }
|
|
|
|
const MAX_REACH: float = 390.0
|
|
const APPROACH_GAP: float = 90.0
|
|
const APPROACH_REPLAN_LIMIT: int = 1
|
|
const REACH_DURATION: float = 0.34
|
|
const PICKUP_RECOVER_DURATION: float = 0.32
|
|
const LOW_PICKUP_THRESHOLD: float = 110.0
|
|
const LOW_PICKUP_MAX_DROP: float = 110.0
|
|
const LOW_PICKUP_LEAN: float = 28.0
|
|
const THROW_LIFT_DURATION: float = 0.30
|
|
const THROW_SWING_DURATION: float = 0.16
|
|
const THROW_FOLLOW_THROUGH: float = 0.24
|
|
const THROW_PREVIEW_HORIZON: float = 2.0
|
|
const MIN_THROW_FLIGHT_TIME: float = 0.35
|
|
const MAX_THROW_RANGE: float = 3600.0
|
|
const MAX_THROW_SPEED: float = 2100.0
|
|
const ZERO_THROW_DISTANCE: float = 4.0
|
|
const THROW_DESCENT_EPSILON: float = 0.001
|
|
const THROW_SPIN_SPEED: float = 2.4
|
|
const THROW_TRAJECTORY_SEGMENTS: int = 24
|
|
const THROW_HEAD_CLEARANCE: float = 36.0
|
|
const THROW_REACH_MARGIN: float = 8.0
|
|
|
|
signal action_completed
|
|
signal prop_event(event_type: String, prop: PropBlock, reason: String)
|
|
|
|
var _rig: Node2D
|
|
var _locomotion: Node
|
|
var _resolver: Callable
|
|
var _phase: Phase = Phase.IDLE
|
|
var _held_prop: PropBlock
|
|
var _held_anchor: Dictionary = {}
|
|
var _hand: Hand = Hand.RIGHT
|
|
var _active_action: Dictionary = {}
|
|
var _reach_start: Vector2 = Vector2.ZERO
|
|
var _reach_target: Vector2 = Vector2.ZERO
|
|
var _reach_elapsed: float = 0.0
|
|
var _pickup_recover_elapsed: float = 0.0
|
|
var _pickup_torso_start: Vector2 = Vector2.ZERO
|
|
var _pickup_torso_start_rotation: float = 0.0
|
|
var _pickup_torso_crouched: Vector2 = Vector2.ZERO
|
|
var _pickup_torso_crouched_rotation: float = 0.0
|
|
var _pickup_uses_crouch: bool = false
|
|
var _throw_elapsed: float = 0.0
|
|
var _throw_released: bool = false
|
|
var _throw_base_marker_local: Vector2 = Vector2.ZERO
|
|
var _throw_windup_marker_local: Vector2 = Vector2.ZERO
|
|
var _throw_overhead_marker_local: Vector2 = Vector2.ZERO
|
|
var _throw_swing_control_marker_local: Vector2 = Vector2.ZERO
|
|
var _throw_release_marker_local: Vector2 = Vector2.ZERO
|
|
var _throw_follow_control_marker_local: Vector2 = Vector2.ZERO
|
|
var _throw_follow_marker_local: Vector2 = Vector2.ZERO
|
|
var _throw_release_attachment_local: Transform2D = Transform2D.IDENTITY
|
|
var _throw_facing_left: bool = false
|
|
var _throw_effective_target: Vector2 = Vector2.ZERO
|
|
var _throw_torso_start: Vector2 = Vector2.ZERO
|
|
var _throw_torso_windup: Vector2 = Vector2.ZERO
|
|
var _throw_torso_start_rotation: float = 0.0
|
|
var _throw_torso_windup_rotation: float = 0.0
|
|
var _approach_replans: int = 0
|
|
var _marker_start_position: Vector2 = Vector2.ZERO
|
|
var _saved_body_state: Dictionary = {}
|
|
var _last_transform: Transform2D = Transform2D.IDENTITY
|
|
var _sampled_linear_velocity: Vector2 = Vector2.ZERO
|
|
var _sampled_angular_velocity: float = 0.0
|
|
|
|
|
|
func _exit_tree() -> void:
|
|
if _held_prop != null and is_instance_valid(_held_prop):
|
|
_release_held("scene_reset", false)
|
|
else:
|
|
_clear_reservation()
|
|
|
|
|
|
func configure(rig: Node2D, locomotion: Node, resolver: Callable) -> void:
|
|
_rig = rig
|
|
_locomotion = locomotion
|
|
_resolver = resolver
|
|
|
|
|
|
## Returns true when the queue runner must wait for action_completed.
|
|
## Immediate success and safe no-op failures both return false.
|
|
func start_action(action: Dictionary) -> bool:
|
|
var type := String(action.get("type", ""))
|
|
match type:
|
|
"pick_up_prop":
|
|
return _begin_pickup(String(action.get("target_prop_id", "")), String(action.get("hand", "auto")), action)
|
|
"drop_prop":
|
|
if _held_prop != null and is_instance_valid(_held_prop):
|
|
_release_held("manual", false)
|
|
return false
|
|
"throw_prop":
|
|
if _held_prop == null or not is_instance_valid(_held_prop):
|
|
return false
|
|
var target: Variant = action.get("target_position", Vector2.INF)
|
|
if not target is Vector2 or not (target as Vector2).is_finite():
|
|
push_warning("StickmanPropInteractor: invalid throw target; skipped.")
|
|
return false
|
|
var raw_target := target as Vector2
|
|
if _rig == null or raw_target.distance_to(_rig.global_position) <= ZERO_THROW_DISTANCE:
|
|
return false
|
|
var effective_target := _clamp_throw_target(raw_target)
|
|
if absf(effective_target.x - _rig.global_position.x) > 0.5:
|
|
_rig.call("set_facing_profile", 0 if effective_target.x < _rig.global_position.x else 1)
|
|
var marker := _hand_marker()
|
|
if marker == null:
|
|
return false
|
|
var pose := _build_throw_pose(effective_target, marker, _held_prop, _hand, Vector2.ZERO)
|
|
if pose.is_empty():
|
|
return false
|
|
var throw_facing_left := bool(pose["facing_left"])
|
|
var pose_transform := _rig_transform_for_facing(throw_facing_left)
|
|
var release_marker_world: Vector2 = pose_transform * (pose["release"] as Vector2)
|
|
var release_attachment := _predicted_attachment_transform(release_marker_world, throw_facing_left, _held_prop, _held_anchor, _hand)
|
|
var release_attachment_local: Transform2D = pose_transform.affine_inverse() * release_attachment
|
|
var spin_sign := -1.0 if throw_facing_left else 1.0
|
|
var predicted_release := pose_transform * release_attachment_local
|
|
if _solve_throw(predicted_release, effective_target, _held_prop, spin_sign * THROW_SPIN_SPEED).is_empty():
|
|
return false
|
|
_store_throw_pose(pose, marker)
|
|
_throw_facing_left = throw_facing_left
|
|
_throw_release_attachment_local = release_attachment_local
|
|
_throw_effective_target = effective_target
|
|
_active_action = action.duplicate(true)
|
|
_throw_elapsed = 0.0
|
|
_throw_released = false
|
|
_phase = Phase.THROWING
|
|
return true
|
|
return false
|
|
|
|
|
|
func tick(delta: float) -> void:
|
|
if _rig == null or not is_instance_valid(_rig):
|
|
return
|
|
match _phase:
|
|
Phase.APPROACHING:
|
|
if _locomotion != null and bool(_locomotion.call("consume_walk_completed")):
|
|
_on_approach_arrived()
|
|
Phase.REACHING:
|
|
_update_reach(delta)
|
|
Phase.PICKUP_RECOVERING:
|
|
_update_pickup_recovery(delta)
|
|
Phase.HELD:
|
|
_update_held_transform(delta)
|
|
Phase.THROWING:
|
|
_update_throw(delta)
|
|
|
|
|
|
func cancel_action() -> void:
|
|
if _phase == Phase.APPROACHING and _locomotion != null:
|
|
_locomotion.call("cancel_walk")
|
|
if _phase == Phase.APPROACHING or _phase == Phase.REACHING:
|
|
_clear_reservation()
|
|
_restore_hand_target()
|
|
_restore_pickup_torso()
|
|
elif _phase == Phase.PICKUP_RECOVERING:
|
|
_restore_pickup_torso()
|
|
_phase = Phase.HELD
|
|
_active_action.clear()
|
|
return
|
|
elif _phase == Phase.THROWING and not _throw_released:
|
|
var marker := _hand_marker()
|
|
if marker != null:
|
|
marker.position = _throw_base_marker_local
|
|
_restore_throw_torso()
|
|
_phase = Phase.HELD if _held_prop != null else Phase.IDLE
|
|
_active_action.clear()
|
|
return
|
|
elif _phase == Phase.THROWING and _throw_released:
|
|
_throw_released = false
|
|
_throw_elapsed = 0.0
|
|
_restore_hand_target()
|
|
_restore_throw_torso()
|
|
if _phase != Phase.HELD:
|
|
_phase = Phase.IDLE
|
|
_active_action.clear()
|
|
|
|
|
|
func preview_throw(target: Vector2, queue_prefix: Array[Dictionary] = []) -> Dictionary:
|
|
if not target.is_finite():
|
|
return {}
|
|
var context := _build_throw_preview_context(queue_prefix)
|
|
if not bool(context.get("available", false)):
|
|
return {
|
|
"preview_available": false,
|
|
"preview_reason": String(context.get("reason", "No prop is held or planned before this throw.")),
|
|
}
|
|
var prop: PropBlock = context["prop"]
|
|
var anchor: Dictionary = context["anchor"]
|
|
var hand_value := int(context["hand"])
|
|
var root_offset: Vector2 = context["root_offset"]
|
|
var effective_target := _clamp_throw_target(target, context["root_position"])
|
|
if _rig == null or target.distance_to(context["root_position"]) <= ZERO_THROW_DISTANCE:
|
|
var invalid := _invalid_throw_preview(effective_target, _rig.global_position if _rig != null else target)
|
|
invalid.merge(_throw_preview_metadata(context), true)
|
|
return invalid
|
|
var marker := _hand_marker_for(hand_value)
|
|
if marker == null:
|
|
return {"preview_available": false, "preview_reason": "The planned pickup hand is unavailable."}
|
|
var pose := _build_throw_pose(effective_target, marker, prop, hand_value, root_offset)
|
|
if pose.is_empty():
|
|
return {"preview_available": false, "preview_reason": "The throw pose cannot be estimated from the current rig."}
|
|
var facing_left := bool(pose["facing_left"])
|
|
var release_marker_world := _rig_transform_for_facing(facing_left, root_offset) * (pose["release"] as Vector2)
|
|
var release_transform := _predicted_attachment_transform(release_marker_world, facing_left, prop, anchor, hand_value, root_offset)
|
|
var spin_speed := -THROW_SPIN_SPEED if facing_left else THROW_SPIN_SPEED
|
|
var solution := _solve_throw(release_transform, effective_target, prop, spin_speed)
|
|
if solution.is_empty():
|
|
var invalid := _invalid_throw_preview(effective_target, release_transform.origin)
|
|
invalid.merge(_throw_preview_metadata(context), true)
|
|
return invalid
|
|
solution.merge(_throw_preview_metadata(context), true)
|
|
solution["effective_target"] = effective_target
|
|
solution["target_reachable"] = true
|
|
return _clip_preview_to_collision(solution, prop)
|
|
|
|
|
|
func _build_throw_preview_context(queue_prefix: Array[Dictionary]) -> Dictionary:
|
|
if _rig == null or not is_instance_valid(_rig):
|
|
return {"available": false, "reason": "The acting stickman is unavailable."}
|
|
var prop: PropBlock = _held_prop if _held_prop != null and is_instance_valid(_held_prop) else null
|
|
var anchor: Dictionary = _held_anchor.duplicate(true) if prop != null else {}
|
|
var hand_value := int(_hand)
|
|
var has_prop := prop != null
|
|
var root_position := _rig.global_position
|
|
var root_offset := Vector2.ZERO
|
|
var predicted_facing_left := _is_facing_left()
|
|
var planned := false
|
|
var uncertain := _phase != Phase.IDLE and _phase != Phase.HELD
|
|
var plan_step := 0
|
|
for entry: Dictionary in queue_prefix:
|
|
var action: Dictionary = entry.get("action", {})
|
|
if action.is_empty():
|
|
continue
|
|
if bool(entry.get("active", false)):
|
|
uncertain = true
|
|
var action_type := String(action.get("type", ""))
|
|
match action_type:
|
|
"walk_to":
|
|
var feet_target: Variant = action.get("target", Vector2.INF)
|
|
if feet_target is Vector2 and (feet_target as Vector2).is_finite() and _locomotion != null:
|
|
var previous_root := root_position
|
|
var foot_offset: Vector2 = _locomotion.call("get_foot_offset")
|
|
root_position = (feet_target as Vector2) + foot_offset
|
|
root_offset = root_position - _rig.global_position
|
|
if not is_zero_approx(root_position.x - previous_root.x):
|
|
predicted_facing_left = root_position.x < previous_root.x
|
|
uncertain = true
|
|
"pick_up_prop":
|
|
if has_prop:
|
|
continue
|
|
var prop_id := String(action.get("target_prop_id", ""))
|
|
if prop_id.is_empty() or not _resolver.is_valid():
|
|
return {"available": false, "reason": "A pickup before this throw has no resolvable prop."}
|
|
var resolved: Variant = _resolver.call(prop_id)
|
|
if not resolved is PropBlock or not is_instance_valid(resolved) or (resolved as PropBlock).is_queued_for_deletion():
|
|
return {"available": false, "reason": "A pickup before this throw refers to a missing prop."}
|
|
var candidate_prop := resolved as PropBlock
|
|
var owner_id := int(candidate_prop.interaction_owner_id)
|
|
var reserved_by := int(candidate_prop.interaction_reserved_by)
|
|
if (owner_id != 0 and owner_id != int(_rig.get_instance_id())) or (reserved_by != 0 and reserved_by != int(_rig.get_instance_id())):
|
|
return {"available": false, "reason": "The planned pickup prop is held or reserved by another stickman."}
|
|
var requested_hand := String(action.get("hand", "auto"))
|
|
var picked := _choose_preview_grip_and_hand(candidate_prop, requested_hand, root_offset, predicted_facing_left)
|
|
if picked.is_empty():
|
|
return {"available": false, "reason": "The planned prop has no compatible grip for this pickup."}
|
|
var candidate_anchor: Dictionary = picked["anchor"]
|
|
var candidate_hand := int(picked["hand"])
|
|
var grip_position := _grip_world_position_for_facing(candidate_prop, candidate_anchor, predicted_facing_left)
|
|
var wrist_position := _preview_wrist_position(candidate_hand, root_offset, predicted_facing_left)
|
|
if wrist_position.distance_to(grip_position) > MAX_REACH:
|
|
uncertain = true
|
|
var side := -1.0 if root_position.x <= grip_position.x else 1.0
|
|
var approach_root := Vector2(grip_position.x + side * APPROACH_GAP, root_position.y)
|
|
if not is_equal_approx(approach_root.x, root_position.x):
|
|
predicted_facing_left = approach_root.x < root_position.x
|
|
root_position = approach_root
|
|
root_offset = root_position - _rig.global_position
|
|
grip_position = _grip_world_position_for_facing(candidate_prop, candidate_anchor, predicted_facing_left)
|
|
wrist_position = _preview_wrist_position(candidate_hand, root_offset, predicted_facing_left)
|
|
if wrist_position.distance_to(grip_position) > MAX_REACH:
|
|
uncertain = true
|
|
prop = candidate_prop
|
|
anchor = candidate_anchor.duplicate(true)
|
|
hand_value = candidate_hand
|
|
has_prop = true
|
|
planned = true
|
|
plan_step = int(entry.get("step", 0))
|
|
"drop_prop", "throw_prop":
|
|
if has_prop:
|
|
prop = null
|
|
anchor.clear()
|
|
has_prop = false
|
|
planned = false
|
|
uncertain = true
|
|
"ragdoll":
|
|
uncertain = true
|
|
if not has_prop or prop == null or not is_instance_valid(prop):
|
|
return {"available": false, "reason": "No prop is held or picked up earlier in this queue."}
|
|
return {
|
|
"available": true,
|
|
"prop": prop,
|
|
"anchor": anchor,
|
|
"hand": hand_value,
|
|
"root_position": root_position,
|
|
"root_offset": root_offset,
|
|
"planned": planned,
|
|
"uncertain": uncertain,
|
|
"plan_step": plan_step,
|
|
}
|
|
|
|
|
|
func _choose_preview_grip_and_hand(prop: PropBlock, requested_hand: String, root_offset: Vector2, facing_left: bool) -> Dictionary:
|
|
var anchors := prop.get_interaction_anchors()
|
|
var candidates: Array[Dictionary] = []
|
|
for hand_name: String in ["left", "right"]:
|
|
if requested_hand != "auto" and requested_hand != hand_name:
|
|
continue
|
|
var hand_value: Hand = Hand.LEFT if hand_name == "left" else Hand.RIGHT
|
|
var compatible: Array[String] = ANCHOR_DATA.compatible_grip_ids(anchors, hand_value)
|
|
for anchor_id: String in compatible:
|
|
var candidate_anchor: Dictionary = anchors.get(anchor_id, {})
|
|
var wrist_position := _preview_wrist_position(hand_value, root_offset, facing_left)
|
|
var grip_position := _grip_world_position_for_facing(prop, candidate_anchor, facing_left)
|
|
candidates.append({"anchor_id": anchor_id, "anchor": candidate_anchor, "hand": hand_value, "distance": wrist_position.distance_to(grip_position)})
|
|
if candidates.is_empty():
|
|
return {}
|
|
candidates.sort_custom(func(a: Dictionary, b: Dictionary) -> bool:
|
|
var a_primary := String(a.get("anchor_id", "")) == "primary_grip"
|
|
var b_primary := String(b.get("anchor_id", "")) == "primary_grip"
|
|
if a_primary != b_primary:
|
|
return a_primary
|
|
return float(a.get("distance", INF)) < float(b.get("distance", INF))
|
|
)
|
|
return candidates[0]
|
|
|
|
|
|
func _preview_wrist_position(hand_value: int, root_offset: Vector2, facing_left: bool) -> Vector2:
|
|
var wrist := _solved_wrist_transform_for(hand_value)
|
|
var rig_transform := _rig_transform_for_facing(facing_left, root_offset)
|
|
return rig_transform * _rig.to_local(wrist.origin)
|
|
|
|
|
|
func _throw_preview_metadata(context: Dictionary) -> Dictionary:
|
|
var planned := bool(context.get("planned", false))
|
|
var uncertain := bool(context.get("uncertain", false))
|
|
var hint := ""
|
|
var step := int(context.get("plan_step", 0))
|
|
if planned and step > 0:
|
|
hint = "Assumes Step %d pickup succeeds." % step
|
|
elif planned:
|
|
hint = "Assumes an earlier pickup succeeds."
|
|
if uncertain:
|
|
hint = "Estimated preview. " + hint if not hint.is_empty() else "Estimated preview from earlier actions."
|
|
return {"preview_available": true, "preview_planned": planned, "preview_uncertain": uncertain, "preview_hint": hint}
|
|
|
|
|
|
func _build_throw_pose(target: Vector2, marker: Marker2D, prop: PropBlock, hand_value: int, root_offset: Vector2) -> Dictionary:
|
|
var prethrow_delta := target - prop.global_position
|
|
if not prethrow_delta.is_finite():
|
|
return {}
|
|
var root_position := _rig.global_position + root_offset
|
|
var facing_left := target.x < root_position.x if absf(target.x - root_position.x) > 0.5 else _is_facing_left()
|
|
var suffix := "Left" if hand_value == Hand.LEFT else "Right"
|
|
var shoulder_bone := _rig.get_node_or_null(NodePath("Skeleton2D/Torso/%sUpperArm" % suffix)) as Bone2D
|
|
var lower_bone := _rig.get_node_or_null(NodePath("Skeleton2D/Torso/%sUpperArm/%sLowerArm" % [suffix, suffix])) as Bone2D
|
|
var head_node := _rig.get_node_or_null(NodePath("Body/Head")) as Node2D
|
|
if shoulder_bone == null or lower_bone == null or head_node == null:
|
|
return {}
|
|
var pose_transform := _rig_transform_for_facing(facing_left, root_offset)
|
|
var head_center := pose_transform * _rig.to_local(head_node.global_position)
|
|
var shoulder := pose_transform * _rig.to_local(shoulder_bone.global_position)
|
|
var head_radius := 100.0
|
|
var radius_value: Variant = head_node.get("radius")
|
|
if radius_value is float or radius_value is int:
|
|
head_radius = maxf(float(radius_value), 20.0)
|
|
var aim_sign := signf(target.x - root_position.x)
|
|
if is_zero_approx(aim_sign):
|
|
aim_sign = -1.0 if facing_left else 1.0
|
|
var max_reach := maxf(1.0, shoulder_bone.length + lower_bone.length - THROW_REACH_MARGIN)
|
|
var behind_control := head_center + Vector2(-aim_sign * head_radius * 0.78, -head_radius * 0.20)
|
|
var overhead := head_center + Vector2(-aim_sign * 8.0, -head_radius - THROW_HEAD_CLEARANCE)
|
|
var swing_control := head_center + Vector2(aim_sign * (head_radius * 0.62), -head_radius - THROW_HEAD_CLEARANCE * 0.45)
|
|
var release := head_center + Vector2(aim_sign * (head_radius + 44.0), -head_radius * 0.26)
|
|
var follow_control := release + Vector2(aim_sign * 44.0, -12.0)
|
|
var follow := release + Vector2(aim_sign * 88.0, 46.0)
|
|
behind_control = _clamp_to_arm_reach(behind_control, shoulder, max_reach)
|
|
overhead = _clamp_to_arm_reach(overhead, shoulder, max_reach)
|
|
swing_control = _clamp_to_arm_reach(swing_control, shoulder, max_reach)
|
|
release = _clamp_to_arm_reach(release, shoulder, max_reach)
|
|
follow_control = _clamp_to_arm_reach(follow_control, shoulder, max_reach)
|
|
follow = _clamp_to_arm_reach(follow, shoulder, max_reach)
|
|
var torso_marker := _torso_marker()
|
|
var torso_start := torso_marker.position if torso_marker != null else Vector2.ZERO
|
|
var torso_start_rotation := torso_marker.rotation if torso_marker != null else 0.0
|
|
var local_aim_sign := -aim_sign if facing_left else aim_sign
|
|
return {
|
|
"facing_left": facing_left,
|
|
"base": marker.position,
|
|
"windup": pose_transform.affine_inverse() * behind_control,
|
|
"overhead": pose_transform.affine_inverse() * overhead,
|
|
"swing_control": pose_transform.affine_inverse() * swing_control,
|
|
"release": pose_transform.affine_inverse() * release,
|
|
"follow_control": pose_transform.affine_inverse() * follow_control,
|
|
"follow": pose_transform.affine_inverse() * follow,
|
|
"torso_start": torso_start,
|
|
"torso_start_rotation": torso_start_rotation,
|
|
"torso_windup": torso_start + Vector2(-local_aim_sign * 24.0, -14.0),
|
|
"torso_windup_rotation": torso_start_rotation - local_aim_sign * 0.12,
|
|
}
|
|
|
|
|
|
func _store_throw_pose(pose: Dictionary, marker: Marker2D) -> void:
|
|
_throw_base_marker_local = marker.position
|
|
_throw_windup_marker_local = pose["windup"]
|
|
_throw_overhead_marker_local = pose["overhead"]
|
|
_throw_swing_control_marker_local = pose["swing_control"]
|
|
_throw_release_marker_local = pose["release"]
|
|
_throw_follow_control_marker_local = pose["follow_control"]
|
|
_throw_follow_marker_local = pose["follow"]
|
|
_throw_torso_start = pose["torso_start"]
|
|
_throw_torso_start_rotation = float(pose["torso_start_rotation"])
|
|
_throw_torso_windup = pose["torso_windup"]
|
|
_throw_torso_windup_rotation = float(pose["torso_windup_rotation"])
|
|
|
|
|
|
func _rig_transform_for_facing(facing_left: bool, root_offset: Vector2 = Vector2.ZERO) -> Transform2D:
|
|
var result := _rig.global_transform
|
|
result.origin += root_offset
|
|
var x_axis := result.x
|
|
if _is_facing_left():
|
|
x_axis = -x_axis
|
|
if facing_left:
|
|
x_axis = -x_axis
|
|
result.x = x_axis
|
|
return result
|
|
|
|
|
|
func _clamp_to_arm_reach(point: Vector2, shoulder: Vector2, max_reach: float) -> Vector2:
|
|
var delta := point - shoulder
|
|
if delta.length() <= max_reach or delta.is_zero_approx():
|
|
return point
|
|
return shoulder + delta.normalized() * max_reach
|
|
|
|
|
|
func _clamp_throw_target(target: Vector2, root_position: Vector2 = Vector2.INF) -> Vector2:
|
|
if _rig == null:
|
|
return target
|
|
var center := root_position if root_position.is_finite() else _rig.global_position
|
|
var offset := target - center
|
|
if offset.length() <= MAX_THROW_RANGE or offset.is_zero_approx():
|
|
return target
|
|
return center + offset.normalized() * MAX_THROW_RANGE
|
|
|
|
|
|
func _invalid_throw_preview(effective_target: Vector2, start_position: Vector2) -> Dictionary:
|
|
return {
|
|
"start_position": start_position,
|
|
"effective_target": effective_target,
|
|
"landing_position": effective_target,
|
|
"collision_position": Vector2.INF,
|
|
"collision_before_target": false,
|
|
"target_reachable": false,
|
|
"flight_time": 0.0,
|
|
"trajectory_points": PackedVector2Array(),
|
|
}
|
|
|
|
|
|
func disarm_for_ragdoll() -> void:
|
|
var interrupted_pickup := _phase == Phase.APPROACHING or _phase == Phase.REACHING or _phase == Phase.PICKUP_RECOVERING
|
|
var interrupted_windup := _phase == Phase.THROWING and not _throw_released
|
|
if _phase == Phase.APPROACHING or _phase == Phase.REACHING or _phase == Phase.PICKUP_RECOVERING:
|
|
cancel_action()
|
|
elif interrupted_windup:
|
|
cancel_action()
|
|
if _held_prop != null and is_instance_valid(_held_prop):
|
|
_release_held("ragdoll", false)
|
|
if interrupted_pickup or interrupted_windup:
|
|
action_completed.emit()
|
|
|
|
|
|
func reset_for_scene_exit() -> void:
|
|
if _phase == Phase.APPROACHING or _phase == Phase.REACHING or _phase == Phase.PICKUP_RECOVERING or (_phase == Phase.THROWING and not _throw_released):
|
|
cancel_action()
|
|
if _held_prop != null and is_instance_valid(_held_prop):
|
|
_release_held("scene_reset", false)
|
|
_phase = Phase.IDLE
|
|
_active_action.clear()
|
|
_restore_hand_target()
|
|
|
|
|
|
func _begin_pickup(prop_id: String, requested_hand: String, action: Dictionary) -> bool:
|
|
if _phase != Phase.IDLE or _held_prop != null or _rig == null:
|
|
return false
|
|
if int(_rig.get("state")) != 0:
|
|
return false
|
|
if prop_id.is_empty() or not _resolver.is_valid():
|
|
return false
|
|
var resolved: Variant = _resolver.call(prop_id)
|
|
if not resolved is PropBlock:
|
|
return false
|
|
var prop := resolved as PropBlock
|
|
if not is_instance_valid(prop) or prop.is_queued_for_deletion():
|
|
return false
|
|
if prop.interaction_owner_id != 0 or prop.interaction_reserved_by != 0:
|
|
return false
|
|
var picked := _choose_grip_and_hand(prop, requested_hand)
|
|
if picked.is_empty():
|
|
push_warning("StickmanPropInteractor: no compatible one-hand grip; pickup skipped.")
|
|
return false
|
|
_held_anchor = (picked["anchor"] as Dictionary).duplicate(true)
|
|
_hand = int(picked["hand"])
|
|
_held_prop = prop
|
|
_held_prop.interaction_reserved_by = _rig.get_instance_id()
|
|
_active_action = action.duplicate(true)
|
|
_approach_replans = 0
|
|
var marker := _hand_marker()
|
|
if marker == null:
|
|
_clear_reservation()
|
|
_phase = Phase.IDLE
|
|
return false
|
|
_marker_start_position = marker.position
|
|
var grip_position := _grip_world_position(prop, _held_anchor)
|
|
if _solved_wrist_transform().origin.distance_to(grip_position) > MAX_REACH:
|
|
if not _start_approach(grip_position):
|
|
_clear_reservation()
|
|
_phase = Phase.IDLE
|
|
return false
|
|
_phase = Phase.APPROACHING
|
|
return true
|
|
_start_reach(grip_position)
|
|
return true
|
|
|
|
|
|
func _choose_grip_and_hand(prop: PropBlock, requested_hand: String) -> Dictionary:
|
|
var anchors := prop.get_interaction_anchors()
|
|
var candidates: Array[Dictionary] = []
|
|
for hand_name: String in ["left", "right"]:
|
|
if requested_hand != "auto" and requested_hand != hand_name:
|
|
continue
|
|
var hand_value: int = Hand.LEFT if hand_name == "left" else Hand.RIGHT
|
|
var compatible: Array[String] = ANCHOR_DATA.compatible_grip_ids(anchors, hand_value)
|
|
for anchor_id: String in compatible:
|
|
var anchor: Dictionary = anchors.get(anchor_id, {})
|
|
var distance: float = _solved_wrist_transform_for(hand_value).origin.distance_to(_grip_world_position(prop, anchor))
|
|
candidates.append({"anchor_id": anchor_id, "anchor": anchor, "hand": hand_value, "distance": distance})
|
|
if candidates.is_empty():
|
|
return {}
|
|
candidates.sort_custom(func(a: Dictionary, b: Dictionary) -> bool:
|
|
var a_primary := String(a.get("anchor_id", "")) == "primary_grip"
|
|
var b_primary := String(b.get("anchor_id", "")) == "primary_grip"
|
|
if a_primary != b_primary:
|
|
return a_primary
|
|
return float(a.get("distance", INF)) < float(b.get("distance", INF))
|
|
)
|
|
return candidates[0]
|
|
|
|
|
|
func _start_approach(grip_position: Vector2) -> bool:
|
|
if _locomotion == null:
|
|
return false
|
|
var side := -1.0 if _rig.global_position.x <= grip_position.x else 1.0
|
|
var foot_offset: Vector2 = _locomotion.call("get_foot_offset")
|
|
var target_root := Vector2(grip_position.x + side * APPROACH_GAP, _rig.global_position.y)
|
|
var target_feet := target_root - foot_offset
|
|
return bool(_locomotion.call("walk_to", target_feet, -1.0))
|
|
|
|
|
|
func _on_approach_arrived() -> void:
|
|
if _held_prop == null or not is_instance_valid(_held_prop):
|
|
_clear_reservation()
|
|
_restore_hand_target()
|
|
_restore_pickup_torso()
|
|
_phase = Phase.IDLE
|
|
_active_action.clear()
|
|
action_completed.emit()
|
|
return
|
|
var grip_position := _grip_world_position(_held_prop, _held_anchor)
|
|
var marker := _hand_marker()
|
|
if marker == null:
|
|
_clear_reservation()
|
|
_restore_hand_target()
|
|
_phase = Phase.IDLE
|
|
_active_action.clear()
|
|
action_completed.emit()
|
|
return
|
|
if _solved_wrist_transform().origin.distance_to(grip_position) > MAX_REACH:
|
|
if _approach_replans < APPROACH_REPLAN_LIMIT:
|
|
_approach_replans += 1
|
|
if _start_approach(grip_position):
|
|
return
|
|
_clear_reservation()
|
|
_restore_hand_target()
|
|
_phase = Phase.IDLE
|
|
_active_action.clear()
|
|
action_completed.emit()
|
|
return
|
|
_start_reach(grip_position)
|
|
|
|
|
|
func _start_reach(grip_position: Vector2) -> void:
|
|
var marker := _hand_marker()
|
|
if marker == null:
|
|
_clear_reservation()
|
|
_restore_hand_target()
|
|
_phase = Phase.IDLE
|
|
_active_action.clear()
|
|
action_completed.emit()
|
|
return
|
|
_reach_start = marker.global_position
|
|
_reach_target = grip_position
|
|
_reach_elapsed = 0.0
|
|
var torso_marker := _torso_marker()
|
|
_pickup_uses_crouch = false
|
|
if torso_marker != null:
|
|
_pickup_torso_start = torso_marker.position
|
|
_pickup_torso_start_rotation = torso_marker.rotation
|
|
_pickup_torso_crouched = _pickup_torso_start
|
|
_pickup_torso_crouched_rotation = _pickup_torso_start_rotation
|
|
var grip_local := _rig.to_local(grip_position)
|
|
var low_amount := clampf((grip_local.y - _pickup_torso_start.y - LOW_PICKUP_THRESHOLD) / LOW_PICKUP_MAX_DROP, 0.0, 1.0)
|
|
if low_amount > 0.0:
|
|
var toward_prop := signf(grip_local.x - _pickup_torso_start.x)
|
|
if is_zero_approx(toward_prop):
|
|
toward_prop = -1.0 if _is_facing_left() else 1.0
|
|
_pickup_torso_crouched += Vector2(toward_prop * LOW_PICKUP_LEAN * low_amount, LOW_PICKUP_MAX_DROP * low_amount)
|
|
_pickup_torso_crouched_rotation -= toward_prop * 0.10 * low_amount
|
|
_pickup_uses_crouch = true
|
|
_rig.call("_set_limb_mods_enabled", true)
|
|
_phase = Phase.REACHING
|
|
|
|
|
|
func _update_reach(delta: float) -> void:
|
|
if _held_prop == null or not is_instance_valid(_held_prop):
|
|
_clear_reservation()
|
|
_restore_hand_target()
|
|
_phase = Phase.IDLE
|
|
action_completed.emit()
|
|
return
|
|
var marker := _hand_marker()
|
|
if marker == null:
|
|
cancel_action()
|
|
action_completed.emit()
|
|
return
|
|
_reach_elapsed += delta
|
|
var weight := clampf(_reach_elapsed / REACH_DURATION, 0.0, 1.0)
|
|
var eased_weight := smoothstep(0.0, 1.0, weight)
|
|
_reach_target = _grip_world_position(_held_prop, _held_anchor)
|
|
marker.global_position = _reach_start.lerp(_reach_target, eased_weight)
|
|
_update_pickup_crouch(eased_weight)
|
|
if weight < 1.0:
|
|
return
|
|
if _solved_wrist_transform().origin.distance_to(_reach_target) > MAX_REACH:
|
|
cancel_action()
|
|
action_completed.emit()
|
|
return
|
|
_commit_pickup(marker)
|
|
|
|
|
|
func _commit_pickup(marker: Marker2D) -> void:
|
|
if _held_prop == null or not is_instance_valid(_held_prop):
|
|
cancel_action()
|
|
action_completed.emit()
|
|
return
|
|
_saved_body_state = {
|
|
"freeze": _held_prop.freeze,
|
|
"freeze_mode": _held_prop.freeze_mode,
|
|
"collision_layer": _held_prop.collision_layer,
|
|
"collision_mask": _held_prop.collision_mask,
|
|
"z_index": _held_prop.z_index,
|
|
"z_as_relative": _held_prop.z_as_relative,
|
|
"linear_velocity": _held_prop.linear_velocity,
|
|
"angular_velocity": _held_prop.angular_velocity,
|
|
}
|
|
_held_prop.interaction_reserved_by = 0
|
|
_held_prop.interaction_owner_id = _rig.get_instance_id()
|
|
_held_prop.freeze_mode = RigidBody2D.FREEZE_MODE_KINEMATIC
|
|
_held_prop.freeze = true
|
|
_held_prop.sleeping = false
|
|
_held_prop.collision_layer = 0
|
|
_held_prop.collision_mask = 0
|
|
if _pickup_uses_crouch:
|
|
_pickup_recover_elapsed = 0.0
|
|
_phase = Phase.PICKUP_RECOVERING
|
|
else:
|
|
_phase = Phase.HELD
|
|
_active_action.clear()
|
|
_update_held_transform(0.0)
|
|
prop_event.emit("prop_picked_up", _held_prop, "")
|
|
if not _pickup_uses_crouch:
|
|
action_completed.emit()
|
|
|
|
|
|
func _update_pickup_recovery(delta: float) -> void:
|
|
_pickup_recover_elapsed += delta
|
|
var weight := smoothstep(0.0, 1.0, clampf(_pickup_recover_elapsed / PICKUP_RECOVER_DURATION, 0.0, 1.0))
|
|
_update_pickup_crouch(1.0 - weight)
|
|
_update_held_transform(delta)
|
|
if weight < 1.0:
|
|
return
|
|
_restore_pickup_torso()
|
|
_phase = Phase.HELD
|
|
_active_action.clear()
|
|
action_completed.emit()
|
|
|
|
|
|
func _update_pickup_crouch(weight: float) -> void:
|
|
var torso_marker := _torso_marker()
|
|
if torso_marker == null or not _pickup_uses_crouch:
|
|
return
|
|
torso_marker.position = _pickup_torso_start.lerp(_pickup_torso_crouched, weight)
|
|
torso_marker.rotation = lerpf(_pickup_torso_start_rotation, _pickup_torso_crouched_rotation, weight)
|
|
|
|
|
|
func _restore_pickup_torso() -> void:
|
|
var torso_marker := _torso_marker()
|
|
if torso_marker != null and _pickup_uses_crouch:
|
|
torso_marker.position = _pickup_torso_start
|
|
torso_marker.rotation = _pickup_torso_start_rotation
|
|
_pickup_uses_crouch = false
|
|
|
|
|
|
func _update_held_transform(delta: float, follow_hand_marker: bool = false) -> void:
|
|
if _held_prop == null or not is_instance_valid(_held_prop):
|
|
_clear_held_state()
|
|
return
|
|
var marker := _hand_marker()
|
|
if follow_hand_marker and marker != null:
|
|
_held_prop.global_transform = _predicted_attachment_transform(marker.global_position, _is_facing_left())
|
|
else:
|
|
var wrist := _solved_wrist_transform()
|
|
var anchor := _scaled_anchor(_held_anchor, _held_prop)
|
|
_held_prop.global_transform = ANCHOR_DATA.solve_attachment_transform(wrist, anchor, Vector2.ONE, _is_facing_left())
|
|
_held_prop.z_as_relative = true
|
|
_held_prop.z_index = _rig.z_index + int(_held_anchor.get("z_index_offset", 0))
|
|
if delta > 0.0:
|
|
var current := _held_prop.global_transform
|
|
_sampled_linear_velocity = (current.origin - _last_transform.origin) / delta
|
|
_sampled_angular_velocity = wrapf(current.get_rotation() - _last_transform.get_rotation(), -PI, PI) / delta
|
|
_last_transform = _held_prop.global_transform
|
|
|
|
|
|
func _update_throw(delta: float) -> void:
|
|
_throw_elapsed += delta
|
|
var marker := _hand_marker()
|
|
var release_time := THROW_LIFT_DURATION + THROW_SWING_DURATION
|
|
if not _throw_released:
|
|
if _held_prop == null or not is_instance_valid(_held_prop):
|
|
_phase = Phase.IDLE
|
|
_active_action.clear()
|
|
action_completed.emit()
|
|
return
|
|
if marker != null:
|
|
if _throw_elapsed < THROW_LIFT_DURATION:
|
|
var lift_weight := smoothstep(0.0, 1.0, clampf(_throw_elapsed / THROW_LIFT_DURATION, 0.0, 1.0))
|
|
marker.position = _quadratic_bezier(_throw_base_marker_local, _throw_windup_marker_local, _throw_overhead_marker_local, lift_weight)
|
|
_update_throw_torso(lift_weight)
|
|
else:
|
|
var swing_weight := smoothstep(0.0, 1.0, clampf((_throw_elapsed - THROW_LIFT_DURATION) / THROW_SWING_DURATION, 0.0, 1.0))
|
|
marker.position = _quadratic_bezier(_throw_overhead_marker_local, _throw_swing_control_marker_local, _throw_release_marker_local, swing_weight)
|
|
_update_throw_torso(1.0 - swing_weight * 0.65)
|
|
_update_held_transform(delta, true)
|
|
if not _throw_released and _throw_elapsed >= release_time:
|
|
if marker != null:
|
|
marker.position = _throw_release_marker_local
|
|
_update_throw_torso(0.35)
|
|
if _held_prop != null and is_instance_valid(_held_prop):
|
|
_held_prop.global_transform = _rig_transform_for_facing(_throw_facing_left) * _throw_release_attachment_local
|
|
var target := _throw_effective_target
|
|
var spin_sign := -1.0 if _throw_facing_left else 1.0
|
|
var solution := _solve_throw(_held_prop.global_transform, target, _held_prop, spin_sign * THROW_SPIN_SPEED)
|
|
if solution.is_empty():
|
|
if marker != null:
|
|
marker.position = _throw_base_marker_local
|
|
_restore_throw_torso()
|
|
_phase = Phase.HELD
|
|
_active_action.clear()
|
|
action_completed.emit()
|
|
return
|
|
_release_held("throw", true, solution["velocity"], spin_sign * THROW_SPIN_SPEED)
|
|
_throw_released = true
|
|
if _throw_released and marker != null:
|
|
var follow_weight := smoothstep(0.0, 1.0, clampf((_throw_elapsed - release_time) / THROW_FOLLOW_THROUGH, 0.0, 1.0))
|
|
marker.position = _quadratic_bezier(_throw_release_marker_local, _throw_follow_control_marker_local, _throw_follow_marker_local, follow_weight)
|
|
_update_throw_torso(0.35 * (1.0 - follow_weight))
|
|
if _throw_released and _throw_elapsed >= release_time + THROW_FOLLOW_THROUGH:
|
|
_phase = Phase.IDLE
|
|
_throw_released = false
|
|
_active_action.clear()
|
|
_restore_hand_target()
|
|
_restore_throw_torso()
|
|
action_completed.emit()
|
|
|
|
|
|
func _update_throw_torso(weight: float) -> void:
|
|
var torso_marker := _torso_marker()
|
|
if torso_marker == null:
|
|
return
|
|
torso_marker.position = _throw_torso_start.lerp(_throw_torso_windup, weight)
|
|
torso_marker.rotation = lerpf(_throw_torso_start_rotation, _throw_torso_windup_rotation, weight)
|
|
|
|
|
|
func _restore_throw_torso() -> void:
|
|
var torso_marker := _torso_marker()
|
|
if torso_marker != null:
|
|
torso_marker.position = _throw_torso_start
|
|
torso_marker.rotation = _throw_torso_start_rotation
|
|
|
|
|
|
func _solve_throw(release_transform: Transform2D, target: Vector2, prop: PropBlock, spin_speed: float) -> Dictionary:
|
|
var start := release_transform.origin
|
|
var delta_position := target - start
|
|
if not start.is_finite() or not target.is_finite() or not delta_position.is_finite():
|
|
return {}
|
|
if delta_position.is_zero_approx():
|
|
return {}
|
|
var gravity_direction: Vector2 = ProjectSettings.get_setting("physics/2d/default_gravity_vector", Vector2.DOWN)
|
|
var gravity_magnitude := float(ProjectSettings.get_setting("physics/2d/default_gravity", 980.0)) * prop.gravity_scale
|
|
if not gravity_direction.is_finite() or not is_finite(gravity_magnitude) or not is_finite(spin_speed):
|
|
return {}
|
|
var gravity := gravity_direction.normalized() * gravity_magnitude
|
|
if not gravity.is_finite():
|
|
return {}
|
|
var flight_time := _shortest_valid_throw_time(delta_position, gravity)
|
|
if flight_time <= 0.0:
|
|
return {}
|
|
var velocity := (delta_position - 0.5 * gravity * flight_time * flight_time) / flight_time
|
|
if not velocity.is_finite() or velocity.length() > MAX_THROW_SPEED + 0.01:
|
|
return {}
|
|
return _make_throw_solution(start, target, velocity, gravity, release_transform.get_rotation(), spin_speed, flight_time)
|
|
|
|
|
|
func _shortest_valid_throw_time(displacement: Vector2, gravity: Vector2) -> float:
|
|
var gravity_squared := gravity.length_squared()
|
|
var lower_time := MIN_THROW_FLIGHT_TIME
|
|
var upper_time := THROW_PREVIEW_HORIZON
|
|
if gravity_squared > 0.000001:
|
|
var a := 0.25 * gravity_squared
|
|
var b := -(displacement.dot(gravity) + MAX_THROW_SPEED * MAX_THROW_SPEED)
|
|
var c := displacement.length_squared()
|
|
var discriminant := b * b - 4.0 * a * c
|
|
if discriminant < 0.0:
|
|
return 0.0
|
|
var root := sqrt(maxf(discriminant, 0.0))
|
|
var lower_time_squared := (-b - root) / (2.0 * a)
|
|
var upper_time_squared := (-b + root) / (2.0 * a)
|
|
if upper_time_squared <= 0.0:
|
|
return 0.0
|
|
lower_time = maxf(lower_time, sqrt(maxf(lower_time_squared, 0.0)))
|
|
upper_time = minf(upper_time, sqrt(upper_time_squared))
|
|
var down_direction := gravity / sqrt(gravity_squared)
|
|
var down_displacement := displacement.dot(down_direction)
|
|
if down_displacement < 0.0:
|
|
var descending_time := sqrt(-2.0 * down_displacement / sqrt(gravity_squared)) + THROW_DESCENT_EPSILON
|
|
lower_time = maxf(lower_time, descending_time)
|
|
else:
|
|
lower_time = maxf(lower_time, displacement.length() / MAX_THROW_SPEED)
|
|
if lower_time > upper_time or lower_time > THROW_PREVIEW_HORIZON:
|
|
return 0.0
|
|
return lower_time
|
|
|
|
|
|
func _make_throw_solution(start: Vector2, target: Vector2, velocity: Vector2, gravity: Vector2, release_rotation: float, spin_speed: float, flight_time: float) -> Dictionary:
|
|
var points := PackedVector2Array()
|
|
for index: int in THROW_TRAJECTORY_SEGMENTS + 1:
|
|
var t := flight_time * float(index) / float(THROW_TRAJECTORY_SEGMENTS)
|
|
points.append(start + velocity * t + gravity * (0.5 * t * t))
|
|
return {
|
|
"velocity": velocity,
|
|
"landing_position": target,
|
|
"start_position": start,
|
|
"effective_target": target,
|
|
"release_rotation": release_rotation,
|
|
"spin_speed": spin_speed,
|
|
"flight_time": flight_time,
|
|
"trajectory_points": points,
|
|
}
|
|
|
|
|
|
func _predicted_attachment_transform(wrist_position: Vector2, facing_left: bool, prop_override: PropBlock = null, anchor_override: Dictionary = {}, hand_override: int = -1, root_offset: Vector2 = Vector2.ZERO) -> Transform2D:
|
|
var prop := _held_prop if prop_override == null else prop_override
|
|
var anchor := _held_anchor if anchor_override.is_empty() else anchor_override
|
|
var hand_value := int(_hand) if hand_override < 0 else hand_override
|
|
if _rig == null or prop == null or not is_instance_valid(prop):
|
|
return Transform2D(0.0, wrist_position)
|
|
var suffix := "Left" if hand_value == Hand.LEFT else "Right"
|
|
var lower_visual := _rig.get_node_or_null(NodePath("Body/%sLowerArm" % suffix)) as Node2D
|
|
var elbow_world := _solved_wrist_transform_for(hand_value).origin
|
|
if lower_visual != null:
|
|
elbow_world = lower_visual.global_position
|
|
var rig_transform := _rig_transform_for_facing(facing_left, root_offset)
|
|
var elbow_position := rig_transform * _rig.to_local(elbow_world)
|
|
var arm_direction := wrist_position - elbow_position
|
|
var arm_angle := arm_direction.angle() if not arm_direction.is_zero_approx() else _solved_wrist_transform_for(hand_value).get_rotation()
|
|
var wrist_transform := Transform2D(arm_angle, wrist_position)
|
|
return ANCHOR_DATA.solve_attachment_transform(wrist_transform, _scaled_anchor(anchor, prop), Vector2.ONE, facing_left)
|
|
|
|
|
|
func _clip_preview_to_collision(solution: Dictionary, prop: PropBlock) -> Dictionary:
|
|
if prop == null or not is_instance_valid(prop):
|
|
return solution
|
|
var collision_shape: Shape2D
|
|
var collision_local_transform := Transform2D.IDENTITY
|
|
var polygon_node := prop.get_node_or_null(NodePath("CollisionPolygon2D")) as CollisionPolygon2D
|
|
if polygon_node != null and polygon_node.polygon.size() >= 3:
|
|
var convex_points := Geometry2D.convex_hull(polygon_node.polygon)
|
|
if convex_points.size() >= 3:
|
|
var convex_shape := ConvexPolygonShape2D.new()
|
|
convex_shape.points = convex_points
|
|
collision_shape = convex_shape
|
|
collision_local_transform = prop.global_transform.affine_inverse() * polygon_node.global_transform
|
|
if polygon_node.disabled:
|
|
collision_shape = null
|
|
var circle_node := prop.get_node_or_null(NodePath("CollisionShape2D")) as CollisionShape2D
|
|
if collision_shape == null and circle_node != null and circle_node.shape != null and not circle_node.disabled:
|
|
collision_shape = circle_node.shape
|
|
collision_local_transform = prop.global_transform.affine_inverse() * circle_node.global_transform
|
|
if collision_shape == null:
|
|
return solution
|
|
var collision_mask := int(_saved_body_state.get("collision_mask", prop.collision_mask))
|
|
if collision_mask == 0:
|
|
return solution
|
|
var points: PackedVector2Array = solution.get("trajectory_points", PackedVector2Array())
|
|
if points.size() < 2:
|
|
return solution
|
|
var space_state := prop.get_world_2d().direct_space_state
|
|
if space_state == null:
|
|
return solution
|
|
var excluded: Array[RID] = [prop.get_rid()]
|
|
if _rig != null and _rig.has_method("get_collision_body_rids"):
|
|
for body_rid: RID in _rig.call("get_collision_body_rids"):
|
|
if body_rid.is_valid():
|
|
excluded.append(body_rid)
|
|
var clipped_points := PackedVector2Array([points[0]])
|
|
var impact_position := points[-1]
|
|
var impact_time := float(solution.get("flight_time", THROW_PREVIEW_HORIZON))
|
|
var collision_position := Vector2.INF
|
|
var collision_before_target := false
|
|
var segment_count := points.size() - 1
|
|
var horizon := float(solution.get("flight_time", THROW_PREVIEW_HORIZON))
|
|
var start_rotation := float(solution.get("release_rotation", 0.0))
|
|
for index: int in segment_count:
|
|
var from_position := points[index]
|
|
var to_position := points[index + 1]
|
|
var t0 := horizon * float(index) / float(segment_count)
|
|
var dt := horizon / float(segment_count)
|
|
var query := PhysicsShapeQueryParameters2D.new()
|
|
query.shape = collision_shape
|
|
query.transform = Transform2D(start_rotation + float(solution.get("spin_speed", THROW_SPIN_SPEED)) * t0, from_position) * collision_local_transform
|
|
query.motion = to_position - from_position
|
|
query.collision_mask = collision_mask
|
|
query.exclude = excluded
|
|
var cast := space_state.cast_motion(query)
|
|
if cast.size() >= 2 and cast[0] < 0.9999:
|
|
var safe_fraction := clampf(cast[0], 0.0, 1.0)
|
|
impact_position = from_position.lerp(to_position, safe_fraction)
|
|
impact_time = t0 + dt * safe_fraction
|
|
collision_position = impact_position
|
|
collision_before_target = true
|
|
clipped_points.append(impact_position)
|
|
break
|
|
clipped_points.append(to_position)
|
|
var clipped := solution.duplicate(true)
|
|
clipped["landing_position"] = impact_position
|
|
clipped["flight_time"] = impact_time
|
|
clipped["trajectory_points"] = clipped_points
|
|
clipped["collision_position"] = collision_position
|
|
clipped["collision_before_target"] = collision_before_target
|
|
return clipped
|
|
|
|
|
|
func _quadratic_bezier(from: Vector2, control: Vector2, to: Vector2, weight: float) -> Vector2:
|
|
var t := clampf(weight, 0.0, 1.0)
|
|
var inverse := 1.0 - t
|
|
return from * inverse * inverse + control * (2.0 * inverse * t) + to * t * t
|
|
|
|
|
|
func _release_held(reason: String, throwing: bool, throw_velocity: Vector2 = Vector2.ZERO, throw_spin: float = 0.0) -> void:
|
|
if _held_prop == null or not is_instance_valid(_held_prop):
|
|
_clear_held_state()
|
|
return
|
|
var prop := _held_prop
|
|
var release_velocity := throw_velocity if throwing else _sampled_linear_velocity
|
|
var release_angular := _sampled_angular_velocity
|
|
if not release_velocity.is_finite():
|
|
release_velocity = Vector2.ZERO
|
|
if not is_finite(release_angular):
|
|
release_angular = 0.0
|
|
prop.interaction_owner_id = 0
|
|
prop.interaction_reserved_by = 0
|
|
prop.collision_layer = int(_saved_body_state.get("collision_layer", 1))
|
|
prop.collision_mask = int(_saved_body_state.get("collision_mask", 1))
|
|
prop.z_index = int(_saved_body_state.get("z_index", prop.z_index))
|
|
prop.z_as_relative = bool(_saved_body_state.get("z_as_relative", prop.z_as_relative))
|
|
prop.freeze_mode = int(_saved_body_state.get("freeze_mode", RigidBody2D.FREEZE_MODE_KINEMATIC))
|
|
prop.freeze = false if throwing else bool(_saved_body_state.get("freeze", false))
|
|
if throwing:
|
|
prop.sleeping = false
|
|
prop.linear_velocity = release_velocity
|
|
prop.angular_velocity = throw_spin
|
|
elif not prop.freeze:
|
|
prop.sleeping = false
|
|
prop.linear_velocity = release_velocity
|
|
prop.angular_velocity = release_angular
|
|
_held_prop = null
|
|
_held_anchor.clear()
|
|
_saved_body_state.clear()
|
|
_sampled_linear_velocity = Vector2.ZERO
|
|
_sampled_angular_velocity = 0.0
|
|
if not throwing:
|
|
_restore_hand_target()
|
|
_phase = Phase.IDLE if not throwing else Phase.THROWING
|
|
if reason == "manual" or reason == "ragdoll":
|
|
prop_event.emit("prop_dropped", prop, reason)
|
|
elif reason == "throw":
|
|
prop_event.emit("prop_thrown", prop, "")
|
|
|
|
|
|
func _clear_reservation() -> void:
|
|
if _held_prop != null and is_instance_valid(_held_prop):
|
|
if _held_prop.interaction_reserved_by == _rig.get_instance_id():
|
|
_held_prop.interaction_reserved_by = 0
|
|
_held_prop = null
|
|
_held_anchor.clear()
|
|
_active_action.clear()
|
|
|
|
|
|
func _clear_held_state() -> void:
|
|
_restore_pickup_torso()
|
|
_held_prop = null
|
|
_held_anchor.clear()
|
|
_saved_body_state.clear()
|
|
_phase = Phase.IDLE
|
|
_active_action.clear()
|
|
|
|
|
|
func _restore_hand_target() -> void:
|
|
if _rig == null:
|
|
return
|
|
var marker := _hand_marker()
|
|
if marker != null:
|
|
marker.position = _marker_start_position
|
|
|
|
|
|
func _hand_marker() -> Marker2D:
|
|
return _hand_marker_for(_hand)
|
|
|
|
|
|
func _torso_marker() -> Marker2D:
|
|
return _rig.get_node_or_null(NodePath("IK_Targets/Torso")) as Marker2D if _rig != null else null
|
|
|
|
|
|
func _hand_marker_for(hand: int) -> Marker2D:
|
|
if _rig == null:
|
|
return null
|
|
var path := "IK_Targets/Left_Hand" if hand == Hand.LEFT else "IK_Targets/Right_Hand"
|
|
return _rig.get_node_or_null(NodePath(path)) as Marker2D
|
|
|
|
|
|
func _solved_wrist_transform() -> Transform2D:
|
|
return _solved_wrist_transform_for(_hand)
|
|
|
|
|
|
func _solved_wrist_transform_for(hand: Hand) -> Transform2D:
|
|
var suffix := "Left" if hand == Hand.LEFT else "Right"
|
|
var lower_visual := _rig.get_node_or_null(NodePath("Body/%sLowerArm" % suffix)) as Node2D
|
|
var lower_bone := _rig.get_node_or_null(NodePath("Skeleton2D/Torso/%sUpperArm/%sLowerArm" % [suffix, suffix])) as Bone2D
|
|
if lower_visual == null or lower_bone == null:
|
|
var marker := _hand_marker_for(hand)
|
|
return Transform2D(0.0, marker.global_position if marker != null else _rig.global_position)
|
|
var elbow := lower_visual.to_global(Vector2.ZERO)
|
|
var wrist := lower_visual.to_global(Vector2(0.0, lower_bone.length))
|
|
var direction := (wrist - elbow).normalized()
|
|
return Transform2D(direction.angle(), wrist)
|
|
|
|
|
|
func _scaled_anchor(anchor: Dictionary, prop: PropBlock) -> Dictionary:
|
|
var result := anchor.duplicate(true)
|
|
result["position"] = (anchor.get("position", Vector2.ZERO) as Vector2) * prop.get_interaction_scale()
|
|
return result
|
|
|
|
|
|
func _grip_world_position(prop: PropBlock, anchor: Dictionary) -> Vector2:
|
|
return _grip_world_position_for_facing(prop, anchor, _is_facing_left())
|
|
|
|
|
|
func _grip_world_position_for_facing(prop: PropBlock, anchor: Dictionary, facing_left: bool) -> Vector2:
|
|
var scaled := _scaled_anchor(anchor, prop)
|
|
var local_position: Vector2 = scaled.get("position", Vector2.ZERO)
|
|
if facing_left:
|
|
local_position.x = -local_position.x
|
|
return prop.global_transform * local_position
|
|
|
|
|
|
func _is_facing_left() -> bool:
|
|
return _rig != null and int(_rig.call("get_facing_profile")) == 0
|