무한 톱니바퀴

gears.fla

Gears.as (내가 만들어놓고도 왜 따로 만들었는지 모르겠다. 어차피 OOP에 관심도 없는데 말이지...)

const DOC_X:uint=stage.stageWidth;
const DOC_Y:uint=stage.stageHeight;

var gears:Array=new Array();


// for main()
const MAX_NUM:uint=29;


// for convenience
var i:int, j:int;



// main
make_bg_line();
make_gears();
make_gear_line();
stage.addEventListener(Event.ENTER_FRAME, idle);


// functions
function make_gears():void
{
    const RADIUS_MIN:Number=DOC_X/120;
    const RADIUS_MAX:Number=RADIUS_MIN*5;
    const OUTER_THICKNESS_MIN:Number=RADIUS_MIN/2;
    const OUTER_THICKNESS_MAX:Number=RADIUS_MAX/6;
    const CORE_TO_OUTER_P:Number=0.95; // probability
    const CORE_TO_OUTER_NUM_MIN:int=4;
    const CORE_TO_OUTER_NUM_MAX:int=20;
    const TEETH_NUM_MIN:int=20;
    const TEETH_NUM_MAX:int=40;

    const CORE_VS_RADIUS_RATIO:Number=0.5;

    const ROTATION_SPEED_MIN:Number=0.5;
    const ROTATION_SPEED_MAX:Number=2;
    const FILL_COLOR_MIN:uint=0;
    const FILL_COLOR_MAX:uint=128;
    const COLLISION_P:Number=0.1; // collision is allowed by this probability
           
    for(i=1;i<=MAX_NUM;i++)
    {
        gears[i]=new Gears();
        gears[i].rotation_speed=fy_random(ROTATION_SPEED_MIN,ROTATION_SPEED_MAX);
        var t=(fy_random(FILL_COLOR_MIN,FILL_COLOR_MAX)).toString(16);
        if(t.length<2) t="0"+t;
        gears[i].fill_color=uint("0x"+t+t+t);

        var real=new Sprite();
        var cur_alpha:Number=1;

        var radius:Number=fy_random(RADIUS_MIN,RADIUS_MAX);
        var scale:Number=radius/RADIUS_MAX;
        var outer_thickness:Number=fy_random(OUTER_THICKNESS_MIN*scale,OUTER_THICKNESS_MAX*scale);
        var core:Number=fy_random(0, radius-outer_thickness)*CORE_VS_RADIUS_RATIO;

        real.graphics.beginFill(gears[i].fill_color, cur_alpha);
        real.graphics.drawCircle(0,0,radius);
        real.graphics.drawCircle(0,0,radius-outer_thickness);
        real.graphics.drawCircle(0,0,core);


        // teeth
        var teeth:Array=new Array();
        var cur_rotation:Number=0;

        var teeth_num:uint=uint(fy_random(TEETH_NUM_MIN*scale,TEETH_NUM_MAX*scale))/scale;
        var teeth_height:Number=fy_random(outer_thickness/1.5, outer_thickness);
        var teeth_thickness:Number=fy_random(teeth_height/3, teeth_height/1.5);
        var teeth_screwed_d=fy_random(0,teeth_height);

        for(j=0;j<teeth_num;j++)
        {
            teeth[j]=new Sprite();
            teeth[j].graphics.beginFill(gears[i].fill_color, cur_alpha);
            teeth[j].graphics.lineStyle(teeth_thickness, gears[i].fill_color, cur_alpha, true, "normal", "none", "bevel");
            teeth[j].graphics.moveTo(radius-teeth_thickness/3, -teeth_thickness/2);
            teeth[j].graphics.lineTo(radius-teeth_thickness/3+teeth_height, teeth_screwed_d);
            teeth[j].graphics.lineTo(radius-teeth_thickness/3, teeth_thickness/2+teeth_screwed_d/2);
            teeth[j].graphics.endFill();

            teeth[j].rotation=cur_rotation;
            cur_rotation+=360/teeth_num;
            real.addChild(teeth[j]);
        }


        // core_to_outer
        var core_to_outer_num:int=fy_random(CORE_TO_OUTER_NUM_MIN,CORE_TO_OUTER_NUM_MAX);
        var core_to_outer_thickness:Number=fy_random(outer_thickness/2,outer_thickness);

        if(Math.random()<CORE_TO_OUTER_P)
        {
            var core_to_outer:Array=new Array();
            cur_rotation=0;

            for(j=0;j<core_to_outer_num;j++)
            {
                core_to_outer[j]=new Sprite();
                core_to_outer[j].graphics.lineStyle(core_to_outer_thickness, gears[i].fill_color, cur_alpha, true);
                core_to_outer[j].graphics.lineTo(radius-outer_thickness,0);
                core_to_outer[j].rotation=cur_rotation;
                cur_rotation+=360/core_to_outer_num;
                real.addChild(core_to_outer[j]);
            }
        }

        real.graphics.endFill();

        gears[i].addChild(real);

        gears[i].x=fy_random(0, DOC_X);
        gears[i].y=fy_random(0, DOC_Y);
        stage.addChild(gears[i]);


        // collision check
        for(j=1;j<=i;j++)
        {
            if(i!=j && gears[i].hitTestObject(gears[j]) && Math.random()>COLLISION_P)
            {
                gears[i].x=fy_random(0, DOC_X);
                gears[i].y=fy_random(0, DOC_Y);
                j=1;
            }
        }
    }
}


