Rings

/**
 * Copyright aobyrne ( http://wonderfl.net/user/aobyrne )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/v1gQ
 */

package  
{
    import Box2D.Common.Math.b2Vec2;
    import Box2D.Dynamics.b2Body;
    import com.actionsnippet.qbox.QuickBox2D;
    import com.actionsnippet.qbox.QuickObject;
    import flash.display.Graphics;
    import flash.display.MovieClip;
    import flash.display.Sprite;

    public class Ring extends MovieClip 
    {
        public var sim:QuickBox2D;
        private var segmentWidth:Number;
        private var segmentHeight:Number;
        private var deltaAngle:Number;
        private var segmentAmount:Number;
        private var manageGroupIndex:Boolean;
        private var limitAngle:Number;
        public var properties:Array;
        
        public function Ring() 
        {
            
            //limitAngle = Math.PI*0.5;
            properties = [];
            var wallWidth:Number = 1;
            var wallWidthHalves:Number = wallWidth*0.5;
            var cx:Number = wallWidthHalves;
            var cy:Number = wallWidthHalves;
            var stageWidth:Number = stage.stageWidth / 30-wallWidth;
            var stageHeight:Number = stage.stageHeight / 30-wallWidth;
            segmentWidth = 0.25;
            var ringsAmount:Number = 2;
            var ringsColumns:Number = 3;
            var cellSize:Number = stageWidth / ringsColumns;
            var radius:Number = (cellSize) * 0.5-segmentWidth;
            segmentAmount = 14;
            deltaAngle = Math.PI * 2 / segmentAmount;
            var ringHeight:Number = radius * Math.cos(deltaAngle * 0.5);
            sim = new QuickBox2D(this, { debug:false } );
            sim.gravity = new b2Vec2;
            sim.grid(30,0x666666);
            sim.createStageWalls();
            manageGroupIndex = false;
            new Additions(this);
            for (var i:int = 0; i < properties.length; i++) 
            {
                addRing(
                    cx+cellSize*((i % ringsColumns)+0.5),
                    cy+cellSize*(Math.floor(i / ringsColumns)+0.5),
                    ringHeight,
                    properties[i]
                );
                
            }
            // start simulation
            sim.start();
            sim.mouseDrag();            
        }
        
        private function addRing(cx:Number, cy:Number,h:Number,p:RingMechanicalProperties):void 
        {
            var extraWidthFactor:Number = 1.2;
            segmentHeight = 2 * h * Math.sin(deltaAngle * 0.5)*extraWidthFactor;
            var angle:Number = 0;
            var box:Object = 
            { 
                x:cx + h * Math.cos(angle), 
                y:cy + h * Math.sin(angle), 
                width:segmentWidth, 
                height:segmentHeight, 
                fixedRotation:false,
                angularDamping:1,
                linearDamping:2,
                density:1,
                fillAlpha:0.5
                };
           if(manageGroupIndex) box["groupIndex"] = -1;
            var pre:QuickObject = sim.addBox( box );
            if(manageGroupIndex) box["groupIndex"] = 1;
            box["fillAlpha"] = 0;
            var first:QuickObject = pre;
            for (var i:int = 0; i <segmentAmount-1; i++) 
            {
                angle += deltaAngle;
                box["angle"] = angle;
                box["x"] = cx + h * Math.cos(angle);
                box["y"] = cy + h * Math.sin(angle);
                if (i == segmentAmount - 2)
                {
                    if(manageGroupIndex) box["groupIndex"] = -1;
                    box["fillAlpha"] = 0.5;
                }
                var curr:QuickObject = sim.addBox(box);
                addJoint( pre.body, curr.body,0,p );
                pre = curr;
            }
            curr = first;
            addJoint(pre.body,curr.body,curr.body.GetAngle()-pre.body.GetAngle(),p);
        }
        
        private function addJoint(aArg:b2Body, bArg:b2Body,referenceAngleArg:Number=0,p:RingMechanicalProperties=null):QuickObject 
        {
            var radius:Number = 1;
            var getAngle:Number = aArg.GetAngle()+Math.PI*0.5;
            var output:QuickObject = sim.addJoint( { a:aArg, b:bArg, type:QuickBox2D.REVOLUTE 
            ,lowerAngle: p.lowerAngle, upperAngle:p.upperAngle, enableLimit:true, referenceAngle:referenceAngleArg,
            vecA:new b2Vec2(
                aArg.GetWorldCenter().x + segmentHeight * 0.5 * Math.cos(getAngle), 
                aArg.GetWorldCenter().y + segmentHeight * 0.5 * Math.sin(getAngle)
                ),
                collideConnected:false
            } );
            return output
        }
        
        
        
    }

}
class Additions
{
    private var main:Ring;
    private var properties:Array;
    public function Additions(mainArg:Ring)
    {
        main = mainArg;
        init();
    }
    
    private function init():void 
    {
        properties = main.properties;
        var property:RingMechanicalProperties = new RingMechanicalProperties();
        var ringAmount:Number = 6;
        var symmetryAngle:Number = 0;
        var maxLimit:Number = Math.PI*0.5;
        for (var i:int = 0; i < ringAmount; i++) 
        {
            property = new RingMechanicalProperties();
            symmetryAngle = maxLimit - i * maxLimit / ringAmount;
            property.lowerAngle = -symmetryAngle;
            property.upperAngle = symmetryAngle;
            properties[properties.length] = property;
        }
    }
}
class RingMechanicalProperties
{
    private var _lowerAngle:Number;
    private var _upperAngle:Number;
    public function RingMechanicalProperties()
    {
        _lowerAngle = 1;
        _upperAngle = 1;
    }
    
    public function get lowerAngle():Number 
    {
        return _lowerAngle;
    }
    
    public function set lowerAngle(value:Number):void 
    {
        _lowerAngle = value;
    }
    
    public function get upperAngle():Number 
    {
        return _upperAngle;
    }
    
    public function set upperAngle(value:Number):void 
    {
        _upperAngle = value;
    }
}