Flash / Tutorials 7

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
 needBePaused = new Array();//тут хранятся все клипы для ПАУЗЫ
_global.addToPause = function(obj){
    if(!obj._inPause){//2 раза в ПАУЗУ не добавляем
        needBePaused.push(obj);
        obj._inPause = true;
    }
}
_global.setPause = function(flag) {
    isPause = flag;//переменная, на всякий случай
    var i = needBePaused.length;
    while(i--) {
        var curObj = needBePaused[i];
        if (flag) {
            curObj.stop();
            curObj.oef = curObj.onEnterFrame;//временно сохраняем
            curObj.onEnterFrame = null;
        } else {
            curObj.onEnterFrame = curObj.oef;//восстанавливаем
            curObj.play();
        }
    }
}

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
this.removeMovieClip();

fire._visible = false;//скрываем эталон
lev = 0;//переменная для уровней
this.onEnterFrame = function() {
    for (var i = 0; i < 2; i++) {//выполняется 2 раза чтобы увеличить плотность
        lev++;
        d = fire.duplicateMovieClip("f" + lev, lev);
        d._x += Math.random() * 6 - 3;//случайный разброс по координатам
        d._y += Math.random() * 6 - 3;
        d._alpha = Math.random() * 50 + 50;//реализм
        d._xscale = d._yscale = Math.random() * 50 + 70;//реализм
    }
}

//------------------------------------------

fire._visible = false;
lev = 0;
this.onEnterFrame = function() {
    for (var i = 0; i < 2; i++) {
        lev++;
        if(lev > 1000) {
            lev = 0;
        }
        d = fire.duplicateMovieClip("f" + lev, lev + 2000);//огонь
        d2 = fire.duplicateMovieClip("f2" + lev, lev);//контурная подложка
        d2._x = d._x += Math.random() * 6 - 3;
        d2._y = d._y += Math.random() * 6 - 3;
        d._alpha = Math.random() * 50 + 50;
        d2._xscale = d2._yscale = d._xscale = d._yscale = Math.random() * 50 + 70;
        var col = new Color(d2);
        var tr = col.getTransform();
        tr.ab = tr.rb = tr.gb = tg.bb = 255;//не знаю почему, но закрашивает желтым
        col.setTransform(tr);
    }
}
//------------------------------------------
fire._visible = false;
lev = 0;
function placeFire(x, y) {
    for (var i = 0; i < 2; i++) {
        lev++;
        d = fire.duplicateMovieClip("f" + lev, lev);
        d._x = x + Math.random() * 6 - 3;
        d._y = y + Math.random() * 6 - 3;
        d._alpha = Math.random() * 50 + 50;
        d._xscale = d._yscale = Math.random() * 50 + 70;
    }
}
onEnterFrame = function() {
    placeFire(_xmouse, _ymouse);
}

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
this.removeMovieClip();

lev = 0;
var w = box._width;
var h = box._height;
onEnterFrame = function() {
    lev++;
    var d = wave.duplicateMovieClip("d" + lev, lev);
    d._x = box._x + Math.random() * w;//ложим в случайную точку
    d._y = box._y + Math.random() * h;//на поверхности воды
    d._xscale = d._yscale = 50 + Math.random() * 100;//больше реализма
}

//------------------------------------------
x0 = _x;
x9 = x0 - _width / 2;
onEnterFrame = function() {
    _x -= speed;//скорость задается снаружи
    var dx = x9 - _x;
    if (dx > 0) {
        _x = x0 - dx;
    }
}

onClipEvent (load) {
    speed = 3.5;//для верхнего клипа
}
//------------------------------------------

if(!_first) {
    _first = true;
    gotoAndPlay(Math.floor(Math.random()*_totalframes));

}

onClipEvent (load) {
    y0 = _y;//запомним координату и привяжемся к ней
    onEnterFrame = function() {
        _y += .5;
        if(_y > 175) _y = y0;
    }
}