function make_gear_line():void
{
    const GL_FILL_COLOR:uint=0x000000;
    const GL_ALPHA:Number=1/3;

    var real=new Sprite();
    var cur_alpha:Number=GL_ALPHA;

    real.graphics.lineStyle(1,GL_FILL_COLOR,cur_alpha,"true");
    real.graphics.moveTo(gears[1].x, gears[1].y);

    for(i=2;i<=MAX_NUM;i++)
    {
        real.graphics.lineTo(gears[i].x, gears[i].y);
        stage.addChild(real);
        stage.setChildIndex(real, 0);
    }
}


function make_bg_line():void
{
    const BL_FILL_COLOR:uint=0x000000;
    const BL_THICKNESS:uint=3;

    var cur_alpha:Number=1;
    var real=new Sprite();

    real.graphics.lineStyle(BL_THICKNESS,BL_FILL_COLOR,cur_alpha,"true");

    real.graphics.moveTo(fy_random(0,DOC_X/2),-fy_random(DOC_Y/2,DOC_Y));
    real.graphics.curveTo(DOC_X/2,DOC_Y/2, fy_random(DOC_X,DOC_X*2),fy_random(DOC_Y,DOC_Y*2));
    stage.addChild(real);

    real.graphics.moveTo(fy_random(DOC_X/2,DOC_X),-fy_random(DOC_Y/2,DOC_Y));
    real.graphics.curveTo(DOC_X/2,DOC_Y/2, -fy_random(0,DOC_X*2),fy_random(DOC_Y,DOC_Y*2));
    stage.addChild(real);

    real.graphics.moveTo(fy_random(0,DOC_X/2),-fy_random(DOC_Y/2,DOC_Y));
    real.graphics.curveTo(DOC_X/4,DOC_Y/2, fy_random(0,DOC_X/2),fy_random(DOC_Y,DOC_Y*2));
    stage.addChild(real);

    real.graphics.moveTo(fy_random(DOC_X/2,DOC_X),-fy_random(DOC_Y/2,DOC_Y));
    real.graphics.curveTo(DOC_X/(3/4),DOC_Y/2, fy_random(DOC_X/2,DOC_X),fy_random(DOC_Y,DOC_Y*2));
    stage.addChild(real);
}


function idle(e:Event):void
{
    update_gears();
}


function update_gears():void
{
    for(i=1;i<=MAX_NUM;i++)
    {
        gears[i].rotation+=gears[i].rotation_speed;
        if(gears[i].rotation>360)
            gears[i].rotation-=360;
    }
}


function fy_random(min:Number, max:Number):Number // returns n ( min <= n < max )
{
    return(Math.random()*(max-min)+min);
}