मुझे मनमाने ढंग से / सामान्य श्रेणी के नोड्स के साथ एक उत्परिवर्ती, विविध jtree कैसे बनाना चाहिए?

Question

कृपया ध्यान दें: मैं यहाँ कोडिंग सहायता नहीं चाहता, मैं Programmersएक कारण से हूँ । मैं अपने प्रोग्राम प्लानिंग / राइटिंग स्किल्स को बेहतर बनाना चाहता हूं (सिर्फ) जावा की मेरी समझ को नहीं ।

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

मैं इसके बाद एक पेड़ बनाने का एक तरीका है जो मॉडल और दृश्य को अलग करने का प्रयास करता है, और एक मध्यस्थ माता-पिता के साथ एक मनमानी प्रकार के बच्चे के नोड को जोड़ने की अनुमति देता है (एक अलग तरीके से संपादित / प्रस्तुत किया जा रहा है)।

एनबी सब कुछ यहां एक कौशल के रूप में खरीदा जाता है, यहां तक ​​कि जहां यह एक संपत्ति की तरह लगता है। एंड-यूजर्स इसे खरीदने के कौशल के रूप में देखेंगे (जो वे पेपर एटम पर करते हैं) इसलिए इसे सभी पेज पर एक जैसे प्रस्तुत किया जाना चाहिए।

वृक्ष की व्याख्या: वृक्ष कठोर कोडित उच्चतम स्तरीय श्रेणियों ( हथियार, शारीरिक और मानसिक, चिकित्सा और अधिक आदि) के एक सेट के साथ 'जन्म' है । इससे उपयोगकर्ता को एक कौशल जोड़ने में सक्षम होने की आवश्यकता है। अंततः वे उदाहरण के लिए 'एक हाथ की तलवार विशेषज्ञता' कौशल ( आइटम नहीं ) जोड़ना चाहते हैं । ऐसा करने के लिए आप आदर्श रूप से Weaponsचयनित के साथ 'ऐड' पर क्लिक करेंगे और फिर One-handedउस बच्चे पर दिखाई देने वाले कॉम्बोक्स नोड से चयन करेंगे, फिर फिर से क्लिक करें और उस चाइल्ड नोड पर एक टेक्स्ट फ़ील्ड में एक नाम दर्ज करें जो दिखाई देता है। फिर उस पत्ते के लिए एक 'स्तर' या 'स्तरीय' जोड़ने / निर्दिष्ट करने के लिए फिर से क्लिक करें; पहले प्रवीणता, फिर विशेषज्ञता (उदाहरण के लिए)।

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

कोड में इस तरह के पेड़ का वर्णन करने के लिए एक अच्छी प्रणाली क्या है? अन्य सभी JTree उदाहरण मैंने देखा है कुछ अनुमानित पैटर्न है, और मेरा नहीं है । मैं, 'शाब्दिक' में कोड यह सब करने के लिए क्या की लंबी सूची के साथ नहीं करना चाहती प्रकार बच्चों नोड के (कॉम्बो बॉक्स, पाठ क्षेत्र आदि) क्या माता-पिता पर अनुमति दी जानी चाहिए। क्या मुझे अमूर्त कक्षाओं का उपयोग करना चाहिए? इंटरफेस?

जब मैं ऊपर सूचीबद्ध नहीं किए गए अन्य कौशलों में अलग-अलग व्यवहार करता हूं, तो मैं इस प्रकार की वस्तुओं को कैसे एक्स्टेंसिबल बना सकता हूं?

यदि उपयोग करने के लिए एक अच्छी प्रणाली नहीं है, तो क्या इस तरह की चीज़ को करने के लिए काम करने की एक अच्छी प्रक्रिया है?

मेरे सिर में गियर बदल रहे हैं:

मुझे हमेशा इसकी आवश्यकता है:

• माता-पिता की जाँच करें
• जनक के आधार पर विकल्प प्रदान करें

मुझे लगता है कि मैं इस समानता की वजह से भीख माँग रहा हूँ मुझे कुछ प्रकार के सार / इंटरफ़ेस skillवर्ग की आवश्यकता है जो कौशल और श्रेणी के लिए सामान्य तरीकों को परिभाषित / रेखांकित करता है। मैं (उम्मीद है) एक डेटाबेस में नियम और विकल्प रख सकता हूं और वहां से पढ़ सकता हूं। सवाल यह है कि मुझे लगता है कि अब, एक अमूर्त या इंटरफ़ेस विधि के बीच और कैसे लागू करने के लिए।

Comments

मैंने शुरू किया है (एक दोस्त से बात करने के बाद) डेटा में SkillCompenders के लिए एक अमूर्त वर्ग को बाहर कर दिया है, फिर मूल वर्ग का विस्तार करके व्यक्तिगत मामलों को निर्दिष्ट कर रहा है। पेड़ केवल डेटा को देखेगा और उचित रूप से खुद को आकर्षित करेगा। अगर यह काम करता है तो मैं जवाब दूंगा।

— प्यूरफेरेट

