/* ----------------------------------------------  
FORMULA COORDINATE POLARI: R=SIN(PETALI*ANGOLO) 
-----------------------------------------------*/ 

// ---------------------------------------------- Costanti  
var RADIANTI = Math.PI/180;
var GRADI = 180/Math.PI;
var PI2 = Math.PI*2;
var CENTROX = 350;
var CENTROY = 200;

// ---------------------------------------------- VARIABILI 
var petali = 3;
var raggio = 150;

// ---------------------------------------------- FUNZIONI  
function RosediGrandi(petali, raggio) {
    var punti = 40*petali;
    var t = r=x=y=0;
    disegno.clear();
    disegno.lineStyle(8,0x222222,100);
    for (var i = 0; i<=punti; i++) {
        t = (i/punti)*PI2;
        r = raggio*Math.sin(petali*t);
        x = CENTROX+r*Math.cos(t);
        y = CENTROY+r*Math.sin(t);

        //disegna la curva 
        (i) ? disegno.lineTo(x, y) : disegno.moveTo(x, y);
    } 
} 

/*----------------------------------------------

FORMULE: 

distanza=arrivo-origine.x 
α = (0-90)*RADIANTI 
v0=SQRT((distanza*gravita)/(2*SIN(α)*COS(α))); 

vx=spinta*COS(α),  
vy=spinta*SIN(α)); 

tempototalevolo = (vy/gravita)*2; 


// calcolo punto nel momento t 
x = origine.x+vx*t; 
y = origine.y-vy*t+.5*gravita*(t*t); 

----------------------------------------------*/ 




import flash.geom.Point;

// ---------------------------------------------- COSTANTI  
var RADIANTI = Math.PI/180;
var GRADI = 180/Math.PI;
var PI2 = Math.PI*2;
var CENTROX = 350;
var CENTROY = 200;

// ---------------------------------------------- VARIABILI  
var gravita = 9.81;
var inc = .1;
var origine:Point = new Point(missile_mc._x, missile_mc._y);
var arrivo:Number = base_mc._x;
var velocita:Point = new Point(0, 0);
var tempototale = 0;
var tempo = 0;
var verso=1
var involo = false;
// ---------------------------------------------- FUNZIONI  
// genera un numero casuale tra min e max
function Rand(min, max) {
    if (min>max) {
        return 0;
    } 
    return min+Math.random()*(max-min);
} 

// calcola la parbola in base alla velocità e il tempo
function CalcolaTraiettoria(velx, vely, t):Point {
    var p:Point = new Point(0, 0);
    p.x = velx*t;
    p.y = -vely*t+.5*gravita*(t*t);
    return p;
} 

function Loop() {
    tempo += inc;
    if (tempo<=tempototale) {
        var vettore = CalcolaTraiettoria(velocita.x, velocita.y, tempo);
        missile_mc._x = origine.x+vettore.x;
        missile_mc._y = origine.y+vettore.y;
    }  
} 

function Init() {
    tempo = 0;

    // parametri per calcolo della traiettoria e del tempo di volo
    //------------------------------------------------------------------------------- 
    // distanza target 
    var distanza=(arrivo>origine.x)?arrivo-origine.x:origine.x-arrivo 
    // corregge direzione 
    verso=(arrivo>origine.x)?1:-1 
     
    // calcola l'angolo iniziale
    var angolo = (90-Rand(15, 45))*RADIANTI;
    // spinta necessari per raggiungere il target
    var spinta:Number = Math.sqrt((distanza*gravita)/(2*Math.sin(angolo)*Math.cos(angolo)));
     
    // vettore di volo 
    velocita = new Point(spinta*Math.cos(angolo)*verso, spinta*Math.sin(angolo));

    // tempo totale di volo 
    tempototale = (velocita.y/gravita)*2;

    //------------------------------------------------------------------------------- 
}

