Urti e reazioni con Flash CS3 - Massa e Quantità di moto

[Flep]

Salve a tutti !

Fino ad oggi abbiamo visto come applicare alcune leggi fisiche ( velocità, accelerazione, frizione, spring, gravità ) per creare animazioni con Flash CS3.
I tutorials sono partiti con un grado di difficoltà abbastanza semplice e via via sono sono diventati un po più difficili implementando l' uso della trigonometria come ad esempio le formule di rotazione delle coordinate dell' intero sistema utilizzato per captare collisioni su superfici angolate.

Il fine di questi tutorial sarà quello di arrivare a capire come simulare l' asse Z con Flash CS3 e quindi di creare delle animazioni tridimensionali.
Per arrivare a tale scopo, il passo successivo è quello di applicare la massa e la quantità di moto ( 2 leggi fisiche ).

La massa è una proprietà fisica intrinseca di ciascun corpo e indipendente da ciò che lo circonda e dal metodo adoperato per misurarla.
La quantità di moto, detta anche momento lineare o semplicemente momento, è una grandezza vettoriale che misura la capacità di un corpo di modificare il movimento di altri corpi con cui interagisce dinamicamente. È una grandezza utile quando vengono trattati urti e reazioni.

Cosa centra tutto questo con Flash ?
Semplice, per simulare degli urti tra 2 MovieClip e scatenare una reazione che simuli il più possibile ciò che avverrebbe nella realtà abbiamo bisogno di applicare le leggi fisiche della massa e della quantità di moto con Actionscript 3.0 .

Quando pensiamo alla massa corporea di un corpo, ci viene da associarla al peso del corpo ed effettivamente sono 2 cose che vanno di pari passo in quanto il peso è proporzionale alla masa.
Più la massa del corpo è maggiore più il peso del corpo sarà maggiore.
Tecnicamente parlando, la massa di un oggetto è la misurazione di quanto questo oggetto resiste sottoponendolo a cambiamenti di velocità.
Quindi, più la massa dell' oggetto è grande e più sarà difficile muovere quell' oggetto o cambiarne le sue direzioni di movimento.
Inoltre, la massa si relaziona anche all' accelerazione e alla forza: più la massa è grande più la forza sarà grande per aumentare l' accelerazione dell' oggetto.

La Quantità di movimento è il risultato del prodotto di una massa di un oggetto per la sua velocità.
In sostanza è il tempo di velocità della massa.
La legge fisica della Quantità di moto dice:

P = M * V

dove P è la Quantità di moto, M è la massa e V la velocità.
Questo significa che una piccola massa ed un' alta velocità possono avere una simile Quantità di movimento di una grande massa ed una piccola velocità.
Per citare un paragone concreto, un autobus che viaggia alla velocità di 30 km orari può facilmente uccidermi tanto quanto può farlo una piccola pallottola che viaggia a velocità altissima.
Dato che la velocità è definita in fisica come un vettore, anche la Quantità di moto è un vettore.
Per definire completamente la Quantità di moto, possiamo dire qualcosa del genere:

5 kg * 20 m/s con 23 gradi

Adesso entriamo nel succo del tutorial: la conservazione della Quantità di moto.
Cosa significa ? Come si fa a conservare una quantità di moto ? Quando ? Perchè ?
La conservazione della Quantità di moto trova tantissime applicazioni con le collisioni ( concetto Actionscript con il quale a questo punto dovreste essere familiari ), in quanto abbiamo visto fino ad ora come intercettare la collisione tra oggetti con Actionscript 3.0 ma non abbiamo ancora scatenato una reazione data appunto da tale collisione.
Come ogni collisione reale, vogliamo che anche con Actionscript avvenga un urto e quindi una reazione di importanza proporzionale all' urto avvenuto.
La conservazione della Quantità di moto è esattamente il principio di cui abbiamo bisogno per avere una reazione di risposta alla collisione il più realistica possibile.
Ad esempio, se abbiamo due MovieClip che si muovo rispettivamente a velocità A e B e ad una direzione C e D. Quando avviene la collisione e quindi l' urto, le 2 MovieClip dovranno muoversi ( dopo l' urto ) con delle velocità e direzioni nuove in base appunto all' impatto e alle forze che entrano in campo al momento della collisione.
Per fare questo dobbiamo conoscere la masa di entrambi gli oggetti e quindi ... come si fa ad applicare una massa ad una MovieClip ?
Semplicemente creando una nuova proprietà alla MovieClip e assegnandole un valore in proporzione alla sua grandezza di width/heigth oppure di scaleX/scaleY.

