Introduzione ai modelli di progettazione

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

Un modello di progettazione è un modo noto e con un nome per organizzare le classi in modo da risolvere un problema che si ripresenta in un programma dopo l’altro. Non è una libreria né codice da copiare: descrive quali oggetti esistono, di cosa è responsabile ciascuno e come collaborano. Scrivi tu il codice, adattandolo al tuo gioco.

Anche i pattern forniscono agli sviluppatori un vocabolario condiviso. «I nemici provengono da una factory» oppure «la barra della salute osserva il giocatore» spiega a un membro del team come è organizzato il codice prima ancora che apra un file.

Ecco un problema che un pattern risolve. Avviare un livello significa comunicare con tre oggetti, e ogni script che avvia un livello ripete queste righe:

var music := MusicPlayer.new()
var level_map := LevelMap.new()
var hud := Hud.new()
music.play("forest.ogg")
level_map.load_map(1)
hud.show_hearts(3)

Il pattern Facade mette una classe davanti a quegli oggetti e le fornisce un metodo semplice:

# game_facade.gd
class_name GameFacade
extends RefCounted

var music := MusicPlayer.new()
var level_map := LevelMap.new()
var hud := Hud.new()

func start_level(number: int) -> void:
	music.play("forest.ogg")
	level_map.load_map(number)
	hud.show_hearts(3)

# main.gd
var game := GameFacade.new()
game.start_level(1)

Music: playing forest.ogg
Map: level 1 loaded
HUD: hearts 3

Il resto del programma chiama start_level() e, quando cambia il livello iniziale, modifichi un file.

I pattern sono raggruppati in base al problema che risolvono:

I pattern creazionali controllano come vengono creati gli oggetti: Singleton, Factory.
I pattern strutturali combinano gli oggetti in strutture più ampie: Facade, Adapter, Decorator, Composite.
I pattern comportamentali organizzano il modo in cui gli oggetti collaborano: Observer, Strategy, Command, Template Method, State.

Questo capitolo e il prossimo trattano questi schemi. Ognuno si basa su ciò che già conosci: classi nei propri file, ereditarietà, polimorfismo, composizione e segnali.

Sfida

Facile

Un gioco avvia e termina i livelli tramite tre oggetti già scritti: MusicPlayer (music_player.gd), LevelMap (level_map.gd) e Hud (hud.gd). Scrivi la facciata GameFacade davanti a essi:

Crea un MusicPlayer, un LevelMap e un Hud nelle sue variabili membro.
start_level(number, hearts) riproduce la traccia level_N.ogg (N è il numero del livello), oppure boss.ogg quando il numero è un multiplo di 5, poi carica la mappa di quel livello e infine mostra i cuori.
quit_level() nasconde l’HUD, poi interrompe la musica.

Il codice fornito legge quanti comandi seguono, poi un comando per riga: start NUMBER HEARTS oppure quit. Per start 5 2 e quit, l’output è:

Music: playing boss.ogg
Map: level 5 loaded
HUD: hearts 2
HUD: hidden
Music: stopped

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

Provalo tu

extends Node

func _ready():
	# Codice di input/output fornito: lascialo così com'è
	var game := GameFacade.new()
	var count := int(OS.read_string_from_stdin())
	for i in count:
		var parts := OS.read_string_from_stdin().split(" ")
		if parts[0] == "start":
			game.start_level(int(parts[1]), int(parts[2]))
		elif parts[0] == "quit":
			game.quit_level()