โปรดทราบ: ฉันไม่ต้องการความช่วยเหลือในการเขียนโปรแกรมที่นี่ฉันเปิดProgrammersเพื่อเหตุผล ฉันต้องการพัฒนาทักษะการวางแผนโปรแกรม / การเขียนของฉันไม่ใช่แค่เข้าใจ Javaเท่านั้น

ฉันพยายามที่จะคิดออกว่าจะทำให้ต้นไม้ที่มีระบบหมวดหมู่โดยพลการบนพื้นฐานของทักษะที่ระบุไว้สำหรับเกมสวมบทบาทนี้ที่นี่ ความพยายามครั้งก่อนของฉันมีบูลว่าทักษะนั้นเป็นหมวดหมู่หรือไม่ พยายามรหัสรอบที่ยุ่ง การวาดต้นไม้ของฉันฉันสังเกตเห็นว่า 'ใบไม้' ของฉันเป็นทักษะเท่านั้น

สิ่งที่ฉันตามมาคือวิธีในการสร้างทรีที่พยายามแยกโมเดลและมุมมองและอนุญาตให้เพิ่มโหนดย่อยประเภทลูก (โดยมีวิธีการแก้ไข / เรนเดอร์แยกต่างหาก) ให้กับผู้ปกครองโดยพลการ

NB ซื้อทุกอย่างที่นี่เป็นทักษะแม้ในที่ที่ดูเหมือนว่าเป็นทรัพย์สิน ผู้ใช้จะเห็นว่านี่เป็นทักษะการซื้อ (ซึ่งพวกเขาทำบนกระดาษ ATM) ดังนั้นจึงควรแสดงเช่นนี้ทั้งหมดในหน้าเดียวกัน

คำอธิบายของต้นไม้:ต้นไม้ 'เกิด' พร้อมชุดหมวดหมู่ระดับสูงที่มีการเข้ารหัสอย่างหนัก ( อาวุธ, ร่างกายและจิตใจ, การแพทย์และอื่น ๆ ) จากนี้ผู้ใช้จะต้องสามารถเพิ่มทักษะ ในที่สุดพวกเขาต้องการเพิ่มทักษะ 'ความเชี่ยวชาญพิเศษด้วยดาบ' ( ไม่ใช่ไอเท็ม) เป็นต้น จะทำอย่างไรเพื่อให้คุณนึกคิดต้องการคลิก 'เพิ่ม' กับWeaponsที่เลือกแล้วเลือกOne-handedจากโหนด ComboBox ที่ปรากฏในเด็กนั้นแล้วคลิกเพิ่มอีกครั้งและใส่ชื่อในช่องข้อความในว่าเด็กโหนดที่ปรากฏ จากนั้นคลิกเพิ่มอีกครั้งเพื่อเพิ่ม / ระบุ 'ระดับ' หรือ 'ระดับ' สำหรับลีฟนั้น ความเชี่ยวชาญครั้งแรกจากนั้นเชี่ยวชาญ (เช่น)

แน่นอนถ้าคุณต้องการซื้อทักษะที่แตกต่างมันเป็นเส้นทางที่แตกต่างไปจากเดิมอย่างสิ้นเชิง คุณอาจไม่จำเป็นต้องใช้กล่องคอมโบที่ระดับเดียวกับต้นไม้ในแบบเดียวกับที่คุณทำกับตัวอย่างอาวุธและต้องการตรรกะอื่น ๆ ที่อยู่เบื้องหลัง นี่คือสิ่งที่ฉันมีปัญหาในการทำให้หัวของฉันเขียนโปรแกรมอยู่คนเดียว วิธีสร้างชุดของคลาสและไม่ได้ระบุว่าคำสั่งใดที่จะแนบเข้าด้วยกัน แต่ยังคงพอดี

ระบบที่ดีสำหรับการอธิบายต้นไม้ประเภทนี้ในรหัสคืออะไร? ทั้งหมดตัวอย่าง JTree อื่น ๆ ที่ผมเคยเห็นมีบางส่วนที่คาดการณ์รูปแบบและเหมืองไม่ได้ ฉันไม่ต้องการรหัสนี้ทั้งหมดใน 'ตัวอักษร' ด้วยรายการแบบยาวประเภทใด (กล่องคำสั่งผสมฟิลด์ข้อความและอื่น ๆ ) ของโหนดลูกควรได้รับอนุญาตในสิ่งที่ผู้ปกครอง ฉันควรจะใช้คลาสนามธรรม? อินเตอร์เฟซ?

