gistfile1.as

public class GameBoardMediator extends Mediator {
    [Inject] public var view:GameBoardView;
    [Inject] public var applicationModel:ApplicationModel;
    [Inject] public var levelModel:CurrentLevel;

    private var tilesInGame:Array = [];
    private var tileTypes:Array = [];


    // LOGIC
    private var firstSelectedTile:BoardTile;
    private var secondSelectedTile:BoardTile;
    private var selectedTiles:Array = []
    private var locked:Boolean = false;
    private var timeoutTimer:Timer;


    public function GameBoardMediator() {
        super();
    }
    override public function initialize():void{

        tileTypes.push(McChipsImage1)
        tileTypes.push(McChipsImage2)
        tileTypes.push(McChipsImage3)


        var tilesNumber:int = 0;
        for(var i:int = 0; i < levelModel.sizeX; i++){
            for(var j:int = 0; j < levelModel.sizeY; j++){
                if(levelModel.levelMask[i][j] == 1){
                    tilesNumber++;
                }
            }
        }
        var possibleTiles:Array = [];
        tilesNumber = tilesNumber/2;
        for(var k:int = 0; k < tilesNumber; k++){
            var index:int = Math.random() * tileTypes.length;
            possibleTiles.push(new BoardTile({}, new tileTypes[index]()),new BoardTile({}, new tileTypes[index]()))
        }
        var tileIndex:int = 0;
        var gap:int = 5;

        for(i = 0; i < levelModel.sizeX; i++){
            for(j = 0; j < levelModel.sizeY; j++){
                if(levelModel.levelMask[i][j] == 1){

                    tileIndex = Math.random() * possibleTiles.length;
                    var tile:BoardTile = possibleTiles[tileIndex];
                    possibleTiles.splice(tileIndex,1)
                    tile.x = tile.size * i + gap ;
                    tile.y = tile.size * j + gap ;

                    tile.addEventListener(MouseEvent.CLICK, onBoardTileClick, false, 0, true);
                    tile.addEventListener(MouseEvent.MOUSE_OVER, onBoardTileOver, false, 0 ,true);
                    tile.addEventListener(MouseEvent.MOUSE_OUT, onBoardTileOut, false, 0, true);
                    tilesInGame.push(tile);
                    view.addChild(tile);

                    CONFIG::debug{
                        trace(view.numChildren,"TILE POSITION: ", tile.x, tile.y, "i", i, "j", j);
                    }
                }
            }
        }

        timeoutTimer = new Timer(1000,1);
        timeoutTimer.addEventListener(TimerEvent.TIMER_COMPLETE, onTimeoutTimerComplete, false, 0 ,true);


        CONFIG::debug{
            trace(tilesInGame.length, view.numChildren);
        }
        arrange();
    }

    private function arrange():void{
        view.x = (applicationModel.currentWidth - view.width)/2;
        view.y = (applicationModel.currentHeight - view.height)/2;
    }
    private function lock():void{
        locked = true;
    }
    private function unlock():void{
        locked = false;
    }
    private function onBoardTileClick(e:MouseEvent):void{
        if(locked) return;

        var tileSelected:BoardTile = e.currentTarget as BoardTile;
        if(!firstSelectedTile){
            firstSelectedTile = tileSelected;
            firstSelectedTile.filters = [new GlowFilter(0x00ff00,1,1,6,6,8,true)];
            return;
        }
        if(!secondSelectedTile && tileSelected != firstSelectedTile){
            secondSelectedTile = e.currentTarget as BoardTile;
            secondSelectedTile.filters = [new GlowFilter(0x00ff00,1,1,6,6,2,true)];

            var transition:ShowTilesTransition = new ShowTilesTransition([firstSelectedTile, secondSelectedTile]);
            transition.addEventListener(Event.COMPLETE, onShowTransitionComplete, false, 0, true);
            transition.execute();
            lock();

        }
    }

    private function onBoardTileOver(e:MouseEvent):void {
    }

    private function onBoardTileOut(e:MouseEvent):void {
    }

    private function onShowTransitionComplete(e:Event):void {
        //TODO: сделать универсально.
        if(firstSelectedTile.type == secondSelectedTile.type){
            timeoutTimer.delay = 300;
        }
        else{
            timeoutTimer.delay = 1000;
        }

        timeoutTimer.start();
    }

    private function onHideRemoveTransitionComplete(e:Event):void {
        unlock();
    }

    private function onTimeoutTimerComplete(e:TimerEvent):void {
        timeoutTimer.stop();

        var transition:BaseTransition;
        if(firstSelectedTile.type == secondSelectedTile.type){

            transition = new RemovePairsTransition([firstSelectedTile, secondSelectedTile]);
            var index:int = tilesInGame.indexOf(firstSelectedTile);
            if(index > 0) tilesInGame.splice(index,1);
            index = tilesInGame.indexOf(secondSelectedTile);
            if(index > 0) tilesInGame.splice(index,1);

        }else{
            transition = new HideTilesTransition([firstSelectedTile, secondSelectedTile]);
        }

        transition.addEventListener(Event.COMPLETE, onHideRemoveTransitionComplete, false, 0 ,true);
        transition.execute();
        firstSelectedTile.filters = [];
        secondSelectedTile.filters = [];
        firstSelectedTile = null;
        secondSelectedTile = null;

    }