Actionscript 3 我有100个不同大小的电影嘴唇可以随机制作一个网格，我该如何优化它？

我们的客户让我们（嗯，我一个人…）用不同大小的盒子动态生成网格。网格不应具有定义的边，但每个movieclip应具有特定的定义边界。我对AS3还是相当陌生，但除了这类巨大的数学问题外，我几乎可以处理所有事情

以下是我正在寻找的一个小规模的简单布局：

你们中有谁能有效地做到这一点吗

我几乎可以模仿这一点，但有时我的盒子会重叠，这是一个交易破坏者。如果我开始测试它，直到我用55+个movieclips尝试它，那么我担心脚本可能会冻结

下面的代码可以工作，但有时可能会冻结。我如何优化它以避免发生堆栈溢出错误

package 
{

import flash.display.MovieClip;
import flash.display.Sprite;
import flash.utils.getDefinitionByName;


public class box_builder extends MovieClip
{

    private var _path:MovieClip;
    private var mc_holder:Sprite;
    private var box_ar:Array;
    private var box_spacing:int = 5;
    private var mc_ar:Array = new Array();
    private var placed_box_ar:Array = new Array();
    private var p_step:int = 0;

    public function box_builder()
    {
        _path = this;
        mc_holder = new Sprite();
        _path.addChild(mc_holder);
        getBoxArray();
        startBoxDistribution();
    }
    private function getBoxArray()
    {
        box_ar = new Array("box_1","box_2","box_3","box_4","box_3","box_3","box_1","box_2","box_4","box_1","box_1","box_2","box_3","box_4","box_3","box_3","box_1","box_2","box_4","box_1","box_1","box_2","box_3","box_4","box_3","box_3","box_1","box_2","box_4","box_1",
           "box_1","box_2","box_3","box_4","box_3","box_3","box_1","box_2","box_4","box_1","box_1","box_2","box_3","box_4","box_3","box_3","box_1","box_2","box_4","box_1","box_1","box_2","box_3","box_4","box_3","box_3","box_1","box_2","box_4","box_1");
    }
    private function startBoxDistribution():void
    {
        var i = 0;
        var len = box_ar.length;
        createBoxes();
    }
    private function createBoxes():void
    {
        var len = box_ar.length;
        for (var i=0; i<len; i++)
        {
            var tMC:Class = getDefinitionByName(box_ar[i]) as Class;
            var newMc:MovieClip = new tMC() as MovieClip;
            mc_ar.push(newMc);
            mc_holder.addChild(newMc);
        }
        executeQueue();
    }

    private function executeQueue():void
    {
        if (p_step < box_ar.length)
        {
            var mc = mc_ar[p_step];

            p_step++;
            try{ findPlacement(mc); }
            catch(e:Error){ trace("ERROR!",e) };
        }
        else centerAll();
    }
    private function findPlacement(mc:MovieClip,prev_seed:int = 0):void
    {
        var mc_len:int = mc_ar.length;
        var rN:int = randomNumber(0,mc_len - 2);
        if (prev_seed == 0)
        {
            rN = rN;
        }
        else if (prev_seed == mc_len-1)
        {
            rN = 0;
        }
        else
        {
            rN = prev_seed + 1;
        }
        trace(rN,mc);
        var seed = mc_ar[rN];
        var d = randomNumber(1,8);

        if (d == 1)
        {
            mc.x = seed.x - seed.width - box_spacing;
            mc.y = seed.y - seed.height - box_spacing;
        }
        else if (d==2)
        {
            mc.x = seed.x + seed.width / 2 - mc.width / 2;
            mc.y = seed.y - seed.height - box_spacing;
        }
        else if (d==3)
        {
            mc.x = seed.x + seed.width + box_spacing;
            mc.y = seed.y - seed.height - box_spacing;
        }
        else if (d==4)
        {
            mc.x = seed.x + seed.width + box_spacing;
            mc.y = seed.y + seed.height / 2 - mc.width / 2;
        }
        else if (d==5)
        {
            mc.x = seed.x + seed.width + box_spacing;
            mc.y = seed.y + seed.height + box_spacing;
        }
        else if (d==6)
        {
            mc.x = seed.x + seed.width / 2 - mc.width / 2;
            mc.y = seed.y + seed.height + box_spacing;
        }
        else if (d==7)
        {
            mc.x = seed.x - mc.width - box_spacing;
            mc.y = seed.y - mc.height - box_spacing;
        }
        else if (d==8)
        {
            mc.x = seed.x - mc.width - box_spacing;
            mc.y = seed.y + seed.height / 2 - mc.width / 2;
        }


        var isGood:int = 0;
        for (var c=0; c<placed_box_ar.length; c++)
        {
            if (mc.hitTestObject(placed_box_ar[c]) && mc != placed_box_ar[c])
            {
                trace("overlap, retrying");
                findPlacement(mc,rN);//Retry placing this box.
            }
            else
            {
                isGood++;
            }
        }
        if (isGood == placed_box_ar.length)
        {
            placed_box_ar.push(mc);
            executeQueue();//Moves to next box to be placed.
        }
    }

    private function centerAll():void
    {
        _path.addChild(mc_holder);
        mc_holder.x = _path.stage.stageWidth / 2;
        mc_holder.y = _path.stage.stageHeight / 2;
    }
    private function randomNumber(low:Number=0, high:Number=1):Number
    {
        return Math.floor(Math.random() * (1+high-low)) + low;
    }
}

包
{
导入flash.display.MovieClip；
导入flash.display.Sprite；
导入flash.utils.getDefinitionByName；
公共类box\u生成器扩展了MovieClip
{
私有变量路径：MovieClip；
私人var mc_持有人：Sprite；
私有变量框：数组；
专用var箱_间距：int=5；
私有变量mc_ar:Array=new Array（）；
private-var-placed_-box_-ar:Array=new-Array（）；
私有var p_阶跃：int=0；
公共功能盒_builder（）
{
_路径=这个；
mc_holder=新精灵（）；
_路径addChild（mc_持有者）；
getBoxArray（）；
startBoxDistribution（）；
}
私有函数getBoxArray（）
{
box_ar=新数组（“box_1”、“box_2”、“box_3”、“box_4”、“box_3”、“box_1”、“box_2”、“box_4”、“box_1”、“box_1”、“box_2”、“box_3”、“box_4”、“box_3”、“box_3”、“box_3”、“box_1”、“box_2”、“box_4”、“box_1”、“box_1”、“box_1”、“box_2”、“box_3”、“box_4”、“box_3”、“box_2”、“box_1”，
“盒子1”、“盒子2”、“盒子3”、“盒子4”、“盒子3”、“盒子3”、“盒子3”、“盒子1”、“盒子2”、“盒子1”、“盒子4”、“盒子1”、“盒子1”、“盒子2”、“盒子3”、“盒子4”、“盒子3”、“盒子3”、“盒子3”、“盒子3”、“盒子1”、“盒子1”、“盒子2”、“盒子4”、“盒子1”、“盒子1”、“盒子1”、“盒子1”、“盒子3”、“盒子4”、“盒子3”、“盒子3”、“盒子1”、“盒子2”、“盒子4”、“盒子4”、“盒子1”、“盒子1”）；
}
私有函数startBoxDistribution（）：void
{
var i=0；
var len=盒子长度；
CreateBoxs（）；
}
私有函数createBox（）：void
{
var len=盒子长度；
对于（var i=0；i这个答案可能有点不同寻常，但无论如何，为了其他碰巧来过的人，我将把它留在这里

毫无疑问，有很多方法可以动态生成和随机排列一组边界框（查找装箱算法），但有一种技术含量极低的方法可以做到这一点并实现相同的效果，假设其目的是模拟UI中的随机性或动态性

只需创建20个左右的预设布局，然后随机选择其中一个。除非界面完全依赖于随机化或随机化的说明，或者传入的数据确实不可预测，否则最终用户感知到的结果应该与实际在运行时以编程方式创建布局无异。
F首先：我同意阿勒梅的回答

如果你不能选择一组布局，或者只是不想，你应该看看。老实说，你需要一些数学知识，但结果往往出奇的好

您可以确定最大或最重要的精灵作为主节点，该节点居中且固定。现在使用弹簧将每个其他精灵连接到主节点（数学就在这里）。经过几次迭代（精灵被拉到主节点）后，它将看起来类似于您的草图

还可以通过将图元与另一个弹簧连接来对其进行分组