Merge branch 'multiplayer-rework'

scripts/multiplayer/lobby.gd

@@ -78,6 +78,20 @@ func set_teams(attack: Array[int],defence: Array[int],spectators: Array[int]):
 func switch_team(team: int) -> void:
 	team_switch_notification.rpc(multiplayer.get_unique_id(),team)
 
+func swap_teams() -> void:
+	if not multiplayer.is_server():
+		return
+	
+	var temp_defenders = defence_team.duplicate()
+	
+	for attacker in attack_team:
+		server_team_switch.rpc(attacker,Session.TEAMS.DEFENCE)
+	
+	for defender in temp_defenders:
+		server_team_switch.rpc(defender,Session.TEAMS.ATTACK)
+	
+	update_peers.rpc()
+
 @rpc("any_peer","call_local","reliable")
 func team_switch_notification(id: int, team: int) -> void:
 	if (team == Session.TEAMS.DEFENCE and len(defence_team) > 4) or (team == Session.TEAMS.ATTACK and len(attack_team) > 4):
@@ -105,6 +119,32 @@ func team_switch_notification(id: int, team: int) -> void:
 		
 	update_teams_state.emit()
 
+@rpc("authority","call_local","reliable")
+func server_team_switch(id: int, team: int) -> void:
+	if multiplayer.get_remote_sender_id() != 1 and not multiplayer.is_server():
+		return
+	
+	if team == Session.TEAMS.DEFENCE:
+		if attack_team.has(id):
+			attack_team.erase(id)
+		if specators_team.has(id):
+			specators_team.erase(id)
+		defence_team.append(id)
+	
+	if team == Session.TEAMS.ATTACK:
+		if defence_team.has(id):
+			defence_team.erase(id)
+		if specators_team.has(id):
+			specators_team.erase(id)
+		attack_team.append(id)
+	
+	if team == Session.TEAMS.SPECTATE:
+		if attack_team.has(id):
+			attack_team.erase(id)
+		elif defence_team.has(id):
+			defence_team.erase(id)
+		specators_team.append(id)
+
 @rpc("authority","call_local","reliable")
 func start_game() -> void:
 	get_tree().change_scene_to_file("res://levels/prototype_scene.tscn")
@@ -121,3 +161,7 @@ func get_team() -> Session.TEAMS:
 	if specators_team.has(id):
 		return Session.TEAMS.SPECTATE
 	return Session.TEAMS.UNASSIGNED
+
+@rpc("authority","call_local","reliable")
+func update_peers():
+	update_teams_state.emit()

scripts/multiplayer/own_visibility_toggle.gd

@@ -1,9 +1,12 @@
 extends Node
 
+class_name PlayerBasedVisibility
+
 @export var visible_for_others: bool = false
+@export var reference_player: Player
 
 func _ready() -> void:
-	get_parent().visible = (get_multiplayer_authority() != multiplayer.get_unique_id()) == visible_for_others
+	get_parent().visible = (reference_player.player_id != multiplayer.get_unique_id()) == visible_for_others
 
 func reverse() -> void:
 	get_parent().visible = not get_parent().visible

scripts/multiplayer/player_input.gd

