Global refactor

multiplayer/dynamic_objects_parent.gd

@@ -0,0 +1,6 @@
+extends Node
+
+
+# Called when the node enters the scene tree for the first time.
+func _ready() -> void:
+	Session.dynamic_objects_parent = get_parent()

multiplayer/dynamic_objects_parent.gd.uid

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

multiplayer/level_container.gd

@@ -0,0 +1,10 @@
+extends Node
+
+func _ready() -> void:
+	Session.session_ended.connect(destroy_level)
+
+func destroy_level() -> void:
+	for child in get_children():
+		if child is MultiplayerSpawner:
+			continue
+		child.queue_free()

multiplayer/level_container.gd.uid

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

multiplayer/lobby.gd

@@ -0,0 +1,171 @@
+extends Node
+
+
+const MAX_PLAYERS: int = 10
+const PORT: int = 7777
+
+signal lobby_created
+signal lobby_joined
+signal lobby_closed
+signal update_teams_state
+
+var in_lobby: bool = false
+
+var attack_team: Array[int] = []
+var defence_team: Array[int] = []
+var specators_team: Array[int] = []
+
+# Host defined variables
+var win_score: int = 13
+var half_rounds :int = 12
+var bomb_time: float = 45.0
+var buy_time: float = 15.0
+var round_time: float = 150.0
+
+func _ready() -> void:
+	multiplayer.peer_disconnected.connect(player_left)
+	multiplayer.server_disconnected.connect(server_disconnected)
+	multiplayer.peer_connected.connect(add_and_sync_peer)
+
+func player_left(id: int) -> void:
+	if attack_team.has(id):
+		attack_team.erase(id)
+	elif defence_team.has(id):
+		defence_team.erase(id)
+	elif specators_team.has(id):
+		specators_team.erase(id)
+	update_teams_state.emit()
+
+func server_disconnected() -> void:
+	leave()
+
+func host() -> void:
+	var peer: ENetMultiplayerPeer = ENetMultiplayerPeer.new()
+	peer.create_server(PORT,MAX_PLAYERS)
+	multiplayer.multiplayer_peer = peer
+	lobby_created.emit()
+	specators_team.append(multiplayer.get_unique_id())
+	in_lobby = true
+
+func join(ip: String) -> Error:
+	var peer: ENetMultiplayerPeer = ENetMultiplayerPeer.new()
+	var res = peer.create_client(ip,PORT) 
+	if res != 0:
+		return res
+	multiplayer.multiplayer_peer = peer
+	lobby_joined.emit()
+	in_lobby = true
+	return Error.OK
+
+func leave() -> void:
+	multiplayer.multiplayer_peer = OfflineMultiplayerPeer.new()
+	attack_team.clear()
+	defence_team.clear()
+	specators_team.clear()
+	lobby_closed.emit()
+	in_lobby = false
+
+func add_and_sync_peer(id: int) -> void:
+	if multiplayer.is_server() == false:
+		return
+	specators_team.append(id)
+	update_teams_state.emit()
+	set_teams.rpc_id(id,attack_team,defence_team,specators_team)
+	
+@rpc("any_peer","call_remote","reliable")
+func set_teams(attack: Array[int],defence: Array[int],spectators: Array[int]):
+	attack_team = attack
+	defence_team = defence
+	specators_team = spectators
+	update_teams_state.emit()
+
+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):
+		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)
+		
+	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)
+
+func start_game() -> void:
+	if not multiplayer.is_server():
+		return
+	get_tree().current_scene.get_node("%MainMenu").visible = false
+	get_tree().current_scene.get_node("%LevelContainer").add_child(preload("res://levels/prototype_scene.tscn").instantiate())
+	Session.start_session()
+
+func get_team() -> Session.TEAMS:
+	var id = multiplayer.get_unique_id()
+	if attack_team.has(id):
+		return Session.TEAMS.ATTACK
+	if defence_team.has(id):
+		return Session.TEAMS.DEFENCE
+	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()

multiplayer/lobby.gd.uid

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

multiplayer/own_visibility_toggle.gd

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

multiplayer/own_visibility_toggle.gd.uid

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

multiplayer/plant_site/plant_deadzone.gd

@@ -0,0 +1,9 @@
+extends Area3D
+
+@export var bound_plant: Area3D
+
+func _ready() -> void:
+	if multiplayer.is_server():
+		Session.plant_deadzones[bound_plant.name] = self
+	else:
+		queue_free()

multiplayer/plant_site/plant_deadzone.gd.uid

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

multiplayer/plant_site/plant_site.gd

@@ -0,0 +1,23 @@
+extends Area3D
+
+class_name PlantSite
+
+var players_on_site: Array[int]
+
+# Called when the node enters the scene tree for the first time.
+func _ready() -> void:
+	body_entered.connect(on_body_entered)
+	body_exited.connect(on_body_exited)
+	
+	Session.plants.append(self)
+
+func on_body_entered(body: Node3D):
+	if body is Player:
+		players_on_site.append(int(body.name))
+
+func on_body_exited(body: Node3D):
+	if body is Player:
+		players_on_site.erase(int(body.name))
+
+func is_player_on_site(id: int):
+	return players_on_site.has(id)