/*----------------------------------------------
Algoritmo: 

In un esagono tutte le misure  dipendono dal lato,  
quindi settando il lato è possibile calcolare  tutti i valori mancanti.  

L'altezza         h= sin( 30°) * lato 
La distanza     r = cos( 30°) * lato 
L'altezza del rettangolo che circonda l'esagono     b = lato + 2 * h 
La larghezza del rettangolo che circonda l'esagono  a = 2 * r 

Usando il l'istruzione modulo  (%) è possibile calcolare 
le righe pari e dispari in modo da allineare la matrice. 

La posizione di ogni esagono si ricava: 

  
X = j*2*R+R*(i%2) 
Y = i*(h+lato); 

con  
0 ≥ i ≤ numero di esagoni  per le righe  
0 ≥ j ≤ numero di esagoni  per le colonne 

----------------------------------------------*/ 


// ---------------------------------------------- Costanti  
var RADIANTI = Math.PI/180;
var GRADI = 180/Math.PI;
var PI2 = Math.PI*2;

// ---------------------------------------------- VARIABILI  

var cellex = 10;
var celley = 10;
var latoesagono = 21;
var h = latoesagono*Math.sin(30*RADIANTI);
var r= latoesagono*Math.cos(30*RADIANTI);


// crea la matrice di esagoni 
var id = 1;
var esagono_mc:MovieClip;
for (var i = 0; i<celley; i++) {
    for (var j = 0; j<cellex; j++) {
        esagono_mc = disegno.attachMovie("hex", "c"+id, id++);
        // posiziona 
        esagono_mc._x = 50+j*2*r+r*(i%2);
        esagono_mc._y = 40+i*(h+latoesagono);
    } 
      
}

// ---------------------------------------------- COSTANTI  
var RADIANTI = Math.PI/180;
var GRADI = 180/Math.PI;
var PI2 = Math.PI*2;
var centro=new Point(350,200)
// ---------------------------------------------- VARIABILI  
var npetali = 10;
var raggio = 100;
// ---------------------------------------------- FUNZIONI 

function Arcodicerchio() {
     
    //angolo 
    var a = PI2/npetali;

    // lunghezza arco 2rSin(Ï€/n)
    var S = 2*raggio*Math.sin(Math.PI/npetali);

    for (var i = 0; i<npetali; i++) {
         
        var cerchio = _root.attachMovie("cerchio", "c"+i, i);
        var posizione = Point.polar(raggio, a*i).add(centro);
cerchio._x = posizione.x;
cerchio._y = posizione.y;
        cerchio._width = cerchio._height=S;
         
    } 
     
}

// ---------------------------------------------- FUNZIONI 
// calcola il quadrato del numero
function sqr(n) {
    return (n*n);
} 

// scambia i punti 
function swap(p1:Point, p2:Point) {
    var tmp = new Point();
    tmp = p1;
    p1 = p2;
    p2 = temp;
} 

// trova il centro del cerchio definito da tre punti
function TrovaCentro(p1:Point, p2:Point, p3:Point) {
    var xc, yc, ma, mb:Number;
    var test = true;
     
    // verifica la pendenza delle linee
    if ((p1.x == p2.x) or (p1.y == p2.y)) {
        swap(p2,p3);
    } 
    if (p2.x == p3.x) {
        swap(p1,p2);
    } 
    if (p1.x<>p2.x) {
        ma = (p2.y-p1.y)/(p2.x-p1.x);
    } else {
        test = false;
    } 
    if (p2.x<>p3.x) {
        mb = (p3.y-p2.y)/(p3.x-p2.x);
    } else {
        test = false;
    } 
    if ((ma == 0) and (mb == 0)) {
        test = false;
    } 
    // calcola le coordinate per il centro   
    if (test) {
        xc = (ma*mb*(p1.y-p3.y)+mb*(p1.x+p2.x)-ma*(p2.x+p3.x))/(2*(mb-ma));

        if (ma<>0) {
            yc = -(xc-(p1.x+p2.x)/2)/ma+(p1.y+p2.y)/2;
        } else {
            yc = -(xc-(p2.x+p3.x)/2)/mb+(p2.y+p3.y)/2;
        } 
        var centro = new Point(xc, yc);
        return centro;
    } 
    return false;
} 

// trova il raggio del cerchio definito da tre punti
function TrovaRaggio(p1:Point, p2:Point, p3:Point) {
    var s, a, b, c, r:Number;
    a = Math.sqrt(sqr(p1.x-p2.x)+sqr(p1.y-p2.y));
    b = Math.sqrt(sqr(p2.x-p3.x)+sqr(p2.y-p3.y));
    c = Math.sqrt(sqr(p3.x-p1.x)+sqr(p3.y-p1.y));
    s = (a+b+c)/2;
    r = (a*b*c)/(4*Math.sqrt(s*(s-a)*(s-b)*(s-c)));
    return r;
} 

function DisegnaCerchio() {
    var p1 = new Point(c1._x, c1._y);
    var p2 = new Point(c2._x, c2._y);
    var p3 = new Point(c3._x, c3._y);

    var raggio:Number = TrovaRaggio(p1, p2, p3);
    var centro:Point      = TrovaCentro(p1, p2, p3);

    cerchio._x = centro.x;
    cerchio._y = centro.y;
    cerchio._width = cerchio._height=raggio*2;
    cerchio._alpha = 100-(raggio*90/400);
}

/* 
       Intersezione di cerchi 
*/ 

// ---------------------------------------------- VARIABILI  
var r1 = 100;
var r2 = 140;
// ---------------------------------------------- FUNZIONI 

function DisegnaCerchio(x, y, r, c, a) {
    disegno.beginFill(c,a);
    disegno.moveTo(x+r,y);
    disegno.curveTo(r+x,0.4142*r+y,0.7071*r+x,0.7071*r+y);
    disegno.curveTo(0.4142*r+x,r+y,x,r+y);
    disegno.curveTo(-0.4142*r+x,r+y,-0.7071*r+x,0.7071*r+y);
    disegno.curveTo(-r+x,0.4142*r+y,-r+x,y);
    disegno.curveTo(-r+x,-0.4142*r+y,-0.7071*r+x,-0.7071*r+y);
    // 
    disegno.curveTo(-0.4142*r+x,-r+y,x,-r+y);
    disegno.curveTo(0.4142*r+x,-r+y,0.7071*r+x,-0.7071*r+y);
    disegno.curveTo(r+x,-0.4142*r+y,r+x,y);
    disegno.endFill();
} 
function DisegnaLinea(x1, y1, x2, y2, c, a) {
    disegno.lineStyle(0,c,a);
    disegno.moveTo(x1,y1);
    disegno.lineTo(x2,y2);
} 

function Calcola() {
    x1 = n1._x;
    y1 = n1._y;
    x2 = n2._x;
    y2 = n2._y;

    // mostra i cerchi 
    disegno.clear();
    DisegnaCerchio(x1,y1,r1,0xAA8899,10);
    DisegnaCerchio(x2,y2,r2,0x998899,20);
    //-------------------------------------- 
    // calcola la distanza  
    var dx = x2-x1;
    var dy = y2-y1;
    var distanza = Math.sqrt(dx*dx+dy*dy);
    if ((distanza>r1-r2) && (distanza<r1+r2)) {
        // normalizza 
        var dxnorm = dx/distanza;
        var dynorm = dy/distanza;

        // distanza dal centro 1 alla linea di intersezione
        var intersezione = (distanza*distanza+r1*r1-r2*r2)/(2*distanza);
        var sq = Math.sqrt(r1*r1-intersezione*intersezione);

        // trova i due punti di intersezione
        var xs1 = x1+dx*intersezione/distanza+dynorm*sq;
        var ys1 = y1+dy*intersezione/distanza-dxnorm*sq;
        var xs2 = x1+((dx*intersezione)/distanza)-dynorm*sq;
        var ys2 = y1+((dy*intersezione)/distanza)+dxnorm*sq;

        // mostra i punti di intersezione 
        DisegnaCerchio(xs1,ys1,5,0x000000,100);
        DisegnaCerchio(xs2,ys2,5,0x000000,100);
        DisegnaLinea(xs1,ys1,xs2,ys2,0,10);
        DisegnaLinea(x1,y1,x2,y2,0,10);
    } 
} 

// ---------------------------------------------- INIT  
Calcola();

/* 
dot product  
calcolo dell'angolo tra due vettori 
*/ 

// dot product  
DotProduct = function (v1, v2) {
    return (v1.x*v2.x)+(v1.y*v2.y);
};

esempio:
var p1=new Point(100,200);
var p2=new Point(200,250);
var p3=new Point(300,350);
var vett1=new Point(p1.x-p2.x,p1.y-p2.y);
var vett2=new Point(p1.x-p3.x,p1.y-p3.y)
var dot=DotProduct(vett1,vett2);

/* 
PENDOLO 
Calcolo dei valori per l'oscillazione 
*/ 

import flash.geom.Point;

// ---------------------------------------------- COSTANTI  
var PI2 = Math.PI*2;
var _PI = Math.PI/2;
// ---------------------------------------------- VARIABILI  
var tempo = 0;
var tempoinc = .5;
var Gravita = 9.81;
var Smorzamento = .999;
var LunghezzaFilo = 140;
var Periodo = Math.PI*Math.sqrt(LunghezzaFilo/Gravita);
var Angolo = Math.atan2(massa._y-centro._y, massa._x-centro._x)-Math.PI/4;
var cliccato = false;
// ---------------------------------------------- FUNZIONI 
massa.onPress = function() {
    this.startDrag(false, 50, centro._y, 500, 260);
    cliccato = true;
    Periodo = 0;
    tempo = 0;
};
massa.onRelease = massa.onReleaseOutside=function () {
    var p1 = new Point(massa._x, massa._y);
    var p2 = new Point(centro._x, centro._y);
     
    // calcola la lunghezza del filo
    var dx = p1.x-p2.x;
    var dy = p1.y-p2.y;
    LunghezzaFilo = Math.sqrt(dx*dx+dy*dy);
     
    // Controlla la lunghezza del filo
    LunghezzaFilo = Math.min(Math.max(LunghezzaFilo, 1), 200);
     
    // Calcola il periodo e angolo
    Periodo = Math.PI*Math.sqrt(LunghezzaFilo/Gravita);
    Angolo     = Math.atan2(p1.y-p2.y, p1.x-p2.x)-_PI;
    cliccato = false;
    stopDrag();
};
// ---------------------------------------------- INIT  
this.onEnterFrame = function() {
    if (!cliccato) {
        if (Periodo != 0) {
            var a = Angolo*Math.cos(PI2*tempo/Periodo)+_PI;
            // coordinate polari
            var xp = centro._x+LunghezzaFilo*Math.cos(a);
            var yp = centro._y+LunghezzaFilo*Math.sin(a);
            // muove gli elementi
            massa._x = xp;
            massa._y = yp;
            ombramassa._alpha = 20-Math.abs(massa._y-250)*20/200;
            ombramassa._x = massa._x;
            //applica uno smorzamento e incrementa il tempo
            Angolo *= Smorzamento;
            tempo += tempoinc;
        } 
    } else {
        ombramassa._x = massa._x;
        ombramassa._alpha = 20-Math.abs(massa._y-250)*20/200;
    } 
    disegno.clear();
    disegno.lineStyle(0, 0x000000, 20);
    disegno.moveTo(centro._x, centro._y);
    disegno.lineTo(massa._x, massa._y);
};

/* 
    BILANCIA 
    Formule per il calcolo dell'equilibrio 
*/ 

var RADIANTI= Math.PI/180
var lunghezzaAsta = 300;
var posL = -100;
var posR = 100;
var braccioL=100
var braccioR=100
var braccioL2 = braccioL*braccioL;
var braccioR2 = braccioR*braccioR;
var gravita = 9.81;
var MassaL = 150;
var MassaR = 150;

