Collegarsi ai segnali

Fa parte della sezione Programmazione orientata agli oggetti del percorso GDScript di Coddy. Lezione 37 di 65.

connect() prende la funzione da eseguire, come Callable. Indica un metodo senza parentesi oppure scrivi una lambda:

chest.opened.connect(_on_chest_opened)          # un metodo di questo script
chest.opened.connect(quest_log.add_entry)       # un metodo di un altro oggetto
chest.opened.connect(func(): print("Creak!"))   # una funzione lambda

Godot denomina un metodo di ascolto con _on_, poi l'emettitore e infine il segnale: _on_chest_opened. Un segnale può avere molte funzioni connesse e vengono eseguite nell'ordine in cui sono state connesse.

Un oggetto che è in ascolto di solito si connette da solo, in un metodo che riceve l’emettitore:

# quest_log.gd
class_name QuestLog
extends RefCounted

var chests_opened := 0

func track(chest: Chest) -> void:
	if not chest.opened.is_connected(_on_chest_opened):
		chest.opened.connect(_on_chest_opened)

func untrack(chest: Chest) -> void:
	if chest.opened.is_connected(_on_chest_opened):
		chest.opened.disconnect(_on_chest_opened)

func _on_chest_opened() -> void:
	chests_opened += 1

Collegare due volte la stessa funzione allo stesso segnale è un errore, così come scollegare una funzione che non è collegata. is_connected() controlla prima. disconnect() interrompe l'ascolto e l'emissione successiva non esegue più quella funzione.

Passa CONNECT_ONE_SHOT come secondo argomento e la connessione si rimuove dopo la sua prima chiamata: chest.opened.connect(_on_first_open, CONNECT_ONE_SHOT).

Una lambda conserva il valore che aveva una variabile locale quando la lambda è stata creata. count += 1 all'interno di una lambda connessa modifica quella copia, e count in _ready() rimane 0. Mantieni un contatore in una variabile membro di un oggetto listener, come fa QuestLog.

Sfida

Facile

Un poligono di tiro ha dei bersagli che emettono hit quando vengono colpiti. Scrivi ScoreBoard, che li ascolta:

watch(target) collega il segnale hit del bersaglio a _on_target_hit. Se osservi un bersaglio che è già osservato, non cambia nulla.
ignore(target) lo scollega. Se ignori un bersaglio che non è osservato, non cambia nulla.
_on_target_hit() aggiunge 10 a points e stampa Hit! Score: N.

Osservare due volte o ignorare un bersaglio non osservato non deve causare un errore, perché qualsiasi errore fa fallire il test. target.gd è completo.

Il codice fornito legge il numero di bersagli, poi comandi come watch 0, ignore 0 e shoot 0, e stampa il punteggio finale. Per due bersagli e i comandi watch 0, shoot 0, shoot 1, watch 1, watch 1, shoot 1, ignore 0, shoot 0 stampa:

Shot target 0
Hit! Score: 10
Shot target 1
Shot target 1
Hit! Score: 20
Shot target 0
Final score: 20

Il tuo codice va in score_board.gd e target.gd. main.gd contiene il codice fornito per input/output e non può essere modificato.

Provalo tu

extends Node

func _ready():
	# Codice di input/output fornito: lascialo così com'è
	var board := ScoreBoard.new()
	var targets: Array[Target] = []
	for i in int(OS.read_string_from_stdin()):
		targets.append(Target.new())
	var count := int(OS.read_string_from_stdin())
	for i in count:
		var parts := OS.read_string_from_stdin().split(" ")
		var target := targets[int(parts[1])]
		if parts[0] == "watch":
			board.watch(target)
		elif parts[0] == "ignore":
			board.ignore(target)
		else:
			print("Shot target ", parts[1])
			target.shoot()
	print("Final score: ", board.points)