multiplayer/plant_site/plant_site.gd.uid

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

multiplayer/session.gd

@@ -0,0 +1,397 @@
+extends Node
+
+enum TEAMS {
+	DEFENCE,
+	ATTACK,
+	SPECTATE,
+	UNASSIGNED
+}
+
+enum ROUND_STATES {
+	NOT_SET = 0,
+	BUY = 1,
+	ROUND = 2,
+	AFTER_ROUND = 3,
+	AFTER_PLANT = 4,
+	AFTER_SESSION = 5,
+}
+
+const WIN_MONEY: int = 3400
+const LOSE_MONEY: int = 2000
+
+const ATTACK_LAYER: int = 0b10000
+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)
+
+var player_nodes: Dictionary[int,Player] = {}
+var player_data: Dictionary[int,Dictionary] = {}
+
+var dynamic_objects_parent: Node3D
+var object_containers: Array[ObjectContainer]
+var plants: Array[PlantSite]
+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
+var round_timer: Timer
+var buy_timer: Timer
+
+func _ready() -> void:
+	if multiplayer.is_server() == false:
+		return
+	
+	bomb_timer = Timer.new()
+	bomb_timer.wait_time = 45.0
+	bomb_timer.one_shot = true
+	bomb_timer.timeout.connect(end_round.bind(TEAMS.ATTACK))
+	
+	round_timer = Timer.new()
+	round_timer.wait_time = 150
+	round_timer.one_shot = true
+	round_timer.timeout.connect(end_round.bind(TEAMS.DEFENCE))
+	
+	buy_timer = Timer.new()
+	buy_timer.wait_time = 1
+	buy_timer.one_shot = true
+	buy_timer.timeout.connect(begin_main_stage)
+	
+	add_child(bomb_timer)
+	add_child(round_timer)
+	add_child(buy_timer)
+	
+	multiplayer.peer_connected.connect(sync_session_server)
+	multiplayer.peer_disconnected.connect(delete_player)
+
+func sync_session_server(id: int):
+	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)
+	
+	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)
+
+@rpc("authority","call_remote","unreliable")
+func recieve_session_data(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 _process(_delta: float) -> void:
+	if multiplayer.is_server() == false or not session_started:
+		return
+	match round_state:
+		ROUND_STATES.BUY:
+			reference_round_time = buy_timer.time_left
+		ROUND_STATES.ROUND:
+			reference_round_time = round_timer.time_left
+		ROUND_STATES.AFTER_PLANT:
+			reference_round_time = bomb_timer.time_left
+		_:
+			reference_round_time = 0
+	update_clock.rpc(reference_round_time)
+	send_session_data()
+
+@rpc("authority","call_remote","unreliable")
+func update_clock(time: float):
+	reference_round_time = time
+
+@rpc("authority","call_remote","reliable")
+func start_session() -> void:
+	if not is_server_request():
+		return
+	if multiplayer.is_server():
+		start_session.rpc()
+	
+	current_round = 0
+	attacker_score = 0
+	defender_score = 0
+
+	session_started_flag = true
+	session_started.emit()
+	bomb_timer.wait_time = Lobby.bomb_time
+	round_timer.wait_time = Lobby.round_time
+	buy_timer.wait_time = Lobby.buy_time
+	
+	var all_players: PackedInt32Array = multiplayer.get_peers()
+	all_players.append(multiplayer.get_unique_id())
+	for player in all_players:
+		player_data[player] = {
+			"money" : 800,
+			"nickname" : "Seliboba"
+		}
+	
+	start_round()
+
+@rpc("authority","call_remote","reliable")
+func end_session() -> void:
+	if not is_server_request():
+		return
+	if multiplayer.is_server():
+		end_session.rpc()
+	
+	bomb_timer.stop()
+	round_timer.stop()
+	buy_timer.stop()
+	object_containers.clear()
+	session_ended.emit()
+	
+
+	session_started_flag = false
+	plants = []
+	plant_deadzones = {}
+	
+	dynamic_objects_parent = null
+
+func quit_session() -> void:
+	if multiplayer.is_server():
+		end_session()
+		await get_tree().create_timer(0.1).timeout
+	else:
+		session_ended.emit()
+		session_started_flag = false
+	Lobby.leave()
+	
+
+@rpc("authority","call_remote","reliable")
+func start_round() -> void:
+	if not is_server_request():
+		return
+	if multiplayer.is_server():
+		buy_timer.start()
+		start_round.rpc()
+		round_timer.stop()
+		bomb_timer.stop()
+		for container in object_containers:
+			container.despawn()
+	attackers_alive = 0
+	defenders_alive = 0
+	
+	current_round += 1
+	
+	round_started.emit.call_deferred()
+	round_state = ROUND_STATES.BUY
+	round_state_changed.emit.call_deferred(round_state)
+
+@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()
+			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
+		for defender in Lobby.defence_team:
+			player_data[defender].money += WIN_MONEY
+		for attacker in Lobby.attack_team:
+			player_data[attacker].money += LOSE_MONEY
+	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
+	
+	
+	round_state = ROUND_STATES.AFTER_ROUND
+	round_state_changed.emit(round_state)
+
+@rpc("authority","call_remote","reliable")
+func begin_main_stage() -> void:
+	if not is_server_request():
+		return
+	if multiplayer.is_server():
+		round_timer.start()
+		begin_main_stage.rpc()
+	
+	round_state = ROUND_STATES.ROUND
+	round_state_changed.emit(round_state)
+
+@rpc("authority","call_remote","reliable")
+func begin_bomb_stage() -> void:
+	if not is_server_request():
+		return
+	if multiplayer.is_server():
+		bomb_timer.start()
+		round_timer.stop()
+		begin_bomb_stage.rpc()
+	
+	round_state = ROUND_STATES.AFTER_PLANT
+	round_state_changed.emit(round_state)
+
+func defuse_win() -> void:
+	if not multiplayer.is_server():
+		return
+	bomb_timer.stop()
+	end_round(TEAMS.DEFENCE)
+
+func add_dead(team: int):
+	if multiplayer.is_server() == false:
+		return
+	if team == TEAMS.ATTACK:
+		attackers_alive -= 1
+		if attackers_alive == 0 and round_state != ROUND_STATES.AFTER_ROUND and round_state != ROUND_STATES.AFTER_PLANT:
+			end_round(TEAMS.DEFENCE)
+	if team == TEAMS.DEFENCE:
+		defenders_alive -= 1
+		if defenders_alive == 0 and round_state != ROUND_STATES.AFTER_ROUND:
+			end_round(TEAMS.ATTACK)
+
+func is_server_request() -> bool:
+	return multiplayer.is_server() or multiplayer.get_remote_sender_id() == 1
+
+func shoot(id:int , damage: int, distance: float) -> void:
+	if multiplayer.is_server() == false:
+		return
+	
+	var player: Player = player_nodes[id]
+	var player_camera: Camera3D = player.get_node("Camera3D")
+	var space: PhysicsDirectSpaceState3D = player.get_world_3d().direct_space_state
+	var endpoint: Vector3 = player_camera.global_position - player_camera.global_basis.z * distance
+	
+	var ray = PhysicsRayQueryParameters3D.create(player_camera.global_position,endpoint,1)
+	ray.exclude = [player.get_rid()]
+	ray.collide_with_areas = false
+	match player.team:
+		TEAMS.DEFENCE:
+			ray.collision_mask |= ATTACK_LAYER
+		TEAMS.ATTACK:
+			ray.collision_mask |= DEFENCE_LAYER
+		_:
+			ray.collision_mask |= ATTACK_LAYER | DEFENCE_LAYER
+	
+	var collision = space.intersect_ray(ray)
+	
+	if collision != {} and collision["collider"] is Player:
+		collision["collider"].take_damage(damage)
+
+
+func interact(id: int) -> void:
+	if multiplayer.is_server() == false:
+		return
+	
+	var player: Player = player_nodes[id]
+	var player_camera: Camera3D = player.get_node("Camera3D")
+	var space: PhysicsDirectSpaceState3D = player.get_world_3d().direct_space_state
+	var endpoint: Vector3 = player_camera.global_position - player_camera.global_basis.z * 3
+	
+	var ray = PhysicsRayQueryParameters3D.create(player_camera.global_position,endpoint,1)
+	ray.exclude = [player.get_rid()]
+	ray.collide_with_areas = false
+	ray.collision_mask |= 64
+	
+	var collision = space.intersect_ray(ray)
+	if collision != {} and collision["collider"] is Interactible:
+		collision["collider"].interaction_start(id)
+
+func stop_interact(id: int) -> void:
+	if multiplayer.is_server() == false:
+		return
+	player_stopped_interacting.emit(id)
+
+func is_on_site(id: int) -> bool:
+	for plant in plants:
+		if plant.is_player_on_site(id):
+			return true
+	return false
+
+func get_site(id: int) -> PlantSite:
+	for plant in plants:
+		if plant.is_player_on_site(id):
+			return plant
+	return null
+
+func kill_site(site: StringName) -> void:
+	if multiplayer.is_server() == false:
+		return
+
+	for body in plant_deadzones[site].get_overlapping_bodies():
+		if body is Player:
+			body.die()
+
+@rpc("authority","call_remote","unreliable")
+func sync_score(attack: int, defence: int):
+	attacker_score = attack
+	defender_score = defence
+
+@rpc("authority","call_remote","reliable")
+func delete_player(id: int):
+	if not is_server_request():
+		return
+	if multiplayer.is_server():
+		delete_player.rpc_id(id)
+	
+	player_data.erase(id)
+	
+func get_player_data() -> Dictionary:
+	var id: int = multiplayer.get_unique_id()
+	if player_data.has(id):
+		return player_data[id]
+	else:
+		return {}

multiplayer/session.gd.uid

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