flash on 2010-6-16

/**
 * Copyright mtok ( http://wonderfl.net/user/mtok )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/opam
 */

package  
{
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.utils.Timer;
	import flash.events.TimerEvent;
	import flash.utils.Dictionary;
	/**
	 * ...
	 * @author ...
	 */
	public class VectorField extends Sprite
	{
		private var _grid:Grid;
		private var _timer:Timer;
		private var _dic:Dictionary;
		private var _work:Vector.<Cell>;
		private var _sessions:Vector.<Session>;
		
		public function VectorField() 
		{
			addEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);
		}
		
		private function addedToStageHandler(e:Event):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);

			var sw:Number = stage.stageWidth;
			var sh:Number = stage.stageHeight;
			var rows:int = Math.floor( sw / 25 );
			var cols:int = Math.floor( sh / 25 );
			_grid = new Grid(rows, cols);
			
			var i:int;
			var j:int;
			var c:Cell;
			var s:Sprite;
			for ( i = 0; i < cols; i++) {
				for (j = 0; j < rows; j++) {
					c = _grid.cells[i * rows + j];
					s = new Sprite();
					addChild(s);
					s.x = j * 25;
					s.y = i * 25;
					s.graphics.beginFill(0xffffff);
					s.graphics.drawRect(0,0,25,25);
					//s.graphics.drawCircle(12.5, 12.5, 12.5);
					s.graphics.endFill();
					c.data = s;
					
					s.addEventListener(MouseEvent.CLICK, clickHandler);
					s.addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
				}
			}
			
			_timer = new Timer(50);
			_timer.addEventListener(TimerEvent.TIMER, _timerHandler);
			_timer.start();
			
			_sessions = new Vector.<Session>();
		}
		
		private function _timerHandler(e:TimerEvent):void 
		{
			_sessions.forEach(function(s:Session, i:int, vec:Vector.<Session>):void { 
				s.proceed();
			}, null);
			
			for (var i:int = 0; i < _sessions.length; i++) {
				if ( _sessions[i].finished ) {
					_sessions.splice(i, 1);
					i--;
				}
			}
		}
		
		private function clickHandler(e:MouseEvent):void 
		{
			var s:Sprite = e.target as Sprite;
			var c:Cell = _grid.getCell(s);
	
			var session:Session = new Session();
			session.startCell = c;
			session.color = getColor();
			//session.onComplete = onComplete;
			_sessions.push(session);
		}
		private function mouseOverHandler(e:MouseEvent):void{
			var s:Sprite = e.target as Sprite;
			var c:Cell = _grid.getCell(s);
	
			var session:Session = new Session();
			session.startCell = c;
			session.color = getColor();
			_sessions.push(session);			
		}
		
		public function onComplete(s:Session):void {
			this._sessions.splice(_sessions.indexOf(s), 1);
			trace("finish", _sessions.length);
		}
		public function getColor():uint {
			var r:int = Math.floor( 255 * Math.random());
			var g:int = Math.floor( 255 * Math.random());
			var b:int = Math.floor( 255 * Math.random());
			
			return uint (r << 16 | g << 8 | b);
		}
	}
}

import flash.utils.Dictionary;
import flash.display.Sprite;
class Session {
	private var _check:Dictionary;
	private var _startCell:Cell;
	private var _work:Vector.<Cell>;
	public var color:uint;
	private var _finished:Boolean;
	
	//public  var onComplete:Function;
	public function Session()
	{
		_check = new Dictionary(true);
		_work = new Vector.<Cell>();
	}
	public function proceed():void 
	{
		var c:Cell;
		var w:Vector.<Cell> = new Vector.<Cell>();
		while (c = _work.shift()) {
			c.neighbors.forEach(function(nc:Cell, index:int, vec:Vector.<Cell>):void {
					if ( nc == null) return;
					if (_check[nc]) return;
					_check[nc] = true;
					w.push(nc);
					process(nc);
				}, null);
		}
		_work = w;
		if (_work.length == 0) {
			_finished = true;
			//if ( onComplete != null) {
				//onComplete.apply(null, [this]);
			//}
		}
	}
	public function process(c:Cell):void {
		var s:Sprite = c.data as Sprite;
		s.graphics.clear();
		s.graphics.beginFill(color);
		s.graphics.drawRect(0,0,25,25);
		//s.graphics.drawCircle(12.5, 12.5, 12.5);
		s.graphics.endFill();
	}
	public function get startCell():Cell { return _startCell; }
	public function set startCell(value:Cell):void 
	{
		_startCell = value;
		process(value);
		_finished = false;
		_work.push(value);
	}
	
	public function get finished():Boolean { return _finished; }
}
class Grid {
	private var _cells:Vector.<Cell>;
	private var _rows:int;
	private var _cols:int;
	public var _dictionary:Dictionary;
	/**
	 * 
	 * @param	rows
	 * @param	cols
	 */
	public function Grid(rows:int, cols:int) {
		_rows = rows;
		_cols = cols;
		_cells = new Vector.<Cell>(_rows * _cols);
		_dictionary = new Dictionary(true);
		
		var i:int, j:int;
		for (i = 0; i < _rows * _cols; i++) {
			_cells[i] = new Cell();
			_cells[i].grid = this;
		}
		
		var c:Cell;
		c = _cells[0];
		for (j = 1; j < _rows; j++) {
			c.right = _cells[j];
			c = _cells[j];
		}
		for (i = 1; i < _cols; i++) {
			c = _cells[i * _rows];
			c.upper = _cells[( i - 1) * _rows];
			for ( j = 1; j < _rows; j++) {
				c.right = _cells[i * _rows + j];
				c = c.right;
				c.upper　= _cells[(i - 1) * _rows + j];
			}
		}
	}
	public function getCellAt(row:int, col:int):Cell 
	{
		//note not check index
		return _cells[col*_rows + row];
	}
	public function getCell(obj:*):Cell
	{
		//data から該当するcellを取得
		return _dictionary[obj];
	}
	public function get rows():int { return _rows; }
	public function get cols():int { return _cols; }
	public function get cells():Vector.<Cell> { return _cells; }
}
class Cell {
	
	private var _data:*;
	private var _neighbors:Vector.<Cell>;
	private var _grid:Grid;
	
	public function Cell()
	{
		_neighbors = new Vector.<Cell>(4);
	}
	public function get upper():Cell { return _neighbors[0]; }
	public function set upper(value:Cell):void 
	{
		_neighbors[0] = value;
		value._neighbors[2] = this;
	}

	public function get right():Cell { return _neighbors[1]; }
	public function set right(value:Cell):void 
	{
		_neighbors[1] = value;
		value._neighbors[3] = this;
	}

	public function get under():Cell { return _neighbors[2]; }
	public function set under(value:Cell):void 
	{
		_neighbors[2] = value;
		value._neighbors[0] = this;
	}

	public function get left():Cell { return _neighbors[3]; }
	public function set left(value:Cell):void 
	{
		_neighbors[3] = value;
		value._neighbors[2] = this;
	}
	
	public function get data():* { return _data; }
	public function set data(value:*):void 
	{
		_data = value;
		_grid._dictionary[value] = this;
	}
	
	public function get grid():Grid { return _grid; }
	public function set grid(value:Grid):void 
	{
		_grid = value;
	}
	
	public function get neighbors():Vector.<Cell> { return _neighbors; }
	public function set neighbors(value:Vector.<Cell>):void 
	{
		_neighbors = value;
	}
}