प्रश्न: जीवन एक "स्तर" संपत्ति के साथ एक कौशल है जो वेतन वृद्धि करने में सक्षम है। क्या यह जीवन के लिए अद्वितीय है, या अन्य कौशल स्तर में भी वृद्धि हो सकती है? मैं आपके समाधान में एक अमूर्त वर्ग और कई इंटरफेस के संयोजन की कल्पना कर सकता हूं, जैसे एक सार "कौशल" या "श्रेणी" या "SkillNode" वर्ग में अपने पेड़ का निर्माण करने के लिए, साथ ही कई इंटरफेस, जैसे कि "विशेष योग्यता"। "या" स्तरीय ", विभिन्न कार्यक्षमता में मिश्रण करने के लिए जो पेड़ की संरचना के लिए आवश्यक नहीं है। सिर्फ मनोरंजन के लिए टिप्पणी ... आशा है कि आप जो खोज रहे हैं वह आपको मिल जाएगा!

— डेविड कैक्ज़िनस्की

आप सवाल में jTree निर्दिष्ट करते हैं। क्या आप पाठ फ़ील्ड और कॉम्बो बॉक्स को नोड्स के रूप में प्रदर्शित करने के तरीके के बारे में पूछ रहे हैं, या जावा के लिए विशिष्ट नहीं डिजाइन की तलाश कर रहे हैं?

— Psr

@DavidKaczynski आपने सिर पर कील ठोक दी। मैं उस तरह की चीज को लागू करना शुरू करूँगा।

— शुद्ध

@psr मैं यह देखने की कोशिश कर रहा हूं कि क्या कक्षाओं का एक संहिताबद्ध पैटर्न (जरूरी नहीं कि एक 'डिजाइन पैटर्न') है, या फिर इसके आसपास आधार बनाने के लिए। डेविडकैज़िंस्की इसके बहुत करीब आता है।

— शुद्ध

Answer 1

सरल म्यूटेबल जेट्री उदाहरण

कोड (ऊपर चित्र बनाने के लिए जावा 7 के साथ अनुपालन और परीक्षण)

import java.awt.*;
import javax.swing.*;
import javax.swing.tree.*;

public class SimpleTree extends JFrame {
    public static void main(String[] args) {
        new SimpleTree();
    }

    public SimpleTree() {
        super("Mutable Varied JTree");
        Container content = getContentPane();
        N root = new N("Root");

        N weapons = new N("Weapons").add(
            new N("One-handed").add(
                new N("Sword").add("Proficiency", "Specialization"), 
                new N("Mace").add("Proficiency")),
            new N("Bow").add("Proficiency"));
        root.add(weapons);

        N phys = new N("Physical & Mental").add(
            new N("Life"),
            new N("Strength").add(
                "Double", "Triple", "Quadruple"));

        root.add(phys);
        N med = new N("Medical");
        med.add(new N("Bind Wounds"));
        med.add(new N("Set Broken Bones"));
        root.add(med);

        JTree tree = new JTree(root);
        content.add(new JScrollPane(tree), BorderLayout.CENTER);
        setSize(275, 300);
        setVisible(true);
    }

    private class N extends DefaultMutableTreeNode {
        public N(String s) { super(s); }
        public N add(String... strs) {
            for (String s : strs) {
                super.add(new N(s));
            }
            return this;
        }
        public N add(N... ns) {
            for (N n : ns) {
                super.add(n);
            }
            return this;
        }
    }
}

इस JTree ट्यूटोरियल के लिए विशेष धन्यवाद

अपडेट: संभावित समाधानों की चर्चा

एक डायनेमिक ट्री बनाने के लिए एक ट्यूटोरियल है , जिसमें नोड्स को जोड़ने / हटाने / साफ़ करने के लिए फ्रेम के नीचे स्थित बटनों का उपयोग किया गया है।

कॉम्बो-बॉक्स और इस तरह, आप उचित स्विंग क्लास की वस्तुओं को लेना चाहते हैं और उनके पास JComboBox की तरह कुछ होना चाहिए जो java.swing.tree.MutableTreeNode को लागू करता है। जावा स्विंग ट्यूटोरियल में नियंत्रणों की एक सूची है ।

आपको अभी भी लोगों को चुनने के लिए और नोड को संपादित करने के लिए किस प्रकार का नोड चुनना है, यह बताने के लिए उपयोगकर्ता-इंटरफ़ेस तत्व बनाने की आवश्यकता है। यदि वे कॉम्बो-बॉक्स जोड़ते हैं, तो उन्हें यह परिभाषित करने में सक्षम होना होगा कि बॉक्स किन विकल्पों को उपलब्ध कराएगा।

आपको अपना डेटा सहेजने के लिए एक अंतर्निहित डेटा मॉडल की आवश्यकता है। आप सभी जावा ऑब्जेक्ट में निर्मित डिफ़ॉल्ट क्रमांकन योजना का उपयोग कर सकते हैं, लेकिन यह केवल प्रोटोटाइप के लिए है - यदि आप कभी भी अपना प्रोग्राम कोड बदलते हैं तो यह टूट जाएगा। आपको या तो JDBC या JPA के साथ डेटाबेस का उपयोग करने की आवश्यकता होगी या आपको भंडारण प्रारूप के रूप में JSON या XML का उपयोग करके अपनी खुद की क्रमबद्ध दिनचर्या (या आपके लिए क्रमांकन को संभालने वाले पुस्तकालय का उपयोग करना होगा) लिखना होगा।