onClipEvent (load) {
    y0 = _parent.water1.y0;//вот и привязались
    onEnterFrame = function() {
        _y += .5;
        if(_y > 175) _y = y0;
    }
}
//------------------------------------------
onClipEvent (load) {
    y0 = _y;
    y9 = y0 - _height / 2
    speed = .5;
}
onClipEvent (enterFrame) {
    _y -= speed;
    if(_y < y9) {
        var del = Math.abs(_y) - Math.abs(y9);
        _y = y0 + del - speed;
    }
}
//------------------------------------------
lev = 0;
onEnterFrame = function () {
    lev++;
    var d = wave.duplicateMovieClip("w" + lev, lev);
    d._x = water._x + Math.random() * water._width;//располагаем по горизонту
};

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
lev = 0;
speed = 5;
var dist = right._x - left._x;//ширина анимированного фона

//функция создает и модифицирует дубликат
placeTree = function () {
    lev++;
    var d = tree.duplicateMovieClip("t" + lev, lev);
    d._x = right._x + Math.random() * 50; //небольшой разброс для правдоподобности
    d._xscale = d._yscale = 50 + Math.random() * 50;//с той же целью
    if(Math.random() < .5) {//случайно выбирается вид куста
        d.gotoAndStop(1);
    } else {
        d.gotoAndStop(2);
    }

    d.onEnterFrame = function() {
        this._x -= speed;
        if(this._x < left._x){//удаляется, если вышел за пределы слева
            this.removeMovieClip();
        }
    }

    return d;
};
//чтобы сразу что-то было, заполняем экран объектами
var i = 20;//подбираем на глаз
while (i--){
    var d = placeTree();
    d._x = left._x + Math.random() * dist;//случайное начальное положение
}

onEnterFrame = function() {
    if(lev++ % 10 == 0){//выполнять каждый 10-й кадр
        placeTree();
    }
}

//------------------------------------------
lev = 0;
speed = 5;
var dist = right._x - left._x;//расстояние между маркерами

//функция создает обработанный дубликат символа tree
placeTree = function () {
    lev++;
    var d = tree.duplicateMovieClip("t" + lev, lev);
    d._x = right._x;
    d.ky = Math.random();//коэфициент глубины
    d._y = right._y + d.ky * right._height;//высоту тоже регулирую маркерами
    d._xscale = d._yscale = d.ky * 100;//чем дальше, тем меньше

    //с танцами и бубнами - усложняю чтобы получить уникальное число
    //простой Math.random() подозрительно часто повторяется
    d.swapDepths(Math.floor(d._y * 100 + Math.random() * 90));

    //случайно выбираем вид куста
    if(Math.random() < .5) {
        d.gotoAndStop(1);
    } else {
        d.gotoAndStop(2);
    }

    //добавляю воздушную перспективу
    var c = new Color(d);
    var n = 60 - d.ky * 60; //подбираем на глаз
    var ct = {rb:n,gb:n,bb:n};
    c.setTransform(ct);

    d.onEnterFrame = function() {
        this._x -= speed / 2 * (1 + this.ky);//от 50% до 100% от скорости
        if(this._x < left._x){
            this.removeMovieClip();
        }
    }
    return d;
};

//создаем изначально заросшее поле
var i = 70; //подбираем на глаз
while (i--){
    var d = placeTree();
    d._x = left._x + Math.random() * dist;
}

onEnterFrame = function() {
    if(lev++ % 4 == 0){ //каждый четвертый кадр
        placeTree();
    }
}

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------

onClipEvent (load) {
    speed = 4;//скорость
    x0 = _x;//Запоминаем начальное положение
    x9 = x0 - _width / 2;//максимально-допустимое левое положение
    onEnterFrame = function() {
        _x -= speed;
        var dx = x9 - _x; //Вычисляем перебор
        if (dx > 0) {
            _x = x0 - dx;//Компенсируем его и возвращаем в начальное положение
        }
    }
}

//------------------------------------------

onClipEvent (load) {
    backSpeed = 4;//то же что и speed у фона
    maxSpeed = 5;//будем ограничивать максимальную скорость
    speedX = 0;
    onEnterFrame = function() {
        var dx = _parent._xmouse - _x;
        speedX += dx * .1;//сила притяжения к курсору
        speedX *= .7;//затухание
        speedX = (speedX > maxSpeed)? maxSpeed : (speedX < -maxSpeed)? -maxSpeed : speedX;
        if(_currentframe < 23) {
            _x += speedX;//если в воздухе
        } else {
            _x -= backSpeed;//если прижаты к земле
        }
    }
}

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
onClipEvent (load) {
    y0 = _y;
    t = 0;
    onEnterFrame = function(){
        _y = y0 + Math.sin(t += .15)*4;
    }
}
//------------------------------
onClipEvent (load) {
    x0 = _x;
    y0 = _y;
    tx = Math.random()*10000;
    ty = Math.random()*10000;
    onEnterFrame = function() {
        _x = x0 + Math.sin(tx += .3) * 15;
        _y = y0 + Math.sin(ty += .4) * 25;
    }
}
//------------------------------
onClipEvent (load) {
    t = 0;
    onEnterFrame = function () {
        _rotation = Math.sin(t += .1) * 5 - 3;
    };
}
//------------------------------
onClipEvent (load) {
    t = 0;
    x0 = _parent.light._x;
    onEnterFrame = function(){
        var k = Math.sin(t+= .05)*5;
        _rotation = k;
        _parent.light._x = x0 - k*3;//множитель подбирается
    }
}
//------------------------------
onClipEvent (load) {
    y0 = _y;
    t = 0;
    onEnterFrame = function(){
        t += .5;
        _xscale = 100 + Math.sin(t)*30;
        _yscale = 100 - Math.sin(t)*30;
    }
}
//------------------------------
onClipEvent (load) {
    y0 = _y;
    t = 0;
    onEnterFrame = function(){
        _y = y0 - Math.abs(Math.sin(t += .2))*70;
    }
}
//------------------------------
onClipEvent (load) {
    y0 = _y;
    t = 0;
    onEnterFrame = function(){
        _y = y0 - Math.abs(Math.sin(t -= .2))*70;
        _xscale = 100 + Math.sin(t*2)*20;
        _yscale = 100 + Math.cos(t*2)*20;
    }
}
//------------------------------
onClipEvent (load) {
    y0 = _y;
    x0 = _x;
    t = 0;
    onEnterFrame = function(){
        _y = y0 - Math.abs(Math.sin(t -= .2))*70;
        _x = x0 + Math.sin(t + Math.PI / 2)*30;
        _rotation = Math.sin(t + Math.PI / 2)*10;
        _xscale = 100 + Math.sin(t*2)*20;
        _yscale = 100 + Math.cos(t*2)*20;
    }
}

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
import flash.geom.Transform;
import flash.geom.Matrix;

var level = 0;//на сколько клипов вверх компенсировать трансформацию

cameraFrame._visible = false;//делаем саму рамку невидимой
init();

//==================================
//don't tuch this :)

function init(){
    var oldMode = Stage.scaleMode;
    Stage.scaleMode = "exactFit";
    w = Stage.width;
    h = Stage.height;
    Stage.scaleMode = oldMode;
    recalcParentMatrix();
    cameraStep();
    onEnterFrame = cameraStep;
    onUnload = resetStage;
}
//-----------------------------
function recalcParentMatrix() {
    mc = _parent;
    if(level){
        var i = level - 1;
    } else {
        var i = 1000;
    }
    while (i-- && mc && mc != _root) {
        var tempTrans = new Transform(mc);
        if (!parentM) {
            parentM = tempTrans.matrix;
        } else {
            parentM.concat(tempTrans.matrix);
        }
        mc = mc._parent;
    }
    cameraTrans = new Transform(this);
    topLevelTrans = new Transform(mc);
    resetM = topLevelTrans.matrix;
    resetTopLevelColor = topLevelTrans.colorTransform;
}
//-----------------------------
function cameraStep() {
    topLevelTrans.colorTransform = cameraTrans.colorTransform;
    curM = cameraTrans.matrix;
    if (parentM) {
        curM.concat(parentM);
    }
    curM.invert();
    curM.translate(w / 2,h / 2);
    topLevelTrans.matrix = curM;
    //mc.filters = this.filters;
}
//-----------------------------
function resetStage():Void {
    topLevelTrans.matrix = resetM;
    topLevelTrans.colorTransform = resetTopLevelColor;
}

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------

