package 
{
    import flash.display.Graphics;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.KeyboardEvent;
    import flash.events.MouseEvent;
    import flash.geom.Point;
 
    import nape.geom.Vec2;
    import nape.phys.Body;
    import nape.phys.BodyType;
    import nape.phys.Material;
    import nape.shape.Circle;
    import nape.shape.Polygon;
    import nape.space.Space;
    import nape.util.BitmapDebug;
 
    [SWF( width="550", height="400", frameRate="60")]
    public class T7_CreateBodiesOnFly extends Sprite
    {        
 
        private var napeWorld:Space;
        private var debug:BitmapDebug;
 
        private var isCtrlDown:Boolean;
        private var isShiftDown:Boolean;
 
        private var bodyOnFly:Object;
        private var onFlyLayer:Sprite;
 
        public function T7_CreateBodiesOnFly()
        {
            createNapeWorld();
            setUpEvents();
            createWall();
            //create an object to store the information of bodies
            bodyOnFly={x:0, y:0, x1:0, y1:0, w:0, h:0, r:0, mouseAngle:0};
            //create a layer to draw shapes at run time.
            onFlyLayer=new Sprite();
            addChild(onFlyLayer);
            addChild(new Stats());
        }
        //创房Nape世界
        private function createNapeWorld():void
        {
            var gravity:Vec2 = new Vec2( 0, 600 );
            napeWorld =new Space( gravity );
 
            debug= new BitmapDebug(550, 400, 0xD6D6D6);
            addChild(debug.display);
        }
        //添加事件侦听
        private function setUpEvents():void
        {
            //listening to the EnterFrame Event to update the Nape world
            stage.addEventListener(Event.ENTER_FRAME, loop);
            //add listener to MouseEvent,like mouseDown or MouseUp
            stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseEventHanlder);
            stage.addEventListener(MouseEvent.MOUSE_UP, mouseEventHanlder);
            stage.addEventListener(KeyboardEvent.KEY_DOWN, keyBoardEventHanlder);
            stage.addEventListener(KeyboardEvent.KEY_UP, keyBoardEventHanlder);
        }
 
        protected function keyBoardEventHanlder(event:KeyboardEvent):void
        {
            isCtrlDown=event.ctrlKey;
            isShiftDown=event.shiftKey;
        }
        //create several kinds of shape
        private function createBody(bodyInfo:Object):void{
            if(isCtrlDown){
                //如果Ctrl按下，绘制圆形刚体
                createCircle(bodyInfo.x, bodyInfo.y, bodyInfo.r, BodyType.DYNAMIC);
            }else if(isShiftDown){
                //create a regular polygon with 5 edges.
                createRegular(bodyInfo.x, bodyInfo.y, bodyInfo.r, bodyInfo.mouseAngle, 5, BodyType.DYNAMIC);
            }else{
                //and box shape by default
                createBox(bodyInfo.x+bodyInfo.w/2, bodyInfo.y+bodyInfo.h/2, bodyInfo.w, bodyInfo.h,BodyType.DYNAMIC);
            }
        }
        private function createBox(posX:Number, posY:Number, w:Number, h:Number, type:BodyType):void{
            var box:Body = new Body(type, new Vec2(posX, posY));
            var boxShape:Polygon=new Polygon(Polygon.box(w,h), Material.glass());
            box.shapes.push(boxShape);
            box.space= napeWorld;
        }
        //create body with specify counts of edge
        private function createRegular(posX:Number, posY:Number, r:Number, rotation:Number, edgeCount:int, type:BodyType):void{
            var regular:Body = new Body(type, new Vec2(posX, posY));
            var regularShape:Polygon=new Polygon(Polygon.regular(r*2,r*2,edgeCount), Material.glass());
            regularShape.rotate(rotation);
            regular.shapes.push(regularShape);
            regular.space= napeWorld;
        }
        private function createCircle(posX:Number, posY:Number, radius:int, type:BodyType):void
        {
            var circle:Body=new Body(type, new Vec2(posX, posY));
            var shape:Circle=new Circle(radius,null,Material.glass());
            circle.shapes.push(shape);
            circle.space=napeWorld;
        }
        private function createWall():void{
            createBox(stage.stageWidth/2, 0, stage.stageWidth, 10, BodyType.STATIC);
            createBox(stage.stageWidth/2, stage.stageHeight, stage.stageWidth, 10, BodyType.STATIC);
            createBox(0, stage.stageHeight/2, 10, stage.stageHeight, BodyType.STATIC);
            createBox(stage.stageWidth, stage.stageHeight/2, 10,stage.stageWidth, BodyType.STATIC);
            createBox(250, 405, 600,50, BodyType.STATIC);
        }
        protected function mouseEventHanlder(event:MouseEvent):void
        {
            switch (event.type) {
                case MouseEvent.MOUSE_DOWN:
                    stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseEventHanlder);
                    //record the position of mouse when it is down
                    bodyOnFly.x=mouseX;
                    bodyOnFly.y=mouseY;
                    break;
                case MouseEvent.MOUSE_UP:
                    stage.removeEventListener(MouseEvent.MOUSE_MOVE, mouseEventHanlder);
                    //to prevent error when the radius is less than 1
                    if(bodyOnFly.r <1){
                        bodyOnFly.w=4;
                        bodyOnFly.h=3;
                        bodyOnFly.r= Math.sqrt(bodyOnFly.w*bodyOnFly.w + bodyOnFly.h*bodyOnFly.h);
                    }
                    //create bodies according to body information
                    createBody(bodyOnFly);
                    onFlyLayer.graphics.clear();
                    break;
                case MouseEvent.MOUSE_MOVE:
                    //calculate the size of rectangle
                    bodyOnFly.w= mouseX - bodyOnFly.x;
                    bodyOnFly.h= mouseY - bodyOnFly.y;
                    bodyOnFly.mouseAngle=Math.atan2(mouseY-bodyOnFly.y, mouseX-bodyOnFly.x);
                    bodyOnFly.r= Math.sqrt(bodyOnFly.w*bodyOnFly.w + bodyOnFly.h*bodyOnFly.h);
 
                    drawShape(bodyOnFly);
                    break;
            }
 
        }
        private function drawShape(bodyInfo:Object):void{
            var gfc:Graphics=onFlyLayer.graphics;
 
            gfc.clear();            
            gfc.lineStyle(1);
            gfc.beginFill(0x0000FF, 0.5);
 
            if(isCtrlDown){
                //when Ctrl is down
                gfc.drawCircle(bodyInfo.x, bodyInfo.y, bodyInfo.r);
            }else if(isShiftDown){
                //when Shift is down
                var mouseAngle:Number=bodyInfo.mouseAngle;
                var angle:Number = Math.PI*2/5;//the angle between each vertex
                var x:Number, y:Number;
                //move to the first vertex
                gfc.moveTo(bodyInfo.x+bodyInfo.r*Math.cos(mouseAngle), bodyInfo.y+bodyInfo.r*Math.sin(mouseAngle));
                for (var i:int=0; i<5; i++){
                    //calculate each vertex
                    x=bodyInfo.x + bodyInfo.r * Math.cos( i*angle+mouseAngle);
                    y=bodyInfo.y + bodyInfo.r * Math.sin( i*angle+mouseAngle);
                    //连线顶点
                    gfc.lineTo(x,y);
                }
            }
            else{
                gfc.drawRect(bodyInfo.x, bodyInfo.y, bodyInfo.w, bodyInfo.h);
            }
            gfc.endFill();
        }
        protected function loop(event:Event):void
        {
            napeWorld.step(1/60);
            debug.clear();
            debug.draw(napeWorld);
            debug.flush();
        }
 
    }
}

    public function Material (
        elasticity:Number = 0,
        dynamicFriction:Number = 1,
        staticFriction:Number = 2, 
        density:Number = 1,
        rollingFriction:Number = 0.01
        );

        material.elasticity= 1;

    var body:Body = new Body(BodyType.DYNAMIC,new Vec2(bx,by));
Set up the shape of body

function Circle(
            radius:Float, 
            localCOM:Vec2, 
            material:Material, 
            filter:InteractionFilter
        )

        public function Polygon (
            localVerts:*, 
            material:Material = null, 
            filter:InteractionFilter = null
            );

        //create circle shape body
        private function createCircle(posX:Number, posY:Number, radius:int, type:BodyType):void
        {
            //create body, there are 2 parameter of Body class, one is type ,the other is position of body.
            var circle:Body = new Body(type, new Vec2(posX, posY));
            //create shape of body, currently we only have two: circle and rectangle created using Polygon class
            //I will introduce more deeply of Material class in later tutorial
            var shape:Circle = new Circle(radius, null, new Material(1));
            //shapes property of a body is an instance of ShapeList class, we can add a shape using add() or push() method
            circle.shapes.push(shape);
            //set up the space of body belonged to 
            circle.space=space;
        }
        //create rectangle body, mostly same process with circle body
        private function createBox(posX:Number,posY:Number,width:Number,height:Number,type:BodyType, angle:Number=0):Body{
            //create body instance
            var box:Body = new Body(type, new Vec2(posX, posY));
            //get the vertices of a rectangle shape centered at local center of body mass using Polygon.box() 
            //and then pass these vertices to the constructor of Polygon class.
            var shape:Polygon = new Polygon(Polygon.box(width, height));
            //rotate the rectangle by angle specified
            shape.rotate(angle);
            //add rectangle shape in to shape list
            box.shapes.push(shape);
            //set up the space of Body 
            box.space=space;
 
            return box;
        }