अद्यतन: परियोजना अवलोकन के साथ प्रस्तावित समाधान

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

<folder name="Physical &amp; Mental">
    <int name="Life">12</int>
    <drop-down name="Strength">
        <option name="Single" />
        <option name="Double" />
        <option name="Triple" />
        <option name="Quadruple" />
    </drop-down>
</folder>
<folder name="Medical">
    <text name="Bind Wounds" />
    <text name="Set Broken Bones" />
</folder>

यहां आपके लिए कुछ संभावित मील के पत्थर हैं:

• एक XML या JSON डेटा प्रारूप तैयार करें, फिर एक प्रोग्राम लिखें जो उस प्रारूप की एक फ़ाइल पढ़ता है और इसे बिना कॉम्बो-बॉक्स, बस फ़ोल्डर्स और फ़ाइलों के बिना JTree के रूप में प्रदर्शित करता है।
• JTree डिस्प्ले में स्विंग कंट्रोल जोड़ें
• उसी फ़ाइल को लिखने के लिए अपने प्रोग्राम का विस्तार करें
• उपयोगकर्ता इंटरफ़ेस बनाएँ ताकि उपयोगकर्ता GUI का उपयोग करके नोड्स जोड़ और संपादित कर सके

प्रत्येक मील के पत्थर के अंत में हर बार अपने कार्यक्रम का बैकअप सहेजना सुनिश्चित करें। एक अन्य मशीन पर स्थापित एक स्रोत नियंत्रण प्रणाली इसके लिए आदर्श है। यदि आप अपने कोड को साझा करने में कोई आपत्ति नहीं करते हैं और उस पर स्रोत नियंत्रण के साथ एक सर्वर स्थापित नहीं करना चाहते हैं तो आप गितुब, या सोर्सफोर्ज, या कुछ अन्य सार्वजनिक स्रोत नियंत्रण का उपयोग कर सकते हैं।

इनमें से कोई भी समाधान बहुत काम का है, और निश्चित रूप से एक शुरुआत परियोजना से बड़ा है। इसका मतलब है कि आप अपना LARP खेलने की तुलना में जावा स्विंग और XML या JSON सीखने में अधिक समय बिताएंगे, यही कारण है कि मैंने पहले मौजूदा टूल के साथ बनाने के विकल्प तलाशे। लेकिन कुछ भी सीखने का सबसे अच्छा तरीका वह तरीका है जिससे आप सीखने के लिए सबसे ज्यादा प्रेरित होते हैं। तो यह आपके लिए एक सही प्रोजेक्ट हो सकता है।

मुझे आशा है कि वह मदद करेंगे।

Comments

नमस्ते, मैं अभी अपने फोन पर हूं इसलिए मैं पूरी तरह से इसकी समीक्षा नहीं कर सकता हूं लेकिन ऐसा लगता है कि मैं इसके बाद क्या हूं, लेकिन जैसा कि मैंने अपने प्रश्न में कहा है कि मुझे विभिन्न प्रकार के नोड्स का आदान-प्रदान करने में सक्षम होना चाहिए। हालांकि ट्रैक पर होने के लिए +1!

— शुद्ध

"DefaultMutableTreeNode एक नोड के माता-पिता और बच्चों की जांच और संशोधन के लिए संचालन प्रदान करता है:" डॉक्स .oracle.com

— javase

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

— शुद्ध

ठीक है, तो आप एक कार्यक्रम चाहते हैं जो लोगों को एक रूपरेखा की तरह पेड़ बनाने देता है। Microsoft Word में एक बाह्यरेखा दृश्य पहले से ही है। OpenOffice / LibreOffice राइट में कुछ समान कार्यक्षमता है। आपको और क्या चाहिए?

— ग्लेनपेटर्सन

मुझे पता है कि मैं अपने सभी सवालों के साथ लोगों को गलत तरीके से रगड़ सकता हूं और इसके लिए मैं माफी चाहता हूं। लेकिन मुझे समस्या को समझने के लिए ऐसा करने की आवश्यकता है। मैंने ऊपर दिए गए अपने समाधान के अंत को अपडेट किया है (बड़े "अपडेट" शीर्षक के तहत) जो मैं मानता हूं वह आपके प्रश्नों के उत्तर हो सकते हैं, या कम से कम मार्गदर्शन के बारे में हो सकता है कि उन्हें स्वयं कैसे उत्तर दें। मुझे आशा है कि वह मदद करेंगे।

— ग्लेनपेटर्सन सेप

Answer 2

मुझे नहीं लगता कि जेट्री उस समस्या के लिए सही प्रतिनिधित्व है जिसे आप हल करने की कोशिश कर रहे हैं। मैंने आपकी वेब साइट को देखा, और मुझे सामान की सूची दिखाई दी। यह एक शानदार शुरुआत है, लेकिन मुझे लगता है कि एक अंतर्निहित डेटा डिज़ाइन है जो आपके पास हो सकता है, लेकिन मैं नहीं देख रहा हूं।

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