partGo._visible = false; //скрываем эталонный символ
i = 30;
while (i--) {
    d = partGo.duplicateMovieClip("p" + i, i); //делаем дубликат
    d._rotation = Math.random() * 360; //какой сектор покрываем
    d._xscale = d._yscale = Math.random()*70 + 50; //добавляем реализм
}

_parent.removeMovieClip();//удалит клип boom если он добавлен программно
stop();//просто остановит анимацию, если клип добавлен руками

//-----------------------------------
boom._visible = false;
lev = 0;
function placeBoom(x, y){
    lev++;
    var d = boom.duplicateMovieClip("b" + lev, lev);
    d._x = x;
    d._y = y;
}
placeBoom(Math.random()*200, Math.random()*200);//ложим в случайное место

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
MovieClip.prototype.flipX = function () {
this._xscale = -this._xscale;
};

mc.flipX();

MovieClip.prototype.flipY = function () {
this._yscale = -this._yscale;
};

BuiltinObject.prototype.method = function () {
// ну а здесь пошел наш код
};

Array.prototype.push = function (data) {
this[this.length] = data;
};

Math.distance = function (x1, y1, x2, y2) {
var dx = x2 — x1;
var dy = y2 — y1;
return Math.sqrt (dx*dx + dy*dy);
};

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
onClipEvent (load) {
// init variables
startSize = 20;
max = 20;
sizeIncrement = 15;
effectChoice = 1;
roots = new Array();

// Duplication process
for (var i = 0; i<max; i++) {
duplicateMovieClip (originalRoot, «root»+i, i);
roots[i] = eval(«root»+i);
roots[i]. xscale = startSize+(i*sizeIncrement);
roots[i]. yscale = startSize+(i*sizeIncrement);
roots[i]. alpha = 100-(100/max)*i;
roots[i].gotoAndStop(effectChoice);
}

file://A function that changes the mouse effect
function ChooseNewEffect(choice) {
if (choice > 0 and choice <= originalRoot. totalframes){
for (var n = 0; n < max; n ++) {
roots[n].gotoAndStop(choice);
}
}
}

originalRoot. visible = false;
}

onClipEvent (enterFrame) {
roots[0]. x = xmouse;
roots[0]. y = ymouse;
for (var i = 1; i<=roots.length; i++) {
roots[i].xdistance = (roots[i-1]. x-roots[i]. x)/2 + roots[i].xdistance*0.3;
roots[i].ydistance = (roots[i-1]. y-roots[i]. y)/2 + roots[i].ydistance*0.3;
roots[i]. x += roots[i].xdistance;
roots[i]. y += roots[i].ydistance;
}
}

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------

// изменить частоту кадров на 12 fps:

stage.frameRate = 12;
//---------------------------

package {

   import flash.display.Sprite;



   public class ClassScope extends Sprite {



        public function ClassScope() {

             traceThis(); // "Class Instance"


             var obj:Object = new Object();

             obj.traceThis = traceThis;

             obj.traceThis(); // "Class Instance"



             traceThis.call(new Sprite());

           // "Class Instance"

        }



    public override function toString():String {

             return "Class Instance";
        }



       public function traceThis():void {

       trace(this);
        }

   }
}


-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------

var obj:Object = getMyCustomObject();

var customObj:MyClass = MyClass(obj);

var obj:Object = getMyCustomObject();

var customObj:MyClass = obj as MyClass;

stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);

   import flash.display.Sprite;
    import flash.events.MouseEvent;
    import flash.events.Event;
    import Box2D.Common.Math.b2Vec2;
    import com.reyco1.physinjector.PhysInjector;
    import com.reyco1.physinjector.data.PhysicsObject;
    import com.reyco1.physinjector.data.PhysicsProperties;
    public class Main extends Sprite {
        private var physics:PhysInjector;
        public function Main() {
            physics=new PhysInjector(stage,new b2Vec2(0,10),true);
            var floor:Sprite = new Sprite();
            floor.graphics.beginFill(0x000000);
            floor.graphics.drawRect(0,0,640,20);
            floor.graphics.endFill();
            floor.x=0;
            floor.y=460;
            addChild(floor);
            var box2dFloor:PhysicsObject=physics.injectPhysics(floor,PhysInjector.SQUARE,new PhysicsProperties({isDynamic:false,friction:0.5,restitution:0.5}));
            addEventListener(Event.ENTER_FRAME,update);
            stage.addEventListener(MouseEvent.CLICK,addBox);
        }
        private function addBox(e:MouseEvent):void {
            var box:Sprite = new Sprite();
            box.graphics.beginFill(0x000000);
            box.graphics.drawRect(0,0,50,50);
            box.graphics.endFill();
            box.x=mouseX-25;
            box.y=mouseY-25;
            addChild(box);
            var box2dBox:PhysicsObject=physics.injectPhysics(box,PhysInjector.SQUARE,new PhysicsProperties({isDynamic:true,friction:0.2,restitution:0.5}));
        }
        private function update(event:Event):void {
            physics.update();
        }
    }
}

-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------
-------------------------------------------------------