function  Bilancia () {
    // calcola il momento e inerzia
    var tau1 = MassaL*gravita*braccioL;
    var tau2 = MassaR*gravita*braccioR;
    var inerzia = (MassaL*braccioL2+MassaR*braccioR2)*.01;
    var sommatau = (tau2-tau1)+0.5*braccioR2*gravita-0.5*braccioL2*gravita;
     
    // calcola e limita la rotazione
    rotazione += sommatau/inerzia;
    rotazione = Math.min(Math.max(rotazione, -45), 45);
     
    // riposiziona i pesi in base alla rotazione
    var a = rotazione*RADIANTI;
    clipML._x = -braccioL*Math.cos(a);
    clipML._y = -braccioL*Math.sin(a);
    clipMR._x = braccioR*Math.cos(a);
    clipMR._y = braccioR*Math.sin(a);

    // ruota i bracci 
    clipAsta._rotation = rotazione;
}

/* 
    PROIEZIONE DI PUNTI 
    Algoritmo per la proiezione di punti 
*/ 

var  terra =400
// ritorna il punto proiettato tra il vertice p e la fonte di luce verso terra
function Proietta(p, luce) {
    var s = new Object();
    var k = -p.y/(p.y-luce.y);
    s.x = Math.round(p.x+(p.x-luce.x)*k);
    s.y = Math.round(terra+p.y+(p.y-luce.y)*k);
    return s;
} 

esempio:

var sole=new Point(300,100)
var vertice=new Point(200,300)
var proiettato=Proietta(vertice, sole) 

/* 
    Punto dentro un poligono 
    test di contenimento 
*/ 

function PuntoInPoligono(forma:Array, p:Point) {
    var c = false;
    var n = forma.length;
    var pa, pb;
    for (var i = 0; i<n; i++) {
        pa = forma[i];
        pb = forma[(i+1)%n];
        if ((((pa.y<=p.y) && (p.y<pb.y)) || ((pb.y<=p.y) && (p.y<pa.y))) && (p.x<(pb.x-pa.x)*(p.y-pa.y)/(pb.y-pa.y)+pa.x)) {
            c = !c;
        } 
    } 
    if (c) {
        return true;
    } else {
        return false;
    } 
} 

// poligono e punto per la verifica 
poligono=new Array(p1,p2,p3,p4,p5)
punto=new Point(100,200)

test = PointInPolygon(poligono, punto);

/* 
    PERPENDICOLARE 
    calcolare la perpendicolare  ad un segmento 
*/ 


PerpendicolarePuntoSegmento = function (p, p1, p2) {
    var t, dx, dy, np;
    dx = p2.x-p1.x;
    dy = p2.y-p1.y;
    d = Math.sqrt(dx*dx+dy*dy);
    t = ((p.x-p1.x)*dx+(p.y-p1.y)*dy)/d;
    t = (t<0) ? 0 : t;
    t = (t>d) ? d : t;
    np = new xy(p1.x+t*dx/d, p1.y+t*dy/d);
    return np;
};

//esempio: 
var p=new Point(150,150)
var s1=new Point(100,200)
var s2=new Point(300,400)
var perp= PerpendicolarePuntoSegmento(p,s1,s2)

/* 
    Intersezione di 2 segmenti 
    calcolo del punto di intersezione 
*/ 
function IntersezioneSegmenti (p1, p2, p3, p4) {
    var v = ((p4.x-p3.x)*(p1.y-p3.y)-(p4.y-p3.y)*(p1.x-p3.x))/((p4.y-p3.y)*(p2.x-p1.x)-(p4.x-p3.x)*(p2.y-p1.y));
    if ((v>0) and (v<1)) {
        return v;
    } else {
        return null;
    } 
};

// calcola  il punto  per i segmenti definiti da p1,p2,p3,p4
var t = IntersezioneSegmenti(p1, p2, p3, p4);
if (t) {
    np._x = p1.x*(1-t)+p2.x*t;
    np._y = p1.y*(1-t)+p2.y*t;
} 

/* 
    Interpolazione Bezier  
    Metodo deCasteljau 
*/ 