यहां तीन डेटा ऑब्जेक्ट हैं जो आपके डिज़ाइन से अब तक मेरे लिए खड़े हैं:

Character:
    Life (a value: e.g. 12)
    Strength (a value: e.g. double, triple, quadruple)
    Skills (list or set of weapon-skills, healing-skills)
    Possessions (list of weapons, armor and other possessions)
    WornArmor (maybe only wear one you possess at a time?)
    WieldedWeapon (one or two of your posessions)

Skill:
    Skill-Type (healing, manufacture, or weapon)
    RelevantWeapon (for this skill)

Weapon:
    IsOneHanded (boolean)
    IsBow (boolean)

अब एक चरित्र में हथियार और कौशल हो सकते हैं, लेकिन वास्तव में अच्छे हमले के लिए, उन्हें उस हथियार के लिए विशिष्ट कौशल की आवश्यकता होती है जिसका वे उपयोग कर रहे हैं। किसी भी मामले में, यहां एक से कई रिश्ते हैं (एक चरित्र में कई कौशल हो सकते हैं)। लेकिन मैं अभी तक पेड़ नहीं देख रहा हूं।

कागज का एक पैड लें और पहले पृष्ठ पर चरित्र को पृष्ठ के मध्य में रखें और इसके चारों ओर 5-10 सबसे महत्वपूर्ण गेम-वर्ल्ड ऑब्जेक्ट्स को सूचीबद्ध करें। यह पता लगाएं कि क्या डेटा केवल एक वस्तु का एक गुण है (जैसे कि जीवन और शक्ति चरित्र के अविभाज्य भागों के रूप में) और पेड़ों या पाठ-क्षेत्रों या कॉम्बो-बॉक्स के बारे में सोचने के बिना वस्तुओं के बीच सबसे महत्वपूर्ण संबंध क्या हैं। रिश्तों का प्रतिनिधित्व करने के लिए वस्तुओं के बीच की रेखाएं बनाएं फिर पता लगाएं कि कौन से रिश्ते 1: 1 हैं, जो 1: कई हैं, और जो कई हैं: कई और उन्हें लेबल करते हैं। इसमें "है-ए" और "ए-ए" और अन्य प्रकार के संबंध भी हो सकते हैं।

आप तय कर सकते हैं कि आपको वीप्सस्किल बनाम हीलिंगस्किल बनाम मैन्युफैक्चरस्किल के लिए अलग-अलग प्रतिनिधित्व की आवश्यकता है। या आप यह तय कर सकते हैं कि वे समान हैं कि वे एक स्किल टेबल में हैं (ऊपर मेरे उदाहरण में) जो यह निर्धारित करता है कि यह किस प्रकार का कौशल है।

यह एक अच्छा संकेत है कि आप अभी तक अपने प्रयासों से संतुष्ट नहीं हैं - इसका मतलब है कि आप किसी को चुनने से पहले कई संभावनाओं पर विचार करने को तैयार हैं। आप जितना अधिक स्केच पर विचार करेंगे, आपका अंतिम डिज़ाइन उतना ही बेहतर होगा। आखिरकार, सबसे अच्छा आपका डेटा आरेख बन जाएगा। जब यह काफी अच्छी तरह से तय हो जाता है, तो आप "कॉम्बो-बॉक्स" या "टेक्स्ट फ़ील्ड" के बारे में सोच सकते हैं, लेकिन मैं यूआई के फैसले को अंत तक छोड़ दूंगा।

JTrees को देखने के बजाय, मैं आपको डेटा संरचना, डेटाबेस डिज़ाइन और शायद डेटा मॉडलिंग के विषयों पर ध्यान देने का सुझाव दूंगा। EDIT-> या बेहतर अभी तक इकाई-संबंध मानचित्रण आरेख के रूप में डेविड काकज़ेंस्की ने सुझाव दिया! <-EDIT यदि आपको डेटा डिज़ाइन सही मिलता है, तो जावा और यूआई स्पष्ट रूप से और स्वाभाविक रूप से प्रवाह करेंगे। लेकिन अगर आप इसे गलत पाते हैं, तो जावा-कुंग-फू या यूआई-सौंदर्य की कोई भी राशि इसे ठीक नहीं करेगी।

सौभाग्य!

Answer 3

मैं ऑब्जेक्ट मॉडल पर ध्यान केंद्रित करने जा रहा हूं।

मुझे लगता है कि आप जो लचीलापन चाहते हैं, आप शायद अपनी कक्षाओं को एक ज्ञान में बदलना चाहते हैं (शायद "परिभाषा" इस मामले में एक बेहतर शब्द है) परत और लेनदेन की परत। "परत" से मेरा वास्तव में मतलब है कि आप उन्हें अपने सिर में तार्किक रूप से अलग करें। ज्ञान की परत में आपकी परिभाषा है कि पेड़ को कैसे लगाया जाए, और इसमें डेटा एक गेम डिजाइनर से आता है और डेटा लेयर किसी विशेष चरित्र के लिए विशेष विकल्प संग्रहीत करता है।

आपका ज्ञान स्तर कम से कम थोड़ा गन्दा होगा, क्योंकि आप गणितीय रूप से स्वच्छ मॉडल के बजाय एक शांत खेल बनाने की कोशिश कर रहे हैं।

