Huge amount of updates

scenes_old/characters/character_wrapper.gd

@@ -0,0 +1,82 @@
+extends Marker3D
+class_name CharacterWrapper
+
+@export var die_script: GDScript = null
+@export var owner_placeholder: CharacterBody3D = null
+
+@export var server_node: Node3D  # The real synced node from the server
+@export var interpolation_delay: float = 0.1  # Stay 100ms behind for smooth interpolation
+@export var snap_threshold: float = 2.0  # If desync is larger than this, snap instantly
+
+var position_buffer = []  # Stores past positions (tuples of (timestamp, position, rotation))
+var previous_position: Vector3 = Vector3.ZERO
+var previous_rotation: Quaternion = Quaternion.IDENTITY
+var pseudo_velocity: Vector3 = Vector3.ZERO  # Approximate velocity without CharacterBody3D
+
+func _physics_process(delta: float) -> void:
+	var server_pos = owner_placeholder.global_transform.origin
+	var server_rot = owner_placeholder.global_transform.basis.get_rotation_quaternion()
+
+	# Calculate pseudo velocity (difference per second)
+	pseudo_velocity = (server_pos - previous_position) / delta
+	previous_position = server_pos  # Store for next frame
+	previous_rotation = server_rot  # Store rotation for next frame
+
+	# Store position & rotation in buffer
+	position_buffer.append([Time.get_ticks_msec() / 1000.0, server_pos, server_rot])
+
+	# Remove old positions to keep buffer clean
+	while position_buffer.size() > 2 and position_buffer[1][0] < (Time.get_ticks_msec() / 1000.0) - interpolation_delay:
+		position_buffer.pop_front()
+
+	# Get current client position
+	var client_pos = global_transform.origin
+
+	# Check if the client is too far from the server
+	if client_pos.distance_to(server_pos) > snap_threshold:
+		global_transform.origin = server_pos  # Instantly move to the correct position
+		global_transform.basis = Basis(server_rot)  # Instantly rotate to the correct orientation
+		position_buffer.clear()  # Reset buffer to prevent interpolation from old positions
+		return  # Skip interpolation this frame to avoid weird blending
+
+	# If we have at least 2 points, interpolate between them
+	if position_buffer.size() >= 2:
+		var t_now = (Time.get_ticks_msec() / 1000.0) - interpolation_delay
+		var prev_point = position_buffer[0]
+		var next_point = position_buffer[1]
+
+		var alpha = (t_now - prev_point[0]) / (next_point[0] - prev_point[0])
+		alpha = clamp(alpha, 0.0, 1.0)
+
+		# Interpolate position
+		global_transform.origin = prev_point[1].lerp(next_point[1], alpha)
+
+		# Interpolate rotation using slerp
+		var interpolated_rot = prev_point[2].slerp(next_point[2], alpha)
+		global_transform.basis = Basis(interpolated_rot)		
+
+func _ready() -> void:
+	set_multiplayer_authority(multiplayer.get_unique_id())
+	global_position = owner_placeholder.global_position
+	
+# Set the owner placeholder, so the characters can send the requests to a node
+# it depends on
+func set_owner_placeholder(owner_placeholder: Node3D):
+	owner_placeholder = owner_placeholder
+	
+func die():
+	push_warning("TODO: Implement ragdoll kind of dying and respawn character as an object")
+	queue_free()
+
+
+func _on_area_body_part_hit(damage: int) -> void:
+	# The owner node should be aware of how to take damage, so we need to
+	# pass the value.
+	if owner_placeholder:
+		if owner_placeholder.has_method("take_damage"):
+			owner_placeholder.take_damage(damage)
+		else:
+			push_warning("Node doesn't know how to take the damage")
+
+func is_vector_a_lower_than_b(vec_a: Vector3, vec_b: Vector3) -> bool:
+	return vec_a.x < vec_b.x and vec_a.y < vec_b.y and vec_a.z < vec_b.z

scenes_old/characters/hit_detected.gd

@@ -0,0 +1,13 @@
+extends Area3D
+
+@export var damage_multiplexer: float = 1.0
+@export var body_part: String = ""
+
+signal body_part_hit(damage: int)
+
+func _ready() -> void:
+	add_to_group("target")
+
+func hit(base_damage: int):
+	var final_damage = round(base_damage * damage_multiplexer)
+	body_part_hit.emit(final_damage)