Сложная структура данных дерева

Ответ 1

ОК, наконец, после того, как я возился и смотрел на всю систему в течение нескольких часов, вчера я придумал идею, я ее реализовал, и все получилось очень хорошо:) Я просто протестировал ее на трех уровнях трансформаций и он работал как магия. (на pic показан только один комбо, но я заверяю вас, что все комбо работают)

Позвольте мне поделиться своим решением. Было несколько настроек, которые я должен был сделать в своей предыдущей системе, сначала скажу, что это за хитрости, и почему я сделал каждый из них.

• Я изменил данные, хранящиеся на каждом node. В моем предыдущем подходе я если бы каждый node зависел от предыдущего, теперь требования к узлам происходит непосредственно из корня.

Вот как выглядит структура:

public struct TransData
{
    public TransData(string itemName, List <string> itemsRequired)
    {
        this.itemName = itemName;
        this.itemsRequired = itemsRequired;
    }
    public string itemName;
    public List <string> itemsRequired;
}

Node конструктор:

public TransNode(string itemName, List <string> itemsRequired)
{
    data = new TransData(itemName, itemsRequired);
}

Пример того, как теперь обрабатываются требования:

Necklace L.1_A: Requires BlueGem
Necklace L.1_B: Requires GreenGem
Necklace L.1_C: Requires RedGem
Necklace L.2_A: Requires BlueGem AND GreenGem
Necklace L.2_B: Requires GreenGem AND RedGem
Necklace L.2_C: Requires RedGem AND BlueGem
Necklace L.3_A: Requires RedGem AND BlueGem AND GreenGem

Теперь XML:

<IOUTransformableItemsDatabaseManager>
    <Necklace>
        <Level_0>
            <Path_0>
                <NewName>RedNecklace</NewName>
                <ItemsRequired>
                    <Item_0>Red</Item_0>
                </ItemsRequired>
            </Path_0>
            <Path_1>
                        .......
            </Level_0>
        <Level_1>
            <Path_0>
                <NewName>RedGreenNecklace</NewName>
                <ItemsRequired>
                    <Item_0>Red</Item_0>
                    <Item_1>Green</Item_1>
                </ItemsRequired>
            </Path_0>
            <Path_1>
                  .....
        </Level_1>
        <Level_2>
            <Path_0>
                <NewName>RedGreenBlueNecklace</NewName>
                <ItemsRequired>
                    <Item_0>Red</Item_0>
                    <Item_1>Green</Item_1>
                    <Item_2>Blue</Item_2>
                </ItemsRequired>
            </Path_0>
        </Level_2>
    </Necklace>
</IOUTransformableItemsDatabaseManager>

• Я добавил root node к моему дереву и удалил список nodes это имеет смысл. Этот предыдущий список nodes теперь равен  до root.nodes

Вот как выглядит дерево:

public class TransTree
{
    //public string itemName;
    //public List <TransNode> nodes;
    public List <TransLevel> levels = new List<TransLevel>();
    public TransNode root { private set; get; }
    public TransTree(string itemName)
    {
    //  this.itemName = itemName;
        root = new TransNode(itemName, null);
    }
}

• Теперь, почему я сделал первое изменение? (требования) Поскольку это позволил мне наладить связь между узлами, которые, в свою очередь, позволили мне, наконец, подключить их так, как я точно (как они связаны в дереве с 7 состояниями выше в моем Q) Как? - В моем примере ожерелья, какая связь между L.1_A и L.2_A? Ответ: L.1_A имеет один из требований L.2_A, который является BlueGem, они оба имеют это общее, что приводит нас к заключение:

Всякий раз, когда два узла, разделенных одним уровнем между ними, имеют что-то в общий, node на вышеуказанном уровне должен указывать на один выше

Итак, все, что я делаю, это просто перебрать все узлы на одном уровне и сравнить каждый из этих узлов уровня с каждым node на следующем уровне, если node на первом уровне имеет одно требование: node на следующем уровне есть, есть соединение:

public void ConnectNodes()
{
   for (int i = 0; i < levels.Count - 1; i++)
       ConnectNodes(i, i + 1);
   ConnectRoot();
}
private void ConnectNodes(int level1, int level2)
{
    int level1_nNodes = levels[level1].nodes.Count;
    int level2_nNodes = levels[level2].nodes.Count;
    for (int i = 0; i < level1_nNodes; i++)
    {
        var node1 = levels[level1].nodes[i];
        for (int j = 0; j < level2_nNodes; j++)
        {
            var node2 = levels[level2].nodes[j];
            foreach (var itemReq in node1.data.itemsRequired)
            {
                if (node2.data.itemsRequired.Contains(itemReq))
                {
                    node1.nodes.Add(node2);
                    break;
                }
            }
        }
     }
}

Обратите внимание на очень важную строку:

ConnectRoot();

public void ConnectRoot()
{
    foreach (var node in levels[0].nodes)
       root.nodes.Add(node);
}

Это ясно? - Я просто подключаю корень node к узлам первого уровня, а затем подключаю узлы уровня 1 к 2, от 2 до 3 и т.д. Конечно, я должен сделать это, прежде чем очищать уровни. Это не изменилось:

// fetching the data from the xml file
    tree.ConnectNodes();
    tree.RemoveLevels();