@@ -0,0 +1,182 @@
+extends MultiplayerSynchronizer
+
+class_name PlayerInput
+
+const SCOPE: int = 0b1
+const CROUCH: int = 0b10
+const WALK: int = 0b100
+
+#region SYNC
+@export var direction: Vector2
+@export var compressed_states: int
+#endregion
+
+signal jumped
+signal drop
+signal switch_weapon(to_slot: StringName)
+signal fire_begin
+signal fire_end
+signal alternate_state
+signal switch_firemode
+signal reload
+signal scope_begin
+signal scope_end
+signal crouch_begin
+signal crouch_end
+signal walk_begin
+signal walk_end
+signal interact_begin
+signal interact_end
+
+func _process(_delta: float) -> void:
+	if not is_multiplayer_authority(): return
+	direction = Input.get_vector("plr_strafe_r","plr_strafe_l", "plr_back","plr_forward")
+
+func _input(event: InputEvent) -> void:
+	if not is_multiplayer_authority(): return
+	if event.is_action_pressed("plr_ult"):
+		switch_on_server.rpc_id(1,"ultimate")
+	elif event.is_action_pressed("plr_bomb"):
+		switch_on_server.rpc_id(1,"bomb")
+	elif event.is_action_pressed("plr_primary"):
+		switch_on_server.rpc_id(1,"primary")
+	elif event.is_action_pressed("plr_active_first"):
+		switch_on_server.rpc_id(1,"ability_first")
+	elif event.is_action_pressed("plr_active_second"):
+		switch_on_server.rpc_id(1,"ability_second")
+	elif event.is_action_pressed("plr_active_third"):
+		switch_on_server.rpc_id(1,"ability_third")
+	elif event.is_action_pressed("plr_secondary"):
+		switch_on_server.rpc_id(1,"secondary")
+	elif event.is_action_pressed("plr_knife"):
+		switch_on_server.rpc_id(1,"knife")
+	
+	if event.is_action_pressed("plr_fire"):
+		fire_on_server.rpc_id(1,false)
+	if event.is_action_released("plr_fire"):
+		fire_on_server.rpc_id(1,true)
+	if event.is_action_pressed("plr_scope"):
+		alternate_state_on_server.rpc_id(1)
+	if event.is_action_pressed("plr_firemode"):
+		switch_firemode_on_server.rpc_id(1)
+		
+	if event.is_action_pressed("plr_drop"):
+		drop_on_server.rpc_id(1)
+	
+	var crouching: bool = compressed_states & CROUCH
+	var walking: bool = compressed_states & WALK
+	var scoping: bool = compressed_states & SCOPE
+	
+	if event.is_action_pressed("plr_crouch"):
+		if ClientSettings.TOGGLE_CROUCH:
+			crouch_on_server.rpc_id(1,crouching)
+			compressed_states ^= CROUCH
+		elif not crouching:
+			compressed_states |= CROUCH
+			crouch_on_server.rpc_id(1,false)
+	if event.is_action_released("plr_crouch") and not ClientSettings.TOGGLE_CROUCH and crouching:
+		compressed_states &= ~CROUCH
+		crouch_on_server.rpc_id(1,true)
+		
+	if event.is_action_pressed("plr_walk"):
+		if ClientSettings.TOGGLE_WALK:
+			walk_on_server.rpc_id(1,walking)
+			compressed_states ^= WALK
+		elif not walking:
+			compressed_states |= WALK
+			walk_on_server.rpc_id(1,false)
+	if event.is_action_released("plr_walk") and not ClientSettings.TOGGLE_WALK and walking:
+		compressed_states &= ~WALK
+		walk_on_server.rpc_id(1,true)
+	
+	if event.is_action_pressed("plr_scope"):
+		if ClientSettings.TOGGLE_SCOPE:
+			scope_on_server.rpc_id(1,scoping)
+			compressed_states ^= SCOPE
+		elif not scoping:
+			compressed_states |= SCOPE
+			scope_on_server.rpc_id(1,false)
+	if event.is_action_released("plr_scope") and not ClientSettings.TOGGLE_SCOPE and scoping:
+		compressed_states &= ~SCOPE
+		scope_on_server.rpc_id(1,true)
+	
+	if event.is_action_pressed("plr_reload"):
+		reload_on_server.rpc_id(1)
+	
+	if event.is_action_pressed("plr_interact"):
+		interact_on_server.rpc_id(1,false)
+	if event.is_action_released("plr_interact"):
+		interact_on_server.rpc_id(1,true)
+	
+	if event.is_action_pressed("plr_jump"):
+		jump_on_server.rpc_id(1)
+
+@rpc("authority","call_local","reliable")
+func switch_on_server(slot: StringName) -> void:
+	if not multiplayer.is_server(): return
+	switch_weapon.emit(slot)
+
+@rpc("authority","call_local","reliable")
+func drop_on_server() -> void:
+	if not multiplayer.is_server(): return
+	drop.emit()
+
+@rpc("authority","call_local","reliable")
+func fire_on_server(end: bool) -> void:
+	if not multiplayer.is_server(): return
+	if end:
+		fire_end.emit()
+	else:
+		fire_begin.emit()
+
+@rpc("authority","call_local","reliable")
+func alternate_state_on_server() -> void:
+	if not multiplayer.is_server(): return
+	alternate_state.emit()
+
+@rpc("authority","call_local","reliable")
+func switch_firemode_on_server() -> void:
+	if not multiplayer.is_server(): return
+	switch_firemode.emit()
+
+@rpc("authority","call_local","reliable")
+func crouch_on_server(end: bool) -> void:
+	if not multiplayer.is_server(): return
+	if end:
+		crouch_end.emit()
+	else:
+		crouch_begin.emit()
+
+@rpc("authority","call_local","reliable")
+func walk_on_server(end: bool) -> void:
+	if not multiplayer.is_server(): return
+	if end:
+		walk_end.emit()
+	else:
+		walk_begin.emit()
+
+@rpc("authority","call_local","reliable")
+func scope_on_server(end: bool) -> void:
+	if not multiplayer.is_server(): return
+	if end:
+		scope_end.emit()
+	else:
+		scope_begin.emit()
+
+@rpc("authority","call_local","reliable")
+func reload_on_server() -> void:
+	if not multiplayer.is_server(): return
+	reload.emit()
+
+@rpc("authority","call_local","reliable")
+func interact_on_server(end: bool) -> void:
+	if not multiplayer.is_server(): return
+	if end:
+		interact_end.emit()
+	else:
+		interact_begin.emit()
+
+@rpc("authority","call_local","reliable")
+func jump_on_server() -> void:
+	if not multiplayer.is_server(): return
+	jumped.emit()

