91 lines
3.4 KiB
GDScript
91 lines
3.4 KiB
GDScript
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
|