package  

{

        import flash.display.GraphicsPath;

/* * * * * * * * * *

*                  *

*  @author wolsh   *

*                  *

\* * * * * * * * * */ 

        public class RoundPoly 

        {

                private static const RAD180:Number = Math.PI;

                private static const RAD:Number = Math.PI / 180;

                private static const RAD90:Number = Math.PI / 2;

 

 

                public function RoundPoly() {        }

 

                public static function getPath(sides:uint, centerX:Number, centerY:Number, radius:Number, round:Number, rotation:Number):GraphicsPath

                {

                        rotation *= RAD;

                        var c:Vector.<int> = new Vector.<int>();

                        var d:Vector.<Number> = new Vector.<Number>();

 

                        var roundCenterR:Number = radius - round;

                        var sideAngle:Number = 2 * RAD180 / sides;

                        var roundAngle:Number = RAD90 - sideAngle / 2;

                        //// move to start coordinates

                        var startX:Number = centerX + roundCenterR * Math.cos(rotation);

                        var startY:Number = centerY + roundCenterR * Math.sin(rotation)

                        var startArc:GraphicsPath = RoundPoly.getArc(startX, startY, round, rotation - sideAngle / 2, sideAngle);

                        c = startArc.commands;

                        d = startArc.data;

 

                        //// lines to anchors

                        for (var i:uint = 1; i < sides; i++)

                        {

                                var angle:Number = rotation + sideAngle * i;

                                var roundCenterX:Number = centerX + roundCenterR * Math.cos(angle);

                                var roundCenterY:Number = centerY + roundCenterR * Math.sin(angle);

                                var arcStartAngle:Number = angle - sideAngle / 2;

                                var arc:GraphicsPath = RoundPoly.getArc(roundCenterX, roundCenterY, round, arcStartAngle, sideAngle);

                                arc.commands[0] = 2;

                                c = c.concat(arc.commands);

                                d = d.concat(arc.data);

                        }

                        //// Close contur line

                        c.push(2);

                        d.push(startArc.data[0], startArc.data[1]);

 

                        return new GraphicsPath(c, d);

                }

 

                private static function getArc(centerX:Number, centerY:Number, radius:Number, rotation:Number, arc:Number, startCommand:int = 1) : GraphicsPath

                {

                        if (arc == 0)

                        {

                                return null; // ? //

                        }

                        // alias arc to 360 gradians

                        arc = arc % (RAD180 * 2);

                        // 18 gradians max at one step

                        var frags:Number = Math.abs( Math.ceil(arc * 10 / RAD180) ); 

                        if (arc < 0)

                        {

                                frags += 1;

                        }

                        var fragAngle:Number = arc / frags;

                        var controlR:Number = radius / Math.cos( -fragAngle / 2);

 

                        var c:Vector.<int> = Vector.<int>([ startCommand ]);

                        var d:Vector.<Number> = new Vector.<Number>();

                        d.push(centerX + radius * Math.cos(rotation));

                        d.push(centerY + radius * Math.sin(rotation));

 

                        for (var i:uint = 1; i < frags + 1; i++) 

                        {

                                var aA:Number = rotation + fragAngle * i;

                                var aX:Number = centerX + radius * Math.cos(aA);

                                var aY:Number = centerY + radius * Math.sin(aA);

                                var cA:Number = aA - fragAngle / 2;

                                var cX:Number = centerX + controlR * Math.cos(cA);

                                var cY:Number = centerY + controlR * Math.sin(cA);

                                c.push(3);

                                d.push(cX, cY, aX, aY);

                        }

                        return new GraphicsPath(c, d);

                }

        }

}

                        var gPath:GraphicsPath = RoundPoly.getPath(

                        5, // кол-во сторон

                        150, // х центра полигона

                        150, // у центра полигона

                        120, // радиус полигона

                        20, // радиус скругления

                        72  // угол поворота полигона

                        );

                        var gData:Vector.<IGraphicsData> = Vector.<IGraphicsData>

                        ([

                                new GraphicsSolidFill(0x000000, 0.5),

                                gPath,

                                new GraphicsEndFill()

                        ]);

                        var s:Shape = new Shape();

                        super.addChild(s);

                        s.graphics.drawGraphicsData(gData);