ฉันจะทำให้กลุ่มของวัตถุประเภทนี้ขยายได้เมื่อฉันเพิ่มทักษะอื่น ๆ ที่ไม่ได้ระบุไว้ข้างต้นที่มีพฤติกรรมแตกต่างกันอย่างไร

หากไม่มีระบบที่ดีในการใช้มีกระบวนการที่ดีในการหาวิธีการทำสิ่งนี้หรือไม่?

หัวเกียร์ของฉันกำลังหมุน:

ฉันต้องการ:

• ตรวจสอบผู้ปกครอง
• ให้ตัวเลือกตามผู้ปกครอง

ฉันเริ่มคิดว่าเพราะสามัญชนฉันต้องการskillคลาสนามธรรม / อินเตอร์เฟสที่กำหนด / แสดงวิธีการทั่วไปสำหรับทักษะและหมวดหมู่ ฉันสามารถวางกฎและตัวเลือกในฐานข้อมูลและอ่านจากที่นั่น คำถามคือฉันคิดว่าตอนนี้ระหว่างวิธีนามธรรมหรืออินเตอร์เฟซและวิธีการใช้นั้น

ตัวอย่าง JTree ที่ไม่เปลี่ยนแปลงได้ง่าย

รหัส (ปฏิบัติตามและทดสอบกับ Java 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 ชวาสวิงกวดวิชามีรายการของตัวควบคุม

คุณยังคงต้องสร้างองค์ประกอบส่วนต่อประสานผู้ใช้เพื่อให้ผู้ใช้สามารถเลือกชนิดของโหนดที่ต้องการเพิ่มและแก้ไขโหนด หากพวกเขาเพิ่มกล่องคำสั่งผสมพวกเขาจะต้องสามารถกำหนดตัวเลือกที่กล่องจะให้ใช้ได้

คุณต้องการโมเดลข้อมูลพื้นฐานเพื่อบันทึกข้อมูลของคุณ คุณสามารถใช้รูปแบบการทำให้เป็นอนุกรมเริ่มต้นที่สร้างขึ้นในวัตถุ Java ทั้งหมด แต่มันมีไว้สำหรับการสร้างต้นแบบเท่านั้น - มันจะแตกถ้าคุณเคยเปลี่ยนรหัสโปรแกรมของคุณ คุณจะต้องใช้ฐานข้อมูลกับ JDBC หรือ JPA หรือคุณจะต้องเขียนรูทีนการทำให้เป็นอนุกรมของคุณเอง (หรือใช้ไลบรารีที่จัดการการทำให้เป็นอันดับสำหรับคุณ) โดยใช้ JSON หรือ XML เป็นรูปแบบการจัดเก็บ

อัปเดต: โซลูชันที่เสนอพร้อมภาพรวมโครงการ

ทางออกที่ง่ายที่สุดอาจจะลืมเกี่ยวกับฐานข้อมูลและหานิพจน์ XML ของข้อมูลก่อนจากนั้นแก้ไขไฟล์ XML และแสดงผลลัพธ์เป็น JTree โดยไม่มีกล่องคำสั่งผสมพิเศษหรืออะไร ฉันคิดว่านี่เป็นสิ่งที่ Chibueze Opata แนะนำด้วยคำตอบของเขา การแทนค่า 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

ตรวจสอบให้แน่ใจว่าได้บันทึกข้อมูลสำรองของโปรแกรมของคุณทุกครั้งที่ทำงานในตอนท้ายของแต่ละเหตุการณ์ ระบบควบคุมแหล่งที่ติดตั้งบนเครื่องอื่นเหมาะสำหรับสิ่งนี้ คุณสามารถใช้ github หรือ sourceforge หรือตัวควบคุมแหล่งสาธารณะอื่น ๆ ได้หากคุณไม่ต้องการแชร์รหัสของคุณและไม่ต้องการตั้งค่าเซิร์ฟเวอร์ที่มีตัวควบคุมแหล่งที่มาอยู่

โซลูชันใด ๆ เหล่านี้มีการทำงานมากมายและใหญ่กว่าโครงการเริ่มต้นแน่นอน หมายความว่าคุณจะใช้เวลาเรียนรู้ Java Swing และ XML หรือ JSON มากกว่าเล่น LARP ของคุณซึ่งเป็นเหตุผลที่ฉันสำรวจตัวเลือกในการทำด้วยเครื่องมือที่มีอยู่ก่อน แต่วิธีที่ดีที่สุดในการเรียนรู้ทุกอย่างคือวิธีที่คุณมีแรงจูงใจในการเรียนรู้มากที่สุด ดังนั้นนี่อาจเป็นโครงการที่สมบูรณ์แบบสำหรับคุณ

ฉันหวังว่าจะช่วย

ฉันไม่คิดว่า JTree เป็นตัวแทนที่ถูกต้องสำหรับปัญหาที่คุณพยายามแก้ไข ฉันดูที่เว็บไซต์ของคุณและฉันเห็นรายการสิ่งของ นี่เป็นการเริ่มต้นที่ดี แต่ฉันคิดว่ามีการออกแบบข้อมูลพื้นฐานที่คุณอาจมี แต่ฉันไม่เห็น

ชีวิตและความแข็งแกร่งมีลักษณะเหมือนตัวละครในตัวฉัน Double, Triple และ Quadruple มีลักษณะเหมือนค่าสำหรับแอตทริบิวต์ Strength จากนั้นฉันก็เห็นทักษะแบ่งออกเป็นอาวุธและการแพทย์ ฉันคิดว่าอาวุธเป็นสมบัติ (ที่คุณสามารถซื้อหาหรือทิ้ง) และฉันคิดว่าทักษะคือสิ่งที่ช่วยให้คุณมีประสิทธิภาพด้วยอาวุธที่กำหนด แต่วิธีที่ฉันดูมันอาวุธและยารักษาโรคไม่มีทักษะ ที่จริงแล้วฉันสงสัยอย่างยิ่งว่าตัวละครนั้นเป็นตัวเลขหลักในการออกแบบข้อมูลของคุณ

นี่คือวัตถุข้อมูลสามอย่างที่โดดเด่นสำหรับฉันจากการออกแบบของคุณ:

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: จำนวนมากและกลุ่มที่มีจำนวนมาก: จำนวนมากและติดป้ายกำกับไว้ อาจมี "มี - a" และ "เป็น - a" และความสัมพันธ์ประเภทอื่น ๆ เช่นกัน

คุณอาจตัดสินใจว่าคุณต้องการการรับรองแยกต่างหากสำหรับ WeaponSkill vs. HealingSkill vs. การผลิตทักษะ หรือคุณอาจตัดสินใจว่ามันคล้ายกันมากกับตารางทักษะ (ในตัวอย่างของฉันด้านบน) โดยมีเขตข้อมูลกำหนดประเภทของทักษะ

มันเป็นสัญญาณที่ดีที่คุณไม่พอใจกับความพยายามของคุณ - หมายความว่าคุณยินดีพิจารณาความเป็นไปได้มากมายก่อนที่จะเลือก ยิ่งคุณพิจารณาภาพร่างมากเท่าไหร่การออกแบบขั้นสุดท้ายของคุณก็จะยิ่งดีขึ้นเท่านั้น ในที่สุดสิ่งที่ดีที่สุดจะกลายเป็นแผนภาพข้อมูลของคุณ เมื่อการตัดสินค่อนข้างดีคุณสามารถกลับไปคิดเกี่ยวกับ "กล่องคำสั่งผสม" หรือ "ช่องข้อความ" แต่ฉันจะปล่อยให้การตัดสินใจของ UI สิ้นสุดลง

แทนที่จะดูที่ JTrees ฉันขอแนะนำให้คุณดูหัวข้อของโครงสร้างข้อมูลการออกแบบฐานข้อมูลและการสร้างแบบจำลองข้อมูล แก้ไข -> หรือดีกว่ายังไดอะแกรมการทำแผนที่ความสัมพันธ์เอนทิตีตามที่ David Kaczynski แนะนำ! <-EDIT หากคุณได้รับการออกแบบข้อมูลที่ถูกต้องแล้ว Java และ UI จะไหลจากมันชัดเจนและเป็นธรรมชาติ แต่ถ้าคุณเข้าใจผิด Java-kung-fu หรือ UI-beauty จะไม่แก้ไข

โชคดี!

ฉันจะมุ่งเน้นไปที่โมเดลวัตถุ

ฉันคิดว่าเพื่อความยืดหยุ่นที่คุณต้องการคุณอาจต้องการแยกชั้นเรียนของคุณออกเป็นความรู้ (บางที "คำจำกัดความ" เป็นคำที่ดีกว่าในกรณีนี้) เลเยอร์และเลเยอร์ธุรกรรม โดย "เลเยอร์" ฉันแค่หมายถึงการแยกพวกมันอย่างมีเหตุผลในหัวของคุณ เลเยอร์ความรู้ประกอบด้วยคำจำกัดความของคุณเกี่ยวกับวิธีการจัดโครงสร้างต้นไม้และข้อมูลในนั้นมาจากผู้ออกแบบเกมและชั้นข้อมูลจะจัดเก็บตัวเลือกเฉพาะสำหรับอักขระเฉพาะ

ระดับความรู้ของคุณจะยุ่งอย่างน้อยเล็กน้อยเพราะคุณกำลังพยายามสร้างเกมเจ๋ง ๆ มากกว่ารูปแบบทางคณิตศาสตร์ที่สะอาด

พยายามจัดระเบียบสิ่งที่คุณมีจนถึงตอนนี้ฉันคิดว่าคุณมีคลาส SkillDefinition มีคุณสมบัติพาเรนต์ของประเภท SkillDefinition คุณยังมีคลาสย่อยของ SkillDefinition (ซึ่งอาจกลายเป็นรายการในตาราง DEF_SkillType ในฐานข้อมูล) เพื่อครอบคลุมบางกรณี

"อาวุธ", "ร่างกายและจิตใจ" และ "การแพทย์" ดูเหมือนจะไม่มีอะไรนอกจากชื่อ (และทักษะเด็ก)

"One Handed", "Strength" และ "Bind Wounds" ดูเหมือนจะมีช่องคำสั่งผสมที่เกี่ยวข้อง (ซึ่งหมายถึงบางสิ่งเช่นตาราง DEF_SkillChoice ในฐานข้อมูลที่มี foreign key to DEF_Skill) ดูเหมือนว่า Sword and Bow จะเป็นสตริงที่ผู้ใช้กำหนด (ดังนั้นจึงไม่มีตารางที่เกี่ยวข้องในระดับความรู้ แต่ข้อมูลจะถูกเก็บไว้ที่ชั้นการทำธุรกรรม)

"ชีวิต" ดูเหมือนจะมีจำนวนเต็มที่เกี่ยวข้องกับมัน อาจไม่สามารถแชร์คลาสนี้กับคุณสมบัติในอนาคตใด ๆ ที่ใช้จำนวนเต็มเนื่องจากมีพฤติกรรมโดยนัยเกี่ยวกับวิธีการเพิ่มจำนวนเต็ม ไม่ว่าในกรณีใดในขณะนี้จะต้องการคลาสของตัวเอง

"Sword", "Bow", "Strength" และ "Bind Wounds" ทุกคนดูเหมือนจะมีระดับความสัมพันธ์ที่ก้าวหน้าของทักษะด้านล่างในต้นไม้ ในกรณีของ "Sword" และ "Bow" ระดับเหล่านั้นเกี่ยวข้องกับทักษะการเป็นพ่อแม่ ฉันคิดว่าคุณต้องการคลาส ProgressiveSkillDefinition พร้อมชุดของค่าทางกฎหมายที่สั่ง (ตาราง DEF_SkillLevel พร้อมคีย์ต่างประเทศเพื่อ DEF_Skill ในระดับความรู้มันยังไม่ชัดเจนว่าคุณกำลังสร้างแบบจำลองกฎอะไรถ้า "ความเชี่ยวชาญ" และ "ความเชี่ยวชาญ" เสมอ สำหรับอาวุธทุกชนิดคุณอาจมีตาราง DEF_SkillLevel ที่มีบันทึก "ความชำนาญ" และ "ความเชี่ยวชาญ" ที่มีคีย์ต่างประเทศในบันทึก "อาวุธ"

สิ่งนี้ครอบคลุมสิ่งที่คุณรู้ในระดับความรู้ ระดับธุรกรรม (อาจเป็น "ระดับตัวอักษร" อาจเป็นชื่อที่ดีกว่าใช่หรือไม่) เพียงชี้ไปที่ระดับความรู้ที่เหมาะสม ดังนั้นในตัวอย่างของคุณคุณจะมีตัวละครวัตถุที่มีทักษะสกิลที่มีชุดทักษะ - สิ่งที่เขามี

ดังนั้นตัวละครจะมีทักษะ "ความชำนาญ" ซึ่งผู้ปกครองเป็นทักษะ "ดาบ" และประเภทที่มี Skill_Level ในฐานข้อมูลเร็กคอร์ด TRANS_SkillDefinition มีคีย์ต่างประเทศสำหรับบันทึกทักษะ "sword" ของทรานแซคชันและระดับความรู้ DEF_SkillLevel บันทึกที่มีชื่อ "ความเชี่ยวชาญ"

ทักษะความชำนาญจะมีวัตถุแม่ของทักษะ "ดาบ" ประเภท Skill_UserNamed ในฐานข้อมูลนี้จะไม่มีคีย์ต่างประเทศในระดับความรู้เนื่องจากไม่มีสิ่งใดที่กำหนดเป็นพิเศษสำหรับ "ดาบ" (เป็นชื่อของผู้ใช้) อย่างไรก็ตามมันยังมีคีย์ต่างประเทศไปยังระเบียนทรานแซคชันของผู้ปกครองเพื่อให้สามารถดูข้อมูลเพิ่มเติมได้

วัตถุทักษะ "ดาบ" มีวัตถุหลักของ "มือเดียว" เนื่องจากผู้ใช้เลือกที่จะใส่ "ดาบ" ในหมวดหมู่ "มือเดียว" นี่เป็นวัตถุประเภท SkillCategory ในฐานข้อมูลมีคีย์ต่างประเทศไปยังตาราง DEF_SkillChoice สำหรับบันทึก "มือเดียว" และไม่มีผู้ปกครองทำธุรกรรมเพราะข้อมูลเพิ่มเติมทั้งหมดสำหรับทักษะนี้จะถูกเก็บไว้ที่ระดับความรู้

ในการสร้างทรีเริ่มต้นสำหรับอักขระใหม่ต้องมีการสอบถามระดับความรู้เท่านั้น ในการเติมตัวเลือกที่สร้างขึ้นสำหรับตัวละครต้องใช้ระดับการทำธุรกรรม

คุณจะต้องใช้รหัสเพื่อแปลโมเดลวัตถุเป็นแผนผังและย้อนกลับ มันควรจะชัดเจนว่าฉันหวังว่าสิ่งที่คุณต้องทำ - แต่ละประเภทที่ชั้นความรู้จะมีชุดควบคุมที่เกี่ยวข้องบนต้นไม้ที่ได้รับข้อมูลที่เหมาะสมสำหรับประเภทนั้น

หลังจากนั้นคุณอาจต้องการคลาสสำหรับแต่ละตัวเลือกในระเบียน SkillCategory (หาก "ความเชี่ยวชาญ" มีพฤติกรรมที่เกี่ยวข้องรหัสจะต้องไปที่ใดที่หนึ่ง) แต่คุณยังไม่ต้องการต้นไม้เหล่านี้และการออกแบบนี้จะเข้ากันได้ กับที่ คุณจะต้องมีโรงงานที่ใช้ข้อมูลระดับความรู้เพื่อสร้างวัตถุที่เหมาะสม

ท้ายที่สุดเรามักจะจัดการโครงสร้างแบบลำดับชั้นเสมอไม่ว่าจะเป็นลำดับชั้นของโปรแกรมหรือโปรแกรมที่สร้างขึ้นจากโมดูลต่าง ๆ ที่เชื่อมต่อคุณกับ "โลกภายใน" (GUI, การเชื่อมต่อฐานข้อมูล, ตรรกะทางธุรกิจที่ถูกผูกไว้เป็นต้น) . แต่นี่คือปรัชญามันควรจะทำงานอย่างไรในกรณีของคุณ?

คุณมีโหนดในต้นไม้นี้แต่ละรายการเป็น "วัตถุตัวอย่าง"; ในขณะที่พฤติกรรมของพวกเขา (ซึ่งคุณสามารถวางไว้ได้รายการของโหนดลูกที่ได้รับอนุญาต ฯลฯ ) เป็นเรื่องปกติสำหรับบางชุดเช่น "คลาส" ใช่มันเหมือนกับรหัสโปรแกรม หากคุณรู้ว่ามีการสะท้อน Java เพียงพอคุณสามารถใช้คลาส POJO และลำดับชั้นการสืบทอดเพื่อสร้างส่วนประกอบนี้ด้วยคอนเทนเนอร์ IoC หรือกลไกจากโรงงานเพื่อสร้างอินสแตนซ์จริง แต่ฉันคิดว่าคุณไม่ต้องการเพราะมันเป็นการแฮ็คภาษาอย่างหนักดังนั้น ...

ขั้นแรกให้สร้างวัตถุ "คลาส" ที่จะอธิบายพฤติกรรมของรายการ ที่มีตัวระบุคลาสชื่อ "ฟิลด์" และประเภทและจำนวนรายการที่อนุญาตเป็นต้นตัวอย่าง: คลาส "รูท" คือ "คุณสมบัติของผู้เล่น" มี "ทางกายภาพ / จิต", "ทางการแพทย์", "อาวุธ" ประเภทนี้คือ "ขั้นสุดท้าย": ตอนนี้คุณไม่ต้องการมีเครื่องเล่นประเภทต่าง ๆ คำแนะนำ: ในภายหลังคุณสามารถทำได้โดยใช้เครื่องมือเดียวกันเพื่อจัดการ "สัตว์ประหลาดที่ไม่ใช่มนุษย์" ... :-)

ฟิลด์ "การแพทย์" คือ

• "ซิงเกิล": ผู้เล่นไม่สามารถมีข้อมูล "ทางการแพทย์" หลายรายการ
• ประเภทเด็กได้รับการแก้ไขเฉพาะวัตถุประเภท "การแพทย์" สามารถใช้ที่นี่
• ต้องมี: เมื่อคุณสร้างผู้เล่นจะต้องมีช่อง "ทางการแพทย์"

ตรงกันข้าม: ไม่จำเป็นต้องมีสมาชิกอาวุธมันควรจะสร้างขึ้นเมื่อมีการเพิ่มอาวุธชุดแรกลงในเครื่องเล่นของคุณ ซึ่งหมายความว่า: เมื่อคุณ "แก้ไข" วัตถุ "ของคุณ" (ตอนนี้ผู้เล่น) และต้องการอนุญาตให้เพิ่มรายการใหม่คุณไม่ควร จำกัด การเลือกตามคุณสมบัติจริงของอินสแตนซ์ (ซึ่งตอนนี้ไม่มีอาวุธ ") ") แต่แสดงฟิลด์ทั้งหมดของการกำหนดคลาสและสร้างฟิลด์ใหม่ (โหนดย่อย) อย่างเกียจคร้านเมื่อใช้ครั้งแรก สิ่งนี้จะสร้างสภาพแวดล้อมที่สามารถขยายได้ ในภายหลังคุณสามารถเพิ่มช่อง "เพื่อน" ด้วยการอ้างอิงผู้เล่นหลายคน ... เอ้อ ... (ดูภายหลัง)

ทำตามกระบวนการด้วย "คลาส" ที่แท้จริง มันจะช่วยให้คุณปรับแต่งความคิดของคุณเช่น: ดูเหมือนจะดีกว่าที่จะแยกประเภทอาวุธ (ดาบ, มีดสั้น, ธนู, ... ), จัดการกระสุนด้วยวิธีใดวิธีหนึ่ง (รู้ว่าบางทีผู้เล่นอาจไม่มีธนู แต่สามารถรวบรวมลูกธนูได้ อาวุธบางอย่างจำเป็นต้องใช้และการลดลงกระสุนบางส่วนของพวกเขาสามารถพบได้อื่น ๆ จะหายไป ... ) ภายใต้ชั้น "อาวุธ": มันง่ายต่อการสำรวจและยังแสดงว่าผู้เล่นของคุณดำเนินรายการเท่านั้นหรือสามารถใช้มันได้เช่นกัน มีทักษะ) ในทางตรงกันข้าม: คุณจะเปลี่ยนโครงสร้างนี้ในภายหลังในขณะที่คุณพัฒนาเกม

สร้าง "คลาสสโตร์" ที่มีอยู่ทั่วโลกที่คุณเริ่มต้นเมื่อเกมของคุณเริ่มต้นและให้บริการคำจำกัดความของคลาสเมื่อใครก็ตามที่อ้างถึงชื่อของพวกเขา วัตถุ def คลาสจะต้องไม่เปลี่ยนรูปในกรณีนี้

"ออบเจ็กต์" นั้นง่ายกว่า: พวกมันสามารถได้มาจากคลาสรูทเดียวกันที่มีการอ้างอิงไปยังนิยามคลาสและการเข้าถึงฟิลด์ทั่วไปเช่นกัน อาจใช้ HashMap เพื่อเก็บเด็กเหล่านั้นโดยระบุชื่อฟิลด์ ข้อควรจำ: ฟิลด์เหล่านี้บางอันมีวัตถุหนึ่งชิ้นส่วนของวัตถุอื่น ๆ แน่นอนว่ากรณีเหล่านี้ไม่แน่นอน

ตอนนี้สำหรับส่วนต่อประสาน ก่อนอื่นคุณควรตรวจสอบการสอน JTree ...และตอนนี้ควรชัดเจน แต่ละ "วัตถุ" สามารถแสดงโดย DefaultMutableTreeNode "userObject" ของโหนดควรเป็นวัตถุของคุณ (ฉันคิดว่า toString () ของโหนดนั้นจะแสดงเป็นป้ายชื่อของโหนด แต่คุณสามารถสร้างตัวจัดรูปแบบเซลล์แบบกำหนดเอง) เมื่อใดก็ตามที่คุณเปิดโหนดคุณจะเรียกดูฟิลด์ของวัตถุและสร้างโหนดย่อยภายใต้พาเรนต์ (ถ้าคุณต้องการทำแบบไดนามิก) - หรือเรียกดูทั้งแผนผังและสร้างโครงสร้าง TreeNode เมื่อคุณแสดง JTree (คำใบ้: เป็น JTree constuctor พร้อมพารามิเตอร์ TreeNode)