// Metodo per trovare un punto sulla curva
// in base al parametro t [0-1] 
function BezierdeCasteljau(punti, t) {
    curr = new Array();
    next = punti;
    while (next.length>1) {
    curr = next;
    next = new Array();
    for (var i = 0; i<curr.length-1; i++) {
        p = new xy();
        p.x = (1-t)*curr[i].x+t*curr[i+1].x;
        p.y = (1-t)*curr[i].y+t*curr[i+1].y;
        next[i] = p;
    } 
    } 
    return next[0];
} 

// punti da interpolare 
punti =[p1,p2,p3,p4,p5]
p=BezierdeCasteljau(punti,.5)

/* 
    Interpolazione Catmull-Rom 
    disegno di una lista di punti su una curva spline 
*/ 

//Nota: In una sequenza di punti il primo e l'ultimo punto devono essere doppi
function CatmullRom(p1, p2, p3, p4, t) {
    var t2 = t*t;
    var t3 = t2*t;
    var p = new Object();
    p.x = (((-p1.x+3*p2.x-3*p3.x+p4.x)*t3)+((2*p1.x-5*p2.x+4*p3.x-p4.x)*t2)+((-p1.x+p3.x)*t)+(2*p2.x))*.5;
    p.y = (((-p1.y+3*p2.y-3*p3.y+p4.y)*t3)+((2*p1.y-5*p2.y+4*p3.y-p4.y)*t2)+((-p1.y+p3.y)*t)+(2*p2.y))*.5;
    return p;
} 

//---------------------------------------------------- 
// array di punti 
Curva=new Array(p0,p1,p2,p3,p4,p5,p6,p7);

for (var i = 1; i<Curva.length-2; i++) {
    p0 = Curva[i-1];
    p1 = Curva[i];
    p2 = Curva[i+1];
    p3 = Curva[i+2];
    disegno.moveTo(p1.x, p1.y);
    steps=10
    for (var j = 0; j<=steps; j++) {
        t = j/steps;
        p = CatmullRom(p0, p1, p2, p3, t);
        lineTo(p.x, p.y);
    } 
    } 
}

/* 
    Interpolazione Hermite 
    disegno di punti su curve spline con tensione variabile 
*/ 

tensione=0
steps=10


//Tensione: 1 alta, 0 normale, -1 bassa 
function Hermite (n0, n1, n2, n3, t, tensione) {
    var m0, m1, mu2, mu3;
    var a0, a1, a2, a3;
    var t2,t3,te
    t2 = t*t;
    t3 = t2*t;
    te = 1-tensione;
    m0 = (n1-n0)*te*.5;
    m0 = m0+(n2-n1)*te*.5;
    m1 = (n2-n1)*te*.5;
    m1 = m1+(n3-n2)*te*.5;
    //  
    a0 = 2*t3-3*t2+1;
    a1 = t3-2*t2+t;
    a2 = t3-t2;
    a3 = -2*t3+3*t2;
    return (a0*n1+a1*m0+a2*m1+a3*n2);
};

//Nota: In una sequenza di punti il primo e l'ultimo  punto devono essere doppi
// array di punti 
Curva=new Array(p0,p0,p1,p2,p3,p4,p5,p6,p7,p7);

for (var i = 1; i<Curva.length-2; i++) {
    p0 = Curva[i-1];
    p1 = Curva[i];
    p2 = Curva[i+1];
    p3 = Curva[i+2];
    disegno.moveTo(p1.x, p1.y);
    for (var j = 0; j<=steps; j++) {
        t = j/steps;
        p = new Point();
        p.x = Hermite(p0.x, p1.x, p2.x, p3.x, t, tensione);
        p.y = Hermite(p0.y, p1.y, p2.y, p3.y, t, tensione);
        lineTo(p.x, p.y);
    } 
} 

/* 
    Movimento Browniano 
    movimaneto casuale di particelle 
*/ 

var GRADI=180/Math.PI;
var pos = new Point(300, 300);
var range = Math.PI/20;
var angolo = Math.random()*(Math.PI*2);
var passo = 2+Math.random()*3;

