Proper swap, generic mouse confinment and win

multiplayer/lobby.gd

@@ -74,15 +74,17 @@ func set_teams(attack: Array[int],defence: Array[int],spectators: Array[int]):
 	defence_team = defence
 	specators_team = spectators
 	update_teams_state.emit()
+	if is_multiplayer_authority():
+		set_teams.rpc(attack,defence,spectators)
 
 func switch_team(team: int) -> void:
 	team_switch_notification.rpc(multiplayer.get_unique_id(),team)
 
 func swap_teams() -> void:
-	if not multiplayer.is_server():
+	if not is_multiplayer_authority():
 		return
 	
-	set_teams.rpc(defence_team,attack_team,specators_team)
+	set_teams(defence_team,attack_team,specators_team)
 
 @rpc("any_peer","call_local","reliable")
 func team_switch_notification(id: int, team: int) -> void:

multiplayer/session.gd

@@ -25,9 +25,9 @@ const DEFENCE_LAYER: int = 0b100000
 signal session_started
 signal session_ended
 signal round_started
-signal late_player_connected(id: int)
 signal round_state_changed(state: int)
 signal player_stopped_interacting(id: int)
+signal team_won(team: TEAMS)
 
 var player_nodes: Dictionary[int,Player] = {}
 var player_data: Dictionary[int,Dictionary] = {}
@@ -39,11 +39,14 @@ var plant_deadzones: Dictionary[StringName, Area3D]
 
 var session_started_flag: bool = false
 var round_state: ROUND_STATES
+
 var current_round: int = 0
 var attacker_score: int = 0
 var defender_score: int = 0
+
 var attackers_alive: int = 0
 var defenders_alive: int = 0
+
 var reference_round_time: float
 
 var bomb_timer: Timer
@@ -73,53 +76,25 @@ func _ready() -> void:
 	add_child(round_timer)
 	add_child(buy_timer)
 	
-	multiplayer.peer_connected.connect(sync_session_server)
+	multiplayer.peer_connected.connect(send_session_data)
 	multiplayer.peer_disconnected.connect(delete_player)
 
-func sync_session_server(id: int):
+func send_session_data(peer_id: int = -1):
 	if multiplayer.is_server() == false or session_started_flag == false:
 		return
 	
 	var data: PackedByteArray
-	data.resize(6)
+	data.resize(5)
 	data.encode_u8(0,current_round)
-	data.encode_u8(1,attacker_score)
-	data.encode_u8(2,defender_score)
-	data.encode_u8(3,attackers_alive)
-	data.encode_u8(4,defenders_alive)
-	data.encode_u8(5,round_state)
+	data.encode_u8(1,attackers_alive)
+	data.encode_u8(2,defenders_alive)
+	data.encode_u8(3,round_state)
+	data.encode_u8(4,session_started_flag)
 	
-	sync_session_client.rpc_id(id,data,player_data)
-	late_player_connected.emit(id)
-
-@rpc("authority","call_remote","reliable")
-func sync_session_client(data: PackedByteArray,players_data_sent: Dictionary[int,Dictionary]):
-	if not is_server_request():
-		return
-	
-	current_round = data.decode_u8(0)
-	attacker_score = data.decode_u8(1)
-	defender_score = data.decode_u8(2)
-	attackers_alive = data.decode_u8(3)
-	defenders_alive = data.decode_u8(4)
-	round_state = data.decode_u8(5) as ROUND_STATES
-	session_started.emit()
-	player_data = players_data_sent
-
-func send_session_data():
-	if multiplayer.is_server() == false or session_started_flag == false:
-		return
-	
-	var data: PackedByteArray
-	data.resize(6)
-	data.encode_u8(0,current_round)
-	data.encode_u8(1,attacker_score)
-	data.encode_u8(2,defender_score)
-	data.encode_u8(3,attackers_alive)
-	data.encode_u8(4,defenders_alive)
-	data.encode_u8(5,round_state)
-	
-	recieve_session_data.rpc(data,player_data)
+	if peer_id == -1:
+		recieve_session_data.rpc(data,player_data)
+	else:
+		recieve_session_data.rpc_id(peer_id,data,player_data)
 
 @rpc("authority","call_remote","unreliable")
 func recieve_session_data(data: PackedByteArray,players_data_sent: Dictionary[int,Dictionary]):
