Dividere le strade del monopolio in gruppi

5

Sono nuovo alla programmazione orientata agli oggetti, a java e alla programmazione in generale, e come primo vero progetto sto provando a programmare il gioco da tavolo Monopoly.

Quello che ho ottenuto finora è un array che può memorizzare oggetti della classe Square (che ha varie sottoclassi, come proprietà, ferrovie, carte chance ecc.). Gli oggetti del giocatore a turno si muovono sulla scacchiera, chiamando un metodo landedOn () per qualsiasi campo su cui si fermano. Le proprietà possono essere contrassegnate con un proprietario, e quindi questo proprietario riceverà denaro se qualcuno atterra sulla sua proprietà.

Tutto sta andando bene finora, ma c'è una piccola cosa che mi infastidisce. Non sono sicuro di come dividere elegantemente le case in gruppi o colori. Ci sono un paio di gruppi di strade sul tabellone e puoi comprare solo case se possiedi tutte le proprietà nel gruppo. Posso immaginare come programmarlo, ma la soluzione mi sembra un po 'sporca e "non generale". Come posso creare una buona soluzione generale?

Per chiarire: voglio essere in grado di controllare se tutte le proprietà di un tipo sono di proprietà dello stesso giocatore, in un modo generale, in modo che se i gruppi vengono modificati, viene aggiunta una proprietà, o cambia gruppo, ecc. ., Non dovrei cambiare molto codice.

    
posta zxz 10.06.2013 - 23:17
fonte

2 risposte

4

La risposta più elegante è probabilmente Enum .

Crea un valore enum per ogni gruppo di colori e quando crei il tuo oggetto Property (che eredita da Square ), passa il gruppo di colori come parametro costruttore (poiché è richiesto valore per avere un Property valido). Railroad , Utility e simili non accettano questo parametro, poiché non hanno gruppi e ereditano direttamente da Square (non Property ). *

Per verificare se un giocatore ha tutte le proprietà in un dato gruppo, puoi usare un Espressione Lambda se stai usando Java 8, o semplicemente hai un ciclo foreach lungo le linee di

for (property: allProperties)
{
   if (property.getGroup() == targetGroup && property.getOwner() != targetOwner) return false;
}
return true;

* Sarebbe anche valido avere una classe GroupedSquare tra Property e Square , con Railroad e Utility che ereditano da esso e superano un valore enum codificato, ma penso che sia meno elegante.

    
risposta data 10.06.2013 - 23:57
fonte
2

Un'alternativa a un enum di Bobson potrebbe essere quella di avere i gruppi come oggetti indipendenti. Con questo non devi iterare su tutte le atreets per vedere se un gruppo omplte ma può controllare solo il singolo gruppo. In Pseudocode l'implementazione potrebbe apparire come questa:

class Group {
    Set<Road> roads;

    bool hasAll(Player player) {
        for (road: roads) {
            if (road.getOwner() != player) {
                return false;
            }
        }
        return true;
  }
}

class Road {
    Player owner;
    Group group;

    bool canBuildHouses(Player player) {
        return group.hasAll(player);
    }
}

Oltre all'approccio enum questo ha il vantaggio di poter spostare la logica specifica del gruppo nella classe Group.

Ora i progettisti di OO continueranno a non apprezzare questo a causa della dipendenza ciclica (un Gruppo deve conoscere il suo membro Strade e una strada deve conoscere il suo gruppo) che può essere risolto con un approccio basato su eventi che renderebbe questo specifico problema notevolmente più complesso, ma offre maggiore flessibilità, ad esempio aggiungendo regole speciali in quanto si potrebbero aggiungere regole extra come le bonifiche se un giocatore contiene un lato completo del tabellone o tutte le strade che iniziano con la stessa lettera o qualcosa del genere.

    
risposta data 11.06.2013 - 00:52
fonte

Leggi altre domande sui tag