package 
{
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import nape.phys.Material;
 
    import nape.geom.Vec2;
    import nape.phys.Body;
    import nape.phys.BodyType;
    import nape.shape.Circle;
    import nape.shape.Polygon;
    import nape.space.Space;
    import nape.util.Debug;
    import nape.util.ShapeDebug;
 
    //[SWF(frameRate="60", width=550, height=400, backgroundColor="0xCCCCCC")]
    public class Main extends Sprite
    {
        private var space:Space;
        private var debug:ShapeDebug;
 
        public function Main()
        {
            //1. create Nape space
            var gravity:Vec2=new Vec2(0,500);
            space=new Space(gravity);
 
            //2. create debug shape
            debug = new ShapeDebug(550, 400, 0x0000ff);
            addChild(debug.display);
 
            //3. create bodies in game
            createBodies();
 
            //add FPS monitor on left top corner
            addChild(new Stats());
            //4.add enterFrame event listener
            addEventListener(Event.ENTER_FRAME,loop);
        }
 
        private function createBodies():void
        {
            //upper 3 floor
            createBox(92, 130, 120, 15, BodyType.STATIC,Math.PI/6);
            createBox(208, 163, 120, 15, BodyType.STATIC);
            createBox(350, 163, 144, 15, BodyType.STATIC);
 
            //lower 3 floor
            createBox(483, 223, 120, 15, BodyType.STATIC,-Math.PI/6);
            createBox(360, 255, 120, 15, BodyType.STATIC);
            createBox(232, 255, 120, 15, BodyType.STATIC);
 
            //the hook at left down corner
            createBox(49, 297, 15, 70, BodyType.STATIC);
            createBox(157, 297, 15, 70, BodyType.STATIC);
            createBox(100, 325, 120, 15, BodyType.STATIC);
 
            //2 books on floor
            createBox(200, 120, 15, 100, BodyType.DYNAMIC);
            createBox(300, 120, 15, 100, BodyType.DYNAMIC);
 
            //create the falling ball
            createCircle(59, 28, 17, BodyType.DYNAMIC);
            createCircle(422, 130, 17, BodyType.DYNAMIC);
        }
        //create circle shape body
        private function createCircle(posX:Number, posY:Number, radius:int, type:BodyType):void
        {
            //create body, there are 2 parameter of Body class, one is type ,the other is position of body.
            var circle:Body = new Body(type, new Vec2(posX, posY));
            //create shape of body, currently we only have two: circle and rectangle created using Polygon class
            //I will introduce more deeply of Material class in later tutorial
            var shape:Circle = new Circle(radius, null, new Material(1));
            //shapes property of a body is an instance of ShapeList class, we can add a shape using add() or push() method
            circle.shapes.push(shape);
            //set up the space of body belonged to 
            circle.space=space;
        }
        //create rectangle body, mostly same process with circle body
        private function createBox(posX:Number,posY:Number,width:Number,height:Number,type:BodyType, angle:Number=0):Body{
            //create body instance
            var box:Body = new Body(type, new Vec2(posX, posY));
            //get the vertices of a rectangle shape centered at local center of body mass using Polygon.box() 
            //and then pass these vertices to the constructor of Polygon class.
            var shape:Polygon = new Polygon(Polygon.box(width, height));
            //rotate the rectangle by angle specified
            shape.rotate(angle);
            //add rectangle shape in to shape list
            box.shapes.push(shape);
            //set up the space of Body 
            box.space=space;
 
            return box;
        }
        private function loop(event:Event):void
        {
            //Nape simulation
            space.step(1 / 60);
            //clear debug shape
            debug.clear();
            //draw all the stuffs in space
            debug.draw(space);
            //optimize display
            debug.flush();
        }
    }
}

            //1.create a basic Nape space 
            //declare the gravity of Nape space
            var gravity:Vec2 = new Vec2(0, 400);
            space = new Space(gravity);

            //Nape space simulation using step method
            space.step(1 / 60);

            //    1.create a body instance and set its type and position properties.
            var body:Body = new Body(BodyType.DYNAMIC, new Vec2(mouseX, mouseY));
            //    2.Create s Shape instance for body, here we use Polygon.box() method to return a Vector with 4 vertices to represent an rectangle. Finally add this shape into body.shapes list.
            var shape:Polygon = new Polygon(Polygon.box(Math.random()*30+30,Math.random()*30+30));
            body.shapes.add(shape);
            //    3.Indicate the Nape space of Body
            body.space = space;

            //3.create Nape debug shape
            debug = new ShapeDebug(400, 200);
            addChild(debug.display);
 
        private function loop(e:Event):void
        {
            // simulate physic calculation with step method
            space.step(1 / 60, 30);
            // clear display
            debug.clear();
            // optimize display
            debug.flush();
            // draw all the object in space, including bodies , joints etc.
            debug.draw(space);
        }

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import nape.geom.Vec2;
    import nape.phys.*;
    import nape.shape.Polygon;
    import nape.space.Space;
    import nape.util.ShapeDebug;
 
    /**
     * ...
     * @author ladeng6666
     */
    public class HelloNape extends Sprite
    {
        private var space:Space;
        private var debug:ShapeDebug;
 
        public function HelloNape()
        {
            var gravity:Vec2 = new Vec2(0, 400);
            space = new Space(gravity);
 
            var body:Body = new Body(BodyType.STATIC, new Vec2(stage.stageWidth/2, stage.stageHeight-10));
            var shape:Polygon = new Polygon(Polygon.box(stage.stageWidth, 10));
            body.shapes.add(shape);
            body.space = space;
 
            debug = new ShapeDebug(400, 200);
            addChild(debug.display);
 
            addEventListener(Event.ENTER_FRAME, loop);
            stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseEventHandler);
        }
 
        private function mouseEventHandler(e:MouseEvent):void
        {

            var body:Body = new Body(BodyType.DYNAMIC, new Vec2(mouseX, mouseY));
            var shape:Polygon = new Polygon(Polygon.box(Math.random()*30+30,Math.random()*30+30));
            body.shapes.add(shape);
            body.space = space;
        }
 
        private function loop(e:Event):void
        {
            space.step(1 / 60, 30);
            debug.clear();
            debug.flush();
            debug.draw(space);
        }
    }
 
}