scripts/multiplayer/player_input.gd.uid

@@ -0,0 +1 @@
+uid://dfvnx8f1v6m5g

scripts/multiplayer/session.gd

@@ -86,7 +86,7 @@ func _process(_delta: float) -> void:
 func update_clock(time: float):
 	reference_round_time = time
 
-@rpc("any_peer","call_remote","reliable")
+@rpc("authority","call_remote","reliable")
 func start_session() -> void:
 	if not is_server_request():
 		return
@@ -100,7 +100,7 @@ func start_session() -> void:
 	
 	start_round()
 
-@rpc("any_peer","call_remote","reliable")
+@rpc("authority","call_remote","reliable")
 func end_session() -> void:
 	if not is_server_request():
 		return
@@ -114,7 +114,7 @@ func end_session() -> void:
 
 	session_started = false
 
-@rpc("any_peer","call_remote","reliable")
+@rpc("authority","call_remote","reliable")
 func start_round() -> void:
 	if not is_server_request():
 		return
@@ -134,23 +134,26 @@ func start_round() -> void:
 	round_state = ROUND_STATES.BUY
 	round_state_changed.emit.call_deferred(round_state)
 
-@rpc("any_peer","call_remote","reliable")
+@rpc("authority","call_remote","reliable")
 func end_round(win_team: int) -> void:
 	if not is_server_request():
 		return
 	if multiplayer.is_server():
 		get_tree().create_timer(5).timeout.connect(start_round)
 		end_round.rpc(win_team)
+		if current_round == Lobby.half_rounds:
+			Lobby.swap_teams()
 	
 	if win_team == TEAMS.DEFENCE:
 		defender_score += 1
 	elif win_team == TEAMS.ATTACK:
 		attacker_score += 1
 	
+	
 	round_state = ROUND_STATES.AFTER_ROUND
 	round_state_changed.emit(round_state)
 
-@rpc("any_peer","call_remote","reliable")
+@rpc("authority","call_remote","reliable")
 func begin_main_stage() -> void:
 	if not is_server_request():
 		return
@@ -161,7 +164,7 @@ func begin_main_stage() -> void:
 	round_state = ROUND_STATES.ROUND
 	round_state_changed.emit(round_state)
 
-@rpc("any_peer","call_remote","reliable")
+@rpc("authority","call_remote","reliable")
 func begin_bomb_stage() -> void:
 	if not is_server_request():
 		return
@@ -179,7 +182,6 @@ func defuse_win() -> void:
 	bomb_timer.stop()
 	end_round(TEAMS.DEFENCE)
 
-@rpc("any_peer","call_local","reliable")
 func add_dead(team: int):
 	if multiplayer.is_server() == false:
 		return
@@ -204,12 +206,7 @@ func is_server_request() -> bool:
 ## ammo, remaining_ammo, slot - data for dropped weapon [br]
 ## for more, see dyn_objects_spawner.gd
 func spawn(data: Dictionary) -> void:
-	spawn_internal.rpc_id(1,data)
-
-@rpc("any_peer","call_local","reliable")
-func spawn_internal(data: Dictionary) -> void:
 	if multiplayer.is_server() == false:
-		printerr(str(multiplayer.get_remote_sender_id())+" tried to spawn internally on "+str(multiplayer.get_unique_id()))
 		return
 	
 	var object = dynamic_objects_spawner.spawn(data)
@@ -217,25 +214,14 @@ func spawn_internal(data: Dictionary) -> void:
 	if data.has("position"):
 		object.global_position = data.position
 
