Attualmente sto architettando un piccolo dungeon crawl in stile RPG (in Unity), e sono un po 'bloccato su come aggiornare vari oggetti quando le cose cambiano, mentre non non sono in aggiornamento oggetti. Per questa domanda, userò il mio attuale progetto come esempio, ma la domanda stessa può essere applicata a qualsiasi situazione in cui più tipi diversi di Osservatori guardano ciascuno un singolo Soggetto.
Il design a cui sono attualmente orientato per le interazioni tra oggetti nel mio gioco implementa il Pattern di progettazione degli osservatori , dove ho un singolo Soggetto (chiamiamolo GameEventManager
), e ogni oggetto interattivo è un Osservatore di questo Soggetto (questo include cose come giocatore, nemici, oggetti interattivi sul terreno, ecc.).
Quando si verifica un evento (diciamo che un utente colpisce la barra spaziatrice per sparare a una freccia contro un nemico selezionato), il piano corrente che ho per la vita dell'azione può essere suddiviso in passaggi:
- Il sistema di input (non un Observer, ma contiene un riferimento al Subject), invia un
Event
aGameEventManager
per la trasmissione nel posto giusto. Non ho ancora progettato la classeEvent
, per semplificare il problema e nel caso sia necessario riprogettare le cose. - Il
GameEventManager
trasmetteEvent
aPlayer
con le informazioni pertinenti. - Il
Player
, comprendendo unEvent
è venuto nel dire di sparare a una freccia, fa alcuni calcoli interni (come sottrarre dalla munizione totale che ha, magari eseguendo visivamente una sorta di animazione) ed emette un nuovoEvent
alGameEventManager
che dice chePlayer
ha sparato una freccia su "enemy2". - Il
GameEventManager
trasmetteEvent
a "enemy2". - "Enemy2" riceve
Event
, si rende conto che è stato sparato e muore in qualche modo.
Quindi la domanda è: come fa GameEventManager
a sapere dove passare intorno a tutti questi diversi tipi di eventi (ad esempio, l'evento movimento deve andare solo al giocatore, e la freccia deve andare solo a "nemico2"). Inoltre, una volta che l'evento raggiunge i suoi obiettivi designati, in che modo questi osservatori sanno cosa fare con l'evento (ad esempio, come fa il giocatore a sapere di tirare una freccia e non subire danni?).
Ho fatto qualche ricerca sugli esempi di Observer, ma la maggior parte sono oscenamente complessi e astratti, o sono semplicemente semplici "Il soggetto emette un evento per TUTTI gli osservatori, e TUTTI gli osservatori interagiscono con OGNI evento che ottengono", che non è quello che ho voglio a tutti (una freccia sparata a "enemy2" non dovrebbe influenzare "enemy1" in alcun modo).
Scusa se questo è un po 'astratto, mi piace avere un piano prima di iniziare a creare il codice.
Inoltre, come parte a parte, sono pienamente consapevole che in Unity posso avere un GameObject direttamente in interazione con un altro, ma lo scopo di questo intero progetto è di rendere tutto il più possibile polimorfo e riutilizzabile, e la maggior parte dei tutorial di Unity semplicemente non toccare affatto l'estensibilità.