Diagramma di classe Tic tac toe

L'avrei modellato in questo modo:

• Ci sono giocatori mentre li hai modellati
• Una classe Gioco ha uno stato {programmato, in esecuzione, finito}, memorizza anche i puntatori a due giocatori, e Gioco memorizza anche il punteggio per il giocatore 1 e il giocatore 2
• Un sistema tiene traccia di tutti i giochi giocati / programmati (forse deve fornire un ID univoco per un nuovo gioco, diventando così una fabbrica per i giochi)
• Se vuoi calcolare ad es. un punteggio medio per un giocatore specifico, puoi introdurre riferimenti da Giocatore a Gioco . Per un accesso più semplice, non andrei dall'altra parte e attraverserei l'elenco dei giochi per trovare il giocatore a cui X ha partecipato.

È difficile analizzare l'accoppiamento e la coesione su un esempio così piccolo, ma direi che il punteggio non appartiene a un giocatore, ma al gioco a cui partecipa.

A proposito:

In this diagram, Système would have to ask the PlancheDeJeu object about the score and it would itself have to get it from Joueur

Il tuo modello dice che Joueur può accedere a PlancheDeJeu, ma non viceversa.

Il punteggio deriva da dati derivanti dall'accumulo di risultati di gioco. Il risultato del gioco deve essere archiviato nell'oggetto "Tavola da gioco". Da lì potresti prendere un paio di approcci.

1) Puoi tenere un set di tutti i giochi giocati nel "Sistema" e fornire un metodo pubblico "punteggio (Player)" che calcoli il punteggio per tutti i giochi completati da "Player". Questa opzione sembra adattarsi alle esigenze del tuo sistema per visualizzare i dati.

o

2) Il giocatore tiene traccia di tutti i giochi completati e può rispondere in modo appropriato a "punteggio".

Sembra che potresti perdere una lezione.

Giocatore - Un partecipante a un gioco Tic Tac Toe Gioco (tavola) - Un oggetto di stato che riceve l'input del giocatore (mosse) e determina la vincita / perdita / pareggio Sistema: visualizza i dati per un utente (?), Avvia nuovi giochi (?), Crea nuovi giocatori (?).

Il sistema mi sembra abbastanza nebuloso. Sembra che ci dovrebbe essere un controller di qualche tipo che può avviare nuovi giochi e mantenere il riferimento ad essi per l'analisi del risultato. L'introduzione di questo oggetto darebbe al sistema la possibilità di concentrarsi sulla visualizzazione dei dati piuttosto che avere la responsabilità mista di tenere traccia di giocatori, giochi e quant'altro per visualizzare i dati richiesti.

Usando il Controller, fornirà il punteggio del metodo (Player).

Il primo dovrebbe chiarire cosa si intende per punteggio. Se ciò significa "il numero di vittorie, sconfitte e risultati remis in tutti i precedenti giochi", allora dovrebbe essere chiaro che il punteggio non può appartenere a un tabellone di gioco, perché la vita di un gameboard dovrebbe essere solo una partita. Quindi il punteggio è una proprietà personale di ciascun giocatore, il che significa che è posizionato correttamente lì.

Questa immagine diventa ancora più chiara se pensi di avere più di due giocatori, tutti con un torneo di Tic Tac Toe. E infatti, dal momento che devi gestire i giocatori esistenti da qualche parte (indipendentemente dal tabellone di gioco), credo che dovresti aggiungere i giocatori al sistema in forma di relazione.

I am trying to think of how to design an intermediary object that would link Joueur and Système

Perché non creare solo un'associazione 1: n tra System e Player? Questo dovrebbe essere sufficiente. Deve esserci un posto nel programma in cui verranno creati i giocatori e il tabellone vuoto, un luogo in cui vengono selezionati i due giocatori effettivi (tra tutti i giocatori), e un posto in cui viene assegnato il tabellone di gioco corrente. Queste sono attività tipicamente eseguite da un oggetto diverso ("di livello superiore"), forse l'oggetto "Sistema" nel tuo modello.

Non vedo alcun motivo per cui i giocatori stessi debbano mantenere il punteggio del gioco - in realtà penso che il tabellone stesso dovrebbe tenere il punteggio, altrimenti quale giocatore tiene il punteggio? L'umano o il computer? Entrambi mantengono il proprio punteggio? Se è così, è una duplicazione di dati, che non è mai buona, perché potresti finire con un caso in cui quei punteggi non corrispondono e quindi devi capire quale è giusto. Terrò il punteggio sul tabellone effettivo, a cui potranno accedere sia i giocatori che il sistema!

Se hai davvero qualche sorta di obiezione nel tenere il punteggio alla lavagna, potresti dover creare un'altra classe per la memorizzazione dei dati, che è molto comune nei programmi, a cui quindi tutte le parti avrebbero accesso in modo semi-statico moda, sia attraverso un singleton, o una sorta di accessor / setter thread-safe

Prima di tutto non penso che sia eccessivo. Per me è un buon modo per visualizzare come si dovrebbe iniziare la codifica in modo orientato agli oggetti. E ci stai arrivando. Yay!

Non sono un esperto in questo, ma è così che lo farei:

principale per il flusso del gioco.

board per la logica di tutte le mosse del tic tac toe.

gameController per controllare il gioco. in questo caso il turno di quel giocatore è.

input per ottenere la mossa del giocatore

output per stampare tutte le informazioni pertinenti, inclusa la scheda.

potresti finire con dei file molto brevi ma è okie. ne avrai bisogno quando passerai ai giochi più grandi. :)

spero che questo aiuti.