La legge della conservazione della Quantità di moto dice che la quantità di moto totale di un sistema prima di una collisione sarà uguale alla quantità di moto dopo la collisione.
Quindi, la somma delle Quantità di moto dei nostri oggetti prima della collsione sarà uguale alla somma delle Quantità di moto degli stessi oggetti dopo la collisione:
Per cui:

Q1 + Q2 = QF1 + QF2

dove Q1 e Q2 stanno per le Quantità di moto dei nostri oggetti prima della collisione mentre QF1 e QF2 sono le Quantità di moto dei nostri oggetti dopo la collisione.

Adesso, quello che vogliamo conoscere è la velocità finale di ognuno dei nostri oggetti che chiameremo come VF1 e VF2:
La formula che ci permette di risolvere questa equazione è quella dell' energia cinetica:

KE = 0.5 * M * V alla seconda

Dato che l' energia cinetica rimane la stessa sia prima della collisione che dopo, allora possiamo interpretare questa formula ne seguente modo:

KE1 + KE2 = KE1F + KE2F

e quindi

( 0.5 * M1 * V1 alla seconda ) + ( 0.5 * M2 * V2 alla seconda ) = ( 0.5 * M1 * VF1 alla seconda ) + ( 0.5 * M2 * VF2 alla seconda )

e possiamo eliminare i 0.5 in questo modo

( M1 * V1 alla seconda ) + ( M2 * V2 alla seconda ) = ( M1 * VF1 alla seconda ) + ( M2 * VF2 alla seconda )

E infine finalmente calcoliamo le velocità finali

VF1 = ( M1 - M2 ) * V1 + 2 * M2 * V2 / M1 + M2

VF2 = ( M2 - M1 ) * V2 + 2 * M1 * V1 / M1 + M2

Passiamo ora ad Actionscript.
Creo un nuovo FLA che salvo con nome ' main.fla '.
Al suo interno creo una MovieClip con forma circolare e gli assegno nome in libreria ' mc_ball '.
Istanzio 2 volta la MovieClip sullo stage e assegno rispettivamente i nomi istanze ball_1_mc e ball_2_mc.

Creo la Document Class, un file AS che salvo con nome ' main.as ', implementata in questo modo:

