0

我尝试制作一个正方形网格，在那里我可以单独控制每个正方形的颜色参数，即。使它们一一或同时闪烁。

我试图用补间来做，用for循环运行参数。

下面的代码尝试同时闪烁所有方块，每秒一次。但由于某种原因，所有的正方形都不会补间，只有一些会补间。或者他们部分补间，有时他们根本不补间。然而，这种模式不会重复。

这是不是同时有太多的补间？for循环是正确的方法吗？我应该使用 MovieClips 而不是 Sprites 吗？如果我想在非常快的阶段控制许多不同对象的颜色，最好的方法是什么？

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);

            }
        }
    }
4

1 回答 1

0

我通过在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);

                }

            }

        }

grdX = X 轴上的网格大小（多少列）
ptrnSz = 包含 Sprite 的动画剪辑的大小（多少列）
之后我只是用 TweenMax 补间动画剪辑，用 getChildByName 调用它们。

于 2013-08-11T11:56:49.610 回答