आपके पास अब तक जो कुछ भी है उसे व्यवस्थित करने की कोशिश कर रहा है, मुझे लगता है कि आपके पास एक स्किलडिफाइनमेंट क्लास है, जिसमें स्किलडिफाइनमेंट का एक मूल गुण है। आपके पास कुछ मामलों को कवर करने के लिए SkillDefinition (जो डेटाबेस में DEF_SkillType तालिका में प्रविष्टियाँ बन सकता है) के उपवर्ग भी हैं।

"हथियार", "शारीरिक और मानसिक", और "चिकित्सा" में शीर्षक (और बाल कौशल) के अलावा कुछ भी नहीं है।

"वन हैंडेड", "स्ट्रेंथ", और "बिंद वाउंड्स" में एक संबद्ध कॉम्बो बॉक्स (जिसका अर्थ है डेफ़_सकिल के लिए एक विदेशी कुंजी के साथ डेटाबेस पर एक DEF_SkillChoice टेबल जैसा कुछ है)। तलवार और धनुष एक उपयोगकर्ता परिभाषित स्ट्रिंग प्रतीत होते हैं (इसलिए ज्ञान के स्तर पर कोई संबद्ध तालिका नहीं है, लेकिन डेटा लेन-देन परत पर संग्रहीत किया जाएगा)।

"जीवन" से लगता है कि इसके साथ एक पूर्णांक जुड़ा हुआ है। यह भविष्य में किसी पूर्णांक का उपयोग करने वाली विशेषताओं के साथ इस वर्ग को साझा करने में सक्षम नहीं हो सकता है, क्योंकि पूर्णांक कैसे बढ़े हैं, इस पर निहित व्यवहार है। किसी भी मामले में, वर्तमान में इसकी अपनी कक्षा की आवश्यकता है।

"तलवार", "बो", "स्ट्रेंथ", और "बिंद घाव" सभी को पेड़ में उनके नीचे प्रगतिशील कौशल के जुड़े स्तर लगते हैं। "तलवार" और "बो" के मामले में, वे स्तर वास्तव में उनके मूल कौशल से जुड़े होते हैं। मुझे लगता है कि आपको कानूनी मूल्यों के आदेशित संग्रह (DEF_SkillLevel तालिका) में विदेशी कुंजी के साथ DEF_Skill के साथ ProgressiveSkillDefinition वर्ग की आवश्यकता है। ज्ञान के स्तर पर यह पूरी तरह से स्पष्ट नहीं है कि आप क्या नियम बना रहे हैं। यदि "प्रवीणता" और "विशेषज्ञता" हमेशा उपलब्ध हैं। सभी हथियारों के लिए, आपके पास "दक्षता" और "विशेषज्ञता" रिकॉर्ड के साथ DEF_SkillLevel तालिका हो सकती है जिसमें "हथियार" रिकॉर्ड के लिए विदेशी कुंजी होती है।

यह आपके पास ज्ञान स्तर पर जो कुछ भी है उसे कवर करता है। लेन-देन स्तर (शायद "चरित्र स्तर" एक बेहतर नाम होगा?) सिर्फ उचित ज्ञान स्तर की ओर इशारा करता है। इसलिए, आपके उदाहरण में, आपके पास एक स्किल ऑब्जेक्ट के साथ एक कैरेक्टर ऑब्जेक्ट होगा जिसमें कौशल का एक संग्रह है - बस वह जो वास्तव में उसके पास है।

तो, चरित्र में एक "प्रवीणता" कौशल होगा जिसका माता-पिता "तलवार" कौशल है और जिसका प्रकार Skill_Level है। डेटाबेस में Trans_SkillDefinition रिकॉर्ड में ट्रांजेक्शनल "तलवार" स्किल रिकॉर्ड और नॉलेज लेवल DEF_SkillLevel रिकॉर्ड के साथ "प्रवीणता" नाम की एक विदेशी कुंजी है।

दक्षता कौशल "तलवार" कौशल का एक मूल उद्देश्य होगा, Skill_UserNamed प्रकार का। डेटाबेस में यह ज्ञान के स्तर के लिए एक विदेशी कुंजी नहीं होगी, क्योंकि "तलवार" (यह उपयोगकर्ता का नाम) के लिए कुछ विशेष परिभाषित नहीं है। हालाँकि, यह पैतृक लेन-देन रिकॉर्ड के लिए एक विदेशी कुंजी भी है, इसलिए इसके माध्यम से अधिक जानकारी उपलब्ध है।

"तलवार" कौशल वस्तु में "एक-हाथ" की मूल वस्तु होती है, क्योंकि उपयोगकर्ता ने "तलवार" को "एक-हाथ" श्रेणी में रखना चुना। यह एक प्रकार है SkillCategory। डेटाबेस में रिकॉर्ड "एक-हाथ" के लिए DEF_SkillChoice तालिका के लिए एक विदेशी कुंजी है, और कोई लेन-देन करने वाला माता-पिता नहीं है क्योंकि इस कौशल के सभी अतिरिक्त डेटा ज्ञान के स्तर पर संग्रहीत हैं।