var pivots = true;
var pre = space.world;
for(i in 0...30) {
   var box = new Body();
   box.position.setxy(300,50+i*15);
   box.shapes.add(new Polygon(Polygon.regular(24,14,4)));
   box.space = space;
   box.velocity.x = i*20;

   addChild(box.graphic = Debug.createGraphic(box));

   var anchor1 = if(pre==space.world) new Vec2(300,35)
                 else new Vec2(0,7);
   var con:Constraint;
   if(pivots) con = new PivotJoint(pre,box,anchor1, new Vec2(0,-7));
   else {
       con = new DistanceJoint(pre,box,anchor1, new Vec2(0,-7), 2,2);
       con.stiff = false;
       con.frequency = 5;
       con.damping = 0.5;
   } 
   con.space = space;
   pre = box;
}

var debug = new Debug();
debug.drawBodies = false;
debug.drawConstraints = true;

// in update {
    space.step(1/60,6,6);
    graphics.clear();
    debug.draw(graphics,space);
// }

this.collide = function(line, adjx, adjy) {
	var run = line.x2 - line.x1;
	var rise = line.y2 - line.y1;
		
	var angle = radToDeg(Math.atan(rise / run));
	this.rotation -= angle

var accelerate:Vec2 = new Vec2();
const angleInc:Number = 0.06;
if (Key.isKeyDown(Keyboard.LEFT)) {
	_angle += angleInc;
}
if (Key.isKeyDown(Keyboard.RIGHT)) {
	_angle -= angleInc;
}
if (Key.isKeyDown(Keyboard.UP)) {
	const power:int = 10;
	accelerate.x = Math.cos(_angle) * power;
	accelerate.y = Math.sin(_angle) * power;
}
body.rotation = _angle;
body.applyWorldImpulse(accelerate);

package  
{
	import flash.Boot;
	import flash.display.Sprite;
	import flash.events.Event;
	import nape.geom.AABB;
	import nape.geom.Vec2;
	import nape.phys.Material;
	import nape.phys.PhysObj;
	import nape.space.UniformSleepSpace;
	import nape.util.Tools;
	
	public class Test extends Sprite
	{
		private var gravity:Vec2
		private var space:UniformSleepSpace;
		private var physObj:PhysObj;
		
		public function Test() 
		{
			
			new Boot()
			
			
			gravity = new Vec2(0, 100);
			space = new UniformSleepSpace(new AABB(0, 0, 750, 500), 30, gravity);
			
			
			physObj = Tools.createBox(250, 300, 400, 20, 0, 0, 0, true, Material.Steel)			
			addChild(physObj.graphic)
			space.addObject(physObj)
			
			
			
			physObj = Tools.createBox(250, 0, 20, 100, 0, 0, 0, false, Material.Steel)			
			addChild(physObj.graphic)
			space.addObject(physObj)
			
			addEventListener(Event.ENTER_FRAME, onEnterFrame);
		}				
		private function onEnterFrame(e:Event = null):void
		{	
			space.step(1 / 30, 4, 4);
		}
	}
}

body = new Body(x, y);

var array:Array = [[[23.75, -13.3], [18.1, -12.5], [ -17.85, -12.75], [ -24.4, -13.75], [ -26.45, -21.7], [24.9, -21.95]], [[ -17.85, -12.75], [18.1, -12.5], [13.95, 22.4], [ -13.6, 22.55]]];
fromArrayToBody(array, body, mc.scaleX, mc.scaleY, Material.Tire);

var remover_box:Shape = createBoxShape((-1) * mc.scaleX, (-20) * mc.scaleY, 37 * mc.scaleX, 20 * mc.scaleY, null, 0x000001);
remover_box.cbType = FLOWER_TYPE;

body.addShape(remover_box);

body.setAngle(angle / k);
body.calcProperties();
body.update();
world.addObject(body);
body.assignGraphic(mc);

world.addCbPreBegin(WATER_TYPE, FLOWER_TYPE, collisionWaterFlower);

world.addCbPreBegin(CbType.DEFAULT, FLOWER_TYPE, collisionWaterFlower);

private function collisionWaterFlower(arbiter:Arbiter):int
{
	if (arbiter.b1.cbType != WATER_TYPE && arbiter.b2.cbType != WATER_TYPE) return Callback.IGNORE; //this is my comparison

	var b1:PhysObj = arbiter.b1;
	var b2:PhysObj = arbiter.b2;

	if (b1.graphic.name == "WaterDrop")
	{
		removedObjects.push(b1);
		(b2.graphic as Flower).addWaterDrop();
	}
	else
	{
		removedObjects.push(b2);
		(b1.graphic as Flower).addWaterDrop();
	}
	
	return Callback.IGNORE
}

public function createWaterDrop(pos:Vec2, vel:Vec2, radius:Number = 0)
{
	var waterDrop:MovieClip = new WaterDrop();
	waterDrop.x = pos.px;
	waterDrop.y = pos.py;
	GameManager.instance.game.currentLevel.water.addChild(waterDrop);// as MovieClip;
	waterDrop.name = "WaterDrop";

	var waterMaterial:Material = new Material(0.3, 0, 0, 1);
	var body:Body = Tools.createCircle(randomInt(waterDrop.x-radius, waterDrop.x+radius), randomInt(waterDrop.y-radius, waterDrop.y+radius), waterDrop.width * 0.3,
	vel.px, vel.py, 0, false, false, waterMaterial, 0x000001);

	body.cbType = WATER_TYPE;
	body.assignGraphic(waterDrop);
	world.addObject(body);

	if (GameManager.instance.game.score > 0)
	{
		GameManager.instance.game.score --;
		GameManager.instance.game.refreshScore();
	}
}

private var FLOWER_TYPE:int = CbType.get();
private var WATER_TYPE:int = CbType.get();