Actionscript 雪碧上的多色花呢

我试着制作一个正方形网格，在那里我可以单独控制每个正方形的颜色参数，也就是说，让它们一个接一个或同时闪烁

我试着用tweens来做，用for循环运行参数

下面的代码试图同时闪烁所有方块，每秒闪烁一次。但由于某种原因，所有的方块都不是介于二者之间的，只有一些方块是介于二者之间的。或者他们部分地在两人之间，有时他们根本不在两人之间。然而，这种模式不会重复

这是不是同时有太多的孩子？for循环是实现这一点的正确方法吗？我应该用MovieClips而不是sprite吗？如果我想在一个非常快的阶段控制许多不同对象的颜色，那么最好的方法是什么

import fl.transitions.Tween;
import fl.transitions.easing.*;
import fl.transitions.TweenEvent;
import flash.display.*;
import flash.events.*;
import flash.display.Sprite;
import flash.geom.Rectangle;
import flash.geom.ColorTransform;
import Math;
import flash.utils.Timer;
import flash.events.TimerEvent;
import resolumeCom.*;
import resolumeCom.parameters.*;
import resolumeCom.events.*;

    public class LightGrid extends MovieClip
    {
        private var t1:Tween;
        private var resolume:Resolume = new Resolume();
        private var tempo:FloatParameter = resolume.addFloatParameter("Tempo", 0.6);
        private var pad = 3;
        private var dim = 20;
        private var posX = 0 + pad;
        private var posY = 0 + pad;
        private var a:Number = new Number();
        private var b:Number = new Number();
        private var blk:Number = new Number();
        var newCol:ColorTransform = new ColorTransform();

        public function LightGrid()
        {
            resolume.addParameterListener(parameterChanged);

            for (var b = 0; b < 16; b++)
            {
                posY = (b*dim) + (b*pad) + pad;
                trace("New row");
                for (var a = 0; a < 24; a++)
                {
                    posX = (a*dim) + (a*pad) + pad;

                    // l = line, f = fill

                    var l:Sprite = new Sprite;

                    l.graphics.lineStyle(2, 0xFFFFF, 1);
                    l.graphics.drawRect(posX, posY, dim, dim);
                    l.name = "line_Row" + b + "Col" + a;

                    addChild(l);

                    var f:Sprite = new Sprite;
                    f.graphics.beginFill(0x990000, 1);
                    f.graphics.drawRect(posX, posY, dim, dim);
                    f.graphics.endFill();
                    f.name = "fill_Row" + b + "Col" + a;

                    addChild(f);

                    trace(getChildByName("fill_Row" + b + "Col" + a).name);
                }
            }

            var myTimer:Timer = new Timer(1000, 100);
            myTimer.addEventListener("timer", timerHandler);
            myTimer.start();
        }

        public function timerHandler(event:TimerEvent):void {   
            flashTheLights();   
        }

        public function parameterChanged(e:ChangeEvent):void
        {
            if (e.object == tempo)
            {
            }
        }

        public function flashTheLights():void
        {

        blk = 0;

            for (var blk = 0; blk < (24/3); blk++) 
            {
                for (var d = 0; d < 16; d++)
                {
                    for (var c = (0+(3*blk)); c < (3+(3*blk)); c++)
                    {
                        newCol.redOffset=30-(35*blk);
                        newCol.blueOffset=200+(7*blk);
                        newCol.greenOffset=200;

                        trace(getChildByName("fill_Row" + d + "Col" + c).name);
                        var fill:Sprite = getChildByName("fill_Row" + d + "Col" + c) as Sprite;

                        fill.transform.colorTransform.alphaMultiplier = -255;
                        fill.transform.colorTransform = newCol;
                        trace("Run tween");

                        var myTween = new Tween(fill,'alpha',Regular.easeIn,1,0,0.3,true);
                    }
                }

            trace("Done!" + blk);

            }
        }
    }