एक नए चरित्र के लिए प्रारंभिक वृक्ष का निर्माण करने में, केवल ज्ञान के स्तर की आवश्यकता होती है। किसी वर्ण के लिए चुने गए विकल्पों को आबाद करने के लिए लेन-देन के स्तर की आवश्यकता होती है।

आपको ऑब्जेक्ट मॉडल को एक पेड़ में अनुवाद करने के लिए कोड की आवश्यकता होगी, और वापस। यह स्पष्ट होना चाहिए, मुझे उम्मीद है, आपको क्या करने की आवश्यकता है - ज्ञान परत पर प्रत्येक प्रकार के पेड़ पर नियंत्रण का एक संबद्ध सेट होगा, जो उस प्रकार के लिए उपयुक्त डेटा प्राप्त करता है।

बाद में आप SkillCategory रिकॉर्ड्स में प्रत्येक पसंद के लिए कक्षाएं ले सकते हैं, (यदि "स्पेशलाइज़ेशन" के साथ व्यवहार जुड़ा हुआ है, तो कोड को कहीं जाना होगा), लेकिन आपको इस पेड़ के लिए अभी तक इसकी आवश्यकता नहीं है, और यह डिज़ाइन संगत होगा उस के साथ। आपके पास बस एक फैक्ट्री होनी चाहिए जो ज्ञान स्तर की जानकारी का उपयोग सही वस्तु बनाने के लिए करे।

Comments

यदि यह अस्पष्ट है या प्रश्न का उत्तर नहीं दे रहा है, तो मुझे बताएं। यह एक बड़ा विषय है और कुछ बिंदु पर मुझे रुकना पड़ा।

— Psr

यह वास्तव में मैं क्या चाहता हूँ के लिए निकटतम उत्तरदाता है, जो प्रणाली मैं अनुकरण कर रहा हूं और जो काम कर सकता है उसके लिए कोड को स्वाभाविक लगता है। अभी मेरा कौशल सभी एक सार SkillComponent (AbSkillComponent) से निकलता है, क्योंकि मुझे अमूर्त वर्गों के लिए एक अच्छा नामकरण सम्मेलन नहीं मिल सकता है), और मेरे पास एक रूटस्किलकंपोनेंट, SkillComponent और ड्रॉप डाउन बॉक्स और UserNamed भाग करने के लिए कुछ इंटरफेस हैं। मुझे यह जोड़ने के लिए धन्यवाद देना होगा कि यह डेटाबेस से कैसे संबंधित है, कुछ मैं अभी के लिए बंद कर रहा हूं, लेकिन इसके बारे में सोचने लायक है। यह उत्तर बहुत अच्छा है, और निश्चित रूप से ताजी हवा की एक सांस है।

— प्योरफेराट

@Pureferret - मुझे लगता है कि मैं जवाब छोड़ दूंगा जैसा कि तब है - मुझे यकीन नहीं था कि मुझे पता था कि आप क्या देख रहे थे।

— Psr

Answer 4

आखिरकार, हम हमेशा पदानुक्रमित संरचनाओं का प्रबंधन करते हैं - यह एक कार्यक्रम की एक श्रेणी पदानुक्रम है, या खुद को "आंतरिक दुनिया" (जीयूआई, डीबी कनेक्शन, डेटा बाध्य व्यापार तर्क, आदि) से जोड़ने वाले विभिन्न मॉड्यूल से बनाया गया कार्यक्रम है। । लेकिन यह दर्शन है, यह आपके मामले में कैसे काम करना चाहिए?

आपके पास इस पेड़ में नोड्स हैं, प्रत्येक आइटम एक "ऑब्जेक्ट उदाहरण" है; उनके व्यवहार के दौरान (जहां आप उन्हें डाल सकते हैं, अनुमत बच्चे नोड्स, आदि की सूची) कुछ सेटों के लिए आम है, जैसे "कक्षाएं"। हां, यह एक प्रोग्राम कोड की तरह है। यदि आप जावा प्रतिबिंब को पर्याप्त रूप से जानते हैं, तो आप इस घटक को बनाने के लिए POJO वर्गों और वंशानुक्रम पदानुक्रम का भी उपयोग कर सकते हैं, वास्तविक उदाहरणों के निर्माण के लिए IoC कंटेनर या फ़ैक्टरी तंत्र के साथ। लेकिन मुझे लगता है कि आप ऐसा नहीं चाहते, क्योंकि यह एक भारी भाषा हैकिंग है, इसलिए ...

सबसे पहले, एक "वर्ग" ऑब्जेक्ट बनाएं जो वस्तुओं के व्यवहार का वर्णन करेगा। इसमें वर्ग पहचानकर्ता, "फ़ील्ड" नाम और अनुमत प्रकार और वस्तुओं की गणना आदि शामिल हैं। उदाहरण: "रूट" वर्ग "प्लेयर गुण" है, "भौतिक / मानसिक", "चिकित्सा", "हथियार" क्षेत्र है। यह प्रकार "अंतिम" है: अभी आप विभिन्न प्रकार के खिलाड़ी नहीं रखना चाहते हैं। संकेत: बाद में आप इसे कर सकते हैं, "गैर-मानव राक्षसों" को संभालने के लिए एक ही उपकरण का उपयोग करके ... :-)

