Pour l’essayer, il vous faut PySFML >= 1.5 et pymunk et ensuite un petit svn co svn://svn.tuxfamily.org/svnroot/remi/dev/wuispet1 et c’est parti. Il y a le jeu et un éditeur de cartes, qui permet également de modifier le graphe des chemins utilisé par l’algorithme de path finding (ouaip, découper l’espace en petits carrés et y aller à gros coups de dijkstra, c’est assez moyen niveau temps / performances). Bon il y a encore pas mal de boulot à faire… Notamment au niveau des graphismes (qui se limitent pour l’instant à des cercles et des traits).

Capture d'écran des balles rebondissantes en action

Depuis environ un an, je maintiens PySFML, le binding python de SFML, une librairie multimédia vraiment cool. Elle donne facilement accès à tous les périphériques, utilise l’accélération graphique et permet de développer facilement et rapidement des applications 2D.
PySFML rend cette librairie accessible au langage de programmation python, qui est très simple à apprendre et qui permet de développer des applications très rapidement.

Aujourd’hui je vous présente un petit programme exemple de balles rebondissantes, assez simple, avec moins de 240 lignes de code. Les balles ont des tailles, masses et pénétrations dans l’air différentes, et c’est assez amusant à voir en action. Le terrain est une simple image png que tu peux éditer.
Dans le programme, tu peux appuyer sur + pour faire apparaitre d’autres balles et sur enter pour redonner de l’énergie à une balle au hasard.

Téléchargement : sources (tu auras besoin de python et pysfml version >= 1.3).
Tu peux aussi directement faire un checkout du dépôt svn : svn co svn://svn.tuxfamily.org/svnroot/remi/dev/bouncing_ball bouncing_ball

Il ne te reste qu’à double cliquer sur main.py et à lire la suite.

Je vais ici présenter un peu plus en détail certains aspects du code.

En rouge foncé : la carte originale, en rouge et vert : la carte approximative.

1) Les collisions avec la carte (map.py)

Lors de l’initialisation, une carte approximative est créée (ligne 23, méthode GenerateRoughMap). Pour faire cette carte, c’est très simple. On quadrille la vraie carte avec des cases d’une taille fixée, par exemple 32×32. Chacune de ces cases est représentée par un booléen : True si la case contient des pixels opaques, False si elle est entièrement transparente. Ainsi, pour faire un test de collision, on commence par vérifier si le bounding box de l’objet est en collision avec la carte approximative (ligne 34, méthode RoughlyCheckCollision). Ce test est très rapide, et au cas où la collision est détectée, il ne reste plus qu’à effectuer un test plus précis, qui va également permettre de calculer la normale du mur au point de contact.

Ce deuxième test est simple : on va prendre un certain nombre de points sur le périmètre du cercle, et vérifier si la carte y est transparente ou non. En connaissant les deux points limites (ceux en jaune sur l’illustration), on peut calculer la normale (la flèche noire). (ligne 48, méthode CheckCollision.)

Collision entre une balle et un mur.

Tu remarqueras peut être que les balles deviennent blanches près des murs. Elles deviennent en fait blanches dès que RoughlyCheckCollision a détecté une collision.

J’ai aussi fait un algo de QuadTree, mais il n’est pas vraiment adapté à la situation et je ne l’ai donc pas gardé, mais il n’empêche que c’est un concept que j’aime bien.

2) Les rebonds (ball.py)

Dans ball.py, la position, la vitesse et l’accélération sont représentés par des nombres complexes, ce qui raccourci pas mal le code. Pour les rebonds avec la carte (ligne 45, méthode Bounce), ça tient en 2 lignes, un peu plus pour la collision entre deux balles (ligne 53, méthode CheckCollision).

Oui je sais, l'interface de Blender fait peur

Le A comporte très exactement 42 points (j’ai même pas fait exprès), 87 arrêtes et 45 faces. Il a une armature constituée de 8 os : deux pour contrôler la partie supérieure (au dessus de la barre), et de chaque côté il y a la cuisse, la jambe et le pied. J’ai définit un mouvement de marche, et un path (chemin) que le A doit suivre.

Les différents niveaux de subsurf

Quand on regarde la vidéo, on n’a pas l’impression qu’il n’y a que 42 points. En fait il y en a beaucoup plus puisque j’utilise un subsuf (Subsurface Scattering) qui divise chaque surface en plusieurs sous surfaces, on a ainsi un A aux formes lisses et arrondies (voir l’animation à droite).
Je précise également que j’utilise des shaders du type toon, ce qui fait des ombres net, sans dégradés et avec l’option edge, les arrêtes sont mises en valeur, afin de créer un effet dessin animé.

Si tu veux aussi essayer de faire un truc dans le genre, voici quelques liens:

• Blender, site du logiciel d’animation, avec des tutoriaux;
• Tutorial pour créer un walkcycle, malheureusement pour blender 2.3;
• Tu peux jeter un œil au ManCandy;
• Tu peux aussi télécharger le .blend de mon animation;
• Enfin tu peux trouver pleins de tutoriaux sur internet : wikibook, blender clan, et bien d’autres.