package {
    import flash.display.Shape;
    import flash.geom.Point;
    import flash.events.MouseEvent;
    import flash.display.BitmapData;
    import flash.display.Bitmap;
    import flash.display.Sprite;

    //CLICK ON 2 BLACK TILES TO PATHFIND BETWEEN THEM!
    public class Main extends Sprite {
        //Maze should always be an odd-number of tiles! (eg. 9x9, 33x15, etc.)
        public const MAZE_WIDTH:int=31;
        public const MAZE_HEIGHT:int=23;
        public const MAZE_SCALE:Number=20;

        //Directional constants
        public const ILLEGAL:int=0;
        public const OPEN:int=1;
        public const RIGHT:uint=2;
        public const LEFT:uint=3;
        public const DOWN:uint=4;
        public const UP:uint=5;

        public var closed:BitmapData=new BitmapData(MAZE_WIDTH,MAZE_HEIGHT,false,0);
        public var data:BitmapData=new BitmapData(MAZE_WIDTH,MAZE_HEIGHT,false,0xFFFFFF);
        public var bitmap:Bitmap=new Bitmap(data);

        public var start:Point;
        public var end:Point;
        public var pathShape:Shape = new Shape();

        public function Main() {
            x=10;
            y=10;
            bitmap.scaleX=bitmap.scaleY=MAZE_SCALE;
            addChild(bitmap);

            pathShape.scaleX=pathShape.scaleY=MAZE_SCALE;
            pathShape.x=pathShape.y=MAZE_SCALE/2;
            addChild(pathShape);

            generateMaze();
            stage.addEventListener(MouseEvent.CLICK, onClick);
        }

        public function onClick(e:MouseEvent):void {
            start=end;
            end = new Point(int(mouseX / MAZE_SCALE), int(mouseY / MAZE_SCALE));

            if (start != null) {
                pathShape.graphics.clear();
                pathShape.graphics.beginFill(0xFF0000);
                pathShape.graphics.drawCircle(start.x, start.y, 0.25);
                pathShape.graphics.drawCircle(end.x, end.y, 0.25);
                pathShape.graphics.endFill();
                pathShape.graphics.lineStyle(0, 0xFF0000);

                var path:Array=pathfind(start,end);
                if (path != null && path.length > 1) {
                    pathShape.graphics.moveTo(path[0].x, path[0].y);
                    for (var i:int = 1; i < path.length; i++) {
                        pathShape.graphics.lineTo(path[i].x, path[i].y);
                    }
                }
            }
        }

        public function pathfind(start:Point, end:Point):Array {
            if (! getTile(start.x,start.y)&&! getTile(end.x,end.y)) {
                closed.fillRect(closed.rect, 0xFF000000 | OPEN);
                setClosed(start.x, start.y, ILLEGAL);

                var x:int;
                var y:int;
                var xQueue:Array=[];
                var yQueue:Array=[];
                xQueue.push(start.x);
                yQueue.push(start.y);

                while (xQueue.length > 0) {
                    x=xQueue.shift();
                    y=yQueue.shift();

                    if (x == end.x && y == end.y) {
                        var path:Array=[];
                        var tile:int=getClosed(x,y);
                        while (tile != ILLEGAL) {
                            path.push(new Point(x, y));
                            switch (tile) {
                                case RIGHT :
                                    x++;
                                    break;
                                case LEFT :
                                    x--;
                                    break;
                                case DOWN :
                                    y++;
                                    break;
                                case UP :
                                    y--;
                                    break;
                            }
                            tile=getClosed(x,y);
                        }
                        path.push(new Point(x, y));
                        return path.reverse();
                    }
                    else {
                        if (getClosed(x + 1, y) == OPEN && !getTile(x + 1, y)) {
                            setClosed(x + 1, y, LEFT);
                            xQueue.push(x + 1);
                            yQueue.push(y);
                        }
                        if (getClosed(x - 1, y) == OPEN && !getTile(x - 1, y)) {
                            setClosed(x - 1, y, RIGHT);
                            xQueue.push(x - 1);
                            yQueue.push(y);
                        }
                        if (getClosed(x, y + 1) == OPEN && !getTile(x, y + 1)) {
                            setClosed(x, y + 1, UP);
                            xQueue.push(x);
                            yQueue.push(y + 1);
                        }
                        if (getClosed(x, y - 1) == OPEN && !getTile(x, y - 1)) {
                            setClosed(x, y - 1, DOWN);
                            xQueue.push(x);
                            yQueue.push(y - 1);
                        }
                    }
                }
            }

            return null;
        }

        public function generateMaze():void {
            var xStack:Array=[];
            var yStack:Array=[];
            var sides:Array=[];

            data.fillRect(data.rect, 0xFFFFFFFF);

            //Pick random start point
            var x:int=1+int(Math.random()*(MAZE_WIDTH/2))*2;
            var y:int=1+int(Math.random()*(MAZE_HEIGHT/2))*2;
            xStack.push(x);
            yStack.push(y);

            //Maze generation loop
            while (xStack.length > 0) {
                x=xStack[xStack.length-1];
                y=yStack[yStack.length-1];
                sides.length=0;

                if (getTile(x + 2, y)) {
                    sides.push(RIGHT);
                }
                if (getTile(x - 2, y)) {
                    sides.push(LEFT);
                }
                if (getTile(x,y+2)) {
                    sides.push(DOWN);
                }
                if (getTile(x,y-2)) {
                    sides.push(UP);
                }

                if (sides.length>0) {
                    var side:int=sides[int(Math.random()*sides.length)];
                    switch (side) {
                        case RIGHT :
                            setTile(x + 1, y, false);
                            setTile(x + 2, y, false);
                            xStack.push(x + 2);
                            yStack.push(y);
                            break;
                        case LEFT :
                            setTile(x - 1, y, false);
                            setTile(x - 2, y, false);
                            xStack.push(x - 2);
                            yStack.push(y);
                            break;
                        case DOWN :
                            setTile(x, y + 1, false);
                            setTile(x, y + 2, false);
                            xStack.push(x);
                            yStack.push(y + 2);
                            break;
                        case UP :
                            setTile(x, y - 1, false);
                            setTile(x, y - 2, false);
                            xStack.push(x);
                            yStack.push(y - 2);
                            break;
                    }
                }
                else {
                    xStack.pop();
                    yStack.pop();
                }
            }
        }

        public function getTile(x:int, y:int):Boolean {
            if (x < 0 || y < 0 || x >= MAZE_WIDTH || y >= MAZE_HEIGHT) {
                return false;
            }
            return data.getPixel(x, y) > 0x000000;
        }

        public function setTile(x:int, y:int, solid:Boolean):void {
            data.setPixel(x, y, solid ? 0xFFFFFF : 0x000000);
        }

        public function getClosed(x:int, y:int):int {
            if (x < 0 || y < 0 || x >= MAZE_WIDTH || y >= MAZE_HEIGHT) {
                return ILLEGAL;
            }
            return closed.getPixel(x, y);
        }

        public function setClosed(x:int, y:int, value:int):void {
            closed.setPixel(x, y, value);
        }
    }
}