Was ist eine geeignete Datenstruktur und Datenbankschema logische Regeln zu speichern?

Question

Vorwort: Ich habe keine Erfahrung mit Regeln Motoren, Gebäuden Regeln, Modellierung Regeln, Implementierung von Datenstrukturen für die Regeln, oder Dingsbums. Deshalb weiß ich nicht, was ich tue oder wenn das, was ich unten versucht, ist weg Basis.

Ich versuche, herauszufinden, wie das folgende hypothetische Szenario zu speichern und zu verarbeiten. Zu meinem Problem zu vereinfachen, sagen, dass ich eine Art von Spiel, wo ein Benutzer ein Objekt kauft, wo es 1000 von möglichen Objekten sein könnte, und die Objekte müssen in einer bestimmten Reihenfolge erworben werden und nur in bestimmten Gruppen. Zum Beispiel, sagen, dass ich der Benutzer bin und ich möchte Kaufobjekt F. Bevor ich Objekt F kaufen, ich vorher Objekt A haben muss gekauft oder (B und C). Ich kann nicht F und A bei gleichzeitig kaufen, noch F und B, C. Sie müssen die Regel gibt in der Folge sein. Ein erster, dann F später. Oder, B, C zuerst, dann F später. Ich bin jetzt nicht mit der Zeitspanne zwischen Einkäufen oder anderen Merkmalen des Benutzers betrifft, nur, dass sie die richtige Reihenfolge für jetzt sind.

Was ist der beste Weg, um diese Informationen zu speichern, für potenziell Tausende von Objekten, die mich in den Regeln für das Objekt zu lesen erlaubt wird gekauft, und dann überprüfen gegen den frühere Kaufhistorie des Benutzers?

Ich habe dies versucht, aber ich bin zu versuchen, stecken die Gruppierungen zu implementieren wie A OR (B und C). Ich möchte die Regeln in einer Datenbank speichern, wo ich diese Tabellen haben:

 Objects
    (ID(int),Description(char)) 

ObjectPurchRules
    (ObjectID(int),ReqirementObjectID(int),OperatorRule(char),Sequence(int)) 

Aber natürlich, wie Sie durch die Ergebnisse verarbeiten, ohne die Gruppierung, erhalten Sie die falsche Antwort. Ich mag übermäßiges String-Parsing, wenn möglich :) vermeiden. Ein Ziel könnte eine unbekannte Anzahl von vorherigen erforderlichen Einkäufen hat. SQL oder psuedocode Schnipsel für die Regeln der Verarbeitung würde geschätzt. :)

Answer 1

Es scheint, wie Ihr Problem bricht zu testen, ob eine bestimmte Bedingung erfüllt worden ist.

Sie werden zusammengesetzte Bedingungen haben. So eine Tabelle mit Elementen gegeben:

ID_Item    Description
----------------------
1          A         
2          B         
3          C         
4          F         

und da eine Tabelle von möglichen Aktionen:

ID_Action  VerbID  ItemID    ConditionID
----------------------------------------
1          BUY     4         1

Wir haben eine Tabelle von Bedingungen konstruieren:

ID_Condition  VerbA  ObjectA_ID  Boolean  VerbB            ObjectB_ID
---------------------------------------------------------------------
1             OWNS   1           OR       MEETS_CONDITION  2
2             OWNS   2           AND      OWNS             3

So OWNS Mittel die ID ein Schlüssel für die Items-Tabelle ist, und MEETS_CONDITION bedeutet, dass die ID ein Schlüssel für die Bedingungen Tabelle ist.

Dies ist nicht dazu gedacht, Sie zu beschränken. Sie können andere Tabellen mit Aufgaben hinzufügen oder was auch immer, und fügen Sie zusätzliche Verben Ihnen sagen, wo sie suchen müssen. Oder, um es nur von Aufgaben in Ihren Artikel Tisch, wenn Sie sie abgeschlossen ist, und dann eine abgeschlossene Quest interpretieren als ein besonderen Abzeichen zu besitzen. Dann können Sie beiden Elemente und Aufgaben mit dem gleichen Code verarbeiten.

Answer 2

Dies ist ein sehr komplexes Problem, dass ich auf Antwort nicht qualifiziert bin, aber ich habe viele Referenzen zu sehen. Das grundlegende Problem ist, dass für Spiele, Quests und Items und „Statistiken“ für verschiedene Objekte nicht-relationale Abhängigkeiten haben können. Dieser Thread Sie können helfen, eine Menge .

Sie könnten ein paar Bücher über das Thema holen wollen, und Blick in der Verwendung von LUA als Regeln Prozessor.

Answer 3

Persönlich würde ich tun dies in Code, nicht in SQL. Jedes Element sollte seine eigene Klasse Implementierung einer Schnittstelle (das heißt iItem) sein. IItem würde eine Methode OkToPurchase genannt, die bestimmen würde, wenn es OK ist, um das Element zu kaufen. Um dies zu erreichen, wäre es eine oder mehr aus einer Sammlung von Regeln verwenden (das heißt HasPreviouslyPurchased (x), CurrentlyOwns (x), etc.), dass Sie bauen können.

Das Schöne daran ist, dass es einfach ist, diesen Ansatz mit neuen Regeln zu erweitern, ohne all die bestehenden Logik zu brechen.

Hier einige Pseudo-Code:

bool OkToPurchase()
{
   if( HasPreviouslyPurchased('x') && !CurrentlyOwns('y') )
       return true;
   else
       return false;
}

bool HasPreviouslyPurchased( item )
{
    return purchases.contains( item )
}

bool CurrentlyOwns( item )
{
    return user.Items.contains( item )
}