Questo non è certamente un compito facile; ciò di cui hai bisogno è piegare il comportamento in strutture di dati, ovvero, è necessario un algoritmo di controllo del punteggio generico che copra tutti i giochi necessari e abbia regole configurabili (che prende come parametri, in un formato digeribile da una delle applicazioni di destinazione lingue).
Il primo passo, ovviamente, è di creare una struttura dati generica che possa rappresentare accuratamente i punteggi. Ad esempio, per il calcio, l'hockey, il basket, ecc., Una semplice coppia di numeri interi andrà bene; ma altri sport, come il tennis, richiedono strutture dati più complesse, ad esempio un elenco di coppie di numeri interi. Quindi, ad esempio, un risultato di calcio potrebbe essere, in pseudocodice, [(1, 3)] (una lista con una coppia, che rappresenta il risultato "1: 3"); un risultato da tennis potrebbe essere [(6,1), (6,2), (7,6)] (non sono esattamente sicuro delle regole del tennis). E ovviamente, se vuoi modellare i punteggi all'interno di , devi estendere le strutture dati di conseguenza. (Una nota sui punteggi del tennis all'interno dei giochi: mentre il conteggio è non lineare, c'è un numero molto piccolo di punteggi validi e possono essere facilmente mappati su uno spazio intero lineare - [ "love", "15", "30", "40", "game" ] può essere gestito internamente come [ 0, 1, 2, 3, 4 ] , e quindi mappato nuovamente al valore idiomatico per la visualizzazione.)
Quindi è necessario implementare i vincoli generici su questi punteggi; alcuni funzioneranno su coppie individuali, altri considereranno il risultato nel suo complesso. Ad esempio, uno di questi vincoli potrebbe essere "il numero minimo di coppie di risultati", e il suo parametro sarebbe 1 per il calcio, 3 per il tennis. Un altro potrebbe essere "i punteggi all'interno di una coppia non devono essere uguali", e sarebbe applicato a partite di calcio stile tennis o knock-out, ma non in partite di calcio in stile campionato o in lega (dove è possibile pescare). Crea regole sufficienti per coprire tutti i vincoli.
Un file di configurazione potrebbe quindi assomigliare a questo:
[
{
"sportName" : "soccer",
"rules" : [
{ "ruleType": "numberOfSets", "number" : 1 },
{ "ruleType": "minScoreValue", "value" : 0 }
]
},
{
"sportName" : "soccer-knockout",
"rules" : [
{ "ruleType": "numberOfSets", "number" : 1 },
{ "ruleType": "minScoreValue", "value" : 0 },
{ "ruleType": "noDrawsWithinSet" }
]
},
{
"sportName" : "tennis",
"rules" : [
{ "ruleType": "minNumberOfSets", "number" : 3 },
{ "ruleType": "maxNumberOfSets", "number" : 5 },
{ "ruleType": "minWinningSetScore", "value" : 6 },
{ "ruleType": "maxWinningSetScore", "value" : 7 },
{ "ruleType": "noDrawsWithinSet" }
]
}
]
L'ultima parte di cui hai bisogno è la colla per metterlo insieme: un motore di regole che carica le regole da un file, crea un'istanza dei correttori appropriati e li applica ai punteggi specificati. Quest'ultima parte è semplicemente una questione di iterazione delle regole applicabili (in modo ricorsivo se hai punteggi annidati come per il tennis) finché non ne trovi uno che non corrisponde.
Man mano che aggiungi altri giochi al tuo sistema, dovrai aggiungere altri tipi di vincoli, ma se li mantieni generici e parametrizzabili, le possibilità che le regole esistenti coprano già un nuovo gioco aumentano man mano.
In effetti, stai implementando un DSL (linguaggio specifico del dominio) per descrivere punteggi e regole del gioco.