Почему я сделал второе изменение? (добавлен корень node к дереву).  Ну, вы можете ясно видеть преимущества наличия корня node, он  имеет больше смысла. Но главная причина, по которой я реализовал эту корневую идею,  это легко уничтожить узлы, которые я не возьму. Я упомянул в своем  Q, что всякий раз, когда я беру путь /node, узлы того же уровня  должен уйти, потому что это, я пошел по дороге, не собираюсь  назад. С корнем под рукой, теперь я мог бы легко сказать:

tree.SetRoot(nodeTakenToTransform);

Не нужно переходить через те узлы, которые я не брал, и обнулить их, просто изменив корень дерева на node, который я взял, что имеет дополнительное преимущество, чтобы освободить меня от бремени обработки моего дерева как некоторый sorta связанный список, (чтобы получить доступ к node по дереву, мне нужно пройти через корень, а что между корнем и node я хочу получить и, наконец, доехать до места назначения) - после каждого преобразования root уходит на один уровень, теперь мне нужно получить доступ к корневым узлам.

Осталась еще одна проблема. Это метод внутри моего пользовательского словаря для обработки элементов, когда элемент преобразуется, он "уведомляет" словарь о необходимости принятия необходимых действий (обновляет его ключи, значения и т.д.)

public void Notify_ItemTransformed(TransTree itemTree, TransNode nodeTaken)
{
   var key = new Tuple<string, string>(itemTree.root.data.itemName, nodeTaken.data.itemsRequired[0]);
   itemTree.SetRoot(nodeTaken);
   itemTree.UpdateNodesRequirements(itemTree.root); // take note here
   RemoveKey(key);
   RegisterItem(itemTree);
}

Что делает itemTree.UpdateNodesRequirements(itemTree.root)? Мое первое изменение ввело проблему. Например: Когда я достиг L.1_A, у меня уже есть BlueGem? иначе я бы не достиг такого уровня. Но проблема в том, что все узлы, после этого уровня, требующие BlueGem, все еще требуют его, хотя у меня есть это! Они не должны просить об этом, т.е. BlueGreenNecklace должен теперь требовать GreenGem. Вот почему теперь мне нужно обновить эти требования узлов, путем рекурсивного перехода с моего нового корня:

tree.SetRoot(nodeTaken);
tree.UpdateNodesRequirements(tree.root);

Здесь метод:

public void UpdateNodesRequirements(TransNode node)
{
    foreach (var n in node.nodes)
    {
        if (n.data.itemsRequired.Contains(root.data.itemsRequired[0]))
            n.data.itemsRequired.Remove(root.data.itemsRequired[0]);
        if (n.nodes != null && n.nodes.Count > 0)
            UpdateNodesRequirements(n);
    }
}

Все, что я говорю, "дорогой следующий уровень node, если вам требуется что-то, что у меня уже есть, пожалуйста, удалите это требование" - И это:) Надеюсь, вам понравилась моя статья XD - я поставлю следующую видео-демонстрацию в вопрос обновление когда это.

С точки зрения производительности? Хм, там несколько мест, где я мог бы сделать некоторые оптимизации, но на данный момент тестирование с 3 уровнями было действительно хорошим, без ухудшения вообще. Я сомневаюсь, что мой игровой дизайнер придумает что-то, что требует более 4 уровней, но даже если он это сделает, мой код должен быть достаточно быстрым, а если нет, я мог бы использовать yield return null в соответствующих местах, чтобы разделить работу на разных кадрах (Я использую Unity3D)

Что мне действительно нравится в этом решении, так это то, что оно работает для всех видов деревьев преобразования, даже если оно не было симметричным, для nPaths и nLevels:)

Спасибо всем, кто пытался помочь, и потратил время, чтобы прочитать это. - Vexe

Ответ 2

Что мне не нравится в этом решении:

• Простые решения - лучшие решения.
• Сложно поддерживать, поскольку ваш xml основан на графике.
• Не используйте OOP
• Источник ошибок
• Вероятное использование Reflection для небольших проблем (я говорю, потому что, если у вас будет такая игра, вы столкнетесь с гораздо более трудными проблемами;)). Это подразумевает излишнюю сложность.

Что мне нравится в этом решении:

• Вы только прекрасно поняли проблему. У каждого элемента есть список трансконкций с некоторыми другими объектами. Теперь проблема заключается в том, как представлять (а не хранить)

Что бы я сделал (juste IMHO, ваше решение тоже хорошо): используйте OOP в node - только с точки зрения. Таким образом, ваше дерево станет машиной состояния (как вы говорили о пути;)), если вы хотите прикрепить ее к структуре данных.

public class InventoryObject
{
    protected Dictionnary<Type, InventoryObject> _combinations = new Dictionnary<Type, InventoryObject>();

    public InventoryObject() {}       

    public InventoryObject Combine(InventoryObject o)
    {
       foreach (var c in _combinations)
          if (typeof(o) == c.Key)
            return c.Value

       throw new Exception("These objects aren't combinable");
    }
}

public class BlueHerb : InventoryObject
{
    public Herb()
    {
       _combinations.Add(RedHerb, new BlueRedHerb());
       _combinations.Add(GreenHerb, new BlueGreenHerb());
    }
}

public class BlueRedHerb: InventoryObject
{
    public BlueRedHerb()
    {
       _combinations.Add(GreenHerb, new GreyHerb());
    }
}

Затем просто вызовите BlueHerb.Combine(myRedHerb);, чтобы получить результат. Вы также можете сделать BlueHerb.Combine(myStone); и легко отлаживать.

Я стараюсь, чтобы мой пример был как можно более простым. Для подсветки кода (класс Herb, класс CombinedHerb, использование запросов LINQ и т.д.) Может быть сделано много изменений.