Question

我有一个名为Panels的类，它创建了许多不同类型的sprite类，并将它们添加到舞台上的阶段或嵌套的sprite中。要创建精灵，将发送包含所有必需信息的SpriteInfo类。现在，SpriteInfo类可以具有包含子对象的布尔属性，如果为true，则在父SpriteInfo对象的数组中添加子SpriteInfo对象数组。

所以SpriteInfo对象的数组，其中一些带有子SpriteInfo对象的对象是通过类Panels提供的，它创建了sprite并将它们添加到基于SpriteInfo结构的父构造的sprite中。

我一直遇到处理这个问题。我检查了其他网站，看到理想情况下应该使用递归函数，并对数组中嵌套的spriteInfo对象使用深度限制。

所以我编写了一个深度检查器和初始化函数，它通过另一个constructSprite函数将spriteinfo发送到精灵中，该函数工作正常，但问题是初始化函数会导致闪存使用无法正常运行。我一定在某处犯了错误，但我不确定在哪里。任何反馈将不胜感激。

以下是所涉及的主要功能：

private function initialise(spritesList:Array, wrapping:int, baseWrapping:int, wrapper:Sprite = null, addWrapper:Boolean = true, noZeroConstruct:Boolean = false):Sprite {
        var spriteListDepth:int = getArrayDepth(spritesList);
        var sprite:Sprite = null;
        if (spritesList !== null){
            for (var i:int = 0; i < spritesList.length; i++) {
                if (spritesList[i].getChildrenPresent()) {
                    var parent:Sprite = constructSprite(spritesList[i]);
                    parent = initialiseChildren(parent, spritesList[i], spriteListDepth);
                    wrapper.addChild(parent);
                } else {
                    sprite = constructSprite(spritesList[i]);
                    wrapper.addChild(sprite);
                }

            }

            if (wrapper != null) {
                if (baseWrapping == 0) {
                    wrapper.x = baseWrapping;
                    wrapper.y = baseWrapping;
                } else {
                    wrapper.x = wrapping;
                    wrapper.y = wrapping;
                }
                if (addWrapper) {
                    addChild(wrapper);
                }
            }
        }
        return sprite;
    }



    private function initialiseChildren(parent:Sprite, parentSpriteInfo:SpriteInfo, depth:int, count:int = 0):Sprite {
        var baseParent:Sprite = null;
        if (count != 0) {
            this.count = count;
        }
        do {
            var spriteParentChildren:Array = parentSpriteInfo.getChildren();

            for (var i:int = 0; i < spriteParentChildren.length; i++) {
                if (count == 0) {
                    baseParent = parent;
                }

                if (SpriteInfo(spriteParentChildren[i]).getChildrenPresent()) { //if children
                    count++;
                    var newParentSprite:Sprite = constructSprite(spriteParentChildren[i]);
                    parent.addChild(newParentSprite);
                    initialiseChildren(newParentSprite, spriteParentChildren[i], depth, count);

                } else {
                    var child:Sprite = constructSprite(spriteParentChildren[i]);
                    parent.addChild(child);
                }
            }
        } while (this.count <= depth);

        return baseParent;

    }


    private function getArrayDepth(list:Array):int {
        var depth:int = 0; //0 indexed

        for (var i:int = 0; i < list.length; i++) {
            var item:SpriteInfo = list[i];
            if (item.getChildrenPresent()) {
                depth++;
                depth = getArrayChildrenDepth(item.getChildren(), depth);
            }
        }
        return depth;

    }

    private function getArrayChildrenDepth(childrenList:Array, depth:int):int {
        for (var i:int = 0; i < childrenList.length; i++) {
            var item:SpriteInfo = childrenList[i];
            if (item.getChildrenPresent()) {
                depth++;
                depth = getArrayChildrenDepth(item.getChildren(), depth);
            }
        }
        return depth;
    }

Answer 1

也许是这样的：

private function initialise(spritesList:Array, wraper:Sprite = null):Sprite{
    if (!wraper) wraper = new Sprite();
    var rL:uint = spritesList.length; //root length
    var cS:Sprite; // current sprite
    var chs:Array; // children of current sprite
    var allS:Vector.<Sprite> = Vector.<Sprite>([]); //all sprites.
    for (var i:int = 0; i < spritesList.length; i++){
        if (i < rL){
            cS = constructSprite(spritesList[i]);
            wraper.addChild(cS);
        }else cS = allS[i - rL];
        chs = spritesList[i].getChildren();
        if (!chs) continue;
        for (var j:int = 0; j < chs.length; j++){
            allS.push(cS.addChild(constructSprite(chs[j])));
            spritesList.push(chs[j]);
        }
    }return wraper;
}

我没有测试它，因为我没有这方面的数据，但我希望你能得到这个想法。

修改。现在这应该工作 - 使用你给我的数据。

编辑2：

也许我应该按照问题的标题 - 这里是带有深度限制的递归版本：

private var d:uint;
private var l:uint = 100;
private function contstruct(si:SpriteInfo):Sprite{
    d++;
    var ch:Array = si.getChildren();
    var s:Sprite = constructSprite(si);
    var c:uint;
    (ch) ? c = ch.length * uint(d < l): c =0;
    for (var i:int = 0; i < c; i++){
        s.addChild(contstruct(ch[i]));
    }d--; return s;
}

private function initialise(spritesList:Array, wraper:Sprite = null):Sprite {
    if (!wraper) wraper = new Sprite();
    var r:SpriteInfo = new SpriteInfo("root", "", "", 0, 0, 0, 0, 0, "", "", false, spritesList);
    wraper.addChild(contstruct(r));
    return wraper;
}

如果你想在创建父项目之前对子项执行某些操作，你仍然需要修改它，但我希望你能清楚如何。

as3递归数组函数

1 个答案: