/*
* Convex Separator for Box2D Flash
*
* This class has been written by Antoan Angelov. 
* It is designed to work with Erin Catto's Box2D physics library.
*
* Everybody can use this software for any purpose, under two restrictions:
* 1. You cannot claim that you wrote this software.
* 2. You can not remove or alter this notice.
*
*/
 
package Box2DSeparator{
	import Box2D.Collision.Shapes.b2PolygonShape;
	import Box2D.Common.Math.b2Vec2;
	import Box2D.Dynamics.b2Body;
	import Box2D.Dynamics.b2FixtureDef;
 
	public class b2Separator;
	{
		public function b2Separator() {
		}
 
		/**
		 * Separates a non-convex polygon into convex polygons and adds them as fixtures to the <code>body</code> parameter.<br/>
		 * There are some rules you should follow (otherwise you might get unexpected results) :
		 * <ul>
		 * <li>This class is specifically for non-convex polygons. If you want to create a convex polygon, you don't need to use this class - Box2D's <code>b2PolygonShape</code> class allows you to create convex shapes with the <code>setAsArray()</code>/<code>setAsVector()</code> method.</li>
		 * <li>The vertices must be in clockwise order.</li>
		 * <li>No three neighbouring points should lie on the same line segment.</li>
		 * <li>There must be no overlapping segments and no "holes".</li>
		 * </ul> <p/>
		 * @param body The b2Body, in which the new fixtures will be stored.
		 * @param fixtureDef A b2FixtureDef, containing all the properties (friction, density, etc.) which the new fixtures will inherit.
		 * @param verticesVec The vertices of the non-convex polygon, in clockwise order.
		 * @param scale <code>[optional]</code> The scale which you use to draw shapes in Box2D. The bigger the scale, the better the precision. The default value is 30. 
		 * @see b2PolygonShape
		 * @see b2PolygonShape.SetAsArray()
		 * @see b2PolygonShape.SetAsVector()
		 * @see b2Fixture
		 * */
 
		public function Separate(body:b2Body,fixtureDef:b2FixtureDef,verticesVec:Vector.<b2Vec2>,scale:Number=30):void {
			var i:int,n:int=verticesVec.length,j:int,m:int;
			var vec:Vector.<b2Vec2>=new Vector.<b2Vec2>  ,figsVec:Array;
			var polyShape:b2PolygonShape;
 
			for (i=0; i<n; i++) {
				vec.push(new b2Vec2(verticesVec[i].x*scale,verticesVec[i].y*scale));
			}
 
			figsVec=calcShapes(vec);
			n=figsVec.length;
 
			for (i=0; i<n; i++) {
				verticesVec=new Vector.<b2Vec2>  ;
				vec=figsVec[i];
				m=vec.length;
				for (j=0; j<m; j++) {
					verticesVec.push(new b2Vec2(vec[j].x/scale,vec[j].y/scale));
				}
 
				polyShape=new b2PolygonShape  ;
				polyShape.SetAsVector(verticesVec);
				fixtureDef.shape=polyShape;
				body.CreateFixture(fixtureDef);
			}
		}
 
		/**
		 * Checks whether the vertices in <code>verticesVec</code> can be properly distributed into the new fixtures (more specifically, it makes sure there are no overlapping segments and the vertices are in clockwise order). 
		 * It is recommended that you use this method for debugging only, because it may cost more CPU usage.
		 * <p/>
		 * @param verticesVec The vertices to be validated.
		 * @return An integer which can have the following values:
		 * <ul>
		 * <li>0 if the vertices can be properly processed.</li>
		 * <li>1 If there are overlapping lines.</li>
		 * <li>2 if the points are <b>not</b> in clockwise order.</li>
		 * <li>3 if there are overlapping lines <b>and</b> the points are <b>not</b> in clockwise order.</li>
		 * </ul> 
		 * */
 
		public function Validate(verticesVec:Vector.<b2Vec2>):int {
			var i:int,n:int=verticesVec.length,j:int,j2:int,i2:int,i3:int,d:Number,ret:int=0;
			var fl:Boolean,fl2:Boolean=false;
 
			for (i=0; i<n; i++) {
				i2=(i<n-1)?i+1:0;
				i3=(i>0)?i-1:n-1;
 
				fl=false;
				for (j=0; j<n; j++) {
					if (((j!=i)&&j!=i2)) {
						if (! fl) {
							d=det(verticesVec[i].x,verticesVec[i].y,verticesVec[i2].x,verticesVec[i2].y,verticesVec[j].x,verticesVec[j].y);
							if ((d>0)) {
								fl=true;
							}
						}
 
						if ((j!=i3)) {
							j2=(j<n-1)?j+1:0;
							if (hitSegment(verticesVec[i].x,verticesVec[i].y,verticesVec[i2].x,verticesVec[i2].y,verticesVec[j].x,verticesVec[j].y,verticesVec[j2].x,verticesVec[j2].y)) {
								ret=1;
							}
						}
					}
				}
 
				if (! fl) {
					fl2=true;
				}
			}
 
			if (fl2) {
				if ((ret==1)) {
					ret=3;
				}
				else {
					ret=2;
				}
 
			}
			return ret;
		}
 
		private function calcShapes(verticesVec:Vector.<b2Vec2>):Array {
			var vec:Vector.<b2Vec2>;
			var i:int,n:int,j:int;
			var d:Number,t:Number,dx:Number,dy:Number,minLen:Number;
			var i1:int,i2:int,i3:int,p1:b2Vec2,p2:b2Vec2,p3:b2Vec2;
			var j1:int,j2:int,v1:b2Vec2,v2:b2Vec2,k:int,h:int;
			var vec1:Vector.<b2Vec2>,vec2:Vector.<b2Vec2>;
			var v:b2Vec2,hitV:b2Vec2;
			var isConvex:Boolean;
			var figsVec:Array=[],queue:Array=[];
 
			queue.push(verticesVec);
 
			while (queue.length) {
				vec=queue[0];
				n=vec.length;
				isConvex=true;
 
				for (i=0; i<n; i++) {
					i1=i;
					i2=(i<n-1)?i+1:i+1-n;
					i3=(i<n-2)?i+2:i+2-n;
 
					p1=vec[i1];
					p2=vec[i2];
					p3=vec[i3];
 
					d=det(p1.x,p1.y,p2.x,p2.y,p3.x,p3.y);
					if ((d<0)) {
						isConvex=false;
						minLen=Number.MAX_VALUE;
 
						for (j=0; j<n; j++) {
							if (((j!=i1)&&j!=i2)) {
								j1=j;
								j2=(j<n-1)?j+1:0;
 
								v1=vec[j1];
								v2=vec[j2];
 
								v=hitRay(p1.x,p1.y,p2.x,p2.y,v1.x,v1.y,v2.x,v2.y);
 
								if (v) {
									dx=p2.x-v.x;
									dy=p2.y-v.y;
									t=dx*dx+dy*dy;
 
									if ((t<minLen)) {
										h=j1;
										k=j2;
										hitV=v;
										minLen=t;
									}
								}
							}
						}
 
						if ((minLen==Number.MAX_VALUE)) {
							err();
						}
 
						vec1=new Vector.<b2Vec2>  ;
						vec2=new Vector.<b2Vec2>  ;
 
						j1=h;
						j2=k;
						v1=vec[j1];
						v2=vec[j2];
 
						if (! pointsMatch(hitV.x,hitV.y,v2.x,v2.y)) {
							vec1.push(hitV);
						}
						if (! pointsMatch(hitV.x,hitV.y,v1.x,v1.y)) {
							vec2.push(hitV);
						}
 
						h=-1;
						k=i1;
						while (true) {
							if ((k!=j2)) {
								vec1.push(vec[k]);
							}
							else {
								if (((h<0)||h>=n)) {
									err();
								}
								if (! this.isOnSegment(v2.x,v2.y,vec[h].x,vec[h].y,p1.x,p1.y)) {
									vec1.push(vec[k]);
								}
								break;
							}
 
							h=k;
							if (((k-1)<0)) {
								k=n-1;
							}
							else {
								k--;
							}
						}
 
						vec1=vec1.reverse();
 
						h=-1;
						k=i2;
						while (true) {
							if ((k!=j1)) {
								vec2.push(vec[k]);
							}
							else {
								if (((h<0)||h>=n)) {
									err();
								}
								if (((k==j1)&&! this.isOnSegment(v1.x,v1.y,vec[h].x,vec[h].y,p2.x,p2.y))) {
									vec2.push(vec[k]);
								}
								break;
							}
 
							h=k;
							if (((k+1)>n-1)) {
								k=0;
							}
							else {
								k++;
							}
						}
 
						queue.push(vec1,vec2);
						queue.shift();
 
						break;
					}
				}
 
				if (isConvex) {
					figsVec.push(queue.shift());
				}
			}
 
			return figsVec;
		}
 
		private function hitRay(x1:Number,y1:Number,x2:Number,y2:Number,x3:Number,y3:Number,x4:Number,y4:Number):b2Vec2 {
			var t1:Number=x3-x1,t2:Number=y3-y1,t3:Number=x2-x1,t4:Number=y2-y1,t5:Number=x4-x3,t6:Number=y4-y3,t7:Number=t4*t5-t3*t6,a:Number;
 
			a=(((t5*t2)-t6*t1)/t7);
			var px:Number=x1+a*t3,py:Number=y1+a*t4;
			var b1:Boolean=isOnSegment(x2,y2,x1,y1,px,py);
			var b2:Boolean=isOnSegment(px,py,x3,y3,x4,y4);
 
			if ((b1&&b2)) {
				return new b2Vec2(px,py);
			}
 
			return null;
		}
 
		private function hitSegment(x1:Number,y1:Number,x2:Number,y2:Number,x3:Number,y3:Number,x4:Number,y4:Number):b2Vec2 {
			var t1:Number=x3-x1,t2:Number=y3-y1,t3:Number=x2-x1,t4:Number=y2-y1,t5:Number=x4-x3,t6:Number=y4-y3,t7:Number=t4*t5-t3*t6,a:Number;
 
			a=(((t5*t2)-t6*t1)/t7);
			var px:Number=x1+a*t3,py:Number=y1+a*t4;
			var b1:Boolean=isOnSegment(px,py,x1,y1,x2,y2);
			var b2:Boolean=isOnSegment(px,py,x3,y3,x4,y4);
 
			if ((b1&&b2)) {
				return new b2Vec2(px,py);
			}
 
			return null;
		}
 
		private function isOnSegment(px:Number,py:Number,x1:Number,y1:Number,x2:Number,y2:Number):Boolean {
			var b1:Boolean=((((x1+0.1)>=px)&&px>=x2-0.1)||(((x1-0.1)<=px)&&px<=x2+0.1));
			var b2:Boolean=((((y1+0.1)>=py)&&py>=y2-0.1)||(((y1-0.1)<=py)&&py<=y2+0.1));
			return ((b1&&b2)&&isOnLine(px,py,x1,y1,x2,y2));
		}
 
		private function pointsMatch(x1:Number,y1:Number,x2:Number,y2:Number):Boolean {
			var dx:Number=(x2>=x1)?x2-x1:x1-x2,dy:Number=(y2>=y1)?y2-y1:y1-y2;
			return ((dx<0.1)&&dy<0.1);
		}
 
		private function isOnLine(px:Number,py:Number,x1:Number,y1:Number,x2:Number,y2:Number):Boolean {
			if ((((x2-x1)>0.1)||x1-x2>0.1)) {
				var a:Number=(y2-y1)/(x2-x1),possibleY:Number=a*(px-x1)+y1,diff:Number=(possibleY>py)?possibleY-py:py-possibleY;
				return (diff<0.1);
			}
 
			return (((px-x1)<0.1)||x1-px<0.1);
		}
 
		private function det(x1:Number,y1:Number,x2:Number,y2:Number,x3:Number,y3:Number):Number {
			return x1*y2+x2*y3+x3*y1-y1*x2-y2*x3-y3*x1;
		}
 
		private function err():void {
			throw new Error("A problem has occurred. Use the Validate() method to see where the problem is.");
		}
	}
}

package {
	import flash.display.Sprite;
	import flash.events.MouseEvent;
	import flash.events.Event;
	import flash.text.TextField;
 
	public class bejewelled extends Sprite {
		private var gems_array:Array=new Array();
		private var aGem:Sprite;
		private var selectorBox:Sprite=new Sprite();
		private var selectorRow:int=-10;
		private var selectorColumn:int=-10;
		private var red:uint = 0xFF0000;
		private var green:uint = 0xFF00;
		private var blue:uint = 0xFF;
		private var yellow:uint = 0xFFFF00;
		private var cyan:uint = 0xFFFF;
		private var magenta:uint = 0xFF00FF;
		private var white:uint = 0xFFFFFF;
		private var colours_array:Array=new Array(red,green,blue,yellow,cyan,magenta,white);
		private var clickPossible:Boolean=false;
		private var score_txt:TextField=new TextField();
		private var hint_txt:TextField=new TextField();
		private var score:uint=0;
		private var inaRow:uint=0;
		private var match:Boolean = true;
 
		public function bejewelled() {
			// Game initiation
			// Create and style score text
			addChild(score_txt);
			score_txt.textColor=0xFFFFFF;
			score_txt.x=500;
			// Create and style hint text
			addChild(hint_txt);
			hint_txt.textColor=0xFFFFFF;
			hint_txt.x=550;
			// Create Gems in rows and columns
			for (var i:uint=0; i<8; i++) {
				gems_array[i]=new Array();
				for (var j:uint=0; j<8; j++) {
					do {
						gems_array[i][j]=Math.floor(Math.random()*7);
					}
						while (rowLineLength(i,j)>2 || columnLineLength(i,j)>2);
					aGem=new Sprite();
					aGem.graphics.beginFill(colours_array[gems_array[i][j]]);
					aGem.graphics.drawCircle(30,30,29);
					aGem.graphics.endFill();
					aGem.name=i+"_"+j;
					aGem.x=j*60;
					aGem.y=i*60;
					addChild(aGem);
				}
			}
			// Create and style selector box
			addChild(selectorBox);
			selectorBox.graphics.lineStyle(2,red,1);
			selectorBox.graphics.drawRect(0,0,60,60);
			selectorBox.visible=false;
			// Listen for user input
			stage.addEventListener(MouseEvent.CLICK,onClick);
 
			addEventListener(Event.ENTER_FRAME,everyFrame);
		}
 
		// Every frame...
		private function everyFrame(e:Event):void {
			//Assume that gems are not falling
			var gemsAreFalling:Boolean=false;
			// Check each gem for space below it
			for (var i:int=6; i>=0; i--) {
				for (var j:uint=0; j<8; j++) {
					// If a spot contains a gem, and has an empty space below...
					if (gems_array[i][j] != -1 && gems_array[i+1][j]==-1) {
						// Set gems falling
						gemsAreFalling=true;
						gems_array[i+1][j]=gems_array[i][j];
						gems_array[i][j]=-1;
						getChildByName(i+"_"+j).y+=60;
						getChildByName(i+"_"+j).name=(i+1)+"_"+j;
						break;
					}
				}
				// If a gem is falling
				if (gemsAreFalling) {
					// don't allow any more to start falling
					break;
				}
			}
			// If no gems are falling
			if (! gemsAreFalling) {
				// Assume no new gems are needed
				var needNewGem:Boolean=false;
				// but check all spaces...
				for (i=7; i>=0; i--) {
					for (j=0; j<8; j++) {
						// and if a spot is empty
						if (gems_array[i][j]==-1) {
							// now we know we need a new gem
							needNewGem=true;
							// pick a random color for the gem
							gems_array[0][j]=Math.floor(Math.random()*7);
							// create the gem
							aGem=new Sprite();
							aGem.graphics.beginFill(colours_array[gems_array[0][j]]);
							aGem.graphics.drawCircle(30,30,29);
							aGem.graphics.endFill();
							// ID it
							aGem.name="0_"+j;
							// position it
							aGem.x=j*60;
							aGem.y=0;
							// show it
							addChild(aGem);
							// stop creating new gems
							break;
						}
					}
					// if a new gem was created, stop checking
					if (needNewGem) {
						break;
					}
				}
				// If no new gems were needed...
				if (! needNewGem) {
					// assume no more/new lines are on the board
					var moreLinesAvailable:Boolean=false;
					// check all gems
					for (i=7; i>=0; i--) {
						for (j=0; j<8; j++) {
							// if a line is found
							if (rowLineLength(i,j)>2 || columnLineLength(i,j)>2) {
								// then we know more lines are available
								moreLinesAvailable=true;
								// creat a new array, set the gem type of the line, and where it is
								var lineGems:Array=[i+"_"+j];
								var gemType:uint=gems_array[i][j];
								var linePosition:int;
								// check t's a horizontal line...
								if (rowLineLength(i,j)>2) {
									// if so, find our how long it is and put all the line's gems into the array
									linePosition=j;
									while (sameGemIsHere(gemType,i,linePosition-1)) {
										linePosition--;
										lineGems.push(i+"_"+linePosition);
									}
									linePosition=j;
									while (sameGemIsHere(gemType,i,linePosition+1)) {
										linePosition++;
										lineGems.push(i+"_"+linePosition);
									}
								}
								// check t's a vertical line...
								if (columnLineLength(i,j)>2) {
									// if so, find our how long it is and put all the line's gems into the array
									linePosition=i;
									while (sameGemIsHere(gemType,linePosition-1,j)) {
										linePosition--;
										lineGems.push(linePosition+"_"+j);
									}
									linePosition=i;
									while (sameGemIsHere(gemType,linePosition+1,j)) {
										linePosition++;
										lineGems.push(linePosition+"_"+j);
									}
								}
								// for all gems in the line...
								for (i=0; i<lineGems.length; i++) {
									// remove it from the program
									removeChild(getChildByName(lineGems[i]));
									// find where it was in the array
									var cd:Array=lineGems[i].split("_");
									// set it to an empty gem space
									gems_array[cd[0]][cd[1]]=-1;
									// set the new score
									score+=inaRow;
									// set the score setter up
									inaRow++;
								}
								// if a row was made, stop the loop
								break;
							}
						}
						// if a line was made, stop making more lines
						if (moreLinesAvailable) {
							break;
						}
					}
					// if no more lines were available...
					if (! moreLinesAvailable) {
						// allow new moves to be made
						clickPossible=true;
						// remove score multiplier
						inaRow=0;
					}
				}
			}
			// display new score
			score_txt.text=score.toString();
		}
		// When the user clicks
		private function onClick(e:MouseEvent):void {
			// If a click is allowed
			if (clickPossible) {
				// If the click is within the game area...
				if (mouseX<480&&mouseX>0&&mouseY<480&&mouseY>0) {
					// Find which row and column were clicked
					var clickedRow:uint=Math.floor(mouseY/60);
					var clickedColumn:uint=Math.floor(mouseX/60);
					// Check if the clicked gem is adjacent to the selector
					// If not...
					if (!(((clickedRow==selectorRow+1 || clickedRow==selectorRow-1)&&clickedColumn==selectorColumn)||((clickedColumn==selectorColumn+1 || clickedColumn==selectorColumn-1) && clickedRow==selectorRow))) {
						// Find row and colum the selector should move to
						selectorRow=clickedRow;
						selectorColumn=clickedColumn;
						// Move it to the chosen position
						selectorBox.x=60*selectorColumn;
						selectorBox.y=60*selectorRow;
						// If hidden, show it.
						selectorBox.visible=true;
					}
					// If it is not next to it...
					else {
						// Swap the gems;
						swapGems(selectorRow,selectorColumn,clickedRow,clickedColumn);
						// If they make a line...
						if (rowLineLength(selectorRow,selectorColumn)>2 || columnLineLength(selectorRow,selectorColumn)>2||rowLineLength(clickedRow,clickedColumn)>2 || columnLineLength(clickedRow,clickedColumn)>2) {
							// remove the hint text
							hint_txt.text="";
							// dis-allow a new move until cascade has ended (removes glitches)
							clickPossible=false;
							// move and rename the gems
							getChildByName(selectorRow+"_"+selectorColumn).x=clickedColumn*60;
							getChildByName(selectorRow+"_"+selectorColumn).y=clickedRow*60;
							getChildByName(selectorRow+"_"+selectorColumn).name="t";
							getChildByName(clickedRow+"_"+clickedColumn).x=selectorColumn*60;
							getChildByName(clickedRow+"_"+clickedColumn).y=selectorRow*60;
							getChildByName(clickedRow+"_"+clickedColumn).name=selectorRow+"_"+selectorColumn;
							getChildByName("t").name=clickedRow+"_"+clickedColumn;
							match = true;
						}
						// If not...
						else {
							// Switch them back
							swapGems(selectorRow,selectorColumn,clickedRow,clickedColumn);
							match = false;
						}
						if (match) {
							// Move the selector position to default
							selectorRow=-10;
							selectorColumn=-10;
							// and hide it
							selectorBox.visible=false;
						}
						else {
							// Set the selector position
							selectorRow=clickedRow;
							selectorColumn=clickedColumn;
							// Move the box into position
							selectorBox.x=60*selectorColumn;
							selectorBox.y=60*selectorRow;
							match = false;
							// If hidden, show it.
							selectorBox.visible=true;
						}
					}
				}
				// If the click is outside the game area
				else {
					// For gems in all rows...
					for (var i:uint=0; i<8; i++) {
						// and columns...
						for (var j:uint=0; j<8; j++) {
							// if they're not too close to the side... 
							if (i<7) {
								// swap them horizontally
								swapGems(i,j,i+1,j);
								// check if they form a line
								if ((rowLineLength(i,j)>2||columnLineLength(i,j)>2||rowLineLength(i+1,j)>2||columnLineLength(i+1,j)>2)) {
									// if so, name the move made
									selectorBox.x = j*60;
									selectorBox.y = i*60;
									selectorBox.visible = true;
									hint_txt.text = (i+1).toString()+","+(j+1).toString()+"->"+(i+2).toString()+","+(j+1).toString();
								}
								// swap the gems back
								swapGems(i,j,i+1,j);
							}
							// then if they're not to close to the bottom...
							if (j<7) {
								// swap it vertically
								swapGems(i,j,i,j+1);
								// check if it forms a line
								if ((rowLineLength(i,j)>2||columnLineLength(i,j)>2||rowLineLength(i,j+1)>2||columnLineLength(i,j+1)>2) ) {
									// if so, name it
									selectorBox.x = j*60;
									selectorBox.y = i*60;
									selectorBox.visible = true;
									hint_txt.text = (i+1).toString()+","+(j+1).toString()+"->"+(i+1).toString()+","+(j+2).toString();
								}
								// swap the gems back
								swapGems(i,j,i,j+1);
							}
						}
					}
				}
			}
		}
		//Swap given gems
		private function swapGems(fromRow:uint,fromColumn:uint,toRow:uint,toColumn:uint):void {
			//Save the original position
			var originalPosition:uint=gems_array[fromRow][fromColumn];
			//Move original gem to new position
			gems_array[fromRow][fromColumn]=gems_array[toRow][toColumn];
			//move second gem to saved, original gem's position
			gems_array[toRow][toColumn]=originalPosition;
		}
		//Find out if there us a horizontal line
		private function rowLineLength(row:uint,column:uint):uint {
			var gemType:uint=gems_array[row][column];
			var lineLength:uint=1;
			var checkColumn:int=column;
			//check how far left it extends
			while (sameGemIsHere(gemType,row,checkColumn-1)) {
				checkColumn--;
				lineLength++;
			}
			checkColumn=column;
			//check how far right it extends
			while (sameGemIsHere(gemType,row,checkColumn+1)) {
				checkColumn++;
				lineLength++;
			}
			// return total line length
			return (lineLength);
		}
		//Find out if there us a vertical line
		private function columnLineLength(row:uint,column:uint):uint {
			var gemType:uint=gems_array[row][column];
			var lineLength:uint=1;
			var checkRow:int=row;
			//check how low it extends
			while (sameGemIsHere(gemType,checkRow-1,column)) {
				checkRow--;
				lineLength++;
			}
			//check how high it extends
			checkRow=row;
			while (sameGemIsHere(gemType,checkRow+1,column)) {
				checkRow++;
				lineLength++;
			}
			// return total line length
			return (lineLength);
		}
		private function sameGemIsHere(gemType:uint,row:int,column:int):Boolean {
			//Check there are gems in the chosen row
			if (gems_array[row]==null) {
				return false;
			}
			//If there are, check if there is a gem in the chosen slot
			if (gems_array[row][column]==null) {
				return false;
			}
			//If there is, check if it's the same as the chosen gem type
			return gemType==gems_array[row][column];
		}
	}
}

package  
{  
    import Box2D.Collision.Shapes.*;  
    import Box2D.Collision.b2AABB;  
    import Box2D.Common.Math.*;  
    import Box2D.Dynamics.*;  
 
    import flash.display.DisplayObjectContainer;  
    import flash.display.Sprite;  
    import flash.events.Event;  
    import flash.events.KeyboardEvent;  
    import flash.geom.*;  
    import flash.utils.Timer;  
 
    [SWF(width="800", height="600", backgroundColor="0x000000", frameRate="30")]  
    public class Box2Dto3D extends Sprite  
    {  
        private static const Y_DIR:int = 1;  
        private var _moveLeft:Boolean = false;  
        private var _moveRight:Boolean = false;  
        private var _moveUp:Boolean = false;  
        private var _moveDown:Boolean = false;  
 
        //box2D stuff  
        private var _world:b2World;  
        private var _player:b2Body;  
        private var _block1:b2Body;  
        private var _block2:b2Body;  
        private var speed:Number = 5;  
 
 
        private var player_rec:Rectangle = new Rectangle(0,0,50,50);  
        private var block1_rec:Rectangle = new Rectangle(-100,-100,80,80);  
        private var block2_rec:Rectangle = new Rectangle(-200,100,200,100);  
 
        private var shoot_timer:Timer = new Timer(500,1);  
        private var bullets:Vector.<b2body>;  
 
 
 
        public function Box2Dto3D()  
        {  
            x = 400;  
            y = 300;  
 
            bullets = new Vector.<b2body>();  
 
            createScene();  
 
            stage.addEventListener(KeyboardEvent.KEY_DOWN, onKey_Down, false, 0, true);  
            stage.addEventListener(KeyboardEvent.KEY_UP, onKey_Up, false, 0, true);  
            addEventListener(Event.ENTER_FRAME, onLoop, false, 0, true);  
        }  
 
        private function createScene ():void {  
 
            _world = new b2World(new b2Vec2(0,0),true);  
            var contactListener:BulletCollisionListener = new BulletCollisionListener();  
            _world.SetContactListener(contactListener);  
 
            //set up debug draw  
            var debugDraw:b2DebugDraw = new b2DebugDraw();  
            var container:Sprite = new Sprite();  
            addChild(container);  
            debugDraw.SetSprite(container);  
            debugDraw.SetDrawScale(30);  
            debugDraw.SetFlags(b2DebugDraw.e_shapeBit|b2DebugDraw.e_jointBit);  
            debugDraw.SetFillAlpha(0.5);  
 
 
            //create player  
            var bodyDef:b2BodyDef = createBoxDef(player_rec);  
            bodyDef.type = b2Body.b2_dynamicBody;  
            bodyDef.allowSleep = false;  
            var bodyFixture:b2FixtureDef = createBoxFixture(player_rec);  
 
            _player = _world.CreateBody(bodyDef);  
            _player.CreateFixture(bodyFixture);  
 
            var data:Object = {};  
            data.type = "block";  
 
            //create obstacles  
            //block 1  
            bodyDef = createBoxDef(block1_rec);  
            bodyDef.type = b2Body.b2_dynamicBody;  
            bodyDef.linearDamping = 20;  
            bodyFixture = createBoxFixture(block1_rec);  
            bodyFixture.density = 0.5;  
            bodyFixture.friction = 1;  
 
            _block1 = _world.CreateBody(bodyDef);  
            _block1.CreateFixture(bodyFixture);  
            _block1.SetUserData(data);  
 
            //block 2  
            bodyDef = createBoxDef(block2_rec);  
            bodyDef.type = b2Body.b2_dynamicBody;  
            bodyDef.linearDamping = 20;  
            bodyFixture = createBoxFixture(block2_rec);  
            bodyFixture.density = 100;  
            bodyFixture.friction = 1;  
 
            _block2 = _world.CreateBody(bodyDef);  
            _block2.CreateFixture(bodyFixture);  
            _block2.SetUserData(data);  
 
            //fixed pillar  
            bodyDef = new b2BodyDef();  
            bodyDef.position.Set(p2m(100), p2m(40));  
            bodyDef.type = b2Body.b2_staticBody;  
            var bodyShape:b2CircleShape = new b2CircleShape();  
            bodyShape.SetRadius (p2m(20));  
            bodyFixture = new b2FixtureDef();  
            bodyFixture.shape = bodyShape;  
            bodyFixture.density = 1;  
 
            var pillar:b2Body = _world.CreateBody(bodyDef);  
            pillar.CreateFixture(bodyFixture);  
            pillar.SetUserData(data);  
 
 
            _world.SetDebugDraw(debugDraw);  
 
        }  
 
        private function shoot ():void {  
            if (shoot_timer.running) return;  
 
            //create particle  
            var bodyDef:b2BodyDef = new b2BodyDef();  
            var pPos:b2Vec2 = _player.GetPosition();  
            var angle:Number = _player.GetAngle()  + Y_DIR*Math.PI/2;  
            pPos.x -= p2m(10)*Math.cos(angle);  
            pPos.y -= p2m(10)*Math.sin(angle);  
 
            bodyDef.position.Set(pPos.x, pPos.y);  
 
            bodyDef.type = b2Body.b2_dynamicBody;  
            bodyDef.angularDamping = 10;  
 
            var bodyShape:b2CircleShape = new b2CircleShape();  
            bodyShape.SetRadius (p2m(10));  
            var bodyFixture:b2FixtureDef = new b2FixtureDef();  
            bodyFixture.shape = bodyShape;  
            bodyFixture.density = 0;  
            bodyFixture.restitution = 0;  
 
            var bulletData:Object = {};  
            bulletData.type = "bullet";  
            bulletData.hit = false;  
 
            var bullet:b2Body = _world.CreateBody(bodyDef);  
            bullet.CreateFixture(bodyFixture);  
            bullet.SetUserData(bulletData);  
            bullet.SetLinearVelocity(new b2Vec2(-10*Math.cos(angle),-10*Math.sin(angle)));  
 
            bullets.push(bullet);  
 
            //shoot_timer.reset();  
            shoot_timer.start();  
        }  
 
        private function p2m(pixel:Number):Number {  
            return pixel/30;  
        }  
 
        private function m2p(m:Number):Number {  
            return m * 30;  
        }  
 
 
        private function updateBody ():void {  
 
            _player.SetLinearVelocity(new b2Vec2(0,0));  
 
 
            if (_moveLeft) _player.SetAngle( _player.GetAngle() - Y_DIR*0.1);  
            if (_moveRight) _player.SetAngle( _player.GetAngle() + Y_DIR*0.1);  
 
            var angle:Number = _player.GetAngle() + Math.PI/2;  
            var playerVelocity:b2Vec2 = _player.GetLinearVelocity();  
 
            if (_moveUp ) {  
                playerVelocity.x -= Y_DIR*speed*Math.cos(angle);  
                playerVelocity.y -= Y_DIR*speed*Math.sin(angle);  
 
            }  
            if (_moveDown ) {  
                playerVelocity.x += Y_DIR*speed*Math.cos(angle);  
                playerVelocity.y += Y_DIR*speed*Math.sin(angle);      
            }  
 
        }  
 
 
        ///////////////////////////// EVENTS ///////////////////////////////////////  
        private function onKey_Up (event:KeyboardEvent):void {  
 
            switch (event.keyCode) {  
                case 38:  
                    //UP KEY is up  
                    _moveUp = false;  
                    break;  
                case 39:  
                    //RIGHT KEY is up  
                    _moveRight = false;  
                    break;  
                case 37:  
                    //LEFT Key is up  
                    _moveLeft = false;  
                    break;  
                case 40:  
                    //DOWN KEY is up  
                    _moveDown = false;  
                    break;  
                case 32:  
                    //SPACE Bar is up  
                    shoot();  
                    break;  
            }  
        }  
        private function onKey_Down (event:KeyboardEvent):void {  
 
            switch (event.keyCode) {  
                case 38:  
                    //UP KEY is down  
                    _moveUp = true;   
                    break;  
                case 39:  
                    //RIGHT KEY is down  
                    _moveRight = true;  
 
                    break;  
                case 37:  
                    //LEFT Key is down  
                    _moveLeft = true;  
 
                    break;  
                case 40:  
                    //DOWN KEY is down  
                    _moveDown = true;  
                    break;  
                case 32:  
                    //SPACE BAR is down  
                    break;  
 
            }  
        }  
 
        private function onLoop (event:Event):void {  
            updateBody();  
 
            _world.Step(1/30,10,10);  
            _world.DrawDebugData();  
 
            for (var i:int = bullets.length-1; i >= 0; i--) {  
                if (bullets[i].GetUserData().hit == true) {  
                        _world.DestroyBody(bullets[i]);  
                        bullets.splice(i,1);  
                        break;  
                }  
            }  
        }  
 
        private function createBoxDef (rec:Rectangle):b2BodyDef {  
            var bodyDef:b2BodyDef = new b2BodyDef();  
            bodyDef.position.Set(p2m(rec.x + rec.width/2), p2m(rec.y + rec.height/2));  
            bodyDef.type = b2Body.b2_staticBody;  
            bodyDef.angularDamping = 10;  
            return bodyDef;  
        }  
 
 
        private function createBoxFixture (rec:Rectangle):b2FixtureDef {  
            var bodyShape:b2PolygonShape = new b2PolygonShape();  
            bodyShape.SetAsBox (p2m(rec.width/2), p2m(rec.height/2));  
            var bodyFixture:b2FixtureDef = new b2FixtureDef();  
            bodyFixture.shape = bodyShape;  
            bodyFixture.density = 1;  
            bodyFixture.restitution = 0;  
            return bodyFixture;  
        }  
 
    }  
}

package {
	import Box2D.Dynamics.Contacts.b2Contact;
	import Box2D.Dynamics.b2ContactListener;
 
	public class BulletCollisionListener extends b2ContactListener {
		public function BulletCollisionListener() {
			super();
		}
 
		override public function BeginContact(contact:b2Contact):void {
 
			if (contact.GetFixtureA().GetBody().GetUserData()) {
				if (contact.GetFixtureA().GetBody().GetUserData().type == "bullet" &&  
				                        contact.GetFixtureB().GetBody().GetUserData().type == "block") {
					contact.GetFixtureA().GetBody().GetUserData().hit=true;
 
				}
			}
 
			if (contact.GetFixtureB().GetBody().GetUserData()) {
				if ( contact.GetFixtureB().GetBody().GetUserData().type == "bullet" &&  
				                        contact.GetFixtureA().GetBody().GetUserData().type == "block") {
 
					contact.GetFixtureB().GetBody().GetUserData().hit=true;
 
				}
			}
		}
	}
}

import away3d.cameras.*;  
    import away3d.containers.*;  
    import away3d.core.base.Object3D;  
    import away3d.lights.*;  
    import away3d.materials.*;  
    import away3d.primitives.*;  
 
    import flash.display.BitmapData;  
    import flash.display.DisplayObjectContainer;  
    import flash.display.Sprite;  
    import flash.events.Event;  
    import flash.events.KeyboardEvent;  
    import flash.geom.*;  
    import flash.utils.Timer;  
 
    [SWF(width="800", height="600", backgroundColor="0x444444", frameRate="30")]  
    public class Box3D extends Sprite {  
 
        //in case I need to adjust the change in Y direction  
        private static const Y_DIR:int = -1;  
        private var _moveLeft:Boolean = false;  
        private var _moveRight:Boolean = false;  
        private var _moveUp:Boolean = false;  
        private var _moveDown:Boolean = false;  
 
        //box2D stuff  
        private var _world:b2World;  
        private var _b2player:b2Body;  
        private var _b2block1:b2Body;  
        private var _b2block2:b2Body;  
        private var speed:Number = 5;  
 
        private var player_rec:Rectangle = new Rectangle(0,0,50,50);  
        private var block1_rec:Rectangle = new Rectangle(-100,100,80,80);  
        private var block2_rec:Rectangle = new Rectangle(-200,-200,200,100);  
 
        //away3D stuff  
        private var _view:View3D;  
        private var _player:Cube;  
        private var _block1:Cube;  
        private var _block2:Cube;  
        private var _container:ObjectContainer3D;  
        private var camera:TargetCamera3D;  
 
        private var shoot_timer:Timer = new Timer(500,1);  
        private var b2bullets:Vector.<b2body>;  
 
 
        public function Box3D() {  
            x = 400;  
            y = 300;  
            createScene();  
 
            b2bullets = new Vector.<b2body>();  
 
            stage.addEventListener(KeyboardEvent.KEY_DOWN, onKey_Down, false, 0, true);  
            stage.addEventListener(KeyboardEvent.KEY_UP, onKey_Up, false, 0, true);  
            addEventListener(Event.ENTER_FRAME, onLoop, false, 0, true);  
        }  
 
        private function createScene ():void {  
            createBox2DWorld();  
            createAway3DView();  
        }  
 
        private function createBox2DWorld():void {  
 
            _world = new b2World(new b2Vec2(0,0),true);  
            var contactListener:BulletCollisionListener = new BulletCollisionListener();  
            _world.SetContactListener(contactListener);  
 
 
            //create player  
            var bodyDef:b2BodyDef = createBoxDef(player_rec);  
            bodyDef.type = b2Body.b2_dynamicBody;  
            bodyDef.allowSleep = false;  
            var bodyFixture:b2FixtureDef = createBoxFixture(player_rec);  
 
            _b2player = _world.CreateBody(bodyDef);  
            _b2player.CreateFixture(bodyFixture);  
 
            var data:Object = {};  
            data.type = "block";  
 
            //create obstacles  
            //block 1  
            bodyDef = createBoxDef(block1_rec);  
            bodyDef.type = b2Body.b2_dynamicBody;  
            bodyDef.linearDamping = 20;  
            bodyFixture = createBoxFixture(block1_rec);  
            bodyFixture.density = 0.5;  
            bodyFixture.friction = 1;  
 
            _b2block1 = _world.CreateBody(bodyDef);  
            _b2block1.CreateFixture(bodyFixture);  
            _b2block1.SetUserData(data);  
 
 
            //block 2  
            bodyDef = createBoxDef(block2_rec);  
            bodyDef.type = b2Body.b2_dynamicBody;  
            bodyDef.linearDamping = 20;  
            bodyFixture = createBoxFixture(block2_rec);  
            bodyFixture.density = 10;  
            bodyFixture.friction = 1;  
 
            _b2block2 = _world.CreateBody(bodyDef);  
            _b2block2.CreateFixture(bodyFixture);  
            _b2block2.SetUserData(data);  
 
            //fixed pillar  
            bodyDef = new b2BodyDef();  
            bodyDef.position.Set(p2m(100), p2m(40));  
            bodyDef.type = b2Body.b2_staticBody;  
            var bodyShape:b2CircleShape = new b2CircleShape();  
            bodyShape.SetRadius (p2m(20));  
            bodyFixture = new b2FixtureDef();  
            bodyFixture.shape = bodyShape;  
            bodyFixture.density = 1;  
 
            var pillar:b2Body = _world.CreateBody(bodyDef);  
            pillar.CreateFixture(bodyFixture);  
            pillar.SetUserData(data);  
 
 
        }  
        private function createAway3DView ():void {  
            _container = new ObjectContainer3D();  
 
            var scene:Scene3D = new Scene3D();  
 
            camera = new TargetCamera3D();  
            camera.z = -1200;  
 
            _view = new View3D({scene:scene, camera:camera});  
            addChild(_view);  
 
            var light : PointLight3D = new PointLight3D();   
            light.position = new Vector3D(500,0,-500);  
            light.color = 0xFFFFFF;   
            light.diffuse = 0.7;  
            light.brightness = 2;  
            _view.scene.addLight(light);  
 
            //var material:WireColorMaterial = new WireColorMaterial(0xFF9900,{wireColor:0x000000});  
            var material:ShadingColorMaterial = new ShadingColorMaterial();   
            material.ambient = 0xFF9900;   
            material.diffuse = 0xFF9900;   
            material.specular = 0xFF9900;  
 
 
            var plane:Plane = new Plane({material:new WireColorMaterial(0x666666,{wireColor:0x666666}), width:1000,height:1000});  
            plane.bothsides = true;  
            plane.rotationX = 90;  
            plane.segmentsW = plane.segmentsH = 4;  
            plane.z = 200;  
            plane.y = 200;  
            plane.x = 30;  
            plane.ownCanvas = true;  
            _view.scene.addChild(plane);  
            _container.ownCanvas = true;  
 
            _player = new Cube({material:material, width:player_rec.width,height:player_rec.width,depth:player_rec.width});  
            _player.z = 25;  
            _player.x = player_rec.x;  
            _player.y = player_rec.y;  
            //create a 'face' for the cube, so player knows what is the front side  
            _player.cubeMaterials.bottom=new WireColorMaterial(0xFF3399,{wireColor:0x222222});  
            //use own canvas to help with z sorting       
            //_player.ownCanvas = true;  
            _container.addChild(_player);  
 
            material = new ShadingColorMaterial();   
            material.ambient = 0x0099FF;   
            material.diffuse = 0x0099FF;   
            material.specular = 0x0099FF;  
 
            _block1 = new Cube({material:material, width:block1_rec.width,height:block1_rec.width,depth:block1_rec.width});  
            _block1.z = 40;  
            _block1.x = block1_rec.x;  
            _block1.y = block1_rec.y;  
            _block1.segmentsD = 2;  
            _block1.segmentsH = 2;  
            _block1.segmentsW = 2;  
 
            _container.addChild(_block1);  
 
 
            _block2 = new Cube({material:material, width:block2_rec.width,height:block2_rec.height,depth:200});  
            _block2.z = 100;  
            _block2.x = block2_rec.x;  
            _block2.y = block2_rec.y;  
            _block2.segmentsD = 4;  
            _block2.segmentsH = 4;  
            _block2.segmentsW = 4;  
            _container.addChild(_block2);  
 
            material = new ShadingColorMaterial();   
            material.ambient = 0x66FF00;   
            material.diffuse = 0x66FF00;   
            material.specular = 0x66FF00;  
 
            var pillar:Cylinder = new Cylinder({material:material, radius:20, height: 60});  
            pillar.rotationX = 90;  
            /* 
            remember that the origin of an object is at its center: 
            so the z of every object is changed so that they are all "lying on the floor"  
            */  
            pillar.z = 30;  
            pillar.x = Y_DIR*100;  
            pillar.y = Y_DIR*40;  
            _container.addChild(pillar);  
 
 
            //rotate the view to add 3D feel and match the one from the 2D version   
            _container.rotationZ = -180;  
            _container.rotationX = -180;  
            _view.scene.rotationX = -45;  
 
            camera.target = _player;  
            _view.scene.addChild(_container);  
 
        }  
 
        private function shoot ():void {  
            if (shoot_timer.running) return;  
 
            //create particle in box2D  
            var bodyDef:b2BodyDef = new b2BodyDef();  
            var pPos:b2Vec2 = _b2player.GetPosition();  
            var angle:Number = _b2player.GetAngle() + Math.PI/2;  
            pPos.x -= p2m(10)*Math.cos(angle);  
            pPos.y -= p2m(10)*Math.sin(angle);  
 
            bodyDef.position.Set(pPos.x, pPos.y);  
 
            bodyDef.type = b2Body.b2_dynamicBody;  
            bodyDef.angularDamping = 10;  
 
            var bodyShape:b2CircleShape = new b2CircleShape();  
            bodyShape.SetRadius (p2m(10));  
            var bodyFixture:b2FixtureDef = new b2FixtureDef();  
            bodyFixture.shape = bodyShape;  
            bodyFixture.density = 0;  
            bodyFixture.restitution = 0;  
 
 
            var bullet:b2Body = _world.CreateBody(bodyDef);  
            bullet.CreateFixture(bodyFixture);  
            bullet.SetLinearVelocity(new b2Vec2(-10*Math.cos(angle),-10*Math.sin(angle)));  
 
 
            //create sprite3D  
            var sphere : Sphere = new Sphere({segmentsW:4,segmentsH:2, material:new WireColorMaterial(0xFF3399,{wireColor:0x222222}), radius:10 });  
            sphere.z = 35;  
            sphere.x = m2p(pPos.x);  
            sphere.y = m2p(pPos.y);  
            _container.addChild(sphere);  
 
            var bulletData:Object = {};  
            bulletData.type = "bullet";  
            bulletData.hit = false;  
            bulletData.sphere = sphere;  
            bullet.SetUserData(bulletData);  
 
            b2bullets.push(bullet);  
            shoot_timer.start();  
        }  
 
 
        private function p2m(pixel:Number):Number {  
            return pixel/30;  
        }  
 
        private function m2p(m:Number):Number {  
            return m * 30;  
        }  
 
        private function updateBody ():void {  
 
 
            _b2player.SetLinearVelocity(new b2Vec2(0,0));  
 
 
            if (_moveLeft) _b2player.SetAngle( _b2player.GetAngle() - 0.05);  
            if (_moveRight) _b2player.SetAngle( _b2player.GetAngle() + 0.05);  
 
            var angle:Number = _b2player.GetAngle() + Math.PI/2;  
            var playerVelocity:b2Vec2 = _b2player.GetLinearVelocity();  
 
            if (_moveUp ) {  
                playerVelocity.x -= speed*Math.cos(angle);  
                playerVelocity.y -= speed*Math.sin(angle);  
 
            }  
            if (_moveDown ) {  
                playerVelocity.x += speed*Math.cos(angle);  
                playerVelocity.y += speed*Math.sin(angle);    
            }  
 
        }  
        ///////////////////////////// EVENTS ///////////////////////////////////////  
        private function onKey_Up (event:KeyboardEvent):void {  
 
            switch (event.keyCode) {  
                case 38:  
                    //UP KEY is up  
                    _moveUp = false;  
                    break;  
                case 39:  
                    //RIGHT KEY is up  
                    _moveRight = false;  
                    break;  
                case 37:  
                    //LEFT Key is up  
                    _moveLeft = false;  
                    break;  
                case 40:  
                    //DOWN KEY is up  
                    _moveDown = false;  
                    break;  
                case 32:  
                    //SPACE Bar is up  
                    shoot();  
                    break;  
            }  
        }  
        private function onKey_Down (event:KeyboardEvent):void {  
 
            switch (event.keyCode) {  
                case 38:  
                    //UP KEY is down  
                    _moveUp = true;   
                    break;  
                case 39:  
                    //RIGHT KEY is down  
                    _moveRight = true;  
 
                    break;  
                case 37:  
                    //LEFT Key is down  
                    _moveLeft = true;  
 
                    break;  
                case 40:  
                    //DOWN KEY is down  
                    _moveDown = true;  
                    break;  
                case 32:  
                    //SPACE BAR is down  
                    break;  
 
            }  
        }  
 
        private function onLoop (event:Event):void {  
            updateBody();  
 
            _world.Step(1/30,10,10);  
 
            transformObject(_b2player, _player);  
            transformObject(_b2block1, _block1);  
            transformObject(_b2block2, _block2);  
 
            if (b2bullets) {  
                for (var i:int = b2bullets.length-1; i >= 0; i--) {  
                    transformObject(b2bullets[i], b2bullets[i].GetUserData().sphere);  
                    if (b2bullets[i].GetUserData().hit == true) {  
                        _container.removeChild(b2bullets[i].GetUserData().sphere);  
                        _world.DestroyBody(b2bullets[i]);  
                        b2bullets.splice(i,1);  
                        break;  
                    }  
                }  
            }  
 
            _view.render();  
 
        }  
        private function transformObject (original:b2Body, threeD:Object3D):void {  
            var position:b2Vec2 = original.GetPosition();  
            var angle:Number = original.GetAngle() * 180 / Math.PI ;  
 
            threeD.x = Y_DIR*m2p(position.x);  
            threeD.y = Y_DIR*m2p(position.y);  
            threeD.rotationZ = angle;  
        }  
 
        private function createBoxDef (rec:Rectangle):b2BodyDef {  
            var bodyDef:b2BodyDef = new b2BodyDef();  
            bodyDef.position.Set(p2m(rec.x + rec.width/2), p2m(rec.y + rec.height/2));  
            bodyDef.type = b2Body.b2_staticBody;  
            bodyDef.angularDamping = 10;  
            return bodyDef;  
        }  
 
 
        private function createBoxFixture (rec:Rectangle):b2FixtureDef {  
            var bodyShape:b2PolygonShape = new b2PolygonShape();  
            bodyShape.SetAsBox (p2m(rec.width/2), p2m(rec.height/2));  
            var bodyFixture:b2FixtureDef = new b2FixtureDef();  
            bodyFixture.shape = bodyShape;  
            bodyFixture.density = 1;  
            bodyFixture.restitution = 0;  
            return bodyFixture;  
        }         
 
    }  
}

package
{
    import alternativa.Alternativa3D;
    import alternativa.engine3d.containers.*;
    import alternativa.engine3d.controllers.*;
    import alternativa.engine3d.core.Camera3D;
    import alternativa.engine3d.core.Clipping;
    import alternativa.engine3d.core.Debug;
    import alternativa.engine3d.core.MipMapping;
    import alternativa.engine3d.core.MouseEvent3D;
    import alternativa.engine3d.core.Object3D;
    import alternativa.engine3d.core.Object3DContainer;
    import alternativa.engine3d.core.Sorting;
    import alternativa.engine3d.core.View;
    import alternativa.engine3d.materials.FillMaterial;
    import alternativa.engine3d.materials.TextureMaterial;
    import alternativa.engine3d.objects.Sprite3D;
    import alternativa.engine3d.primitives.Box;
    import alternativa.engine3d.primitives.Plane;
    import alternativa.engine3d.primitives.Sphere;
 
    import flash.display.BitmapData;
    import flash.display.BlendMode;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageQuality;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.events.KeyboardEvent;
    import flash.filters.GlowFilter;
    import flash.geom.ColorTransform;
    import flash.geom.Vector3D;
    import flash.sampler.NewObjectSample;
    import flash.system.Capabilities;
    import flash.ui.Keyboard;
 
    [SWF(backgroundColor="#000000", frameRate="100", width="640", height="480")]
    public class alternativa3dSokoban extends Sprite
    {
        private const CUBESIZE:Number=10;
        //embeding textures images
        [Embed(source="resource/crateTextureImg.jpg")] static private const crateTextureImg:Class;
        [Embed(source="resource/floorTextureImg.png")] static private const floorTextureImg:Class;
        [Embed(source="resource/crateTopTextureImg.jpg")] static private const crateTopTextureImg:Class;
        [Embed(source="resource/crateTopGoalTextureImg.jpg")] static private const crateTopGoalTextureImg:Class;
        [Embed(source="resource/wallTextureImg.png")] static private const wallTextureImg:Class;
        [Embed(source="resource/goalTextureImg.jpg")] static private const goalTextureImg:Class;
        [Embed(source="resource/playerTextureImg.jpg")] static private const playerTextureImg:Class;
        [Embed(source="resource/backBitmapImg.jpg")] static private const backTextureImg:Class;
        [Embed(source="resource/backBottomBitmapImg.jpg")] static private const backBottomTextureImg:Class;
 
        // sokobal demo level and player position
        private var levels:Array=[[1,1,1,1,0,0,0,0],[1,0,0,1,1,1,1,1],[1,0,2,0,0,3,0,1],[1,0,3,0,0,2,4,1],[1,1,1,0,0,1,1,1],[0,0,1,1,1,1,0,0]];
        private var playerCol:uint;
        private var playerRow:uint;
        private var playerRotation:Number=0;
        private var playerAngle:Number=0;
        private var playerMovement:Number=0;
        private var dRow:int;
        private var dCol:int;
 
        // alternativa3d  engine variables
        private var camera:Camera3D;
        private var controller:SimpleObjectController;
        private var container:ConflictContainer;           
        private var frame:Sprite = new Sprite();
        public var player:Sphere;// Sphere primitive representing the player
        public var cplayer:SimpleObjectController; //controller for player object
        public var conplayer:Object3DContainer; //container for player
        private var movingCrate:Box;// cube primitive representing the moving crate    
 
        // textures    
        private var crateTexture:TextureMaterial = new TextureMaterial(new crateTextureImg().bitmapData);
        private var floorTexture:TextureMaterial = new TextureMaterial(new floorTextureImg().bitmapData);
        private var crateTopTexture:TextureMaterial = new TextureMaterial(new crateTopTextureImg().bitmapData);
        private var crateTopGoalTexture:TextureMaterial = new TextureMaterial(new crateTopGoalTextureImg().bitmapData);
        private var wallTexture:TextureMaterial = new TextureMaterial(new wallTextureImg().bitmapData);
        private var goalTexture:TextureMaterial = new TextureMaterial(new goalTextureImg().bitmapData);
        private var playerTexture:TextureMaterial = new TextureMaterial(new playerTextureImg().bitmapData);
        // SkyBox textures
        private var backTexture:TextureMaterial = new TextureMaterial(new backTextureImg().bitmapData);
        private var backBottomTexture:TextureMaterial = new TextureMaterial(new backBottomTextureImg().bitmapData);
 
        public function alternativa3dSokoban()
        {          
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
            stage.quality = StageQuality.BEST;
 
            // Camera
            camera = new Camera3D();
            camera.view = new View(640, 480);
            addChild(camera.view);
 
            // Camera controller
            controller = new SimpleObjectController(stage, camera, 200, 3);
 
            // Root object
            container = new ConflictContainer();
            container.resolveByAABB = true;
            container.resolveByOOBB = true;
 
            //Player controller
            conplayer = new Object3DContainer();
            cplayer = new SimpleObjectController(stage, player, 3);
 
//i am not shure about SkyBox in Alternativa and will prepare it manually
            var backBottom:Plane = new Plane(200*CUBESIZE/2,200*CUBESIZE/2);
            backBottom.setMaterialToAllFaces(backBottomTexture);
            backBottom.x = 0;
            backBottom.y = -100*CUBESIZE/2;
            backBottom.z = 0;
            backBottom.rotationX = 90*Math.PI/180;
            container.addChild(backBottom);
 
            var backLeft:Plane = new Plane(200*CUBESIZE/2,200*CUBESIZE/2);
            backLeft.setMaterialToAllFaces(backTexture);
            backLeft.x = 0;
            backLeft.y = 0;
            backLeft.z = 100*CUBESIZE/2;
            container.addChild(backLeft);
 
            var backRight:Plane = new Plane(200*CUBESIZE/2,200*CUBESIZE/2);
            backRight.setMaterialToAllFaces(backTexture);
            backRight.x = 0;
            backRight.y = 0;
            backRight.z = -100*CUBESIZE/2;
            container.addChild(backRight);
 
            var backFront:Plane = new Plane(200*CUBESIZE/2,200*CUBESIZE/2);
            backFront.setMaterialToAllFaces(backTexture);
            backFront.x = -100*CUBESIZE/2;
            backFront.y = 0;
            backFront.z = 0;
            backFront.rotationY = 90*Math.PI/180;
            container.addChild(backFront);
 
            var backBack:Plane = new Plane(200*CUBESIZE/2,200*CUBESIZE/2);
            backBack.setMaterialToAllFaces(backTexture);
            backBack.x = 100*CUBESIZE/2;
            backBack.y = 0;
            backBack.z = 0;
            backBack.rotationY = 90*Math.PI/180;
            container.addChild(backBack);
// end SkyBox
 
            var box:Box;
            /*
            [[1,1,1,1,0,0,0,0],
             [1,0,0,1,1,1,1,1],
             [1,0,2,0,0,3,0,1],
             [1,0,3,0,0,2,4,1],
             [1,1,1,0,0,1,1,1],
             [0,0,1,1,1,1,0,0]];
            */
            // level construction
            for (var i:uint=0; i<6; i++)
            {
                for (var j:uint=0; j<8; j++)
                {
                    switch (levels[i][j])
                    {
                        case 0 :
                            box = new Box(CUBESIZE,CUBESIZE/2,CUBESIZE,1,1);
                            box.setMaterialToAllFaces(floorTexture);
                            box.x = CUBESIZE*j;
                            box.y = 0;
                            box.z = CUBESIZE*i;
                            container.addChild(box);
                            break;
                        case 1 :
                            box = new Box(CUBESIZE,CUBESIZE/2,CUBESIZE,1);
                            box.setMaterialToAllFaces(floorTexture);
                            box.x = CUBESIZE*j;
                            box.y = 0;
                            box.z = CUBESIZE*i;
                            container.addChild(box);
 
                            box = new Box(CUBESIZE,CUBESIZE,CUBESIZE,1);
                            box.setMaterialToAllFaces(wallTexture);
                            box.x = CUBESIZE*j;
                            box.y = CUBESIZE*3/4;
                            box.z = CUBESIZE*i;
                            container.addChild(box);
                            break;
                        case 2 :
                            box = new Box(CUBESIZE,CUBESIZE/2,CUBESIZE,1);
                            box.setMaterialToAllFaces(goalTexture);
                            box.x = CUBESIZE*j;
                            box.y = 0;
                            box.z = CUBESIZE*i;
                            container.addChild(box);
                            break;
                        case 3 :
                            box = new Box(CUBESIZE,CUBESIZE/2,CUBESIZE,1);
                            box.setMaterialToAllFaces(floorTexture);
                            box.x = CUBESIZE*j;
                            box.y = 0;
                            box.z = CUBESIZE*i;
                            container.addChild(box);
                            box = new Box(CUBESIZE,CUBESIZE,CUBESIZE,1);
                            box.name = "crate_"+i+"_"+j;
                            box.setMaterialToAllFaces(crateTexture);
                            box.x = CUBESIZE*j;
                            box.y = CUBESIZE*3/4;
                            box.z = CUBESIZE*i;
                            box.rotationX -= 90*Math.PI/180;
                            // top of the crate
                            box.faces[4].material=crateTopTexture;
                            box.faces[5].material=crateTopTexture;
 
                            container.addChild(box);
                            break;
                        case 4 :
                            box = new Box(CUBESIZE,CUBESIZE/2,CUBESIZE,1);
                            box.setMaterialToAllFaces(floorTexture);
                            box.x = CUBESIZE*j;
                            box.y = 0;
                            box.z = CUBESIZE*i;
                            container.addChild(box);
 
                            player = new Sphere(CUBESIZE/2,16,16,false,playerTexture);
 
                            conplayer.addChild(player);
                            conplayer.visible = true;
                            conplayer.x = CUBESIZE*j;
                            conplayer.y = CUBESIZE*3/4;
                            conplayer.z = CUBESIZE*i;
                            conplayer.rotationX -= 90*Math.PI/180;
                            container.addChild(conplayer);
                            playerCol=j;
                            playerRow=i;
                            break;
                    }
                }
            }
 
            // Adding camera
            container.addChild(camera);
 
            // View frame
            addChild(frame);                                               
            onResize();    
            stage.addEventListener(Event.ENTER_FRAME, updateEvent);        
            stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDwn);      
            stage.addEventListener(Event.RESIZE, onResize);
        }
 
        private function onKeyDwn(e:KeyboardEvent):void
        {
            if (playerRotation==0&&playerMovement==0)
            {
                switch (e.keyCode)
                {
                    case Keyboard.LEFT :
                        playerRotation=+9;
                        playerAngle+=90;
                        break;
                    case Keyboard.RIGHT :
                        playerRotation=-9;
                        playerAngle-=90;
                        break;
                    case Keyboard.UP :
                        movingCrate=null;
                        playerAngle=Math.round(conplayer.rotationY*180/Math.PI)%360;
                        if (playerAngle<0)
                        {
                            playerAngle+=360;
                        }
                        // we have to determine the difference between current row and column
                        // and the new row and column according to player heading
                        switch (playerAngle)
                        {
                            case 0 :
                                dRow=0;
                                dCol=-1;
                                break;
                            case 90 :
                                //dRow=-1;
                                dRow=1;
                                dCol=0;
                                break;
                            case 180 :
                                dRow=0;
                                dCol=1;
                                break;
                            case 270 :
                                //dRow=1;
                                dRow=-1;
                                dCol=0;
                                break;
                        }
                        if (levels[playerRow+dRow][playerCol+dCol]==0||levels[playerRow+dRow][playerCol+dCol]==2)
                        {
                            // the player can move
                            playerMovement=-CUBESIZE/10;
                        }
                        else
                        {
                            if (levels[playerRow+dRow][playerCol+dCol]==3||levels[playerRow+dRow][playerCol+dCol]==5) {
                                if (levels[playerRow+2*dRow][playerCol+2*dCol]==0||levels[playerRow+2*dRow][playerCol+2*dCol]==2) {
                                    // the player can move and can push a crate
                                    movingCrate=container.getChildByName("crate_"+(playerRow+dRow)+"_"+(playerCol+dCol))as Box;
                                    playerMovement=-CUBESIZE/10;
                                }
                            }
                        }
                        break;
 
                }
            }
        }
 
 
        public function updateEvent(e:Event):void
        {      
                if (playerRotation)
                {
                    conplayer.rotationY+=playerRotation*Math.PI/180;
 
                    if (Math.abs(Math.round(conplayer.rotationY*180/Math.PI))%90==0)
                    {
                        playerRotation=0;
                    }
                }
 
                if (playerMovement)
                {                  
                    switch (playerAngle)
                    {
                    case 0 :
                        conplayer.x += playerMovement;
                        player.rotationY -= 18*Math.PI/180;
                    break;
                    case 90 :
                        conplayer.z += -playerMovement;
                        player.rotationY -= 18*Math.PI/180;
                    break;
                    case 180 :
                        conplayer.x += -playerMovement;
                        player.rotationY -= 18*Math.PI/180;
                        break;
                    case 270 :
                        conplayer.z += playerMovement;
                        player.rotationY -= 18*Math.PI/180;
                        break;
                    }
 
                    if (movingCrate)
                    {
                        switch (playerAngle)
                        {
                            case 0 :
                                movingCrate.x += playerMovement;
                                break;
                            case 90 :
                                movingCrate.z += -playerMovement;
                                break;
                            case 180 :
                                movingCrate.x += -playerMovement;
                                break;
                            case 270 :
                                movingCrate.z += playerMovement;
                                break;
                        }
                    }
 
                    // we need this to know if the player stopped on the destination tile
                    if ((playerAngle%180==0&&(Math.round(conplayer.x*10)/10)%CUBESIZE==0)||(playerAngle%180!=0&&(Math.round(conplayer.z*10)/10)%CUBESIZE==0))
                    {
                        playerMovement=0;
                        levels[playerRow+dRow][playerCol+dCol]+=4;
                        levels[playerRow][playerCol]-=4;
                        if (movingCrate) {
                            levels[playerRow+2*dRow][playerCol+2*dCol]+=3;
                            if (levels[playerRow+2*dRow][playerCol+2*dCol]==5) {
                                // changing materials on the fly
                                movingCrate.setMaterialToAllFaces(crateTexture);
                                // top of the crate on goal
                                movingCrate.faces[4].material=crateTopGoalTexture;
                                movingCrate.faces[5].material=crateTopGoalTexture;                             
 
                            }
                            else
                            {
                                //movingCrate.setMaterialToAllFaces(crateMaterial);
                                movingCrate.setMaterialToAllFaces(crateTexture);
                                // top of the crate
                                movingCrate.faces[4].material=crateTopTexture;
                                movingCrate.faces[5].material=crateTopTexture;                             
                            }
                            levels[playerRow+dRow][playerCol+dCol]-=3;
                            movingCrate.name="crate_"+(playerRow+2*dRow)+"_"+(playerCol+2*dCol);
                        }
                        playerCol+=dCol;
                        playerRow+=dRow;
                    }
                }
 
                onEnterFrame();
        }          
 
        public function correct_camera_angles():void
        {
            //set camera position
            var r:Number = 10*CUBESIZE/3;          
            var a:Number = -conplayer