"मेडिकल" क्षेत्र है

• "सिंगलटन": खिलाड़ी के पास कई "मेडिकल" जानकारी नहीं हो सकती
• बाल प्रकार तय हो गया है, केवल "मेडिकल" प्रकार की वस्तु का उपयोग किया जा सकता है
• आवश्यक: जब आप एक खिलाड़ी बनाते हैं, तो उसके पास "चिकित्सा" क्षेत्र होना चाहिए

विपरीत: हथियार के सदस्य की आवश्यकता नहीं है, इसे तब बनाया जाना चाहिए जब आपके खिलाड़ी में पहला हथियार जोड़ा जाए। इसका मतलब है: जब आप अपने "ऑब्जेक्ट" (अब खिलाड़ी) को "संपादित" करते हैं, और इसमें एक नई वस्तु जोड़ने की अनुमति देना चाहते हैं, तो आपको उदाहरण के वास्तविक गुणों (जो अब शामिल नहीं है) द्वारा चयन को सीमित नहीं करना चाहिए "हथियार" "), लेकिन वर्ग परिभाषा के सभी क्षेत्रों को दिखाएं, और जब पहली बार उपयोग किया जाता है तो आलसी नए क्षेत्र (बाल नोड) बनाएं। यह एक एक्स्टेंसिबल वातावरण बनाएगा। बाद में, आप कई खिलाड़ियों के साथ "मित्र" फ़ील्ड जोड़ सकते हैं ... एर ... संदर्भ (बाद में देखें)।

वास्तविक "कक्षाएं" के साथ प्रक्रिया का पालन करें। यह आपके विचारों को परिष्कृत करने में आपकी मदद करेगा, जैसे: हथियार हथियार (तलवार, खंजर, धनुष, ...) को अलग करना बेहतर लगता है, किसी भी तरह बारूद को संभालना (यह जानते हुए कि शायद खिलाड़ी के पास धनुष नहीं है, लेकिन तीर एकत्र कर सकता है, लेकिन उपयोग करना कुछ हथियारों के लिए बारूद की आवश्यकता होती है और उनमें से कुछ को पाया जा सकता है, दूसरों को खो दिया जाता है ...) "हथियार" वर्ग के तहत: यह सर्वेक्षण करना आसान है, और यह भी बताएं कि क्या आपका खिलाड़ी केवल उस सामान को ले जाता है या उसका उपयोग भी कर सकता है ( कौशल है)। दूसरी ओर: आप निश्चित रूप से इस संरचना को बाद में बदल देंगे, जैसा कि आप अपने खेल को विकसित करते हैं।

एक विश्व स्तर पर उपलब्ध "क्लास स्टोर" बनाएं जिसे आप शुरू करते हैं जब आपका गेम शुरू होता है, और वर्ग परिभाषाओं की सेवा करता है जब कोई भी उनके नाम को संदर्भित करता है। इस मामले में क्लास डिफ ऑब्जेक्ट्स को अपरिवर्तनीय होना चाहिए।

"ऑब्जेक्ट्स" आसान हैं: उन्हें उसी मूल वर्ग से प्राप्त किया जा सकता है जिसमें कक्षा की परिभाषा और खेतों तक सामान्य पहुंच का संदर्भ होता है। शायद उन बच्चों को शामिल करने के लिए एक HashMap का उपयोग करें, जिन्हें फ़ील्ड नाम से पहचाना जाता है। याद रखें: उन क्षेत्रों में से कुछ में एक ही वस्तु होती है, दूसरों में वस्तुओं का एक सेट होता है। ये उदाहरण निश्चित रूप से परस्पर हैं।

अब इंटरफ़ेस के लिए। सबसे पहले, आपको JTree ट्यूटोरियल की जांच करनी चाहिए ... , और यह अब स्पष्ट होना चाहिए। प्रत्येक "ऑब्जेक्ट" को एक DefaultMutableTreeNode द्वारा दर्शाया जा सकता है, नोड का "userObject" आपका ऑब्जेक्ट होना चाहिए (मुझे लगता है कि नोड के लेबल के रूप में उस नोड के toString () को प्रदर्शित किया जाता है, लेकिन आप कस्टम सेल फॉर्मैटर बना सकते हैं)। जब भी आप एक नोड खोलते हैं, तो आप ऑब्जेक्ट के फ़ील्ड्स को ब्राउज़ करते हैं, और पेरेंट के तहत चाइल्ड नोड्स बनाते हैं (यदि आप इसे गतिशील रूप से करना चाहते हैं) - या पूरे पेड़ को ब्राउज़ करें और ट्रीटोड संरचना का निर्माण करें जब आप JTree (संकेत) प्रदर्शित करते हैं। एक ट्रीट्रोड पैरामीटर के साथ JTree अवरोधक है)।

