Code Vonc

Physique 2D élémentaire

CommentairesComments
Sans transition

Boucle
cible = souris
Transition progressive


Initialisation
cible = souris

Boucle
cible += (souris - cible) * rapidite
Transition élastique


Initialisation
cible = souris
vitesse = 0

Boucle
vitesse = (vitesse + (souris - cible) * rapidite) * elasticite
cible += vitesse
Suivi rigide


Boucle
direction = (cible - souris).getNormalized()
cible = souris + direction * longueur
Suivi souple


Boucle
difference = cible - souris
longueurDiff = difference.getLength()

direction = Vector()
if (longueurDiff > 0) direction = difference / longueurDiff

longueurCible = longueur
if (longueur > longueurDiff) longueurCible = longueurDiff;

cible = souris + direction * longueurCible
Suivi rigide élastique


Initialisation
cible = souris
vitesse = 0

Boucle
direction = (cible - souris).getNormalized()
destination = souris + (direction * longueur)
vitesse = (vitesse + (destination - cible) * rapidite) * elasticite
cible += vitesse
Gravité et inertie


Initialisation
cible = souris
vitesse = 0

Boucle
destination = cible + vitesse + gravite

vitesse = destination - cible
vitesse *= friction

cible = destination

Cliquez pour lancer la bille.
Liaison souple avec inertie et gravité


Initialisation
cible = souris
vitesse = 0
attache = true

Boucle
destination = cible + vitesse + gravite

difference = destination - souris
longueurDiff = difference.getLength()

if (attache && longueurDiff >= longueur) {
	
	direction = difference.getNormalized()
	destination = souris + (direction * longueur);
}
			
vitesse = destination - cible
vitesse *= friction

cible = destination
Liaison avec inertie, masse et gravité

Initialisation
cible = souris
vitesse = 0
attache = true

Boucle
destination = cible + vitesse + gravite

difference = destination - souris
longueurDiff = difference.getLength()

deplacement = (cible - destination).getNormalized()
destinationLiee = destination

if (attache && longueurDiff >= longueur) {
	
	direction = difference.getNormalized()
	destinationLiee = souris + (direction * longueur);
}

liaison = destinationLiee - destination
destination += liaison

vitesse = destination - cible

inertie = vitesse.getNormalized() * masse * (deplacement • liaison)

vitesse += inertie
vitesse *= friction

cible = destination


Liaison élastique avec inertie et gravité

Initialisation
cible = souris
vitesse = 0
attache = true
elasticiteVitesse = 0

Boucle
destination = cible + vitesse + gravite

difference = destination - souris
longueurDiff = difference.getLength()

if (attache && longueurDiff >= longueur) {
	
	direction = difference.getNormalized()
	
	destinationLiee = souris + (direction * longueur)
	liaison = destinationLiee - destination
	
	elasticiteVitesse += liaison * elasticite
	elasticiteVitesse *= rapidite
	destination += elasticiteVitesse
}
			
vitesse = destination - cible
vitesse *= friction

cible = destination


Corde avec inertie et gravité

Initialisation
attache = true

points = [
	{ x : 0, y : 0 },
	{ x : 20, y : 0 },
	{ x : 40, y : 0 },
	{ x : 60, y : 0 },
	{ x : 80, y : 0 },
	{ x : 100, y : 0 },
	{ x : 120, y : 0 },
	{ x : 140, y : 0 },
	{ x : 160, y : 0 },
	{ x : 180, y : 0 },
	{ x : 200, y : 0 },
	{ x : 220, y : 0 },
	{ x : 240, y : 0 },
	{ x : 260, y : 0 },
]
		
// Liens de chaque point (exemple : le point 1 est lié au point 0 et au point 2).
// Les longueurs pourraient être factorisées pour gagner en mémoire
liens = [
	[{ 'id' :  1, 'long' : 20 }],
	[{ 'id' :  0, 'long' : 20 },  { 'id' :  2, 'long' : 20 }],
	[{ 'id' :  1, 'long' : 20 },  { 'id' :  3, 'long' : 20 }],
	[{ 'id' :  2, 'long' : 20 },  { 'id' :  4, 'long' : 20 }],
	[{ 'id' :  3, 'long' : 20 },  { 'id' :  5, 'long' : 20 }],
	[{ 'id' :  4, 'long' : 20 },  { 'id' :  6, 'long' : 20 }],
	[{ 'id' :  5, 'long' : 20 },  { 'id' :  7, 'long' : 20 }],
	[{ 'id' :  6, 'long' : 20 },  { 'id' :  8, 'long' : 20 }],
	[{ 'id' :  7, 'long' : 20 },  { 'id' :  9, 'long' : 20 }],
	[{ 'id' :  8, 'long' : 20 },  { 'id' :  10, 'long' : 20 }],
	[{ 'id' :  9, 'long' : 20 },  { 'id' :  11, 'long' : 20 }],
	[{ 'id' :  10, 'long' : 20 },  { 'id' :  12, 'long' : 20 }],
	[{ 'id' :  11, 'long' : 20 },  { 'id' :  13, 'long' : 20 }],
	[{ 'id' :  12, 'long' : 20 }],
]

// Vitesse des points
vitesses = [
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
]

// Position des points avant le calcul de la liaison
pointsAvantLiaisons = [ 
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
]

// Position finale des points
pointsApresLiaisons = [ 
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
]

Boucle

nb = points.length;

// Forces

for (i = 0 ; i < nb ; i++) {
	
	pointsAvantLiaisons[i] = points[i] + vitesses[i] + gravite
	
	if (i === 0 && attache) {
		points[i] = souris
		pointsAvantLiaisons[i] = souris
	}
}

// Liaisons
			
for (k = 0 ; k < 20 ; k++) { // 20 = itérations pour l'approximation du calcul des liaisons

	for (i = 0 ; i < nb ; i++) {
		
		pointAvantLiaisons = pointsAvantLiaisons[i]
		liensPoint = liens[i]
		
		pointAvecLiaison = { x : 0, y : 0 }
		direction = { x : 0, y : 0 }
		liaison = { x : 0, y : 0 }
		liaisonMoyenne = { x : 0, y : 0 }
		liensNb = liensPoint.length
		
		for (lien in liensPoint) {
			
			lienPoint = pointsAvantLiaisons[lien.id]
			
			direction = pointAvantLiaisons - lienPoint
			direction.normalize()
			
			pointAvecLiaison = lienPoint + direction * lien.long
			
			liaison = pointAvecLiaison - pointAvantLiaisons
			liaisonMoyenne += liaison
		}
		
		
		if (liensNb > 0) {
			liaisonMoyenne /= liensNb
			pointsApresLiaisons[i] = pointAvantLiaisons + liaisonMoyenne
		}
		
		
		if (i === 0 && attache) {
			pointsApresLiaisons[i] = souris
		}
	}
	
	for (i = 0 ; i < nb ; i++) {
		pointsAvantLiaisons[i] = pointsApresLiaisons[i]
	}
}

// Finalisation

for (i = 0 ; i < nb ; i++) {
	
	pointApresLiaisons = pointsApresLiaisons[i]
	
	vitesses[i] = pointApresLiaisons - points[i]
	points[i] = pointApresLiaisons;
}