तर्क नियमों को संग्रहीत करने के लिए उपयुक्त डेटा संरचना और डेटाबेस स्कीमा क्या है?

Question

प्रस्तावना: मुझे नियम इंजन, नियम बनाने, मॉडलिंग नियमों, नियमों के लिए डेटा संरचनाओं को कार्यान्वित करने, या व्हाट्नॉट के साथ अनुभव नहीं है। इसलिए, मुझे नहीं पता कि मैं क्या कर रहा हूं या यदि मैंने नीचे जो प्रयास किया है वह आधार से बाहर है।

मैं यह समझने की कोशिश कर रहा हूं कि निम्नलिखित काल्पनिक परिदृश्य को कैसे स्टोर और संसाधित करना है। मेरी समस्या को सरल बनाने के लिए, कहें कि मेरे पास एक प्रकार का गेम है जहां कोई उपयोगकर्ता ऑब्जेक्ट खरीदता है, जहां 1000 संभावित वस्तुएं हो सकती हैं, और वस्तुओं को निर्दिष्ट अनुक्रम में और केवल कुछ समूहों में खरीदा जाना चाहिए। उदाहरण के लिए, कहें कि मैं उपयोगकर्ता हूं और मैं ऑब्जेक्ट एफ खरीदना चाहता हूं। इससे पहले कि मैं ऑब्जेक्ट एफ खरीद सकूं, मैंने पहले ऑब्जेक्ट ए या (बी और सी) खरीदा होगा। मैं एक ही समय में एफ और ए नहीं खरीद सकता, न ही एफ और बी, सी। नियम अनुक्रम में अनुक्रम में होना चाहिए। पहले, फिर बाद में एफ। या, बी, सी पहले, फिर बाद में एफ। मैं अभी खरीद, या उपयोगकर्ता की किसी भी अन्य विशेषताओं के बीच समय के साथ चिंतित नहीं हूं, सिर्फ यह कि वे अभी के लिए सही अनुक्रम हैं।

संभावित रूप से हजारों ऑब्जेक्ट्स के लिए इस जानकारी को संग्रहीत करने का सबसे अच्छा तरीका क्या है जो मुझे खरीदे जाने वाले ऑब्जेक्ट के नियमों में पढ़ने की अनुमति देता है, और फिर उपयोगकर्ता के पिछले खरीद इतिहास के विरुद्ध जांचता है?

मैंने इसका प्रयास किया है, लेकिन मैं ए या (बी और सी) जैसे समूहों को लागू करने की कोशिश में फंस गया हूं।

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

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

लेकिन स्पष्ट रूप से के रूप में आप परिणामों के माध्यम से संसाधित करते हैं, समूह के बिना, आप गलत जवाब मिल: मैं जहाँ मैं इन तालिकाओं एक डेटाबेस में नियमों स्टोर करने के लिए करना चाहते हैं। यदि संभव हो तो मैं अत्यधिक स्ट्रिंग पार्सिंग से बचना चाहता हूं :)। एक ऑब्जेक्ट में पिछली आवश्यक खरीदारियों की अज्ञात संख्या हो सकती है। नियमों को संसाधित करने के लिए एसक्यूएल या psuedocode स्निपेट की सराहना की जाएगी। :)

Answer 1

ऐसा लगता है कि आपकी समस्या यह जांचने के लिए टूट जाती है कि कोई विशेष स्थिति संतुष्ट हो गई है या नहीं।

आपके पास परिसर की स्थिति होगी। तो मदों की एक मेज दिया:

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

और संभावित कार्यवाही एक मेज दिया:

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

हम स्थितियों की एक तालिका का निर्माण:

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

तो स्वामित्व के का मतलब आईडी है आइटम तालिका की एक कुंजी, और MEETS_CONDITION का अर्थ है कि आईडी शर्तें तालिका की कुंजी है।

यह आपको प्रतिबंधित करने के लिए नहीं है। आप क्वेस्ट या जो कुछ भी के साथ अन्य टेबल जोड़ सकते हैं, और आपको कहां देखना है, यह बताने के लिए अतिरिक्त क्रियाएं जोड़ें। या, जब आप उन्हें पूरा करते हैं तो बस अपनी आइटम तालिका में क्वेस्ट डाल दें, और फिर किसी विशेष बैज के स्वामित्व के रूप में एक पूर्ण खोज की व्याख्या करें। फिर आप एक ही कोड के साथ दोनों वस्तुओं और quests संभाल सकते हैं।

Answer 2

यह एक बहुत ही जटिल समस्या है जिसे मैं उत्तर देने के योग्य नहीं हूं, लेकिन मैंने बहुत सारे संदर्भ देखे हैं। मौलिक समस्या यह है कि विभिन्न वस्तुओं के लिए गेम, क्वेस्ट और आइटम और "आंकड़े" के लिए गैर-संबंधपरक निर्भरता हो सकती है। This thread may help you a lot।

आप विषय पर कुछ पुस्तकें लेना चाहते हैं, और नियम प्रोसेसर के रूप में LUA का उपयोग करने के लिए देख सकते हैं।

Answer 3

व्यक्तिगत रूप से मैं कोड में ऐसा करता हूं, एसक्यूएल में नहीं। प्रत्येक आइटम एक इंटरफेस को लागू करने वाली अपनी कक्षा होनी चाहिए (यानी।IItem)। IItem में OkToPurchase नामक एक विधि होगी जो यह निर्धारित करेगी कि उस आइटम को खरीदने के लिए ठीक है या नहीं। ऐसा करने के लिए, यह नियमों के संग्रह में से एक या अधिक का उपयोग करेगा (यानी, पूर्व में खरीदा गया है (एक्स), वर्तमान में ओन (x), आदि) जिसे आप बना सकते हैं।

अच्छी बात यह है कि सभी मौजूदा तर्कों को तोड़ने के बिना नए नियमों के साथ इस दृष्टिकोण को विस्तारित करना आसान है।

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) 
} 

:

यहाँ कुछ स्यूडोकोड है