package
{
	import flash.display.MovieClip;
	import flash.events.Event;
	
	public class Main extends MovieClip
	{
		public function Main()
		{
			init();
		}
		
		private function init():void
		{
			stage.frameRate=31;
			
			scaleBalls();
			positionBalls();
			giveMassAndVelocity();
			
			addEventListener(Event.ENTER_FRAME,moveBalls);
		}
		
		private function scaleBalls():void
		{
			ball_1_mc.scaleX=.5;
			ball_1_mc.scaleY=.5;
		}
		
		private function positionBalls():void
		{
			ball_1_mc.x=-ball_1_mc.width/2;
			ball_1_mc.y=stage.stageHeight/2;
			
			ball_2_mc.x=stage.stageWidth+ball_2_mc.width/2;
			ball_2_mc.y=ball_1_mc.y;
		}
		
		private function giveMassAndVelocity():void
		{
			ball_1_mc.vx=1;
			ball_1_mc.mass=ball_1_mc.scaleX*2;
			
			ball_2_mc.vx=-1;
			ball_2_mc.mass=ball_2_mc.scaleX*2;
		}
		
		private function moveBalls(evt:Event):void
		{
			ball_1_mc.x+=ball_1_mc.vx;
			ball_2_mc.x+=ball_2_mc.vx;
			
			var distance:Number=ball_2_mc.x-ball_1_mc.x;
			if(Math.abs(distance)< ball_1_mc.width/2+ball_2_mc.width/2)
			{
				var vx0Final:Number=((ball_1_mc.mass-ball_2_mc.mass)*ball_1_mc.vx+2*ball_2_mc.mass*ball_2_mc.vx)/(ball_1_mc.mass+ball_2_mc.mass);
				var vx1Final:Number=((ball_2_mc.mass-ball_1_mc.mass)*ball_2_mc.vx+2*ball_1_mc.mass*ball_1_mc.vx)/(ball_1_mc.mass+ball_2_mc.mass);
				ball_1_mc.vx=vx0Final;
				ball_2_mc.vx=vx1Final;
				
				ball_1_mc.x+=ball_1_mc.vx;
				ball_2_mc.x+=ball_2_mc.vx;
			}
		}
	}
}

ed ecco il risultato:

Analizziamo il codice:

Funzione Costruttrice
chiamo il metodo init

Metodi

init();
imposto una velocità di framerate
stage.frameRate=31;
chiamo il metodo scaleBalls che assegnerà uno scaleX e scaleY alle 2 MovieClip
scaleBalls();
chiamo il metodo positionBalls che posiziona la MovieClip
positionBalls();
chiamo il metodo giveMassAndVelocity che assegna una masa ed una velocità ad ogni MovieClip
giveMassAndVelocity();
attivo un ENTER_FRAME chiamando il metodo moveBalls che muoverà la MovieClip
addEventListener(Event.ENTER_FRAME,moveBalls);

scaleBalls();
dimezzo scaleX e scaleY di ball_1_mc
ball_1_mc.scaleX=.5;
ball_1_mc.scaleY=.5;

positionBalls();
posiziono le MovieClip
ball_1_mc.x=-ball_1_mc.width/2;
ball_1_mc.y=stage.stageHeight/2;

ball_2_mc.x=stage.stageWidth+ball_2_mc.width/2;
ball_2_mc.y=ball_1_mc.y;

giveMassAndVelocity();
creo due proprietà per ogni MovieClip. Una la chiamo vx e contiene il valore della velocità e l' latra la chiamo mass che contiene il valore della massa
ball_1_mc.vx=1;
ball_1_mc.mass=ball_1_mc.scaleX*2;

ball_2_mc.vx=-1;
ball_2_mc.mass=ball_2_mc.scaleX*2;

moveBalls();
aggiungo le velocità alla x delle MovieClip
ball_1_mc.x+=ball_1_mc.vx;
ball_2_mc.x+=ball_2_mc.vx;
controllo la collisione
var distance:Number=ball_2_mc.x-ball_1_mc.x;
if(Math.abs(distance)< ball_1_mc.width/2+ball_2_mc.width/2)
{
quando collidono applico la formula che abbiamo visto
var vx0Final:Number=((ball_1_mc.mass-ball_2_mc.mass)*ball_1_mc.vx+2*ball_2_mc.mass*ball _2_mc.vx)/(ball_1_mc.mass+ball_2_mc.mass);
var vx1Final:Number=((ball_2_mc.mass-ball_1_mc.mass)*ball_2_mc.vx+2*ball_1_mc.mass*ball _1_mc.vx)/(ball_1_mc.mass+ball_2_mc.mass);
assegno una nuova velocità di uscita
ball_1_mc.vx=vx0Final;
ball_2_mc.vx=vx1Final;
aggungo la nuova velocità alle x delle MovieClip
ball_1_mc.x+=ball_1_mc.vx;
ball_2_mc.x+=ball_2_mc.vx;
}

Alla prossima !