เมื่อคุณเลือกโหนดในทรีคุณมีอินสแตนซ์ของวัตถุ คุณสามารถแสดงแผงตัวแก้ไขที่เหมาะสมหรือคลาสทั่วไปที่สร้างโดยนิยามคลาส (เช่น: พาเนลแท็บที่มีฟิลด์ตัวแก้ไขสำหรับฟิลด์จริงโดยการประกาศฟิลด์: ปุ่มที่สร้างชายด์ของชนิดที่เหมาะสม ของให้คุณเลือกหนึ่งในคลาสที่มีอยู่และฟิลด์ตัวแก้ไขสำหรับอินสแตนซ์นั้นเช่นคุณสมบัติอาวุธ) หลังจากปรับเปลี่ยนโครงสร้างคุณต้องรีเฟรชโครงสร้างของตัวเอง - ฟังก์ชัน TreeModel และไฟ ... เปลี่ยนเป็นเพื่อนของคุณ

ดูดี? หรือซับซ้อนเกินไป? นี่เป็นเพียงส่วนเล็กน้อยของเรื่องราว ฉันไม่ได้พูดคุยเกี่ยวกับ

• ลำดับชั้นนิยาม / หรือการจัดหมวดหมู่ คุณควรใช้หนึ่งในนั้นเมื่อคุณจะสนับสนุนการเพิ่มคลาสต่าง ๆ ลงในเขตข้อมูลเดียวกัน (เช่นดาบชนิดต่าง ๆ ) มืออาชีพสำหรับการจัดหมวดหมู่: คลาสสามารถมีได้หลายหมวดหมู่ไม่ใช่แผนผังสืบทอดถาวรเป็นสิ่งที่ดีเมื่อคุณต้องการรวบรวม "ทักษะทั้งหมด" ของผู้เล่นเมื่อใช้ XP ในการปรับปรุงทักษะ ... :-)
• การสนับสนุนอย่างต่อเนื่อง: คุณต้องสร้างโซลูชันทั่วไปเพื่อจัดเก็บลำดับชั้นของวัตถุภายนอกเช่นในคุณสมบัติหรือไฟล์ JSON ใช้รูปแบบที่มนุษย์สามารถอ่านได้ไม่เป็นอนุกรมไบนารีหากคุณต้องการทำให้สมองของคุณอยู่ในสภาพดี
• อินสแตนซ์เก็บข้อมูล: คุณจะรู้ทันทีว่า "โลก" ของเกมของคุณควรเก็บไว้ในที่เดียว ดาบบางอันไม่ใช่ทรัพย์สินของผู้เล่นของคุณ แต่เป็นนิติบุคคลในโลกในเกมของคุณ (ผู้เล่นสามารถสูญเสียใครบางคนสามารถค้นหาได้ ฯลฯ ) ดังนั้น "วัตถุ" เหล่านี้จำนวนมากในต้นไม้ของคุณจึงอ้างอิงถึงเอนทิตี้ของ (ในขณะที่คนอื่น ๆ เช่นสุขภาพของผู้เล่นเป็นคุณลักษณะเท่านั้น) คุณจะต้องแยกทั้งสองประเภทมีที่เก็บข้อมูลส่วนกลางสำหรับอินสแตนซ์ที่สามารถแก้ไขการอ้างอิงได้ สิ่งนี้จะช่วยคุณประหยัดเวลาในการทำให้ซีเรียลสถานะเกมและหลายเอนทิตีอ้างอิงถึงเอนทิตีอื่น ๆ ที่เหมือนกัน (เช่น "ที่ตั้ง" ของผู้เล่นหลายคนในวัดเดียวกัน)
• (และพูดถึงเครื่องบดสมองจริง: ความคล้ายคลึงกันของการจัดเก็บข้อมูลในชั้นเรียนและการจัดเก็บอินสแตนซ์ความจริงที่ว่าการประกาศประเภทสามารถเป็นวัตถุอินสแตนซ์ของตัวเองในลักษณะเดียวกับส่วนประกอบของโปรแกรมหน้าต่างที่ใช้งานเซสชันของผู้ใช้เป็นต้น ของ maniacs เช่นฉัน.)

