nape example: fat slice

package example
{
    import flash.display.DisplayObjectContainer;
    import flash.display.Sprite;
    import flash.events.MouseEvent;
    import nape.geom.GeomPoly;
    import nape.geom.GeomPolyList;
    import nape.geom.GeomVertexIterator;
    import nape.geom.Vec2;
    import nape.geom.Vec2List;
    import nape.phys.Body;
    import nape.phys.BodyType;
    import nape.phys.Material;
    import nape.shape.Polygon;
    import nape.shape.Shape;
    import nape.shape.ShapeIterator;

    /**
     * ...
     * @author liu wong
     *
     */

    public class fatSlice extends baseExample
    {
        private const borderArray:Array = [
            new Vec2(0, 0),
            new Vec2(640, 0),
            new Vec2(640, 480),
            new Vec2(0, 480)
            ];

        private var balls:Array/*Body*/;

        private var srcBorder:Vec2List;

        private var mouse:Boolean = false;
        private var segmentA:Vec2;
        private var segmentB:Vec2;

        private var mainSprite:Sprite;

        private var borderBody:Body;

        public function fatSlice(prnt:DisplayObjectContainer):void
        {
            super(prnt);
        }

        override protected function init():void
        {
            super.init();

            space.gravity.setxy(0, 0);
            space.worldAngularDrag = 0;
            space.worldLinearDrag = 0;

            var points:Array = [
                new Vec2(100, 100),
                new Vec2(500, 100),
                new Vec2(500, 400),
                new Vec2(100, 400)
                ];

            var poly:GeomPoly = new GeomPoly(points);
            srcBorder = geomPolyToVec2List(poly, true);

            segmentA = new Vec2();
            segmentB = new Vec2();

            mainSprite = new Sprite();
            addChild(mainSprite);

            var k:int = 5;
            var i:int;

            var b:Body;
            var m:Material = new Material(1, 1, 1, 1, 0);

            balls = new Array();

            for (i = 0; i < k; i++)
            {
                b = addCircle(320, 240, 8);
                b.setShapeMaterials(m);
                b.applyImpulse(Vec2.fromPolar(100, i * (Math.PI * 2 / k)), b.position);

                balls.push(b);
            }

            b = new Body(BodyType.STATIC, new Vec2(0, 0));
            var vl:Vec2List = convert(srcBorder);

            vec2ListToShapes(vl, b);

            borderBody = b;

            b.space = space;

            stage.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
            stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
            stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
        }

        private function onMouseDown(event:MouseEvent):void
        {
            mouse = true;

            segmentA.setxy(mouseX, mouseY);
        }

        private function onMouseUp(event:MouseEvent):void
        {
            mouse = false;

            segmentB.setxy(mouseX, mouseY);

            mainSprite.graphics.clear();

            if (segmentA.sub(segmentB).length < 1)
                return;

            var cr:cutResult = cut(new GeomPoly(srcBorder), segmentA, segmentB, checkBalls);

            if (cr == null)
                return;

            if (cr.result == null)
                return;

            if (cr.destroy.length < 1)
                return;

            if (borderBody)
            {
                borderBody.space = null;
            }

            borderBody = new Body(BodyType.STATIC, new Vec2(0, 0));

            srcBorder = geomPolyToVec2List(cr.result, cr.result.isClockwise());

            var vl:Vec2List = convert(srcBorder);
            vec2ListToShapes(vl, borderBody);

            borderBody.space = space;
        }

        private function onMouseMove(event:MouseEvent):void
        {
            if (mouse == false)
                return;

            segmentB.setxy(mouseX, mouseY);

            mainSprite.graphics.clear();

            mainSprite.graphics.lineStyle(2, 0xff0000);
            mainSprite.graphics.moveTo(segmentA.x, segmentA.y);
            mainSprite.graphics.lineTo(segmentB.x, segmentB.y);
        }

        private function geomPolyToVec2List(src:GeomPoly, ccw:Boolean):Vec2List
        {
            var iterator:GeomVertexIterator;

            if (!ccw)
                iterator = src.forwardIterator()
            else
                iterator = src.backwardsIterator();

            var tmp:Vec2List = new Vec2List();

            while (iterator.hasNext())
            {
                var v:Vec2 = iterator.next();

                tmp.add(v.copy());
            }

            return tmp;
        }

        private function vec2ListToShapes(src:Vec2List, dst:Body):void
        {
            var tmp:GeomPoly = new GeomPoly(src);

            var pl:GeomPolyList = tmp.triangularDecomposition();
            var k:int = pl.length;

            if (k > 0)
            {
                var i:int;
                for (i = 0; i < k; i++)
                {
                    var poly:GeomPoly = pl.at(i);

                    if (poly.isDegenerate())
                        continue;

                    dst.shapes.add(new Polygon(poly));
                }
            }
        }

        private function convert(vl:Vec2List):Vec2List
        {
            var k:int = vl.length;
            var len:Number = int.MAX_VALUE;
            var v1:Vec2 = borderArray[0];
            var index:int = 0;

            var i:int;
            for (i = 0; i < k; i++)
            {
                var len2:Number = vl.at(i).sub(v1).length;

                if (i == 0)
                {
                    len = len2;
                }
                else
                {
                    if (len2 < len)
                        {
                            len = len2;
                            index = i;
                        }
                }
            }

            var tmp:Vec2List = new Vec2List();

            for (i = 0; i < 4; i++)
                tmp.add(borderArray[i].copy());
            tmp.add(borderArray[0].copy());

            var j:int = index;

            for (i = 0; i < k; i++)
            {
                tmp.add(vl.at(j).copy());

                j--;
                if (j < 0)
                    j = k - 1;
            }

            tmp.add(vl.at(index).copy());

            return tmp;
        }

        private function checkBalls(src:GeomPoly):Boolean
        {
            var k:int = balls.length;

            if (k == 0)
                return false;

            var i:int;
            for (i = 0; i < k; i++)
            {
                if (src.contains(balls[i].position))
                    return true;
            }

            return false;
        }

        private function cut(src:GeomPoly, s:Vec2, f:Vec2, callback:Function):cutResult
        {
            var tmp:GeomPolyList = src.cut(s, f, true, true);
            var result:cutResult = new cutResult();

            var k:int = tmp.length;
            if (k > 1)
            {
                var i:int;
                for (i = 0; i < k; i++)
                {
                    var gp:GeomPoly = tmp.at(i);

                    if (callback(gp))
                    {
                        if (result.result == null)
                            result.result = gp
                        else
                            return null;
                    }
                    else
                    {
                        result.destroy.push(gp);
                    }
                }
            }

            return result;
        }

        override public function free():void
        {
            stage.removeEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
            stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
            stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);

            super.free();
        }

        override public function update():void
        {
            super.update();

            var k:int = balls.length;
            if (k > 0)
            {
                var i:int;
                for (i = 0; i < k; i++)
                {
                    var b:Body = balls[i];

                    if (b.velocity.length>1)
                        b.velocity.length = 100;
                    else
                        b.velocity.setxy(100, 0);
                }
            }
        }
    }

}

import nape.geom.GeomPoly;

class cutResult
{
    var result:GeomPoly;
    var destroy:Array/*GeomPoly*/;

    function cutResult():void
    {
        result = null;
        destroy = new Array();
    }
}