导入fl.transitions.Tween；
导入fl.transitions.easing.*；
导入fl.transitions.TweenEvent；
导入flash.display.*；
导入flash.events.*；
导入flash.display.Sprite；
导入flash.geom.Rectangle；
导入flash.geom.ColorTransform；
导入数学；
导入flash.utils.Timer；
导入flash.events.TimerEvent；
进口resolumeCom。*；
导入resolumeCom.参数。*；
导入resolumeCom.events.*；
公共级LightGrid扩展了MovieClip
{
私人变量t1:Tween；
private var resolume:resolume=新resolume（）；
私有变量tempo:FloatParameter=resolume.addFloatParameter（“tempo”，0.6）；
私有var pad=3；
私有var-dim=20；
专用var posX=0+pad；
私有变量posY=0+pad；
私有变量a:Number=新编号（）；
私有变量b:Number=newnumber（）；
私有变量blk:Number=新编号（）；
var newCol:ColorTransform=newcolortransform（）；
公共功能LightGrid（）
{
resolume.addParameterListener（parameterChanged）；
对于（var b=0；b<16；b++）
{
posY=（b*dim）+（b*pad）+pad；
跟踪（“新行”）；
对于（var a=0；a<24；a++）
{
posX=（a*dim）+（a*pad）+pad；
//l=直线，f=填充
变量l：精灵=新精灵；
l、 图形。线条样式（2，0xFFFFF，1）；
l、 graphics.drawRect（posX、posY、dim、dim）；
l、 name=“行”+b+“列”+a；
addChild（l）；
变量f：精灵=新精灵；
f、 图形填充（0x990000，1）；
f、 graphics.drawRect（posX、posY、dim、dim）；
f、 graphics.endFill（）；
f、 name=“填充行”+b+“列”+a；
addChild（f）；
跟踪（getChildByName（“填充行”+b+“列”+a）.name）；
}
}
var myTimer:Timer=新定时器（1000100）；
myTimer.addEventListener（“timer”，timerHandler）；
myTimer.start（）；
}
公共函数timerHandler（事件：TimerEvent）：void{
闪光灯（）；
}
公共函数参数已更改（e:ChangeEvent）：无效
{
if（e.object==tempo）
{
}
}
公用函数闪光灯（）：无效
{
blk=0；
对于（变量blk=0；blk<（24/3）；blk++）
{
对于（变量d=0；d<16；d++）
{
对于（var c=（0+（3*blk））；c<（3+（3*blk））；c++）
{
newCol.redOffset=30-（35*blk）；
新Col.blueOffset=200+（7*blk）；
newCol.greenOffset=200；
跟踪（getChildByName（“填充行”+d+“列”+c）.name）；
变量fill:Sprite=getChildByName（“填充行”+d+“列”+c）作为Sprite；
fill.transform.colorTransform.alphaMultiplier=-255；
fill.transform.colorTransform=newCol；
追踪（“奔跑间”）；
var myTween=新的Tween（填充，'alpha'，常规.easeIn，1,0,0.3，真）；
}
}
跟踪（“完成！”+blk）；
}
}
}

我通过将精灵堆叠在movieclips下解决了这个问题，这样我就只在两个元素之间，而不是十个或数百个元素之间

for (var k = 0; k < (grdX/ptrnSz); k++)
        {

            var ptrn:MovieClip = new MovieClip();
            ptrn.name = "ptrn" + k;
            addChild(ptrn);
            ptrn.alpha = 0.01;
            ptrnAm++;

            for (var d = 0; d < grdY; d++)
            {

                posY = (d*dim) + (d*pad) + top;

                for (var c = (0+(ptrnSz*k)); c < (ptrnSz+(ptrnSz*k)); c++)
                {

                    posX = (c*dim) + (c*pad) + left;

                    // l = line, f = fill

                    var f:Sprite = new Sprite;
                    f.graphics.beginFill(0xFFFFFF, 1);
                    f.graphics.drawRect(posX-0.5, posY, dim, dim);
                    f.graphics.endFill();
                    f.name = "fill_Block" + k + "Row" + d + "Col" + c;
                    ptrn.addChild(f);

                }

            }

        }

for（var k=0；k<（grdX/ptrnSz）；k++）
{
var ptrn:MovieClip=新的MovieClip（）；
ptrn.name=“ptrn”+k；
addChild（ptrn）；
ptrn.alpha=0.01；
ptrnAm++；
对于（var d=0；d

grdX=X轴上的网格大小（有多少列）
ptrnSz=包含精灵的movieclips的大小（有多少列）

---

在那之后，我将movieclips与TweenMax连接起来，用getChildByName分别称呼它们。

您是否考虑过尝试不同的连接解决方案？格林斯托克是第一个想到的，或者你可以为自己设计一个更简单的。哎呀，一个100圈的循环，每次创造128个二人圈-当然它太大了。是的，我觉得可能太多了。。。但一定有办法做到这一点？我的意思是我应该试着寻找其他的解决方案吗？