อย่างไรก็ตามฉันหวังว่าคุณจะสามารถใช้บางสิ่งในช่วงวอร์มอัพนี้ได้

ฉันจะไม่ให้คำตอบยาว ๆ กับคุณ แต่ฉันต้องเผชิญกับสถานการณ์แบบนี้มาก่อนและอย่างตรงไปตรงมาฉันเลิกพยายามใช้โครงสร้างข้อมูลใด ๆ ที่มีอยู่ ฉันเพียงแค่สร้างวัตถุของตัวเองที่สามารถยอมรับผู้ปกครองใหม่และเด็ก ๆ ที่คล้ายกับโหนด XML

อย่างไรก็ตามในกรณีของคุณฉันคิดว่าการใช้คลาส Xml จะช่วยได้ จากนั้นคุณสามารถมีคุณสมบัติสำหรับแต่ละโหนดที่สามารถบอกคุณได้ว่าคลาสนั้นเป็นทักษะหรือไม่และคุณสามารถรับผู้ปกครองและลูก ๆ ของโหนดใด ๆ ที่คุณต้องการใช้ในกล่องคำสั่งผสมหรืออย่างอื่นได้

นอกจากนี้ฉันต้องการเพิ่มคุณไม่ควรเรียกใช้จากความคิดที่มีข้อความ / สตริงจำนวนมาก เกมมักจะเกี่ยวข้องกับ AI และ AI มักจะเกี่ยวข้องกับข้อความมากมาย