// calcola il movimento browniano
function Sposta () {
    angolo += range-Math.random()*(range*2);
    // vettore di movimento 
    pos.x += passo*Math.cos(angolo);
    pos.y += passo*Math.sin(angolo);
    // limita spostamento 
    if (pos.x>500) {
    pos.x = 500;
    angolo += range;
    } 
    if (pos.x<50) {
    pos.x = 50;
    angolo += range;
    } 
    if (pos.y>400) {
    pos.y = 400;
    angolo += range;
    } 
    if (pos.y<50) {
    pos.y = 50;
    angolo += range;
    } 
    // sposta e ruota 
    this._x = pos.x;
    this._y = pos.y;
    this._rotation = angolo*GRADI;
};

this.onEnterFrame=Sposta

/* 
    Pattern di Truchet 
    disegno della matrice 
*/ 

// ---------------------------------------------- VARIABILI  
var colonne = 10
var righe = 10
var lar = 40;
var old = 0;
var p0 = .5;
var p1 = .5;
var lista = new Array();
var id = 1;
// ---------------------------------------------- FUNZIONI 
function Truchet() {
    var num = 0;
    var id = 0;
    for (var i = 0; i<righe; i++) {
        for (var j = 0; j<colonne; j++) {
            caso = Math.random();
            if (old == 0) {
                num = (caso<p0) ? 0 : 1;
            } 
            if (old == 1) {
                num = (caso<p1) ? 1 : 0;
            } 
            old = num;
             
            var clip = lista[id];
            clip._rotation = (num) ? 90 : 0;
            id++;
        } 
    } 
} 


// ---------------------------------------------- INIT  
for (var i = 0; i<righe; i++) {
    for (var j = 0; j<colonne; j++) {
        var clip = _root.disegno.attachMovie("box", "b"+id, id);
        clip._x = Math.round(lar*j)+20;
        clip._y = Math.round(lar*i)+20;
        clip._width = clip._height=lar;
        lista.push(clip);
        id++;
    } 
} 

Truchet();

/* 
    Rotolamento 
    calcolo della rotazione di oggetti 


    Formule: 
     
    rotazione=spostamento*(360/circonferenza) 
    numerodigiri=spostamento/circonferenza 


*/ 



import flash.geom.Point;

// ---------------------------------------------- COSTANTI  
var PI2 = Math.PI*2;
// ---------------------------------------------- VARIABILI  
var cliccato = false;
var posizione = 0;
var rotazione = 0;
var dx = 0;
var precedentemouse:Point = new Point(0,0);
var raggio = ruota_mc._width/2;
var circonferenza = raggio*PI2;

// ---------------------------------------------- FUNZIONI 
function Rotazione(spostamento,) {
    var rotolamento = spostamento*(360/circonferenza);
    ruota_mc._x = posizione +spostamento;
    ruota_mc._rotation = rotazione + rotolamento;
} 


_root.onMouseMove = function() {
    if (cliccato) {
        var dx = _xmouse-precedentemouse.x;
        Rotazione(dx);
    } 
};

_root.onMouseDown = function() {
    precedentemouse = new Point(_xmouse,_ymouse);
    posizione = ruota_mc._x;
    rotazione = ruota_mc._rotation;
    cliccato = true;
};
_root.onMouseUp = function() {
    cliccato = false;
};

// ---------------------------------------------- COSTANTI  
var GRAVITA = 9.81;
// ---------------------------------------------- VARIABILI  
var massa = 10;
var calore = 0;
var accy = 0;
var vely = 0;
var frizione = .005;
// ---------------------------------------------- INIT  
onEnterFrame = function() {

    // somma delle forze 
    var spinta = GRAVITA+calore;

    // resistenza al movimento 
    spinta *= frizione;

    //2°; legge di Newton per accelerazione
    accy = spinta/massa;

    // somma accellerazione a velocità
    vely = Math.max(vely+accy, -3);

    // somma la velocità alla posizione
    pallone._y = pallone._y+vely;

    // raffreddamento 
    calore *= .5;

};


onMouseDown=function(){
    calore+=5
}