@@ -127,12 +102,15 @@ func recieve_session_data(data: PackedByteArray,players_data_sent: Dictionary[in
 		return
 	
 	current_round = data.decode_u8(0)
-	attacker_score = data.decode_u8(1)
-	defender_score = data.decode_u8(2)
-	attackers_alive = data.decode_u8(3)
-	defenders_alive = data.decode_u8(4)
-	round_state = data.decode_u8(5) as ROUND_STATES
-	session_started.emit()
+	attackers_alive = data.decode_u8(1)
+	defenders_alive = data.decode_u8(2)
+	round_state = data.decode_u8(3) as ROUND_STATES
+	if session_started_flag != bool(data.decode_u8(4)):
+		session_started_flag = bool(data.decode_u8(4))
+		if session_started_flag:
+			session_started.emit()
+		else:
+			session_ended.emit()
 	player_data = players_data_sent
 
 func _process(_delta: float) -> void:
@@ -235,15 +213,6 @@ func start_round() -> void:
 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()
-			var temp_rounds = attacker_score
-			attacker_score = defender_score
-			defender_score = temp_rounds
-			sync_score.rpc(attacker_score,defender_score)
 	
 	if win_team == TEAMS.DEFENCE:
 		defender_score += 1
@@ -251,13 +220,31 @@ func end_round(win_team: int) -> void:
 			player_data[defender].money += WIN_MONEY
 		for attacker in Lobby.attack_team:
 			player_data[attacker].money += LOSE_MONEY
+		if defender_score >= LobbySettings.win_score:
+			win_session(TEAMS.DEFENCE)
+	
 	elif win_team == TEAMS.ATTACK:
 		attacker_score += 1
 		for defender in Lobby.defence_team:
 			player_data[defender].money += LOSE_MONEY
 		for attacker in Lobby.attack_team:
 			player_data[attacker].money += WIN_MONEY
+		
+		if attacker_score >= LobbySettings.win_score:
+			win_session(TEAMS.ATTACK)
 	
+	if multiplayer.is_server():
+		end_round.rpc(win_team)
+		if defender_score >= LobbySettings.win_score or attacker_score >= LobbySettings.win_score:
+			get_tree().create_timer(7.5).timeout.connect(end_session)
+		else:
+			get_tree().create_timer(5).timeout.connect(start_round)
+		if current_round == LobbySettings.half_rounds:
+			Lobby.swap_teams()
+			var temp_rounds = attacker_score
+			attacker_score = defender_score
+			defender_score = temp_rounds
+			sync_score.rpc(attacker_score,defender_score)
 	
 	round_state = ROUND_STATES.AFTER_ROUND
 	round_state_changed.emit(round_state)
@@ -291,6 +278,15 @@ func defuse_win() -> void:
 	bomb_timer.stop()
 	end_round(TEAMS.DEFENCE)
 
+@rpc("reliable")
+func win_session(team: int):
+	team_won.emit(team)
+	
+	MouseConfiner.set_global_mode(Input.MOUSE_MODE_VISIBLE)
+	
+	if is_multiplayer_authority():
+		win_session.rpc(team)
+
 func add_dead(team: int):
 	if multiplayer.is_server() == false:
 		return
@@ -350,7 +346,6 @@ func shoot(id:int , limb_damage: int, torso_damage: int,head_damage: int, distan
 		hit_player.take_damage(int(float(damage) * reduction))
 		
 
-
 func interact(id: int) -> void:
 	if multiplayer.is_server() == false:
 		return
@@ -398,6 +393,11 @@ func kill_site(site: StringName) -> void:
 func sync_score(attack: int, defence: int):
 	attacker_score = attack
 	defender_score = defence
+	
+	if defender_score >= LobbySettings.win_score:
+			win_session(TEAMS.DEFENCE)
+	elif attacker_score >= LobbySettings.win_score:
+			win_session(TEAMS.ATTACK)
 
 @rpc("authority","call_remote","reliable")
 func delete_player(id: int):

multiplayer/team_spawner.gd

@@ -9,7 +9,7 @@ func _ready() -> void:
 		return
 	Session.round_started.connect(spawn)
 	if team == Session.TEAMS.SPECTATE:
-		Session.late_player_connected.connect(spawn_spectator)
+		multiplayer.peer_connected.connect(spawn_spectator)
 	
 
 func _exit_tree() -> void: