Лучшая практика для Перехода От Вложенного состояния до Вложенного состояния (см. схему),

Я просто угадаю здесь, но вы можете хранить это дерево в настоящем дереве в вашем коде, а затем, когда нажал, вы хотите навигаться, вы называете функцию, называемую, скажем, FindPath (fromnode, Tonode) Эта функция найдет путь между двумя узлами, одним способом сделать это с помощью этого псевдо-кода:

Define array1;
Define array2;

loop while flag is false {
    store fromNode's parent node in array1;
    store toNode's parent node in array2;

    loop through array1 {
        loop through array2 {
            if array1[i] == array2[j] {
             flag = true;
            }
        }
    }
}

path = array1 + reverse(array2);

и есть ваш путь.

Обновление:

Другое решение было бы заставить каждую страницу есть что-то вроде этого псевдо-кода - я начинаю на самом деле любить псевдо-код:

function checkChildren(targetNode) {
    loop through children {
        if children[i] == target {
            return path;
        }
        if children[i].checkChildren == target node {
            return path;
        }
    }
}

Это очень очень абстрактно, имеет гораздо более подробную информацию Это и много оптимизаций, вот что я имею в виду:

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

Я все еще думаю, что я не доставлял свою идею хорошо, так что попробую это объяснить.

Скажем, вы идете с PIC2 в галерее к проектам в проектах.

PIC2 проверит бы свои дети (если есть), если он найдет цель, которая идет туда, в противном случае он называет его CheckChildren его родитель (галерее), передавающую себя к родителю, не будет проверять ее, и передавать себе к Родитель в массиве, поэтому родитель знает, какой путь был принят.

Родитель проверяет своих детей, если кто-либо из них является целью, если оно добавляет себя и ребенку на массив пути, и это путь.

Если ни один из его прямых детей не является целью, то он называет каждую из своих детей CheckChildren, проходящие добавляя себя в массив пути, чтобы, если каковере его дети найдут цель, которую он добавляет себя и ребенка в массив и У вас есть ваш путь.

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

Домашняя страница проверяет все свои дети, кроме галереи, используя тот же метод.

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

Я надеюсь, что я понял. Я могу написать CheckChildren для вас, если хотите.

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

1. получить путь внутри дерева
2. выполнить несколько анимаций последовательно (по этому самому пути)

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

ваша проблема заключается в последовательном выполнении асинхронных задач. получить саму последовательность не так уж и сложно. однако, вы должны учитывать, что не каждый путь проходит через корень (например, от одного листа до его сиблинга). в мире flash единственный способ последовательного выполнения асинхронных задач - это обратный вызов. когда одна задача заканчивается, она перезванивает, и оттуда вы решаете, что делать дальше.

так что вот код:

сначала давайте определим интерфейс для всех ваших листьев/узлов... следующее должно помочь:

package  {
    public interface ITransitionable {
     //implementors are to call callback when the show/hide transition is complete
     function show(callback:Function):void;
     function hide(callback:Function):void;
     function get parent():ITransitionable;
    }
}

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

package  {
 public class Transition {
  ///Array of animation starting functions
  private var funcs:Array;
  ///Function to call at the end of the transition
  private var callback:Function;
  public function Transition(from:ITransitionable, to:ITransitionable, callback:Function) {
   this.callback = callback;
   this.funcs = [];
   var pFrom:Array = path(from).reverse();
   var pTo:Array = path(to).reverse();
   while ((pFrom[0] == pTo[0]) && (pTo[0] != null)) {//eliminate common path to root
    pFrom.shift();
    pTo.shift();
   }
   pFrom.reverse();//bring this one back into the right order
   //fill the function array:
   var t:ITransitionable;
   for each (t in pFrom) this.funcs.push(hider(t));
   for each (t in pFrom) this.funcs.push(shower(t));
   this.next();
  }
  ///cancels the overall transition
  public function cancel():void {
   this.funcs = [];
  }
  ///creates a function that will start a hiding transition on the given ITransitionable.
  private function hider(t:ITransitionable):Function {
   return function ():void {
    t.hide(this.next());
   }
  }
  ///@see hider
  private function shower(t:ITransitionable):Function {
   return function ():void {
    t.show(this.next());
   }
  }
  ///this function serves as simple callback to start the next animation function
  private function next(...args):void {
   if (this.funcs.length > 0) this.funcs.shift()();
   else this.callback();
  }
  ///returns the path from a node to the root
  private function path(node:ITransitionable):Array {
   var ret:Array = [];
   while (node != null) {
    ret.push(node);
    node = node.parent;
   }
   return ret;
  }
 }

}

это не идеальная красота, но этого должно быть достаточно, чтобы направить вас в нужное русло. нет необходимости в причудливых государственных машинах, что бы ни случилось... надеюсь, это поможет...