जब आप पेड़ में एक नोड का चयन करते हैं, तो आपके पास ऑब्जेक्ट उदाहरण होता है। इसकी कक्षा के द्वारा, आप एक उचित संपादक पैनल या कक्षा परिभाषा द्वारा उत्पन्न एक जेनेरिक प्रदर्शित कर सकते हैं (जैसे: फ़ील्ड टैब, फ़ील्ड के साथ संपादक, फ़ील्ड घोषणा द्वारा वास्तविक फ़ील्ड के लिए: एक बटन जो उचित प्रकार का एक बच्चा बनाता है आपको उपलब्ध वर्गों में से एक का चयन करने देता है; और उस उदाहरण के लिए संपादक फ़ील्ड, जैसे हथियार गुण)। संरचना को संशोधित करने के बाद, आपको पेड़ को स्वयं ताज़ा करना होगा - ट्रीमॉडल और इसकी आग ... परिवर्तन कार्य आपके मित्र हैं।

अच्छा लगता है? या बहुत जटिल है? खैर, यह कहानी का एक छोटा सा अंश है। मैंने कोई बात नहीं की है

• वर्ग की परिभाषा पदानुक्रम / या वर्गीकरण। आप उनमें से एक का बेहतर उपयोग करते हैं, जब आप विभिन्न वर्गों को एक ही क्षेत्र में जोड़ने का समर्थन करेंगे (जैसे विभिन्न प्रकार की तलवारें)। वर्गीकरण के लिए एक समर्थक: एक वर्ग में कई श्रेणियां हो सकती हैं, एक निश्चित वंशानुक्रम वृक्ष नहीं, एक अच्छा सामान जब आप कौशल सुधार पर एक्सपी खर्च करने पर किसी खिलाड़ी के "सभी कौशल" एकत्र करना चाहते हैं ... :-)
• दृढ़ता का समर्थन: आपको ऑब्जेक्ट को पदानुक्रम में बाह्य रूप से संग्रहीत करने के लिए एक जेनेरिक समाधान बनाना होगा, जैसे कि गुण याSON फ़ाइल में। यदि आप अपने मस्तिष्क को अच्छे आकार में रखना चाहते हैं, तो मानव पठनीय प्रारूप, सं बाइनरी क्रमांकन का उपयोग करें।
• उदाहरण भंडारण: आप जल्द ही महसूस करेंगे कि आपके खेल की "दुनिया" को एक स्थान पर रखा जाना बेहतर है। एक निश्चित तलवार आपके खिलाड़ी की संपत्ति नहीं है, लेकिन आपके खेल में दुनिया में एक इकाई (खिलाड़ी इसे खो सकता है, कोई इसे पा सकता है, आदि), तो आपके पेड़ में इनमें से कई "वस्तुएं" वास्तव में संस्थाओं के लिए संदर्भ हैं। (जबकि अन्य, खिलाड़ी के स्वास्थ्य की तरह वास्तव में केवल विशेषताएँ हैं)। आपको दो प्रकारों को अलग करना होगा, उदाहरणों के लिए एक वैश्विक भंडारण होगा जो संदर्भों को हल कर सकता है। खेल राज्य को क्रमबद्ध करते समय यह भी आपको बचाएगा, और कई संस्थाएं एक ही अन्य इकाई (जैसे एक ही मंदिर में कई खिलाड़ियों के "स्थान") को संदर्भित करती हैं।
• (और वास्तविक मस्तिष्क की चक्की का उल्लेख करने के लिए: वर्ग भंडारण और उदाहरण भंडारण की समानता; तथ्य यह है कि प्रकार की घोषणा आपके कार्यक्रम घटकों, सक्रिय विंडो, उपयोगकर्ता सत्र, आदि के रूप में उसी तरह वस्तु उदाहरण हो सकती है) यह भूमि है मेरे जैसे पागलों की।)

वैसे भी, मुझे आशा है कि आप इस वॉर्मअप सत्र का उपयोग कर सकते हैं।

Answer 5

मैं आपको एक लंबा जवाब नहीं देने जा रहा हूं, लेकिन मैंने इस तरह की स्थिति का सामना पहले किया है और स्पष्ट रूप से, मैंने किसी भी डेटा संरचना का उपयोग करने की कोशिश की। मैंने बस अपनी खुद की वस्तु बनाई है जो नए माता-पिता और बच्चों को XML नोड के समान स्वीकार कर सकती है।

हालांकि आपके मामले में, मुझे लगता है कि Xml क्लास का उपयोग करने से मदद मिलेगी। फिर आपके पास प्रत्येक नोड के लिए गुण हो सकते हैं जो आपको बता सकते हैं कि क्या एक कक्षा एक कौशल है और आप आसानी से किसी भी नोड के माता-पिता और बच्चों को प्राप्त कर सकते हैं जो आप कॉम्बो बॉक्स में उपयोग करना चाहते हैं या अन्यथा।

इसके अलावा, मैं यह जोड़ना चाहूंगा कि आपको बहुत सारे पाठ / तार के होने के विचार से नहीं चलना चाहिए। खेलों में आमतौर पर एआई शामिल होता है, और एआई में आमतौर पर बहुत सारे ग्रंथ शामिल होते हैं।

Comments

इस खेल को कार्यक्रम के माध्यम से नहीं खेला जा रहा है, यह सिर्फ लगातार प्रस्तुत किए गए डेटा और कुछ तर्क है। हालांकि मैं निश्चित रूप से XML में देखूंगा। धन्यवाद!

— शुद्ध