Improve code style (#1021)

* Remove unnecessary use of `self`
* Connect to signals directly over `connect("name")`
* Use `call_deferred` on callables over `call_deferred("name"))`
* Emit signals directly over `emit_signal("name"...)`

networking/multiplayer_bomber/gamestate.gd

@@ -142,8 +142,8 @@ func end_game():
 
 
 func _ready():
-	multiplayer.peer_connected.connect(self._player_connected)
-	multiplayer.peer_disconnected.connect(self._player_disconnected)
-	multiplayer.connected_to_server.connect(self._connected_ok)
-	multiplayer.connection_failed.connect(self._connected_fail)
-	multiplayer.server_disconnected.connect(self._server_disconnected)
+	multiplayer.peer_connected.connect(_player_connected)
+	multiplayer.peer_disconnected.connect(_player_disconnected)
+	multiplayer.connected_to_server.connect(_connected_ok)
+	multiplayer.connection_failed.connect(_connected_fail)
+	multiplayer.server_disconnected.connect(_server_disconnected)

networking/multiplayer_bomber/lobby.gd

@@ -2,11 +2,11 @@ extends Control
 
 func _ready():
 	# Called every time the node is added to the scene.
-	gamestate.connection_failed.connect(self._on_connection_failed)
-	gamestate.connection_succeeded.connect(self._on_connection_success)
-	gamestate.player_list_changed.connect(self.refresh_lobby)
-	gamestate.game_ended.connect(self._on_game_ended)
-	gamestate.game_error.connect(self._on_game_error)
+	gamestate.connection_failed.connect(_on_connection_failed)
+	gamestate.connection_succeeded.connect(_on_connection_success)
+	gamestate.player_list_changed.connect(refresh_lobby)
+	gamestate.game_ended.connect(_on_game_ended)
+	gamestate.game_error.connect(_on_game_error)
 	# Set the player name according to the system username. Fallback to the path.
 	if OS.has_environment("USERNAME"):
 		$Connect/Name.text = OS.get_environment("USERNAME")

networking/multiplayer_pong/logic/lobby.gd

@@ -17,11 +17,11 @@ var peer = null
 
 func _ready():
 	# Connect all the callbacks related to networking.
-	multiplayer.peer_connected.connect(self._player_connected)
-	multiplayer.peer_disconnected.connect(self._player_disconnected)
-	multiplayer.connected_to_server.connect(self._connected_ok)
-	multiplayer.connection_failed.connect(self._connected_fail)
-	multiplayer.server_disconnected.connect(self._server_disconnected)
+	multiplayer.peer_connected.connect(_player_connected)
+	multiplayer.peer_disconnected.connect(_player_disconnected)
+	multiplayer.connected_to_server.connect(_connected_ok)
+	multiplayer.connection_failed.connect(_connected_fail)
+	multiplayer.server_disconnected.connect(_server_disconnected)
 
 #### Network callbacks from SceneTree ####
 
@@ -30,7 +30,7 @@ func _player_connected(_id):
 	# Someone connected, start the game!
 	var pong = load("res://pong.tscn").instantiate()
 	# Connect deferred so we can safely erase it from the callback.
-	pong.game_finished.connect(self._end_game, CONNECT_DEFERRED)
+	pong.game_finished.connect(_end_game, CONNECT_DEFERRED)
 
 	get_tree().get_root().add_child(pong)
 	hide()

networking/multiplayer_pong/logic/pong.gd

@@ -50,4 +50,4 @@ func update_score(add_to_left):
 
 
 func _on_exit_game_pressed():
-	emit_signal("game_finished")
+	game_finished.emit()

networking/webrtc_minimal/chat.gd

@@ -8,8 +8,8 @@ var channel = peer.create_data_channel("chat", {"negotiated": true, "id": 1})
 
 func _ready():
 	# Connect all functions.
-	peer.ice_candidate_created.connect(self._on_ice_candidate)
-	peer.session_description_created.connect(self._on_session)
+	peer.ice_candidate_created.connect(_on_ice_candidate)
+	peer.session_description_created.connect(_on_session)
 
 	# Register to the local signaling server (see below for the implementation).
 	Signaling.register(String(get_path()))

networking/webrtc_signaling/client/multiplayer_client.gd

@@ -4,24 +4,24 @@ var rtc_mp: WebRTCMultiplayerPeer = WebRTCMultiplayerPeer.new()
 var sealed := false
 
 func _init():
-	connected.connect(self._connected)
-	disconnected.connect(self._disconnected)
+	connected.connect(_connected)
+	disconnected.connect(_disconnected)
 
-	offer_received.connect(self._offer_received)
-	answer_received.connect(self._answer_received)
-	candidate_received.connect(self._candidate_received)
+	offer_received.connect(_offer_received)
+	answer_received.connect(_answer_received)
+	candidate_received.connect(_candidate_received)
 
-	lobby_joined.connect(self._lobby_joined)
-	lobby_sealed.connect(self._lobby_sealed)
-	peer_connected.connect(self._peer_connected)
-	peer_disconnected.connect(self._peer_disconnected)
+	lobby_joined.connect(_lobby_joined)
+	lobby_sealed.connect(_lobby_sealed)
+	peer_connected.connect(_peer_connected)
+	peer_disconnected.connect(_peer_disconnected)
 
 
-func start(url, lobby = "", mesh:=true):
+func start(url, _lobby = "", _mesh := true):
 	stop()
 	sealed = false
-	self.mesh = mesh
-	self.lobby = lobby
+	mesh = _mesh
+	lobby = _lobby
 	connect_to_url(url)
 
 
@@ -36,8 +36,8 @@ func _create_peer(id):
 	peer.initialize({
 		"iceServers": [ { "urls": ["stun:stun.l.google.com:19302"] } ]
 	})
-	peer.session_description_created.connect(self._offer_created.bind(id))
-	peer.ice_candidate_created.connect(self._new_ice_candidate.bind(id))
+	peer.session_description_created.connect(_offer_created.bind(id))
+	peer.ice_candidate_created.connect(_new_ice_candidate.bind(id))
 	rtc_mp.add_peer(peer, id)
 	if id < rtc_mp.get_unique_id(): # So lobby creator never creates offers.
 		peer.create_offer()
@@ -68,8 +68,8 @@ func _connected(id, use_mesh):
 	multiplayer.multiplayer_peer = rtc_mp
 
 
-func _lobby_joined(lobby):
-	self.lobby = lobby
+func _lobby_joined(_lobby):
+	lobby = _lobby
 
 
 func _lobby_sealed():

networking/webrtc_signaling/demo/client_ui.gd

@@ -6,16 +6,16 @@ extends Control
 @onready var mesh = $VBoxContainer/Connect/Mesh
 
 func _ready():
-	client.lobby_joined.connect(self._lobby_joined)
-	client.lobby_sealed.connect(self._lobby_sealed)
-	client.connected.connect(self._connected)
-	client.disconnected.connect(self._disconnected)
+	client.lobby_joined.connect(_lobby_joined)
+	client.lobby_sealed.connect(_lobby_sealed)
+	client.connected.connect(_connected)
+	client.disconnected.connect(_disconnected)
 
-	multiplayer.connected_to_server.connect(self._mp_server_connected)
-	multiplayer.connection_failed.connect(self._mp_server_disconnect)
-	multiplayer.server_disconnected.connect(self._mp_server_disconnect)
-	multiplayer.peer_connected.connect(self._mp_peer_connected)
-	multiplayer.peer_disconnected.connect(self._mp_peer_disconnected)
+	multiplayer.connected_to_server.connect(_mp_server_connected)
+	multiplayer.connection_failed.connect(_mp_server_disconnect)
+	multiplayer.server_disconnected.connect(_mp_server_disconnect)
+	multiplayer.peer_connected.connect(_mp_peer_connected)
+	multiplayer.peer_disconnected.connect(_mp_peer_disconnected)
 
 
 @rpc("any_peer", "call_local")

networking/websocket_multiplayer/script/main.gd

@@ -18,11 +18,11 @@ func _init():
 
 
 func _ready():
-	multiplayer.peer_connected.connect(self._peer_connected)
-	multiplayer.peer_disconnected.connect(self._peer_disconnected)
-	multiplayer.server_disconnected.connect(self._close_network)
-	multiplayer.connection_failed.connect(self._close_network)
-	multiplayer.connected_to_server.connect(self._connected)
+	multiplayer.peer_connected.connect(_peer_connected)
+	multiplayer.peer_disconnected.connect(_peer_disconnected)
+	multiplayer.server_disconnected.connect(_close_network)
+	multiplayer.connection_failed.connect(_close_network)
+	multiplayer.connected_to_server.connect(_connected)
 
 	$AcceptDialog.get_label().horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
 	$AcceptDialog.get_label().vertical_alignment = VERTICAL_ALIGNMENT_CENTER