-func despawn(path: NodePath):
-	despawn_internal.rpc_id(1,path)
-
-@rpc("any_peer","call_local","reliable")
-func despawn_internal(path: NodePath) -> void:
+func despawn(path: NodePath) -> void:
 	if multiplayer.is_server() == false:
 		printerr(str(multiplayer.get_remote_sender_id())+" tried to despawn internally on "+str(multiplayer.get_unique_id()))
 		return
 	
 	get_node(path).queue_free()
 
-func shoot(damage: int,distance: float = 100) -> void:
-	if multiplayer.get_unique_id() == 1:
-		shoot_internal(1,damage,distance)
-	else:
-		shoot_internal.rpc_id(1,multiplayer.get_unique_id(),damage,distance)
-
-@rpc("any_peer","call_local","reliable")
-func shoot_internal(id:int , damage: int, distance: float) -> void:
+func shoot(id:int , damage: int, distance: float) -> void:
 	if multiplayer.is_server() == false:
 		return
 	
@@ -258,16 +244,10 @@ func shoot_internal(id:int , damage: int, distance: float) -> void:
 	var collision = space.intersect_ray(ray)
 	
 	if collision != {} and collision["collider"] is Player:
-		collision["collider"].take_damage.rpc_id(int(collision["collider"].name),damage)
+		collision["collider"].take_damage(damage)
 
-func interact() -> void:
-	if multiplayer.get_unique_id() == 1:
-		interact_internal(1)
-	else:
-		interact_internal.rpc_id(1,multiplayer.get_unique_id())
 
-@rpc("any_peer","call_local","reliable")
-func interact_internal(id:int) -> void:
+func interact(id: int) -> void:
 	if multiplayer.is_server() == false:
 		return
 	
@@ -285,27 +265,20 @@ func interact_internal(id:int) -> void:
 	if collision != {} and collision["collider"] is Interactible:
 		collision["collider"].interaction_start(id)
 
-func stop_interact():
-	if multiplayer.get_unique_id() == 1:
-		stop_interact_internal(1)
-	else:
-		stop_interact_internal.rpc_id(1,multiplayer.get_unique_id())
-
-@rpc("any_peer","call_local","reliable")
-func stop_interact_internal(id: int) -> void:
+func stop_interact(id: int) -> void:
 	if multiplayer.is_server() == false:
 		return
 	player_stopped_interacting.emit(id)
 
-func is_on_site() -> bool:
+func is_on_site(id: int) -> bool:
 	for plant in plants:
-		if plant.is_player_on_site(multiplayer.get_unique_id()):
+		if plant.is_player_on_site(id):
 			return true
 	return false
 
-func get_site() -> PlantSite:
+func get_site(id: int) -> PlantSite:
 	for plant in plants:
-		if plant.is_player_on_site(multiplayer.get_unique_id()):
+		if plant.is_player_on_site(id):
 			return plant
 	return null
 

scripts/multiplayer/spawn_system/team_spawner.gd

@@ -15,6 +15,8 @@ func _exit_tree() -> void:
 	Session.round_started.disconnect(spawn)
 
 func spawn():
+	if not multiplayer.is_server():
+		return
 	match team:
 		Session.TEAMS.ATTACK:
 			for attacker in Lobby.attack_team:
@@ -36,18 +38,22 @@ func spawn_player(id: int) -> void:
 	elif team == Session.TEAMS.ATTACK:
 		Session.attackers_alive += 1 
 	
-	deferred_setup.bind(inst,team).call_deferred()
+	var distance = randf_range(0,spawn_radius)
+	var angle = randf_range(0,TAU)
+	var new_position = global_position + Vector3.RIGHT.rotated(Vector3.UP,angle) * distance
+	inst.player_id = id
+	inst.team = team
+	get_parent().add_child(inst)
+	inst.global_position = new_position
 
 func spawn_spectator(id: int) -> void:
 	var spectator: PackedScene = load("res://scenes/spectator.tscn")
 	var inst = spectator.instantiate()
 	
 	inst.name = str(id)
-	deferred_setup.bind(inst,Session.TEAMS.SPECTATE).call_deferred()
-
-func deferred_setup(what: Node3D, new_team: Session.TEAMS):
-	get_parent().add_child(what,true)
 	var distance = randf_range(0,spawn_radius)
 	var angle = randf_range(0,TAU)
 	var new_position = global_position + Vector3.RIGHT.rotated(Vector3.UP,angle) * distance
-	what.set_after_spawn.rpc_id(int(what.name),new_position,new_team)
+	inst.team = team
+	get_parent().add_child(inst)
+	inst.global_position = new_position