140 lines
5.1 KiB
GDScript
140 lines
5.1 KiB
GDScript
extends Node3D
|
|
class_name ServerNode
|
|
|
|
var jumping := false
|
|
var player_node: PlayerNode
|
|
|
|
# TODO: Shoould not be defined here
|
|
const DEFAULT_WEAPON := "ak"
|
|
var first_slot_weapon: WeaponController
|
|
|
|
@export var input_direction: Vector2
|
|
@export var owner_id: int = 0
|
|
|
|
@onready var camera_mount: Node3D = $SharedNode/CameraMount
|
|
@onready var shared_node: CharacterBody3D = $SharedNode
|
|
@onready var bullet_starting_point: Node3D = $SharedNode/CameraMount/BulletStartingPoint
|
|
@onready var map_controller: MapController
|
|
|
|
|
|
func _ready() -> void:
|
|
shared_node.set_collision_layer_value(3, true)
|
|
shared_node.set_collision_mask_value(1, true)
|
|
shared_node.set_collision_mask_value(3, true)
|
|
map_controller = find_parent("Map")
|
|
_load_weapon()
|
|
# Load the default weapon and set the current attack properties
|
|
|
|
func _load_weapon() -> void:
|
|
var path_tmpl := "res://scenes/weapon/guns/%s/with_hands.tscn"
|
|
var path := path_tmpl % DEFAULT_WEAPON
|
|
var scene: PackedScene = ResourceLoader.load(path)
|
|
var node: WeaponController = scene.instantiate()
|
|
first_slot_weapon = node
|
|
first_slot_weapon.make_invisible()
|
|
first_slot_weapon.set_map_controller(map_controller)
|
|
add_child(first_slot_weapon)
|
|
|
|
func bind_player_node() -> void:
|
|
if multiplayer.get_unique_id() == owner_id:
|
|
player_node = get_tree().get_root().find_child("PlayerController", true, false)
|
|
|
|
func _physics_process(delta: float) -> void:
|
|
if not shared_node.is_on_floor():
|
|
shared_node.velocity += shared_node.get_gravity() * delta
|
|
if shared_node.is_on_floor() && jumping:
|
|
shared_node.velocity.y = consts.DEFAULT_JUMP_VELOCITY
|
|
#if shooting:
|
|
jumping = false
|
|
var direction := (shared_node.transform.basis * Vector3(input_direction.x, 0, input_direction.y)).normalized()
|
|
if shared_node.is_on_floor():
|
|
if direction:
|
|
$SharedNode/Character/Model/AnimationPlayer.play("riffle_run")
|
|
#first_view_legs_anim.play("Run Forward")
|
|
shared_node.velocity.x = direction.x * consts.DEFAULT_CHARACTER_SPEED
|
|
shared_node.velocity.z = direction.z * consts.DEFAULT_CHARACTER_SPEED
|
|
else:
|
|
$SharedNode/Character/Model/AnimationPlayer.play("riffle_idle")
|
|
shared_node.velocity.x = move_toward(shared_node.velocity.x, 0, consts.DEFAULT_CHARACTER_SPEED)
|
|
shared_node.velocity.z = move_toward(shared_node.velocity.z, 0, consts.DEFAULT_CHARACTER_SPEED)
|
|
shared_node.move_and_slide()
|
|
|
|
@rpc("any_peer", "call_local", "unreliable")
|
|
func jump():
|
|
jumping = true
|
|
|
|
@rpc("any_peer", "call_local", "unreliable")
|
|
func sync_velocity(x: float, y: float, z: float) -> void:
|
|
if not multiplayer.is_server():
|
|
shared_node.velocity = Vector3(x, y ,z)
|
|
|
|
|
|
@rpc("any_peer", "call_local", "unreliable")
|
|
func set_input_direction(new_input_direction: Vector2):
|
|
input_direction = new_input_direction
|
|
|
|
@rpc("any_peer", "call_local", "unreliable")
|
|
func set_rotation_x(x: float):
|
|
camera_mount.rotation.x = x
|
|
|
|
@rpc("any_peer", "call_local", "unreliable")
|
|
func set_rotation_y(y: float):
|
|
shared_node.rotation.y = y
|
|
|
|
func _on_reconciliation_timer_timeout() -> void:
|
|
if multiplayer.is_server():
|
|
_veryfy_position_and_rotation.rpc_id(owner_id)
|
|
$ReconciliationTimer.start()
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func _veryfy_position_and_rotation() -> void:
|
|
player_node.verify_position()
|
|
player_node.verify_rotation()
|
|
|
|
#@rpc("authority", "call_remote", "unreliable")
|
|
#func _sync_transorm():
|
|
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func _adjust_position(x: float, y: float, z: float) -> void:
|
|
player_node.adjust_position(x, y, z)
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func _adjust_rotation(x: float, y: float, z: float) -> void:
|
|
player_node.adjust_rotation(x, y, z)
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func send_position(desired_position: Vector3):
|
|
if multiplayer.is_server():
|
|
var real_position: Vector3 = shared_node.global_position
|
|
var difference: Vector3 = desired_position - real_position
|
|
if is_vector_a_lower_than_b(difference, Vector3(0.2, 0.2, 0.2)):
|
|
shared_node.global_position = desired_position
|
|
elif is_vector_a_lower_than_b(difference, Vector3(0.4, 0.4, 0.4)):
|
|
var new_position: Vector3 = desired_position.lerp(real_position, 0.5)
|
|
push_warning("player position is not valid, lerping")
|
|
_adjust_position.rpc_id(owner_id, new_position.x, new_position.y, new_position.z)
|
|
else:
|
|
push_warning("player position is not valid, adjusting")
|
|
_adjust_position.rpc_id(owner_id, real_position.x, real_position.y, real_position.z)
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func send_rotation(x: float, y: float, z: float):
|
|
if multiplayer.is_server():
|
|
var desired_rotation: Vector3 = Vector3(x, y, z)
|
|
if multiplayer.is_server():
|
|
var real_rotation: Vector3 = shared_node.rotation
|
|
var difference: Vector3 = desired_rotation - real_rotation
|
|
if is_vector_a_lower_than_b(difference, Vector3(0.3, 0.3, 0.3)):
|
|
shared_node.rotation = desired_rotation
|
|
else:
|
|
var new_rotation: Vector3 = desired_rotation.lerp(real_rotation, 0.5)
|
|
_adjust_rotation.rpc_id(owner_id, new_rotation.x, new_rotation.y, new_rotation.z)
|
|
|
|
@rpc("any_peer", "call_local", "unreliable_ordered")
|
|
func shoot():
|
|
first_slot_weapon.attack(bullet_starting_point)
|
|
|
|
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
|