Have fun

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

#include <stdio.h>
#include <string.h>
 
#define TAILLE_TABLEAU	111
#define TAILLE_MOT	64 // taille maximale du mot à chercher
char tableau[TAILLE_TABLEAU][3] = {"h", "he", "li", "be", "b", "c", "n", 
"o", "f", "ne", "na", "mg", "al", "si", "p", "s", "cl", "ar", "k", "ca", 
"sc", "ti", "v", "cr", "mn", "fe", "co", "ni", "cu", "zn", "ga", "ge", 
"as", "se", "br", "kr", "rb", "sr", "y", "zr", "nb", "mo", "tc", "ru", 
"rh", "pd", "ag", "cd", "in", "sn", "sb", "te", "i", "xe", "cs", "ba", 
"la", "ce", "pr", "nd", "pm", "sm", "eu", "gd", "tb", "dy", "ho", "er", 
"tm", "yb", "lu", "hf", "ta", "w", "re", "os", "ir", "pt", "au", "hg", 
"tl", "pb", "bi", "po", "at", "rn", "fr", "ra", "ac", "th", "pa", "u", 
"np", "pu", "am", "cm", "bk", "cf", "es", "fm", "md", "no", "lr", "rf", 
"db", "sg", "bh", "hs", "mt", "ds", "rg"};
 
// Note: liste contient des listes de numéros atomiques, mais comme c'est un tableau de char
// qui finit par 0 (aucun élément chimique n'a pour numéro 0), il suffit de faire un strlen
// pour savoir le nombre d'éléments d'une liste ou strcpy pour la copier.
 
unsigned int elchi(char *mot, unsigned char *liste)
{
	unsigned int i;
	unsigned int resultat = 0;
	if (mot[0] == 0)
		return 1;
	for (i=0;i<TAILLE_TABLEAU;i++)
	{
		if (tableau[i][0] == mot[0])
		{
			unsigned int resultat_local = 0;
			if (tableau[i][1]==0) // c'est un élément à un caractère
			{
				resultat_local = elchi(mot+1, liste+resultat*TAILLE_MOT+1);
			}
			else if (strlen(mot) >= 2)
			{
				if (tableau[i][1]==mot[1]) // élément à deux caractères
				{
					resultat_local = elchi(mot+2, liste+resultat*TAILLE_MOT+1);
				}
			}
			if (resultat_local) // il y a un résultat pour l'élément i
			{
				if (resultat) // on avait déjà trouvé un autre résultat avant
				{
					if (strlen((char *)(liste+TAILLE_MOT+1)) < strlen((char *)(liste+1))) // si le nouveau résultat est plus court, on l'utilise
					{
						strcpy((char *)(liste+1), (char *)(liste+TAILLE_MOT+1));
						*(liste) = i+1;
					} // sinon on l'oublie
				}
				else // c'est le premier résultat qu'on trouve
				{
					*(liste) = i+1;
					resultat++;
				}
			}
		}
	}
	return resultat; // en pratique, il y a 0 ou 1 résultat, puisqu'on ne garde que le résultat le plus court
}
 
int main()
{
	char mot[TAILLE_MOT];
	unsigned char liste[TAILLE_MOT*TAILLE_MOT];
	unsigned int i=0;
	memset(liste, 0, TAILLE_MOT*TAILLE_MOT);
	while (scanf("%s", mot) == 1)
	{
		if (elchi(mot, liste))
		{
			printf("%s: ", mot);
			for (i=0;*(liste+i)!=0;i++)
			{
				printf("%d ", *(liste+i));
			}
			printf("
");
		}
		memset(liste, 0, TAILLE_MOT*TAILLE_MOT);
	}
	return 0;
}

La fonction est bien sûr récursive, et lorsqu’il y a plusieurs résultats, seul le plus court est gardé. S’il y a plusieurs résultats de la même longueur, un seul est gardé.
Pour le compiler, il suffit de faire un petit :
# gcc -Wall -O3 el_chim.c -o el_chim
Puis pour traduire le dico et connaître le temps que cela prend :
# time el_chim < /usr/share/dict/french > mots
Note: le code traduit tous les mots un à un (ou du moins tout ce que scanf considère comme étant un mot) et affiche les résultats sur la sortie standard, jusqu’à EOF (End Of File ou Ctrl-D dans un terminal). J’ai un P4 à 3Ghz, voici le résultat :
real 0m0.431s
user 0m0.388s
sys 0m0.008s
Pour connaitre le nombre de mots traduits (affiche le nombre de lignes):
# wc -l mots

Au début j’avais programmé ça en TI-Basic sur ma Ti-89, ça prenait en général plus de 30 secondes pour traduire un seul mot. Voilà, je me suis bien amusé

Tu peux laisser des commentaires si tu t’ennuies.