littleant2.as

蚁群算法蚁群算法在移动Agent迁移中的应用研究文档信息

package com.view
{
	import com.control.events.MessageEvent;
	import com.model.ModelLocator;
	import com.model.valueObjects.MessageInfo;
	
	import flash.display.Sprite;
	import flash.events.*;
	
	
	public class littleAnt2 extends Sprite
	{
		private var __model:ModelLocator = ModelLocator.getInstance();
		
		private var range:int = 3;
		private var remember:Number = 10;
		private var rememberFields:Array = new Array();
		
		private var moveFaultProbability:Number = .02 * Math.random();
		private var messagesFaultProbability:Number = .2;
		
		private var speed:Number = 6;
		private var award:Number = 360 * Math.random();
		
		private var currentField:Array = new Array();
		private var previousField:Array = new Array();
		private var nextFields:Array = new Array();
		private var nextFields4:Array = new Array();
		private var nextMessagesField:Array = new Array();
		
		private var messages:Number = 0;
		private var messagesDecreaseSpeed:Number = 10;
		
		private var TOFOOD:String = "HomeMessages";
		private var TOHOME:String = "FoodMessages";
		private var towhere:String = TOFOOD;
		
		private var xunitdifference:int;
		private var yunitdifference:int;
		private var xdifference:Number;
		private var ydifference:Number;
		
		private var ant:antswc;
		
		public function littleAnt2(xnum:int, ynum:int){
			currentField = [xnum, ynum];
			rememberFields.push(currentField);
			previousField = [-1, -1];
			find();
			
			ant = new antswc();
			addChild(ant);
			ant.scaleX = ant.scaleY = .05;
			ant.rotation = award;
			
			this.addEventListener(Event.ENTER_FRAME, conctrolMove);
		}
		
		private function conctrolMove(event:Event):void{
			
			nextFields = getFieldsAround();
			
			if(nextFields.length == 0){
				moveForMove();
			}else{
				moveForFood(nextMessagesField);
			}
		}
		
		private function moveForMove():void{
			if(Math.random() < moveFaultProbability){
				changeAward();
			}
			
			
			var xnext:Number = this.x + speed * Math.sin(award / 57.3);
			var ynext:Number = this.y - speed * Math.cos(award / 57.3);
			
			if(againstTheWall(xnext, ynext) && noBackWay(xnext, ynext)){
				this.x = xnext;
				this.y = ynext;
				
				var nextplace:Array = [int(xnext/__model.mapinfo.unit), int(ynext/__model.mapinfo.unit)];
				
				if(_getIndexOf(rememberFields, nextplace) == -1){
					if(rememberFields.length == remember){
						rememberFields.shift();
					}
					rememberFields.push(nextplace);
					makeMessage(nextplace);
					//trace(rememberFields.toString());
				}
				
				if(currentField[0] != nextplace[0] || currentField[1] != nextplace[1]){
					currentField = nextplace;
					
				}
				
			}else{
				changeAward();
			}
		}
		
		private function moveForFood(nextField:Array):void{
			if(currentField[0] != previousField[0] || currentField[1] != previousField[1]){
				previousField = currentField;
				
				
				nextField = nextMessagesField = getFieldByMessages(nextFields);
				
				xunitdifference = nextField[0] - currentField[0];
				yunitdifference = nextField[1] - currentField[1];
				
				switch(xunitdifference){
					case -1:
						xdifference = (nextField[0]+1)*__model.mapinfo.unit - this.x;
						break;
					case 1:
						xdifference = nextField[0]*__model.mapinfo.unit - this.x;
						break;
					case 0:
						xdifference = 0;
						break;
				}
				
				switch(yunitdifference){
					case -1:
						ydifference = (nextField[1]+1)*__model.mapinfo.unit - this.y;
						break;
					case 1:
						ydifference = nextField[1]*__model.mapinfo.unit - this.y;
						break;
					case 0:
						ydifference = 0;
						break;
				}
			}
			
			var xnext:Number;
			var ynext:Number;
			
			if(!(xdifference == 0 && ydifference == 0)){
				changeAward(Math.atan(xdifference/(0-ydifference)) * 57.3 + (yunitdifference == 1?180:0));
				
				var difference:Number = Math.sqrt(xdifference*xdifference + ydifference*ydifference);
				
				xnext = this.x + speed * xdifference / difference;
				ynext = this.y + speed * ydifference / difference;
			}else{
				//trace("critical!")
				changeAward();
				xnext = this.x + Math.sin(award / 57.3);
				ynext = this.y - Math.cos(award / 57.3);
			}
			
			this.x = xnext;
			this.y = ynext;
			var nextplace:Array = [int(xnext / __model.mapinfo.unit), int(ynext / __model.mapinfo.unit)];
			if(nextplace[0] != currentField[0] || nextplace[1] != currentField[1]){
				currentField = nextplace;
				makeMessage(currentField);
				
				if(_getIndexOf(rememberFields, nextplace) == -1){
					if(rememberFields.length == remember){
						rememberFields.shift();
					}
						
					rememberFields.push(currentField);
				}
					
			}
		}
		
		private function changeAward(r:Number=361):void{
			if(r == 361){
				ant.rotation = award = 360 * Math.random();
			}else{
				ant.rotation = award = r;
			}
			
			
		}
		
		private function makeMessage(field:Array):void{
			try{
			if(__model.mapinfo.maps[field[1]][field[0]].hasHome){
				//trace("find home");
				towhere = TOFOOD;
				rememberFields.splice(0, rememberFields.length);
				find();
				ant.gotoAndPlay("noFood");
			}else if(__model.mapinfo.maps[field[1]][field[0]].hasFood){
				//trace("find food");
				towhere = TOHOME;
				rememberFields.splice(0, rememberFields.length);
				find();
				ant.gotoAndPlay("hasFood");
			}else if(messages > 0){
				var o:MessageInfo = new MessageInfo();
				o.xnum = field[1];
				o.ynum = field[0];
				o.messages = messages;
				o.type = towhere;
				goBack();
				var event:MessageEvent = new MessageEvent(o);
				event.dispatch();
			}}catch(e:*){
				trace("error")
				trace(field.toString())
			}
		}
		
		private function againstTheWall(xnext:Number, ynext:Number):Boolean{
			if(xnext < 0 || xnext > __model.mapinfo.xnum*__model.mapinfo.unit || ynext < 0 || ynext > __model.mapinfo.ynum*__model.mapinfo.unit)
				return false;
			else
				return true;
		}
		
		private function noBackWay(xnext:Number, ynext:Number):Boolean{
			var nextplace:Array = [int(xnext/__model.mapinfo.unit), int(ynext/__model.mapinfo.unit)];
			if(nextplace[0] == currentField[0] && nextplace[1] == currentField[1]){
				return true;
			}else{
				if(_getIndexOf(rememberFields, nextplace) == -1){
					return true;
				}else if(nextFields4.length > 0){
					//trace("noway");
					var allremember:Boolean = false;
					//trace(rememberFields.toString());
					//trace(nextFields.toString());
					//trace(nextFields.length);
					for(var i:String in nextFields4){
						if(_getIndexOf(rememberFields, nextFields4[i]) == -1){
							allremember = true;
							break;
						}
					}
					//trace(allremember);
					if(!allremember){
						rememberFields.splice(0, rememberFields.length);
						//trace("delete remember");
					}
						
					return false;
				}else{
					return false;
				}
			}
		}
		
		private function _getIndexOf(base:Array, child:Array):int{
			for(var i:Number = 0; i < base.length; i ++){
				if(base[i][0] == child[0] && base[i][1] == child[1]){
					return i;
					break;
				}
			}
			return -1;
		}
		
		private function getFieldsAround():Array{
			var step:int = (range - 1) / 2;
			var currentxnum:int = currentField[0];
			var currentynum:int = currentField[1];
			var choose:Array = new Array();
			
			var xbegin:int = Math.max(0,currentxnum-step);
			var xend:int = Math.min(__model.mapinfo.xnum-1, currentxnum+step);
			var ybegin:int = Math.max(0,currentynum-step);
			var yend:int = Math.min(__model.mapinfo.ynum-1, currentynum+step);
			
			nextFields4.splice(0, nextFields4.length);
			for(var i:int = xbegin; i <= xend; i++){
				for(var j:int = ybegin; j <= yend; j++){
					var mu:MapUnit = __model.mapinfo.maps[j][i];
					if(!(i == currentxnum && j == currentynum)){
						if(i == currentxnum || j == currentynum){
							nextFields4.push([mu.xnum, mu.ynum]);
						}
						//trace(towhere)
						//trace(mu.FoodMessages);
						//trace(mu.HomeMessages);
						if(((towhere == TOFOOD && (mu.FoodMessages > 0 || mu.hasFood)) || (towhere == TOHOME && (mu.HomeMessages > 0 || mu.hasHome))) && mu.through == 0 && _getIndexOf(rememberFields, [mu.xnum, mu.ynum]) == -1){
							choose.push(mu);
						}
					}
				}
			}
			//trace(nextFields4.toString());
			//trace(choose.toString());
			var base:String = towhere == TOFOOD?TOHOME:TOFOOD;
			choose.sortOn(base, Array.NUMERIC);
			
			var fields:Array = new Array();
			
			for(var k:String in choose){
				if((towhere == TOFOOD && choose[k].hasFood) || (towhere == TOHOME && choose[k].hasHome)){
					fields.splice(0, fields.length);
					fields.push([choose[k].xnum, choose[k].ynum]);
					//trace(fields.toString())
					return fields;
				}
				fields.push([choose[k].xnum, choose[k].ynum]);
			}
			//trace(fields.toString())
			//trace("______________________________________")
			return fields;
		}
		
		private function getFieldByMessages(fields:Array):Array{
			//trace(fields.toString());
			var s:String = "";
			var len:int = fields.length;
			if(len > 0){
				var choose:Array;
				
				var random:Number = Math.random();
				if(len == 1 || random > messagesFaultProbability){
					choose = fields[len-1];
				}else{
					var index:int = getRandom(len-1) - 1;
					choose = fields[index];
					
				}
				
				return choose;
			}else{
				return null;
			}
			
		}
		
		private function find():void{
			messages = __model.mapinfo.xnum * 1.4 * messagesDecreaseSpeed;
		}
		
		private function goBack():void{
			messages = Math.max(0, messages - messagesDecreaseSpeed);
		}
		
		private function getRandom(n:int):int{
			var c:int = 0;
			var a:Array = new Array();
			for(var i:int = 0; i < n; i ++){
				var b:int = Math.pow(3, i);
				c += b;
				a.push(c);
			}
			
			var rx:int = int(Math.random() * c);
			var j:int;
			for(j = 0; j < a.length-1; j ++){
				if(rx <= a[j]){
					break;
				}
			}
			return j+1;
		}
		
	}
}