Projet Xmas Rapport de projet

Transcription

Projet Xmas
Rapport de projet
Rapport rédigé par :
Stéphane
Alexandra
Florent
Jean Alexandre
PROTIN
VALAKHANOVICH
RÉTIF
IRAGNE
Rapport rendu le :
26 juin 2003
1
(Sasha)
(Tiboo)
(Adelskott)
Table des matières
1 Introduction
1.1
1.2
1.3
1.4
1.5
Présentation des membres survivants . . . . . . . . . . . .
Histoire du jeu . . . . . . . . . . . . . . . . . . . . . . . .
1.2.1 D'où provient l'idée ? . . . . . . . . . . . . . . . .
1.2.2 Histoire dénitive . . . . . . . . . . . . . . . . . . .
Reprise du cahier des charges . . . . . . . . . . . . . . . .
1.3.1 Nature du projet . . . . . . . . . . . . . . . . . . .
1.3.2 Répartition des taches : . . . . . . . . . . . . . . .
Bref rappels des diérentes soutenances . . . . . . . . . .
1.4.1 Première soutenance . . . . . . . . . . . . . . . . .
1.4.2 Deuxième soutenance . . . . . . . . . . . . . . . .
1.4.3 Troisième soutenance . . . . . . . . . . . . . . . . .
De la troisième à la dernière soutenance . . . . . . . . . .
1.5.1 Avancement des diérentes parties par rapport à la
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
soutenance préédente
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Importance des Inputs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fonctionnalité de DirectInput . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.1 DirectInput et DirectInputDevice sont initialisés en assurant les phases suivantes
3.3.2 Introduction aux diérentes fonctions . . . . . . . . . . . . . . . . . . . . . . . .
Récupération des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.1 Cas du clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.2 Cas de la souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Résumé des soutenances précédentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.1 Pour la première soutenance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.2 Pour la seconde soutenance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.3 Pour la troisième soutenance . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
2 Moteur 3D
2.1
2.2
2.3
2.4
La conception de la map . . . . .
2.1.1 La structure . . . . . . . .
2.1.2 L'initialisation . . . . . .
Le principe d'achage . . . . . .
2.2.1 Le principe utilisé . . . .
2.2.2 Les erreurs possibles . . .
2.2.3 L'utilisation des splashes .
2.2.4 Les Fps : . . . . . . . . .
Les objets MD3 . . . . . . . . . .
2.3.1 La lecture . . . . . . . . .
2.3.2 L'init . . . . . . . . . . .
Les objets obj . . . . . . . . . . .
2.4.1 La lecture . . . . . . . . .
2.4.2 L'initialisation . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 DirectInput
3.1
3.2
3.3
3.4
3.5
4 Mapping
4.1
4.2
4.3
Introduction . . . . . . . . . . . . . . . . . . . . . . .
Il y a plusieurs étapes dans la création des objets . .
4.2.1 La création du model géométrique de la scène
4.2.2 Application pratique . . . . . . . . . . . . . .
4.2.3 La préparation des textures . . . . . . . . . .
Évolution du mapping au cours de l'année . . . . . .
4.3.1 Vers la première soutenance . . . . . . . . . .
4.3.2 Vers la seconde soutenance . . . . . . . . . .
4.3.3 Vers la troisième soutenance . . . . . . . . . .
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
6
6
6
6
7
7
7
8
8
8
9
10
10
11
11
11
11
12
12
12
13
14
14
14
14
15
15
16
17
17
17
17
17
18
18
18
19
20
20
20
21
22
22
22
22
23
24
24
24
24
25
4.3.4
Vers la soutenance nale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 Musique
5.1
5.2
5.3
Les tâches accomplies . . . . . . . . . . . . . . . . . .
5.1.1 Les intérêts du son dans un jeu . . . . . . . . .
5.1.2 Recherche des sons et musiques . . . . . . . . .
5.1.3 Choix des sons initiaux : . . . . . . . . . . . . .
5.1.4 Détails des musiques initialement choisies : . .
5.1.5 Évolution et Implémentation . . . . . . . . . .
5.1.6 Un mur de problèmes : . . . . . . . . . . . . . .
Du nouveau ... et du beau ! : . . . . . . . . . . . . . . .
5.2.1 Le son du Menu Principal à mettre en boucle :
5.2.2 La lenteur de la rafale de tir : . . . . . . . . . .
5.2.3 Du changement dans le code . . . . . . . . . .
5.2.4 Une nouvelle idée ; du son 3D : . . . . . . . . .
5.2.5 Les sons choisis . . . . . . . . . . . . . . . . . .
5.2.6 Les musiques choisies : . . . . . . . . . . . . . .
Conclusion . . . . . . . . . . . . . . . . . . . . . . . .
6 Vidéos
6.1
6.2
6.3
Scenario : . . . . . . . . . . . . . . . . . . . . .
Vidéo : . . . . . . . . . . . . . . . . . . . . . . .
6.2.1 Mise en place de la scène avec 3ds max :
6.2.2 La création de l'animation : . . . . . . .
En conclusion : . . . . . . . . . . . . . . . . . .
7.2
8.2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Ce qui avait déjà été fait . . . . . . . . . . . . . .
8.1.1 Première approche . . . . . . . . . . . . .
8.1.2 Les domaines de l'Intelligence Articielle .
8.1.3 Les premières lignes de code . . . . . . . .
8.1.4 Les collisions Ennemis/map : . . . . . . .
Une Intelligence Articielle peaunée . . . . . . .
8.2.1 Int
gration dans le jeu . . . . . . . . . . .
8.2.2 Les collisions avec les .bmp . . . . . . . .
8.2.3 Manque de jouabilité à corriger . . . . . .
8.2.4 des collisions en mouvement . . . . . . . .
8.2.5 L'attaque . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Les dernières modications : . . . . . . . . . . .
7.1.1 Les sauvegardes : . . . . . . . . . . . . .
7.1.2 L'accès au site web : . . . . . . . . . . .
Le fonctionnement de l'interface : . . . . . . . .
7.2.1 Les diérents composants Delphi utilisés
7.2.2 Fonctionnement de la pile : . . . . . . .
7.2.3 Avantages de notre interface : . . . . . .
7.2.4 les boutons : . . . . . . . . . . . . . . .
9 Installation / Désinstallation
9.1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8 Intelligence Articielle
8.1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7 Achage
7.1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Installation . . . . . . . . . . . . . . . . . . . . .
9.1.1 Saisie . . . . . . . . . . . . . . . . . . . .
9.1.2 Ressources . . . . . . . . . . . . . . . . .
9.1.3 Application pratique . . . . . . . . . . . .
9.1.4 Les points importants . . . . . . . . . . .
9.1.5 Les diérentes installations possibles . . .
9.1.6 Diérence version lite et version normale
3
25
26
26
26
26
26
27
27
28
28
28
29
29
30
30
31
32
33
33
33
33
34
36
37
37
37
37
37
37
37
38
38
40
40
40
40
41
42
42
42
42
43
43
44
45
45
45
45
46
47
47
47
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Intérêt d'un site Internet . . . . . . . . . . . . .
Découpage du site Internet . . . . . . . . . . .
Logiciels utilisés, et apprentissage . . . . . . . .
Les diérentes parties du site Internet . . . . .
10.4.1 Présentation du projet . . . . . . . . . .
10.4.2 Liens . . . . . . . . . . . . . . . . . . . .
10.4.3 Download . . . . . . . . . . . . . . . . .
10.4.4 Espace concepteurs . . . . . . . . . . . .
10.4.5 Forums . . . . . . . . . . . . . . . . . .
10.5 Les événements majeurs de son développement
10.5.1 La première soutenance . . . . . . . . .
10.5.2 La seconde soutenance . . . . . . . . . .
10.5.3 La troisième soutenance . . . . . . . . .
10.5.4 La soutenance nale . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9.2
9.3
9.1.7 Préparation de la désinstallation
Désinstallation . . . . . . . . . . . . . .
9.2.1 Principe du programme . . . . .
Conclusion . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
10 Site Internet
10.1
10.2
10.3
10.4
11 Le générique
11.1 Le choix des musiques . . . .
11.2 Création du générique . . . .
11.2.1 L'image . . . . . . . .
11.2.2 Le Texte . . . . . . . .
11.3 Les problèmes rencontrés . .
11.3.1 La qualité des images
11.3.2 La synchronisation . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12.1 Bilan général de l'année . . . . . . . . .
12.1.1 Progression . . . . . . . . . . . .
12.1.2 Entente dans le groupe . . . . . .
12.1.3 Intéraction cours / projet . . . . .
12.2 Bilan par rapport au cahier des charges
12.3 Qui a fait exactement quoi ? . . . . . . .
12.3.1 Cahier des charges . . . . . . . .
12.3.2 1re soutenance . . . . . . . . . . .
12.3.3 2e soutenance . . . . . . . . . . .
12.3.4 3e soutenance . . . . . . . . . . .
12.3.5 Soutenance nale . . . . . . . . .
12.3.6 Conclusion . . . . . . . . . . . .
12.4 Récits de réalisation . . . . . . . . . . .
12.4.1 Nos joies . . . . . . . . . . . . .
12.4.2 Nos peines . . . . . . . . . . . .
12.5 Ouverture . . . . . . . . . . . . . . . . .
12.6 Remarques face aux jurys . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12 Conclusion
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13 Annexes
47
48
48
48
49
49
49
49
49
49
52
52
53
53
53
53
53
54
54
55
55
55
55
55
55
55
55
56
56
56
56
56
56
56
56
57
58
59
60
62
62
62
63
63
63
64
4
Table des gures
1
2
3
4
5
6
Photos des membres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Création de la vidéo de bonus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Création de la vidéo de bonus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exemple d'utilisation du programme (la poursuite) . . . . . . . . . . . . . . . . . . . .
Ce passage posait particulièrement problème (derrière le Père Noël, se trouvent la table
les chaises) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dessins d'origine du pèr noël . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
. .
. .
. .
. .
et
. .
. .
6
35
38
41
43
67
1 Introduction
Xmas (prononcez : Christmas ) est un jeu en trois dimensions de type FPS (First Person Computer),
exécutable uniquement sur PC (Personal Computer) équipés de Windows, et dont le but est d'eectuer
une mission. Le joueur incarne le Père Noël qui, une nuit de Noël, après la distribution de ses cadeaux,
puis le mystérieux vol de ces derniers, doit retrouver le responsable de cet acte odieux pour lui donner
une bonne correction et récupérer ses cadeaux an de les rendre aux enfants.
1.1 Présentation des membres survivants
Jean-Alexandre Iragne
Stéphane Protin
Florent Rétif
Alexandra Valakhanovich
Fig.
1 Photos des membres
Depuis le début, notre groupe n'a subit aucune modication. les membres sont les mêmes depuis le
tout début du projet.
1.2 Histoire du jeu
1.2.1 D'où provient l'idée ?
Au départ, la recherche d'une inspiration pour le projet d'année fut dicile. La seule chose dont nous
étions sûr, était notre souhait de réaliser un jeu. Le premier choix fut de réaliser un jeu en 3 dimensions,
contrairement à la volonté d'Alexandra qui trouvais que cela représentait trop de travail1 .
Plusieurs choix d'histoire ont été proposés au départ. Lors de notre décision de réaliser un jeu en 3D
où le personnage principale serait le Père noël. Il a été chargé à Florent RÉTIF de réaliser l'histoire.
1.2.2 Histoire dénitive
Par une sublime nuit étoilée de Noël, un vieil homme, barbu, vêtu d'un grand manteau rouge, s'apprête,
comme chaque année, à faire le bonheur de tous les enfants de la planète. Ses lutins ont travaillé durement
toute l'année pour concevoir tous les jouets. Le traîneau est bientôt prêt. Une centaine de joyeux lutins
des glaces y disposent l'énorme sac de jouets alors qu'on équipe les rennes pour leur grande aventure.
Il est désormais temps de partir. Le Père Noël s'installe, et c'est partit ! Le magnique traîneau s'élève
dans les airs et s'éloigne dans les profondeurs du ciel de Décembre.
Au beau milieu de la nuit, le Père Noël s'approche d'un village. Tout est blanc et si calme : on n'entend
que le léger siement d'un vent recouvrant la campagne d'un épais manteau de ocons scintillants. Il
amorce sa descente vers la première maison et se pose délicatement sur le toit. Après s'être emparé de
quelques paquets, il entre dans la maison en se glissant dans la cheminée.
1 Elle n'avait pas tout à fait tord ! Quoique. . .
6
Il règne une ambiance très chaleureuse dans le salon. Plusieurs paires de chaussons ont été disposées
devant l'âtre, toute la maison est décorée de guirlandes multicolores, et un majestueux sapin trône au
centre de la pièce. Le Père Noël s'approche de l'arbre et dépose à son pied les cadeaux pour toute la
famille, puis, s'éclipse aussitôt.
Le gentil barbu repart et accomplit ainsi la même mission sans relâche dans chaque maison, de chaque
ville, de chaque pays (Ne me demandez pas comment il fait !). Une fois son dur labeur terminé, il rentre
regagner ses Pénates car le Noël prochain doit être préparé.
Le père Noël pensais que tout allais pour le mieux dans le meilleur des mondes ! Que ce Noël était
comme tous les autres : les enfants ont vécu un merveilleux moment en découvrant les cadeaux. Eh, bien
non ! Ce Noël, n'avait plus la dimension magique d'autrefois mais s'apparentait plutôt á une tragédie.
Aucun enfant, n'avait obtenu le moindre jouet ! Dès lors, une immense tristesse avait pris la place de
l'atmosphère de fête qui régnait comme chaque année. Que s'était-il passé ? Le Père Noël avait pourtant
bien accompli sa tâche. . .
Sans plus attendre, il ordonne à ses lutins-espions de recueillir toutes les informations nécessaires pour
savoir pourquoi les cadeaux se sont volatilisés. Il ne fallait tout de même pas rester les bras croisés.
L'avenir de Noël était en jeu ! Ils reviennent quelques jours plus tard. Les cadeaux avaient tous été
volés par un mystérieux personnage. Ce dernier se faisait appeler Père Fouettard. De plus, les lutins ont
réussi à savoir qu'il habitait quelque part, vers le nord. Maigres renseignements ! A quoi Petit Papa Noël
va devoir faire face. . .
Votre mission si vous l'acceptez, sera d'inltrer la base de l'ennemi et de l'éliminer, ainsi que de récupérer
tous les cadeaux. La discrétion est vivement conseillée. Cependant il n'est pas interdit de défoncer du
lutin maléque.
Ainsi pour mener á bien cette mission, vous disposerez d'un arsenal complet (à consommer sans modération). De vous dépend la perpétuité de la tradition de Noël et de la joie de quelques millions d'enfants.
Vous seul pourrez déjouer les desseins maléques du Père Fouettard pour que Noël reste à jamais la nuit
de tous les enchantements. . .
Bonne chance Père Noël.
1.3 Reprise du cahier des charges
1.3.1 Nature du projet
Il s'agit d'un jeu vidéo d'ordinateur utilisable sur des PC (Personal Computer) équipés du système
d'exploitation Windows. Le jeu est d'action/aventure à la troisième personne. Le but principal est d'effectuer une mission et non d'exterminer seulement tous les ennemis. Exemples de jeux du même genre :
Mission Impossible, Tomb Raider, etc. . .Le jeu est contrôlable avec la souris et le clavier.
1.3.2 Répartition des taches :
Moteur 3D : Florent RÉTIF et Jean-Alexandre IRAGNE
Mapping : Alexandra VALAKHANOVICH et Jean-Alexandre IRAGNE
Musique : Alexandra VALAKHANOVICH et Florent RÉTIF
Vidéo : Jean-Alexandre IRAGNE et Stéphane PROTIN
Input : Alexandra VALAKHANOVICH et Stéphane PROTIN
Intelligence Articielle : Florent RÉTIF et Stéphane PROTIN
Gestion de l'achage (score, niveau de vie) : Florent RÉTIF et Jean Alexandre IRAGNE
Installation : Alexandra VALAKHANOVICH et Stéphane PROTIN
Site Internet : Alexandra VALAKHANOVICH, Florent RÉTIF,
Jean-Alexandre IRAGNE et Stéphane PROTIN
7
1.4 Bref rappels des diérentes soutenances
Tout d'abord, il est à souligner que pour chaque soutenance, nous avions un peu d'avance par rapport
au planning du cahier des charges. Comment expliquer cette continuelle avance ? Le projet que nous avons
choisi nous a bien plus et passioné, nous n'avions donc aucun mal à nous motiver pour le travailler ! De
ce fait, Xmas est devenu un jeu à part entière, avec certes peu de niveau, mais une solide base derrière
et de bonnes capacités.
1.4.1 Première soutenance
Moteur 3D :
Le moteur avait, particulièrement grâce à Jean-Alexandre IRAGNE , mais aussi à Florent RÉTIF,
plutôt bien avancé ! Il était déjà capable de charger des objets et de les acher.
Mapping :
Pour cette première soutenance, une map d'essai avait été créé an de pouvoir faire des tests sur
notre moteur 3D. Également, le père noël avait été créé. Ces diérents objets avaient été réalisés par
Jean-Alexandre IRAGNE. De son coté, Alexandra VALAKHANOVICH n'avait fait qu'étudier le logiciel
3DS Max.
Input :
Alexandra VALAKHANOVICH et Stéphane PROTIN avaient lu dans le livre Delphi Graphics and
Game with DirectX écrit par John Ayres aux éditions Wordware Pushing, Inc. , les parties correspondant
à Direct Input. Des essais avaient été eectués mais sans réussite !
Intelligence Articielle :
Partie inconnue pour tous les membre du groupe, l'étude de ce que nous ferions sur l'Intelligence
Articielle s'est faite par Florent RÉTIF. Il a déterminé quelles méthodes seront utilisés dans le jeu pour
la gestion des ennemis.
Site Internet :
Entièrement conçue par Stéphane PROTIN, la première version du site Internet était déjà créée. On
y trouvait déjà les parties les plus importantes.
Vidéos :
Jean-Alexandre IRAGNE avait étudié la création des vidéos. Quant à Stéphane PROTIN, il avait
écrit les premiers scénarios des vidéos.
1.4.2 Deuxième soutenance
Moteur 3D :
Jean-Alexandre IRAGNE avait travaillé d'arrache-pied pour faire avancer le moteur, non pas dans sa
réalisation, mais dans son optimisation. Par ailleurs, il avait créé 3 loaders d'objets. De son côté Florent
RÉTIF essayait de le suivre, mais avec diculté.
Mapping :
De nouveaux objets ont été créés, un plus beau Père Noël avait été réalisé. Une texture pour le
Père Noël avait été faite par Jean-Alexandre IRAGNE et les objets avaient été réalisés par Alexandra
VALAKHANOVICH, mais corrigés par Jean-Alexandre IRAGNE.
Musique :
Florent RÉTIF s'était chargé pour cette soutenance de rééchir aux sons qui seraient placés dans le
jeu. Il avait ensuite eectué une recherche dans sa bibliothèque de sons. Jean-Alexandre IRAGNE s'était
chargé d'intégrer les premiers sons dans le jeu.
8
Inputs :
Stéphane PROTIN ne trouvant rien sur les Inputs, Alexandra VALAKHANOVICH s'était chargée
de trouver un exemple tout fait de Direct Input : Récuppération des entrées claviers et souris. JeanAlexandre IRAGNE et Stéphane PROTIN s'étaient occupés d'adapter, et, tant bien que mal, d'utiliser
le code brut téléchargé par Alexandra VALAKHANOVICH, ainsi que de l'intégrer au jeu.
Pour l'intelligence articielle, Florent RÉTIF s'était occupé de d'implémenter les algorithmes de la
poursuite et de la fuite, tandis que Stéphane PROTIN se chargeait de concevoir la vérication de l'attaque
suivant le champ de vision de l'ennemi.
Interface :
Jean-Alexandre IRAGNE s'était déjá occupé de créer l'interface d'accueil. Diverses choses y étaient
dès lors opérationnelles. En tout cas, toutes l'interface avait été pensée.
1.4.3 Troisième soutenance
Moteur 3D :
Pour terminer le moteur 3D et rendre un maximum uide le jeu, Jean-Alexandre IRAGNE a travaillé
sur de nombreuses choses, aussi bien concernant le moteur que les maps, etc. . .
Mapping :
Alexandra VALAKHANOVICH s'est occupée de créer des objets et de les trouver également déjà
conçus. Cependant, en majorité, Jean-Alexandre IRAGNE a dû retravailler ces objets pour y réduire le
nombre de facettes. Il en était de même pour la map dénitive.
Musique :
Florent RÉTIF s'est chargé de nir de réunir tous les sons du jeu. Il a également travaillé avec la
précieuse aide de Jean-Alexandre IRAGNE à l'intégration dans le jeu.
Inputs :
Le dernier bug qui subsistait dans les inputs a été trouvé par Jean-Alexandre IRAGNE, mais les
unités ont de plus étés retravaillées par lui même et Stéphane PROTIN.
Interface :
Jean-Alexandre IRAGNE a travaillé sur la nition de l'interface. Il l'a lui même entièrement termniné,
mis à part la fonction Charger et le lien vers notre site Internet.
Jean-Alexandre IRAGNE s'était occupé des collisions entre le héro et la map. Pendant ce temps,
Florent RÉTIF avait préparé les collisions entre la map et l'ennemi ; et Stéphane PROTIN avait implémenté les collisions ennemi-héros, préparé la gestion de plusieurs ennemis.
Vidéos :
Une bonne partie de ce qui est maintenant la vidéo de début avait était créée par Jean-Alexandre
IRAGNE et Stéphane PROTIN. Du moins, tous les mouvements de la caméra étaient fait.
Installation / Désinstallation :
L'esquisse du programme d'installation et celui de désinstallation avait été entièrement réalisé par
Stéphane PROTIN.
Site Internet :
Le site Internet avait fait peau neuve. Une interface d'accueil réalisée en Flash avait été créée par
Aurélie Debeyter2 avec la petite participation de Stéphane PROTIN.
2 La petite amie de Jean-Alexandre IRAGNE
9
1.5 De la troisième à la dernière soutenance
1.5.1 Avancement des diérentes parties par rapport à la soutenance préédente
Mapping :
Alexandra VALAKHANOVICH a créée une seconde map de jeu. Toutes les erreurs de map ont été
corrigées par Jean-Alexandre IRAGNE.
Musique :
Florent RÉTIF et Jean-Alexandre IRAGNE ont corrigé un bug sur le son et ont developpé un son en
3 Dimensions.
Jean-Alexandre IRAGNE et Stéphane PROTIN se sont occupés de l'integration de l'Intelligence Articielle. Florent RÉTIF est ensuite venu y apporter sa contribution. Plusieurs nouvelles choses ont été
développés.
Vidéo :
Jean-Alexandre IRAGNE et Stéphane PROTIN ont terminé la vidéo d'accueil. Ils ont même créé une
autre vidéo (bonus). . .
Installation / Désinstallation :
Ces deux programmes ont été entièrement terminés par Stéphane PROTIN. Les essais se sont déroulés
avec l'aimable participation de personnes extérieures.
Site Internet :
Aurélie Debeyter a apporté quelques petites modications au site internet pour y améliorer la lisibilité.
Stéphane PROTIN a apporté d'autres mises à jour. Un forum a ét`'e installé dans le site (Toujours du
même auteur). D'autre part, chaque membre a jouté sa petite page !
Partie Introduction rédigée par Stéphane Protin
10
2 Moteur 3D
Le moteur 3d est la plus importante base du jeu car il permet d'acher, c'est-à-dire de visualiser tout
le principe et les fonctions implémentées dans les autres unités. Pour vous familliariser avec ce monstre
de lignes de code et de principes mathématiques nous allons découper cette partie en quatre.
La conception de la map
Le principe d'achage
La gestion des personnages
La gestion du monde
2.1 La conception de la map
Je vais vous décrire son type et son utilisation.
2.1.1 La structure
La map est régit par une structure de données de type record qui contient le type du monde, un
tableau dynamique pour les ennemis, une variable pour le père noël, une variable contenant le nom de la
map et enn un entier pour déterminer le nombre d'ennemis.
Les ennemis et le Père Noël ont tous deux le même type de chier spécique au type de chier md3
alors que le monde a un type diérent. Ce type est spécique, non pas au md3, mais au type de chier
obj.
TMAP= record
persoprincipe : T_Objet;
lemonde : TOBJ;
enemi : array of T_Objet;
nbe : integer;
nommap:string;
end;
// structure de la map
2.1.2 L'initialisation
A l'initialisation, on ouvre un chier map(entier).map qui contient des lignes ayant, $per pour le père
noël, $ene pour l'ennemi, $mon pour le monde, &map pour le nom de la map, toutes ces données
permettent par la suite de charger les ennemis, le Père Noël et le monde. Et pendant le chargement on
ache ce qui se passe.
Dans l'unité INITOPEN il y a une variable globale qui est du type map et c'est elle dont on se sert
pour la gestion du jeu.
&map:niveau1
$per:models\papano\sarge\ -50,0 15,0 0,0
$ene:models\enemiboss\uriel\ -40,0 0,0 40,0
$ene:models\enemiboss\uriel\ 140,0 0,0 140,0
$ene:models\enemiboss\uriel\ -40,0 0,0 -140,0
$mon:maps\map1.obj
11
2.2 Le principe d'achage
2.2.1 Le principe utilisé
Le principe d'achage n'est pas trop compliqué mais un peu dure à comprendre. En tout premier
lieu, il faut savoir que tout mes objets sont prévus pour être achés au point 0,0,0. Puis que tout ces
objets ont dans leur type de donnée leur position. Voilà on a tout en main.
Tout d'abord on ache la map tel que le sol soit à zéro puis on place les ennemis à leur position avec
leur bon angle de vision.
On eectue une rotation d'angle, celui du Père Noël an de voir dans la même direction que le père
noël. Je vous rappel que la vision par défaut d'OPENGL est 0,0,0. Après cette rotation on dessine le
Père Noël en zéro puis on translate tout cela de -5 sur les z an de reculer les objets et de se positionner
derrière le père noël en ayant une vision du style de Lara Croft.
Le fonctionnement est relativement simple et en plus nous n'utilisons pour les translations et rotations
que des fonctions d'OPENGL d'où, moins de pertes de puissance.
Le voici concrètement implémenté :
procedure affichepersoP(i:Boolean);
begin
glPushMatrix();
glTranslatef(0.0,-8.0,-5);
Draw(MApload.persoprincipe,i);
glPopMatrix;
glPushMatrix;
glTranslatef(0.0, -14.0, -5);
glRotatef(-MApload.persoprincipe.rz, 0, 1, 0);
glTranslatef(-MApload.persoprincipe.x,0.01,-MApload.persoprincipe.z);
for x:=0 to MApload.nbe-1 do begin
glPushMatrix();
glTranslatef(MApload.enemi[x].x,MApload.enemi[x].y+5.0,
MApload.enemi[x].z);
glRotatef(MApload.enemi[x].rz, 0, 1, 0);
Draw(MApload.enemi[x],i);
glPopMatrix;
end;
affiche(MApload.lemonde);
glPopMatrix();
end;
2.2.2 Les erreurs possibles
Certaines erreurs peuvent être engendrées par le principe d'achage et par la création d'un jeu en 3D.
La plus fréquente et la plus gênante est l'inversion d'axes en 2D, on le remarque tout de suite mais en
3D c'est plus compliqué car l'axe au sol est l'axe zx et non xz.
12
Ensuite, il est compliqué c'est de savoir où est l'angle de l'ennemi s'il est dans le sens trigonométrique
ou opposé puis le point le plus complexe est l'implémentation d'autres unités car ils ont pu prendre les
données xy et un angle non trigonométrique.
Puis enn le dernier point est le sens des axes. Comme je vous le disais la caméra est positionnées en
0,0,0 et on voit vers -l'inni en z. Et oui, quant on le sait tout devient plus simple et le déboguage est de
même beaucoup plus rapide.
2.2.3 L'utilisation des splashes
Les splashes et les vies sont également très simples. En tout premier lieu, il y a le chargement du chier
BMP et sa préparation à l'utilisation avec openGL. Sa lecture se fait à l'aide d'un composant de Delphi le
TBIMAP de celui-ci on parcours chaque pixel et on eectue un transtypage an de convertir les données
en integer. C'est le format d'utilisation des textures avec OPENGL.
Ensuite pour l'utilisation du splash Jean-Alexandre IRAGNE a créé une procédure qui initialise le
device contexte en un repère xy de dimension (la taille de l'écran) ce qui permet facilement de savoir où
placer les images. Puis je recule un peu ce repère an de le voir, enn voilà pour le splash .
procedure load(s:string;var toto:gluint;var aa:
pointer;alpha:integer; metalpha:Boolean ) ;
var
x,y:integer;
begin
if FileExists(s) then
begin
Load_Texture(aa,x,y,s,alpha,metalpha); //pour les bmps seulement
glgentextures(1,@toto);
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glBindTexture(GL_TEXTURE_2D,toto);//pour tout chargement d'images
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexImage2d(GL_TEXTURE_2D,0,GL_RGBA,x,y,0,GL_RGBA,GL_UNSIGNED_BYTE,aa);
end else
begin
//pour les bmps seulement
Load_Texture(aa,x,y,'IMAGES/mure.bmp',alpha,metalpha);
glgentextures(1,@toto);
glBindTexture(GL_TEXTURE_2D,toto); //pour tout chargement d'images
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexImage2d(GL_TEXTURE_2D,0,GL_RGBA,x,y,0,GL_RGBA,GL_UNSIGNED_BYTE,aa);
end;
end;
13
2.2.4 Les Fps :
An d'améliorer l'achage, on a dû enlever les divisions et les soustractions à chaque boucle car cela
nous prenait à peu près 1 fps (ceci n'est pas négligeable).
2.3 Les objets MD3
Ces chiers sont de type binaire .
2.3.1 La lecture
Ils possèdent une en-tête soit un header contenant l'identiant , le nombre de points, de normes, de
coordonnées puis il y a pour chaque animation une en-tête un mesh qui va dénir le nombre d'images
pour cette animation et les points de cette animation.
Ce format de chier est le meilleur pour acher un personnage car il contient les animations d'un
être humain et il sut alors de changer la forme de l'objet pour avoir un autre objet ayant les mêmes
animations(même si nous n'avons pas trouvé le moyen de bien le faire sans perdre les animations).
Il est aussi très pratique car il diérencie la tête, du torse, de l'arme et des jambes. Ce format de
chier possède également les matrices de position et de rotation intégrées, an que pour chaque animation,l'ensemble du corps soit aligné de la meilleur façon(c'est-à-dire comme un être humain).
La texture de ces objets est au format tga3 et le référentiel exact de toutes les animations, c'est-à-dire,
le nombre exacte d'images pour cette animation, car à la base ce nombre est au maximum soit 25. Les
tests eectués sur ce loader sont de l'ordre de 7000 pour le Père Noël.
2.3.2 L'init
A l'initialisation on demande de charger les jambes, le torse, la tête et enn l'arme puis cela se complique
un peu car il faut dénir en fonction de l'objet, où sont placées ces animations et quelle est sa texture .
Toutes ces données sont stockées dans le chier animation.cfg pour les animations puis dans les chiers
head_(type de skin).skin lower_(type de skin).skin upper_(type de skin).skin pour les textures. Voilà
pour la partie chargement du chier maintenant il faut aussi penser à la taille de l'objet pour qu'il ne
soit pas surdimensionner par rapport au monde, pour cela il y a un scalaire stocké dans le chier mais là
tout se complique à la lecture, les données étaient des entiers (4 octets) mais à l'achage ils doivent être
des oats (16 octets).
Donc, la structure de lecture et d 'achage doit être diérente pour éviter d'avoir à utiliser un scalaire
et oui je suis emmard mais le PC doit quand même être ménagé donc il y a la réduction du modéle.
Puis à l'initialisation il faut régler toutes les données de vie et de cadeau car si on est un big boss on aura
200 de vie et sinon 100. Le père noël lui a juste 100 de vie et zéro de cadeau.
mdel.vivant:=true;
if (path='models\enemiboss\uriel\') or (path='models\bigboss\sarge\')
then mdel.vie:=200 else mdel.vie :=100;
mdel.cadeau:=0;
reductionmd3(mdel.Lower);
reductionmd3(mdel.Upper);
3 tga : Targa le format
14
2.4 Les objets obj
Ces chiers sont au format ascii.
2.4.1 La lecture
On a donc la possibilité de les éditer manuellement. De plus ils sont faciles à comprendre . Ces chiers
contiennent tous les vertices(points) de l'objet, les vecteurs normaux(normales aux faces), les coordonnées
des textures(uv) et tout est indexés par les faces. Par exemple (f 1/3/4 5/6/7 8/9/10), cette face indexe
les trois points 1,5,8 ,les trois normales 4,7,10 et les trois coordonnées de texture 3,6,9. Voici donc la
composition du chier.
L'utilisation de ce type de chier va nous servir à acher le monde car celui-ci va rester statique, il
n'y a donc pas l'utilité de charger des chiers lourds en données pour quelque chose de statique. Les tests
eectués sur ce loader sont de l'ordre de 44 fps4 pour environs 70 000 triangles.
Voici son type de donnée.
TOBJFile=record
verts:array of TVertex;
norm:array of TNormal;
tex:array of T_tex;
// tous les points pour chaque face
face:array of TFace;
x:Glfloat;
y:Glfloat;
z:Glfloat;
nv:Integer;
nf:Integer;
name:string;
vecx:Glfloat;
vecz:Glfloat;
vc:TVertex;
xn:Integer;
yn:Integer;
zn:Integer;
rxz,rxy,rzy:TRect;
texex:Boolean;
texture:GLuint;
collision,cadeau:Boolean;
end;
TOBJ=record
objet:array of TOBJFile;// les petites structures
x:Glfloat;
y:Glfloat;
z:Glfloat;
xn:Glfloat;
// structure de l'objet avec position
yn:Glfloat;
zn:Glfloat;
nbobj:integer;
ot:integer;
vnex:boolean;
vecx:Glfloat;
vecz:Glfloat;
filename:string;
// nom
OBJETINT:gluint;
end;
4 frame per second
15
2.4.2 L'initialisation
A l'initialisation par contre il y a plus de chose a faire car cette structure contient pleins de données
très utiles .
En premier lieu nous allons calculer pour chaque sous objet, sa position minimale et maximale en x
et puis de même pour les z ensuite nous allons calculer la largeur et la longueur du rectangle minimale,
l'encadrant et nalement nous allons calculer son point.
Partie Achage rédigée par Jean-Alexandre IRAGNE
16
3 DirectInput
3.1 Introduction
Le composant DirectInput est responsable de fournir à l'application les données récupérées sur n'importe quel type de périphérique d'entrée. Ceci n'inclut pas seulement la souris et le clavier, mais aussi
les joysticks et pourra supporter d'autres périphériques qui existeront plus tard. DirectInput supporte
aussi des périphériques de sortie, comme les retours de force sur les joysticks. Les joueurs et la plupart
des développeurs considèrent les périphériques d'entrées comme naturels et sans problèmes. Cependant,
la façon dont un joueur interagit avec un jeu peut avoir un impact très important sur l'habileté qu'il peut
avoir pour maîtriser la navigation et ses actions, donc la jouabilité du jeu.
3.2 Importance des Inputs
Les périphériques supportés qui permettent à l'utilisateur d'agir sur le jeu et la façon dont ces périphériques sont utilisés pour manipuler les éléments du jeu peuvent faire le succès ou être la cause de
l'échec du jeu. Techniquement, les machines d'aujourd'hui disposent d'un grand nombre de périphériques
pour recevoir des ordres de l'utilisateur. Tous les jeux devraient supporter tous les périphériques standard
de la plupart des machines. Ces périphériques standard étant le clavier et la souris.
Le clavier est un périphérique d'entrée tout à fait standard depuis l'existence des ordinateurs, et il
doit être disponible pour la saisie quand le jeu est exécuté. La souris est un autre périphérique d'entrée
qui est aujourd'hui disponible sur toutes les machines. Pas tout à fait aussi ancien que le clavier, la souris
est tout aussi nécessaire et probablement même plus importante que le clavier pour l'interaction avec
l'utilisateur depuis l'utilisation de Windows.
Pour certains périphériques, la programmation de DirectInput est évidente, pour d'autres, elle est très
complexe. La complexité de DirectInput provient de l'ouverture de l'outil pour supporter les périphériques
à venir, qui n'existent pas encore, an de décrire la méthode d'accès avec la nesse et la exibilité
nécessaire.
Le clavier et la souris sont le seul lien dans le jeu entre la machine et le joueur. Une utilisation et une
gestion de qualité de ces inputs sont donc indispensables. Les inputs inuent grandement sur la uidité
du jeu. L'intérêt d'utiliser DirectInput est que l'on accède directement au périphérique sans passer par
la couche de messages Windows, la rapidité en est augmentée.
3.3 Fonctionnalité de DirectInput
DirectInput propose de nombreuses fonctionnalités bien au-delà de ce qui est disponible avec l'API
de Win32. Comme tous les composants DirectX, DirectInput donne au développeur plus de possibilités
d'actions que les API de Windows et donne aussi de meilleures performances. DirectInput fournit les
fonctionnalités suivantes qui sont intéressantes pour les développeurs de jeux :
Prend en charge l'acquisition des entrées directement depuis le matériel d'entrée
Supporte presque tous les périphériques d'entrée
Fournit un support pour les retours de force
Possède un temps de réponse plus court que celui des API Windows.
La programmation de DirectInput permet aussi de créer des objets DirectInput et des objets périphériques d'entrée. L'objet DirectInput, lui-même, agit comme le lien entre l'application et le driver du
périphérique d'entrée. Les objets individuels DirectInputDevice représentent l'interface de l'application
pour le hardware d'entrée. L'identiant objet périphérique DirectInput est utilisé pour communiquer avec
les périphériques d'entrée. En d'autres termes, il n'y a pas un type d'objet séparé pour communiquer avec
le clavier et la souris, ils sont tous interfacés avec un objet DirectInput.
Plusieurs étapes sont nécessaires pour initialiser un objet DirectInput et commencer à s'interfacer
avec le périphérique d'entrée. En général, la plupart de ces étapes sont nécessaires pour lire des données
du clavier ou de la souris.
3.3.1 DirectInput et DirectInputDevice sont initialisés en assurant les phases suivantes
Création de l'objet DirectInput (l'interface IDirectinput8)
Création de l'installation (les réceptions de l'interface IDirectInputDevice8
Conguration du niveau coopératif
17
Conguration des propriétés du périphérique
Au cas où l'on travaille avec un interrogation buérisée, on donne la taille du buer pour sauvegarder
l'information
Acquisition du périphérique
Réception des données par la méthode IDirectInputDevice
GetDeviceState
Après l'utilisation de la fonction, libération de l'installation et destruction de l'objet DirectInput
3.3.2 Introduction aux diérentes fonctions
DirectInput contient déjà des fonctions permettant de tout faire avec les inputs. Pour récupérer ces
entrés de périphérique, l'appel de certaines fonctions est nécessaire :
DirectInput8Create
CreateDevice
SetDataFormat
SetCooperativeLevel
GetDeviceState
Acquire
DirectInput8Create :
Cette fonction initialise en fait DirectInput et permet son bon fonctionnement.
CreateDevice :
Cette fonction permet de créer un objet directInput. En eet, ces APIs fonctionnent avec des objets,
d'où l'importance de le créer.
SetDataFormat :
On déni à ce moment le type de périphérique choisi (souris, clavier, manette de jeu, etc...)
clavier : c_dfDIKeyboard
souris : c_dfDIMouse
SetCooperativeLevel :
Avec cette fonction, on déni la manière dont on gère les priorités et les niveaux de coopération des
inputs.
GetDeviceState :
Récupère l'état du périphérique. En lui passant une variable en paramètre, cette fonction nous ressort
directement les inputs. Il ne reste alors plus qu'à les traiter.
Acquire :
Reprend le contrôle du périphérique en cas de perte de celui-ci
3.4 Récupération des données
3.4.1 Cas du clavier
Méthode :
Les touches appuyées sont enregistrées dans un tableau, il sut donc à chaque moment de parcourir
tout le tableau pour récupérer ce qui a été saisie.
Code Pascal :
Une procédure contenant ce code doit être appelé en boucle an de récupérer les entrées à chaque
boucle.
18
if lpDIKeyboard.GetDeviceState( SizeOf( bKeyBuffer ), bKeyBuffer ) = DIERR_INPUTLOST
then
begin
lpDIKeyboard.Acquire();
if FAILED( lpDIKeyboard.GetDeviceState( SizeOf( bKeyBuffer ), bKeyBuffer ) )
then
Exit;
end;
for i := 0 to 255 do
if bKeyBuffer[ i ] = \$080 then
begin
IF i = entréeAttendue THEN agirEnConséquence ;
end;
3.4.2 Cas de la souris
Mouvement de la souris
Méthode On stocke les coordonnées de la souris dans des variables, et il sut d'appeler la fonction
d'actualisation de la position de la souris et de comparer les anciennes coordonnées avec les nouvelles. Si
elles dièrent, alors la souris a bougé.
Code Pascal Une procédure contenant ce code doit être appelé en boucle an de récupéré les
entrées à chaque boucle.
if not UpdateMouseState( dwOffsX, dwOffsY )
then
exit;
dwMouseX:= dwMouseXPos;
dwMouseY:=dwMouseYPos;
Inc( dwMouseXPos, dwOffsX );
Inc( dwMouseYPos, dwOffsY );
souris_a_bouge := false ;
if dwMouseX<>dwMouseXPos
then
souris_a_bouge:=true;
if dwMouseY<>dwMouseYPos
then
souris_a_bouge:=true;
IF souris_a_bouge THEN OnAgitEnConséquence;
Clique sur un bouton de la souris :
Méthode :
Lorsqu'un bouton de la souris est cliqué, alors la valeur est mise dans un tableau. Comme avec le
clavier, il sut de regarder dans quelle case du tableau pour savoir quel est le bouton pressé.
Code Pascal :
Une procédure contenant ce code doit être appelé en boucle an de récupéré les entrées à chaque
boucle.
if lpDImouse.GetDeviceState( SizeOf( TDIMOUSESTATE ), @ms ) = DIERR_INPUTLOST
then
begin
19
lpDIMouse.Acquire();
if FAILED( lpDImouse.GetDeviceState( SizeOf( TDIMOUSESTATE ), @ms ) ) then
Exit;
end;
if ms.lX < 0
if ms.lX > 0
if ms.lY < 0
if ms.lY > 0
x := ms.lX ;
y := ms.lY;
then
then
then
then
ms.lX
ms.lX
ms.lY
ms.lY
:=
:=
:=
:=
Round(
Round(
Round(
Round(
ms.lX
ms.lX
ms.lY
ms.lY
*
*
*
*
CURSOR_SPEED
CURSOR_SPEED
CURSOR_SPEED
CURSOR_SPEED
) else
);
) else
);
if ms.rgbButtons[ 0 ] = \$080 then
BEGIN
onAgitEnConséquence ;
END ;
BEGIN
END ;
BEGIN
END ;
BEGIN
END ;
3.5 Résumé des soutenances précédentes
3.5.1 Pour la première soutenance
N'ayant jamais programmé de jeu, les débuts ont été un peu dicile : il fallait se renseigner sur qu'est
ce qui existe, qu'est ce qu'il est possible de faire, comment, grâce à quoi, comment ça marche ?
De ce fait, notre attention s'est d'abord tournée sur l'étude de ce que sont les inputs, et comment les
utiliser dans notre jeu. Pour ce faire, nous avons pour la toute première soutenance étudié dans le livre
Delphi Graphics and Game with DirectX écrit par John Ayres aux éditions Wordware Pushing, Inc les
parties inéressantes.
Suite à cela, nous avons essayé, d'après ce qu'il nous a appris, de commencer à implémenter le code
source, mais la compilation ne voulait même pas se faire.
3.5.2 Pour la seconde soutenance
Déjà, nous avons commencé par dénir quels types de périf¯ique seront utilisables, et dans quel usage ?
Il a été décidé de contrôler le père noël entièrement grâce au clavier, mais d'avoir la possibilité aussi de
tourner autour de soit même via la souris.
Faisant face à de multiples problèmes de compilation, et ne trouvant pas d'erreurs (par rapport au
livre), nous avons fait des recherches. Il s'est avéré que la version de DirectX que nous utilisons ne
correspondais pas avec ce qu'il est raconté dans le livre. Sur Internet, Alexandra VALAKHANOVICH a
trouvé un tutorial avec toutes les fonctions DirectInput déjà implémentées.
20
Stéphane PROTIN et Jean-Alexandre IRAGNE se sont chargés tous deux d'adapter le code à notre
jeu, de supprimer les portions de code inutiles, bref de faire quelque chose de propre. Ils ont également
permis le paramétrage par le joueur des touches qu'il souhaite utiliser.
Cependant, un problème était persistant : les inputs pour la souris ne voulaient pas s'initialiser. La
correction du problème ne sera pas pour cette seconde soutenance.
3.5.3 Pour la troisième soutenance
Les inputs étant déjà implémentées et intégrées, seul la correction du bug subsistait et donc seule la
souris renvoyait une erreur (puisqu'elle ne s'initialisait pas !). Après plusieurs tests, il s'est avéré que la
fonction de création de l'objet DirectInput5 peut renvoyer une erreur, mais la création est tout de même
faite. Nous n'avions pas pris cela en compte, et une fois la fonction d'arrêt du programme suite à une
erreur enlevée à cet endroit, tout s'est mis à fonctionner correctement. Le bug était alors corrigé.
Ne souhaitant pas apporter des possibilités de péri¯iques supplémentaires, nous avions pu considéré
à partir de ce moment, les inputs comme dénitivement terminés.
Partie Inputs rédigée par Alexandra Valakhanovich
Complétée par Stéphane Protin
5 La fonction DirectInput8Create
21
4 Mapping
4.1 Introduction
L'interface est ce que nous voyons sur l'écran. La création de l'interface comprend la création de la
carte du jeu et des objets particuliers, qui se trouvent sur celle-ci. Pour notre projet nous avons créé
le héros principal (le Père Noël), ses ennemis (de méchants Pères Noël) et les objets sur lesquels il a la
possibilité d'agir (les cadeaux, les maisons. . .). Pour s'approcher de la réalité nous avons créé notre jeu
dans un espace tridimensionnel ; tous les objets ont 3 paramètres (largeur, longueur, hauteur).
Pour la simplication du travail de création de graphiques en 3 dimensions, nous avons utilisé 3D
Studio Max.
3DS Max est sans conteste l'un des meilleurs programmes et des plus populaires pour la modélisation
de graphiques 3D en informatique. Ses capacités sont immenses, ce qui en fait un logiciel très complexe.
Le graphique 3D est destiné à l'imitation de la prise de photos ou de prise vidéos d'images 3D d'objets,
qui doivent être au préalable préparés dans la mémoire de l'ordinateur.
4.2 Il y a plusieurs étapes dans la création des objets
4.2.1 La création du model géométrique de la scène
On construit les modèles tridimensionnels géométriques des objets de la scène. Après avoir créé ces
modèles d'objets, on les dispose dans l'espace tridimensionnel. Les objets tridimensionnels permettent de
mettre des objets dans les objets (comme des poupées russes).
Le constructeur de la scène utilise tous les objets qui ont ainsi été préparés. Le constructeur de 3DS
Max possède l'environnement le plus complet et le plus puissant de tous les programmes de construction
de vues en 3D. Cela permet de faciliter le travail sur le modèle géométrique de la scène et donne la
possibilité de réaliser des modèles tridimensionnels de pratiquement n'importe quel objet du monde, réel
ou imaginaire. Une fois que le modèle tridimensionnel géométrique de la scène est créé, on peut facilement
l'examiner et le photographier de n'importe quel point.
3ds-max ore un ensemble d'outils pour créer les objets en 3D. Je présenterai certains de ces outils qui
semblent les plus importants ou ceux que j'utilise dans le projet.
Les éléments de base pour créer les scènes sont :
les objets primitifs
Les courbes NURBS et les splines
Les objets booléens
Modications
Les objets primitifs :
Ils sont créés comme des objets tridimensionnels sous forme de gures géométriques simples. Ces
objets sont utilisés pour créer la modélisation tridimensionnelle de la scène environnante : morceaux de
maison, l'architecture, les détails, etc. . .où l'on trouve des objets créés par l'homme.
De plus, les objets primitifs ne sont pas utilisés isolément, mais pour former des objets composés
qui sont des assemblages d'objets primitifs.
à l'aide des objets primitifs (boîte) j'ai créé la surface de base pour placer tous les objets de la scène :
les diérents murs de la maison, les sols. J'ai crée également la table et les chaises, lits, sofas, sapin de
noël. On peut remarquer que les objets primitifs comprennent de nombreuses parties. Par exemple, la
chaise comprend 8 parties, qui ont été créées de façon séparée. On doit calculer la taille de chacun de ses
objets et les lier ensemble en déterminant le lieu exact où ils se rejoignent. Bien sûr, la création de ces
objets prend beaucoup de temps.
22
Courbes NURBS and splines :
Les courbes Nurbs et splines sont utilisés habituellement dans 3ds-max pour la création des prols des
sections, que l'on peut transformer en objets tridimensionnels par des méthodes de rotation, extrusion
ou de lofting. Les splines sont des courbes appartenant à un plan. Les courbes NURBS peuvent être
tridimensionnelles (non plus dans un plan). On peut créer une telle courbe en utilisant une vue ou une
autre de 3ds-max pour dessiner la courbe dans l'espace. Avec ces lignes, en appliquant les méthodes dont
je parlerai plus tard, on peut obtenir des objets 3d du modèle. J'utilise des splines pour la création de
l'inscription sur le bâtiment, l'assiette et la coupe.
La méthode de révolution :
La méthode de révolution convient bien pour la création tridimensionnelle des modèles des objets
du monde possédant une symétrie axiale. Pour de tels objets, tous les plans perpendiculaires à l'axe
de symétrie, représentent les cercles concentriques. Ceci est vérié, par exemple, par presque tous les
récipients habituels comme les verres, les assiettes, les vases, les barils, etc. . .Cette méthode a été utilisée
pour créer la coupe et l'assiette.
La méthode d'extrusion :
La méthode d'extrusion, ou de pression, est très pratique pour modeler des objets ayant une section
constante transversale. Ces objets sont les résultats de l'empreinte d'un objet sur une surface plastique qui
conservera l'empreinte de cet objet. On peut voir les objets extrudés selon diérents points de vue : comme
le résultat d'un découpage selon le contour d'une feuille à épaisseur constante. La méthode d'extrusion
convient parfaitement, par exemple, pour le modelage des détails d'une voiture, des meubles en bois ou
pour la création de textes en relief. Cette méthode a été utilisée pour créer le texte Xmas en relief.
Les objets Booléens :
Les objets Booléens sont
d'algèbre booléenne : union,
elles doivent se toucher pour
(anciennement présente dans
créés en utilisant deux objets 3d sur lesquels on applique une opération
soustraction, intersection. Ces deux surfaces s'appellent des opérandes et
donner un résultat. J'ai utilisé cette méthode pour la création de la porte
notre jeu) et de la fenêtre de notre bâtiment.
Modication :
J'ai déjà dit qu'il est impossible de créer des scènes 3d sans utiliser des transformations standard.
Il est aussi impossible d'éviter les modications des objets. Ces modications peuvent être le loft d'une
ligne ou ce peut être le changement de la forme d'un objet. Pour chacune de ces modications, 3dsmax a des outils appelés modier. En plus des modicateurs de formes, on trouve de nombreux autres
modicateurs pour imiter l'élasticité par exemple.
Je parle maintenant du modicateur noise, que j'utilise pour créer des tas de neige. Ce modicateur
provoque une modication aléatoire de la surface du modèle géométrique, en donnant une impression sur
l'original de l'objet. Pour la création de la surface neigeuse, j'ai d'abord créé l'objet box, puis j'ai appliqué
ce modicateur.
4.2.2 Application pratique
Le Père Noël est repris du modèle de Quake (format md3), on a refait toutes les textures et on lui a
modié quelques parties du corps an de le rendre plus gentil à l'aide de Mikeshape3D.
Nous avons créé des groupes d'objets, chaque groupe comprend plusieurs sous-objets. Une telle approche
hiérarchique simplie le travail de gestion des objets. Par exemple, un groupe dénit une chaise : le dossier,
le siège et les pieds de la chaise. De cette façon, notre plan inclut des groupes d'objets composés de sous
objets. Tous les objets sont placés sur le plan ; 1er plan : Nous avons une grande maison placée dans le
plan qui est constituées de quelques pièces et de plusieurs objet. 2er plan : Nous avons 4 maisons placées
dans le plan, qui sont constituées de quelques pièces et de quelques objets ; Des murs limitent le plan, et
empêchent le héros de sortir de ses frontières.
23
Nous avons aussi créé les accessoires : des objets utilisés dans le jeu, tels que le cadeau. . .
4.2.3 La préparation des textures
Dans cette étape, on attribue le rendu des diverses textures et matières pour donner la plus forte
vraisemblance à la représentation. 3DS Max donne de très nombreuses possibilités, selon la nature des
matières utilisées. On peut ainsi dénir certaines propriétés comme l'éclat, la transparence, la luminosité,
la capacité de rééchir, le relief et plusieurs autres propriétés. On peut insérer des photos d'objets réels
pour créer des textures ou des matières. De plus, on peut utiliser les photos pour l'arrière-plan de la scène
que l'on crée.
Pour créer et dénir nement les propriétés des matières dans 3ds-max, on utilise le programme du
module Material Editor (l'éditeur de matières).
La matière est considérée comme la composition dénie par certaines caractéristiques, une surface
dénissant le modèle géométrique qui ore une ressemblance avec la surface de l'objet réel. On dénit
ainsi les caractéristiques, comme par exemple :
Les couleurs des surfaces de l'objet avec les points lumineux, les eets de miroir, d'ombre et la
réexion dispersée de la lumière ;
la taille et l'éclat d'un point lumineux ;
le degré de luminosité ou d'opacité ;
le type d'opacité et la couleur de la lumière qui travers un objet translucide comme un ltre coloré ;
l'importance du coecient de la réfraction des rayons de la lumière dans la matière transparente
etc. . .
Le type de matière le plus important et le plus communément utilisé est le type standard (dont la ressemblance visuelle avec les objets du monde réel est assurée par la sélection de caractéristiques de matière
standard) ; On utilise aussi le type maps (une photo ou une représentation d'un dessin caractéristique
de n'importe quelle surface ; dans 3ds-max, on utilise 35 types de telles textures).
Nous avons créé certains types de matières, tels que :
le blanchiment (pour le plafond),
la faïence (pour l'assiette),
le verre (pour la coupe),
la neige (pour la surface neigeuse),
l'enseigne (pour les inscriptions sur les maisons).
Je rappelle que le nombre de paramètres dénissant la matière la plus simple (standard) est assez
grand. Heureusement, la valeur initiale d'une grande partie de ces paramètres peut être conservée, et au
nal, on ne change, le plus souvent, qu'une dizaine de paramètres.
4.3 Évolution du mapping au cours de l'année
4.3.1 Vers la première soutenance
Le début d'année a été marqué par un petit apprentissage des diverses et très variés fonctionnalités de
3DS Max (même si au jour d'aujourd'hui, il y a encore des fonctionalités qui nous paraissent inconnues).
De plus, Jean-Alexandre IRAGNE s'est démené pour créer une première map pour pouvoir faire des
essais du jeu. Il a Également créé un premier père noël, en travaillant déjà sur l'application de texture
dessus.
4.3.2 Vers la seconde soutenance
Un nouveau père noël, repris certes de Quake, mais totalement remanié, notamment au niveau des
textures a été réalisé par Jean-Alexandre IRAGNE. Une première map ocielle a été réalisés par
24
Alexandra VALAKHANOVICH, mais sérieusement reprises pour des problèmes de comptabiltés par
Jean-Alexandre IRAGNE. A part des objets de la map, peu d'objets ont étés créés pour cette soutenance.
4.3.3 Vers la troisième soutenance
Alexandra VALAKHANOVICH a récup¯é dans une bibliothèque d'objets beaucoup d'objets et a appliqué certaines fonctionalités pour rendre du réalisme au jeu.
Lorsque nous avons intégré ces objets dans le moteur 3D, nous avons découvert certains problèmes. La
carte est apparue très volumineuse et occupait beaucoup de mémoire, ce qui rendait les processus très
lents. Nous avons alors décidé de simplier notre carte. Nous avons décidé de retirer systématiquement
tous les objets qui consommaient beaucoup de ressources graphiques et qui étaient très volumineux.
Par exemple, après l'application de la méthode noise pour créer un tas de neige, cette représentation contenait 4096 sous-objets, et de plus nous appliquions des modications spéciales à chacun de ces
objets. . .Nous avons écarté ces objets et nous ne les avons pas utilisés. Ces modications ont fortement
simplié la carte, une fois que tous les objets lourds furent retirés. Lorsque nous avons du choisir entre
la qualité des graphiques et la vitesse, nous avons privilégié la vitesse.
Toutes les modications majeures pour la simplication des objets et des maps ont été faite par JeanAlexandre IRAGNE. Tandis qu'une très grande partie des objets qu'à récupéré Alexandra VALAKHANOVICH se sont retrouvés inutiles (aucun jeu ne se risquerai de charger de tels objets, même des jeux
professionnels).
Un autre problème est apparu lors de la création de ces objets : à l'exportation du chier .max (le type
du chier utilisé par 3ds-max) vers le chier avec l'extension .3ds (le type du chier utilisé par le moteur
3d) nous nous sommes rendu compte que tous les objets avaient perdu leur couleur et n'avaient gardé
que leur forme. Il nous a fallu trouver une solution à ce problème. Nous avons compris que chaque objet
devait conserver sa texture et ceci était une des options de 3ds-max.
Lorsque l'on utilise tous les paramètres de matières (qu'on a créé) dans le moteur 3d, il est clair que
celui-ci n'applique pas tous les paramètres dans la représentation tridimensionnelle. Par exemple, toutes
les matières ont le type .mat, mais elles n'ont pas toutes un chier de type .jpeg, qui est nécessaire au
programme principal. Nous avons décidé de créer pour chacune des matières et pour tous les objets, les
chiers de type .jpeg en utilisant Photoshop. On peut voir les résultats de ce travail lors de l'exécution
du programme principal.
4.3.4 Vers la soutenance nale
Une map apparaissait à nos yeux insusant, Alexandra VALAKHANOVICH a donc été chargée de la
réaliser, ainsi que de nouveau objets pour allez avec.
Cependant, la création graphique via 3DS Max n'étant pas extèmement facile, Jean-Alexandre IRAGNE
a dû faire une correction des maps an d'y enlever les défaults comme :
Des murs de hauteurs diérentes
Des gros espaces entre les murs
Des objets pas toujours bien placés par rapport au sol
etc. . .
Partie Mapping rédigée par Alexandra Valakhanovich
25
5 Musique
5.1 Les tâches accomplies
5.1.1 Les intérêts du son dans un jeu
Notre projet étant un jeu video en 3D, il nous fallait impérativement des sons et des musiques, puisque
tout bon jeu, et même tout jeu qui se respecte a des sons et éventuellement des musiques. De nos jours,
on ne peut imaginer un jeu sans cet élément essentiel.
Ces sons sont destinées à l'habillage du jeu an de le rendre attractif, convivial et intéressant à jouer.
Un jeu qui ne contient aucun son est morne, terne et sans intérêt pour le joueur.
C'est pourquoi nous avons décidé de mettre autant de sons et de musiques que possible pour que le
rendu soit très agréable à l'oreille. Nous voulions ainsi des sons d'excellente qualité pour avoir l'assurance
que ceux-ci allaient s'intéger parfaitement dans le jeu.
5.1.2 Recherche des sons et musiques
Puisqu'aucun des membres désignés pour la tâche du son et même aucun des membres n'avaient assez
de connaissances et de talent artistique en ce qui concerne la musique, on ne pouvait pas créé nous même
nos propres musiques. Cependant il était tout à fait faisable de concevoir nos propres bruitages à la
bouche ou à l'aide d'objets car il n'était pas nécessaire d'être un virtuose de la musique pour une telle
création.
En ce qui concerne les sons, nous avons organisé une recherche parmi nos jeux video, nos CD's, nos
mp3 et sur des sites Web. Nous avions trouver pour les bruitages des sites Web spécialisés dans lesquels de
nombreux sons étaient centralisés. Il nous fallait des sons qui soient en adéquation parfaite avec l'ambiance
du jeu : des sons proches de l'esprit de Noël ou de l'hiver. Le jeu était également violent (Un Père Noël
meurtrier). Les sons devaient en plus traduire cet esprit.
Pour les musique, nous avions pensé chercher davantage parmi les mp3, et CD's car les sites proposant
des musiques sont en général payant, et la qualité n'est pas garantie.
5.1.3 Choix des sons initiaux :
Après une importante recherche des sons qui pourraient être ajoutés dans le jeu. Nous avons collecté
plusieurs sons depuis certains sites. Cependant nous avions choisi de n'intégrer qu'assez peu de sons.
En eet, le jeu n'était alors qu'à ses premiéres lignes de codes, il était alors impossible de déterminer si
certains sons manquaient au jeu ou non.
Nous avions opté pour les sons suivant :
Les bruits de pas dans la neige (Xmas est un jeu basé sur l'univers de Noël)
Les bruitages pour créer l'ambiance du jeu (vent, ricanement, grognement...)
Les bruits des armes (armement, coup de feu...)
Détails des sons initialement choisis
Les bruits de pas dans la neige Puisque Xmas est un jeu dont le thème principal est Noël, il
devait y avoir des bruits de pas dans la neige pour rendre les bruitages des pas du Père Noël très réalistes.
Cependant, nous n'avions pas le matériel nécessaire et bien évidemment pas de neige (il était impossible
d'imiter le bruit avec la bouche, à moins d'avoir des dons). Nous avons donc réussi à trouver ce son dans
la bibliothèque de Counter-Strike. Ce jeu rendait délement l'impression de marcher dans la neige, le
réalisme était parfait : noter choix était fait.
Les sons ambiants Nous voulions des sons ambiants pour mettre plus de piments dans le jeu. Nous
avions l'intention d'intégrer un soue de blizzard, pour accentuer l'eet hiver et erayant de Xmas :
cela était relativement simple à imiter, mais nous avions également trouvé ce son dans la bibliothèque de
Counter-Strike.
Nous avions pensé mettre dans le jeu un grognement (pour les ennemis ou de temps en temps dans le
déroulement du jeu). Les sites Web contenaient de nombreux ricanements et autres grognements amusants,
nous avons donc recueilli certains de ces bruitages.
26
Les bruits de l'armement Nous ne savions pas encore si le Père Noël aurait plusieurs armes, si
son arme aurait un magasin de balles limité. Pour être sur que rien de manquait, il était plus sûr de tout
avoir en stock.
Pour les trouver, pas besoin de chercher très loin, seul Counter-Strike pouvais répondre le plus à nos
attentes. Tout y était. De plus chaque son reproduisait dèlement la réalité.
Non seulement, la bibliothèque de sons de Counter-Strike était très compète pour les bruitages en
général, mais pour tous les bruits d'armes (rechargement, armement, coups de feux, ricochets, pose du
silencieux. . .) c'est la biblioéque la plus exhaustive que nous connaissions : FN P90, USP45 Tactical,
Ingram Mac10, Colt M4A1, Benneli XM 1014, H&K UMP45, etc. . .
5.1.4 Détails des musiques initialement choisies :
Idées et critères de sélection Nous avions une première idée pour les musique du jeu : nous n'avions
l'intention que d'en diuser une en continue dans le jeu pendant le déroulement de la partie. Il fallait
donc trouver une musique, bien sûr de qualité, mais celle-ci devaient pouvoir être jouer en boucle sans
sentir de rupture à l'oreille ou extraire un tel sample d'une musique.
Choix des musiques Ainsi nous avons choisi de récupérer les musiques de Nobuo Uematsu, composi-
teur de toutes les musiques de la série des Final Fantasy.
Pourquoi avoir choisi cet auteur plutôt qu'un autre ? Parce que ses musiques sont, d'une part, dignes
de grands compositeurs, et d'autre part, l'univers de Final Fantasy se passe sur une planète comme la
terre, avec ses montagnes, ses mers, ses déserts, ses glaciers, ses forêts. . .et ce, accompagné d'une musique
diérente pour chaque lieu. Un autre avantage, non négligeable, car c'est là que résidait tout le problème :
toutes ces musiques peuvent se mettre en boucle avec uidité dans le jeu. Étant elles-mêmes mises en
boucle dans les Final Fantasy.
Caractéristiques de la musique d'ambiance Pour cette musique d'ambiance, nous désirions diuser
quelque chose d'un rien angoissant pour mettre un peut de suspense dans le scénario. Cependant, elle ne
devait pas être terriante comme celles de Resident Evil an de ne pas frustrer le joueur pendant une
partie. Xmas se veut être un jeu, certes violent, mais impreigné de l'esprit de Noël et drôle.
De plus, il fallait que cette musique soit en corrélation avec le jeu, pour qu'elle se fonde totalement
dans le jeu.
Nous avons donc trouvé plusieurs musiques pour l'ensemble du jeu, mais nous ne pouvions choisir
dénitivement les musiques nales que lorsque le jeu serait quasiment terminé, an d'avoir une idée
d'ensemble et voir si tout se marierait bien ensemble.
5.1.5 Évolution et Implémentation
Tous les sons que nous avions recueillis jusqu'à présent, n'allaient pas être les sons dénitifs. En eet,
l'avancement du projet allait nous faire découvrir de nouvelles choses. À ce stade, le travail à fournir pour
que les sons apparaîssent dans le jeu était l'intégration de ceux-ci. Nous devions commencer à implémenter
toutes les fonctions et procédures nécessaires an de diuser tous ces sons et musiques dans le jeu.
Utilisation de l'API fmod pour l'intégration du son
Raison de notre choix : Nous avions utilisé pour cela l'API fmod, en raison de sa facilité d'emploi
et de sa puissance.
C'est notamment grâce à fmod que l'on peut créé des playlist et utiliser les sons de nombreuses façons
diérentes.
Intégration On pouvait donc, grâce à fmod, intégrer des bruitages ou musiques à n'importe quel
moment du jeu en les manipulant comme bon nous semblait. On peut ainsi, les jouer normalement,
changer le volume, déterminer quelle enceinte jouera plus fortement le son que l'autre, répéter des sons
en boucles, etc. . .
Ceci est très utile, notamment dans un jeu, car il permet de créé de multiples eets tel une rafale de
coups de feu.
27
Les avantages de fmod : Grâce aux canaux de fmod, nous avons pu déterminer le nombre de canaux
à utiliser. Ce qui permettait de pouvoir jouer autant de sons en même temps que de canaux. Ceci est
tout à fait intéressant pour jouer une musique de fond, lorsqu'on qu'on entend parallèlement le Père Noël
marcher dans la neige, tout en attaquant un ennemi. Dans un tel cas on à trois voire quatre sons joués
simultanément : la musique de fond, les bruits de pas dans la neige, les coups de feu et éventuellement
bruit émis par l'ennemi. Nous utilisons donc autant de canaux que de sons.
La répétition des sons :
Explication du principe :
Fmod nous permet également de jouer des sons en boucle, ce qui autoriserait utilement la possibilité
de travailler avec de petits chiers de sons plutôt que de détenir des sons importants qui utiliseraient
inutilement de la place. Il sut d'avoir un son bien sélectionné, assez court et qui puisse être mis en
boucle sans percevoir de rupture.
Application du principe :
Cette astuce à été utilisée dans le menu du jeu. une séquence de musique y avait été mise en boucle
comme musique de fond. Nous pensions qu'il était judicieux de l'utiliser pour les coups de feu. Il fallait
qu'en attaquant en full auto, soit entendue une rafale basée sur l'unique coup de feu répertorié comme
son, sans avoir en complément de celui-ci, diérentes autres cadences de rafales.
5.1.6 Un mur de problèmes :
Énoncé du problème :
Pour les sons répétés, nous avions rencontré un problème qu'il nous a fallu résoudre pour cette dernière
soutenance : les sons n'étaient pas répétés assez rapidement. Ainsi dans le menu, le son pris dans le
répertoire de Counter-Strike était exécuté en boucle dans ce jeu avec une extrême uidité mais nous
déplorions dans notre jeu, un temps mort entre chaque répétitions. Ce temps de chargement devait à tout
prix disparraître pour qu'il soit agréable de naviguer sur le menu.
Source du problème :
Ce problème à été d'autant plus important pour les créé rafales, car les coups de feu étaient répétés
tellement rapidement que tous se chevauchaient : le son était répété alors qu'le précécent n'était toujours
pas terminé d'tre joué. À ce stade, nous pensions que ce problème pourrait être résolu lorsque nous
parviendrions à découvrir la fonction ou procédure adéquate de fmod. Nous pensions, alors, que ce
cheminement serais aisé.
5.2 Du nouveau ... et du beau ! :
5.2.1 Le son du Menu Principal à mettre en boucle :
Il fallait absolument trouver un moyen an de supprimer le temps mort entre chaque reprise du sample
dans le menu. En eet, celui-ci avait été choisi à partir du jeu Counter-Strike, dans lequel le son avait
été mis en boucle parfaitement. Nous voulions le même rendu, et cela était donc évident pour nous qu'il
était possible de corriger cette anomalie. Nous avons alors eectué de multiples recherches sur Internet
pour trouver une solution.
Gagner du temps... Nous avions déni un type Enregistrement qui comportait un champ Repeat de
type booléen. An de répter en boucle le son du menu principal nous avons créé une fonction recursive
qui jouait le son du menu. Lorsque le son était joué, Repeat était à False sinon True (il changeait de
valeur à chaque fois). Entre chaque appel, cette fonction devait déterminer, grâce au champ Repeat, si
le sample était terminé an pouvoir le jouer sans pour autant superposer le son. Cependant, à chaque
appel de la fonction, le temps de chargement empêchait la lecture uide du sample.
28
Le bout du tunnel Après de multiples heures de recherche, nous avons trouvé sur http ://www.fmod-
fr.com une application de certaines procédures et fonctions fmod en C très détailléée utilisant notamment
la fonction de FSOUND_Sample_SetLoopMode. Nous avons également découvert un petit programme
de démonstration du son 3D dont nous avions les sources. Celui-ci ne mettait en scéne un avion de chasse
qui venait de la droite de l'écran et repartait vers la gauche et recommençait en boucle. Le son utilisé ne
durait que quelques secondes : il y était donc également mis en boucle. Nous avons étudié tout le code
faisant utilisation de l'API fmod.
Un programme pour tester les solutions An de pouvoir tester les fonctions que nous allions
utiliser, nous avions créé un petit programme avec Delphi qui lorsque l'on appuyait sur un bouton,
jouait le son du menu principal en utilisant la fonction fonction FSOUND_Sample_PlaySound. Nous y
avons ajouté la fonction FSOUND_Sample_SetLoopMode pour tester son eet. Désormais, lorsque nous
appuyions sur le bouton, le son était joué en boucle sans aucune interruption. Nous avons alors intégré
dans le code du jeu cette fonction qui nous permetta de lire le sample en continu.
5.2.2 La lenteur de la rafale de tir :
Ce que nous avions et ce que nous voulions Nous avions malheureusement un problème quant
aux cadences de tir et de bruits de pas. Tout était beaucoup trop lent pour reéter la réalité. Comme
nous avions utilisé la même function recursive que pour le menu, nous avons décidé d'utiliser la fonction
FSOUND_Sample_SetLoopMode. Cependant, le résultat n'était toujours pas celui espéré, et tout était
encore trop lent.
Il fallait que le son soit joué en appuyant sur une touche, et répété, plusieurs fois en même temps : le
même son devait se superposer avec un très court laps de temps de décalage.
Une recherche peu concluante Nous avons alors, comme avant, cherché une aide sur internet mais
aucun site ne pouvait répondre à nos attentes. Nous avons posté un message pour demander de l'aide sur
http ://www.developpez.com. Malheureusement aucune réponse n'était assez précise pour nous permettre
de résoudre ce problème.
Une ébauche de solution Nous avons remarqué dans notre petit programme de test du son, un
comportement intrigant. Alors que nous n'y avions pas encore intégré la fonction de Loop. Lorsque l'on
appuyait sur le bouton, le son était lu une seul fois, mais lorsque nous appuyions sur la touche raccourci
ou sur 'Entrée' en continue, le son était joué ) raison de plusieurs dizaines de fois par millisecondes.
Le problème résolu En utilisant ce phénomène, il nous susait alors de jouer avec le temps pour
trouver la bonne cadence de tir. Une fois la fonction FSOUND_Sample_PlaySound intégrée dans le
code, nous avions juste à déterminer le temps de décalage que nous voulions. Après plusieurs tests nous
avons établi celui qui correspondait le plus à une rafale de balles réelle.
Nous avons également utilisé ce processus pour les bruits de pas dans la neige en modiant seulement le
temps de décalage pour le rendre beaucoup plus grand (des bruits de pas étant plus lents que des coups
de feu).
5.2.3 Du changement dans le code
Comme nous l'avait suggéré quelqu'un sur le forum de http ://www.developpez.com, il fallait utiliser
les sons somme comme des samples. C'est comme ça que tout a pu fonctionner. Cependant, le code
précédent qui avait déjà été fait n'avait pas tenu compte de ce fait.
Ainsi, il a fallut changer toute les fonctions et procédures, notamment l'init, car le nom des fonctions
et procédures utilisées dans ce cas là était diérent et les paramètres également.
Tout à été changé et tout fonctionne, à présent.
29
5.2.4 Une nouvelle idée ; du son 3D :
L'inspiration Dans le programme de l'avion de chasse, le son utilisé était du son 3D. La nuance du son
était modié selon la distance entre le récepteur (la caméra) et l'émetteur (l'avion de chasse). De plus,
selon la position de l'avion de chasse sur l'écran, le son était plus fort sur une enceinte que sur l'autre :
Lorsque l'avion arrivait par la droite, le son était plus fort sur l'enceinte droite et plus l'avion se déplaçait
sur la gauche, plus le son diminuait sur l'enceinte droite tout en augmentant sur l'enceinte gauche.
Nous avions trouvé cela du plus bel eet et avons décidé de l'intégrer dans le jeu, malfré qu'il ne soit pas
prévu pour le projet initial et son cahier des charges.
l'intégration dans le jeu Après plusieurs tests, nous avions une ébauche de son 3D. Nous avions
rencontré un problème : le son 3D était inversé. En eet, Lorsque l'émetteur se situait à droite, le son
venait de l'enceinte gauche et vice et versa. Cette erreur a été rapidement corrigée par la suite et le son
3D marche dorénavant parfaitement.
5.2.5 Les sons choisis
Nous avons utilisé pour tous les sons du jeu des extraits venant du jeu Counter-Strike. La raison de ce
choix : il comporte tout les sons qui pourraient puissent intgrés pour n'importe quel jeu.
Nous avons choisi de rajouter quelques sons supplémentaires an de le rendre plus attractive et plus
intéressant à jouer. Désormais vous pouvez entendre dans le jeu :
Les bruits du menu principal
Un 'Go, go, go ! ! !' en entré de jeu
Les bruits de pas dans la neige
Le son des cadeaux
Les coups de feu
La mort
Le générique
Détails
Les bruits du menu principal : A chaque fois qu'un bouton est cliqué dans le menu principal
dans le but eectuer une action (jouer, visiter le site, etc. . .), un petit son se fait entendre. Il en est de
même lorsque vous revenez en arrière ou lorsque vous voulez quitter le jeu : un autre son se déclenche.
Ces sons correspondent aux sons de Counter-Strike qui sont utilisés pour les mêmes fonctions.
Go, go, go ! ! ! : Á chaque début de level, le fameux Go, go, go ! ! ! de Counter-Strike retentit,
an de motiver votre folie meurtrière.
Bruits de pas dans la neige : Á chaque mouvement du Père Noël, on peut entendre les bruits
de pas dans la neige qui se répètent tant que ce dernier est en mouvement . Vous remarquerez dans le
premier level et dans les maisons du second level que vous entendez le son des bruits de pas dans la neige
même en intérieur. Pourquoi cela ? Ma raison en est simple : le Père Noël a tellement de neige sous ses
bottes quelle colle sous celles-ci. Vous pouvez percevoir cela comme un problème. Cependant, beaucoup
de nouveautés ont été apportées pour le son. Le temps nous étant compté, il nous fallait faire des choix.
Le son des cadeaux : Un son, eet magie provenant, lui, de Warcraft III à été ajouté. À chaque
fois que le Père Noël trouve un cadeau et lorsque qu'il s'en empare, celui-ci disparaît et vous entendez le
son généré par celui-ci.
30
Les coups de feu : Lorsque le Père Noël tire, vous entendez des coups de feu en rafale avec une
cadence très proche de la réalité. Si vous appuyez brièvement sur la touche de tire, vous n'entendez qu'un
seul coup. Plus vous restez longtemps appuyé sur la touche, plus la rafale de tir est longue. De plus,
comme dans la réalité, vous entendrez le son qui sort de votre arme, plus fort que celui de votre ennemi.
La mort : Lorsque vous tirez susamment longtemps en visant un ennemi, vous nissez par tuer
celui-ci qui tombe lourdement sur le sol en poussant un grognement rauque avant de succomber. Lorsque
les rôles s'inversent et que c'est vous qui êtes abattu, un splash de mort, s'ache et vous poussez exactement le même cri guttural et déchirant.
5.2.6 Les musiques choisies :
Comme nous voulions mettre des videos et puisqu'un générique avait été créé, il nous fallait trouver
des musiques en accord avec l'ambiance du jeu, et reèteraient notre état d'esprit. Il nous fallait donc,
une musique diérente pour trois instant du jeu.
Quand le Xmas Père Noël s'exécute, avant d'arriver dans le jeu, se lance une video d'introduction
en 3D mettant en scène l'histoire du jeu. Toute la scène est alors rythmée au son d'une musique.
Quand vous avez terminé le jeu, c'est-à-dire que vous avez alors réussi à prendre tous les cadeaux
de tous les levels prévus (ennemis tués ou pas), un splash de victoire s'ache pendant quelques
secondes avant que le générique de n s'ore à vous. Comme tout bon générique qui se respecte,
celui-ci se déroule au le rythme d'une musique.
la video bonus de n, qui elle, est un lm sur l'équipe du projet, située juste après le générique se
déroule également avec une musique (aucun son ambiant ou voix n'y est présent)
La video d'introduction : La video d'introduction montre, pendant 26 secondes, l'arrivée du Père
Noël dans une maison. Celui-ci dépose les cadeaux au pied du sapin alors qu'un étrange et inquiétant
personnage l'épie d'une autre piéce. La video se termine une fois que le Père Noël repart via la cheminée.
Nous avons opté pour une musique du groupe de Metal, Disturbed : Down with the sickness dont nous
avons choisi un extrait. Ce dernier n'a pas été sélectionné au hasard car il fallait que le rendu soit tout
de même agréable à écouter. Il ne fallait pas penser que la musique gênait et y était trop imposante.
Ainsi, pour un rendu uide, nous avons utilisé SoundForge v6.0 an de sélectionner l'extrait désiré.
Celui-ci a été choisit selon le critère suivant : La synchronisation avec les événements de la video. L'extrait
est principalement instrumental (beat et guitare) avec un cri guttural de temps en temps.
De ce fait, nous avons coupé la musique et rigoureusement sélectionné plusieurs morceaux de cette
chanson que nous avons liés avec précision. Le rendu est très uide et on entend le dit cri guttural, lorsque
le Père Noël entre puis resort par la cheminée.
Le générique : Tout ces sons et musiques du jeu sont en parfaite osmose avec celui-ci (Xmas est tout
de même un jeu violent). Mais où était l'esprit de Noël dans tout cela : il devait absolument y avoir
d'intégré une musique de Noël. Nous avions auparavant, téléchargé plusieurs musiques de Noël dans le
but de les intgrer éventuellement dans le jeu.
Après les avoir toutes écoutées attentivement, notre choix s'est porté sur un medley de chants de Noël
car le choix était vaste et les extraits relativement courts. Nous avons coupé le medley avec SoundForge
v6.0 pour n'en garder qu'un unique chant : Fêtons Noël. Cette musique ayant une durée de 1 minute et
29 secondes, il nous susait d'adapter la durée du générique à celle de la musique. Le rendu était ainsi
très satisfaisant.
La video Bonus : Pour cette video de 2 minutes et 11 secondes. Nous avons choisi d'intégrer le thème
de Mission : Impossible 2 du groupe de fusion Limp Biskit. Nous avons choisi tout simplement les 131
premières secondes de cette chanson. Le timing est parfait car la video s'achève lorsque la musique devient
plus calme.
31
5.3 Conclusion
Nous avions initialement, de nombreuses idées, quelques fois très touues et il s'est avéré que lors
de l'avancement du projet, autres idées venaient germer en nos esprits. C'est ce qui explique que les
propositions initiales concernant le son ont dû subi d'importantes mutations. Le temps nous étant malgré
tout compté, il nous fallut faire des choix rapides et précis. C'est pour cette raison que nous avons réalisé
du son 3D, une playlist mp3 au lieu de diuser une musique d'ambiance au cours du jeu, etc. . .
Nous estimons avoir pris les bonnes décisions car le rendu nous semble tout à fait pertinent et le virtuel
rejoint la réalité. Grâce aux sons, le joueur est, quant à lui totalement plongé dans l'univers captivant de
Xmas.
Partie Achage rédigée par Florent RÉTIF
32
6 Vidéos
Pour la réalisation de la vidéo nous avons tout d'abord été obligés de créer un scenario et de savoir
combien de temps il allait durer. Nous avons donc inventé une histoire, puis décidé que la vidéo aurait
une durée de 26 secondes environ a 24 images par seconde, comme un lm de cinema.
6.1 Scenario :
Nous avions élaboré un scénario de base qui allait être utiliser pour créer la video nale :
Dans le noir, un message qui s'écrit : A noël, dans nos contrés.
La caméra rentre dans la maison en passant par la cheminée. On y voit alors le père noël sans son arme
mais avec un cadeau qu'il dépose au pied du sapin. Une fois le cadeau déposé, la caméra reste statique,
et le père noël s'en va. On entend alors le traîneau s'en aller avec une petite musique de noël. Un ash
illumine alors la pièce (ceci se faisant en même temps que l'envol du traîneau). De suite on entend un
bruit de porte s'ouvrir, et on voit un ennemi qui rentre prudemment dans la pièce tout en s'assurant que
le père noël est bien reparti. Il s'empare alors rapidement du cadeau et part aussitôt (en courant) an de
montrer (et d'exprimer) qu'il s'agit bien d'un vol.
Un nouvel écran noir, avec un message qui s'écrit : Bien loin de là, dans la maison du père noël. . ..
On entend alors un téléphone sonner, style MATRIX, puis on entend décrocher, et s'engage alors le
dialogue suivant :
Allo ?
A ce moment, on voit le père noël en communication (un simple rectangle pour symboliser le
téléphone sura). Le dialogue continue :
Père noël ?
Vous êtes sûr que la ligne est bien sécurisé ?
Oui. J'ai une mauvaise nouvelle : votre pire ennemi vous a volé presque tous les cadeaux que vous
avez distribué cette nuit. Votre mission si toutefois vous l'acceptez : aller les rechercher.
Ok, mission acceptée". Musique de Mission impossible.
Un petit noir, avec un message qui s'écrit : De retour dans nos contrés, avant notre réveil. Et enn,On
voit le père noël se balader dans notre map, à la recherche d'ennemi. On peut éventuellement le voir tuer
un ennemi.
6.2 Vidéo :
6.2.1 Mise en place de la scène avec 3ds max :
Le décor :
Cette scène est le reet du monde dans lequel le jeu se déroule. On y retrouve ainsi, une maison où le
décor intérieur comprend une table, des chaises, un sapin et bien-sûr une cheminée qui, pour le moment
n'est que ctive.
Les textures :
Un travail au niveau des textures a également été réalisé pour que le monde soit le plus proche possible
de la réalité. Cependant, cela n'était pour le moment pas très réussi.
L'ambiance de la scène :
De plus la scène se passant le soir un travail sur le jeu des lumières a été réalisé. En eet, à l'intérieur
de la maison nous avons inséré un spot an de concevoir une lumière articielle, créant un contraste avec
l'extérieur, beaucoup plus sombre, mais étant toutefois éclairé par les astres.
33
6.2.2 La création de l'animation :
Les recherches préliminaires :
Le décor était xé, mais ce n'était pas tout car il fallait intégrer les personnages : le Père Noël et les
ennnemis.
Il a donc fallut rechercher un explorateur 3D qui puisse lire les chiers md3 et qui les transformait en
3DS. Après quelques recherches, nous avons trouvé un logiciel : 3D exploration, qui était assez puissant
et faisait tout ce dont on avait besoin.
Mais le travail ne s'arretait pas là. Il manquait le plus important : comment sortir une video à partir
de 3D Studio Max 5 ? Là était le problème ! De surcroît, les seules vidéos que nous avions faites étaient
d'un rendu de très mauvaise qualité : on ne voyait rien.
Pendant plus de 2 jours, Jean-Alexandre IRAGNE a cherché comment faire une vidéo à partir de 3D
Studio Max. Nous avions enn trouver la solution : cela se faisait dans le banc de montage. Dans celui-ci,
il sut de sélectionner le type de formation, la durée de l'animation, le type de chier de sortie et les
option de rendu que l'on veut lui aecter.
La réalisation et le rendu :
Pour le moment, seuls le monde était réalisé, quelques textures et surtout les mouvements de la caméra ; soit le plus important. Après les recherches, nous avions les chiers de l'ennemis et du Père Noël.
Malheureusement, il était découpé en plusieurs parties, il a donc fallut les recomposer à l'aide de 3D
Studio Max 5.
Tout était près, il ne restait plus qu'à les intégrer dans la scène. Il fallait tout de même faire l'animation
du Père Noël.
Quand la caméra devient statique, on fait arriver le Père Noël, il se déplace tel Néo dans Matrix
Reloaded, vers le sapin de Noël. Il se tourne ensuite, pour être en face de celui-ci et les cadeaux arrivent
comme par miracle sous le sapin de noel.
Quelques instant après, le Père Noël refait un demi tour et se dirige vers la cheminée et là, saute en
prenant la position de Néo et s'eclipse dans la cheminée avec une vitesse rtès élevée : tel un avion de
chasse.
Elle était enn terminée, il ne restait plus qu'à générer la vidéo et après une journée de compilation,
la video se diusait mais pas le son. A ce moment, nous nous étions servit de VirtualDub an d'intégrer
le son et d'encoder la vidéo en dvix.
Voilà la video enn achevée.
La réalisation de la vidéo bonus :
En ayant passé de nombreuses nuits blanches à faire avancer le jeu, nous nous sommes lmé tout le
long de ces longues nuits et à la n du projet nous nous somme dis que nous devions intégrer une vidéo
bonus dès que nous aurions terminer le jeu : nous avons fait un best of des plus beaux moments de la
semaine, cadencés par la musique de Mission : impossible 2, take a look around.
34
Pour plus de détails, nous l'avons tournée avec une camera numérique Sony dvi et eectué le montage à
l'aide de Windows Movie Maker. Ainsi, si l'on termine le jeu, la vidéo bonus se lance à la n du générique.
///////////////////////////////////////////////
lancelejeu(playlistmp3,conf,1);////////////////
///////////////////////////////////////////////
if j=666 then
begin
stopzic(chann);
WindowState:= wsMinimized;
ShellExecute(Handle,'Open','video\bonuscool.wmv',nil,nil,SW_SHOWDEFAULT);
end else chann:=playloopsound(14);
Fig.
2 Création de la vidéo de bonus
La réalisation du lecteur video :
Le lecteur est réaliser en Delphi à l aide de composants déjà existant. Voici le code permettant de
créer une procedure ne se terminant qu'a la n de la video.
procedure init_et_play_player(const src:string);
var
inputparm,rectparm:TMCI_ANIM_RECT_PARMS;
rect,rect1:trect;
begin
terminer:=true;
if FileExists(src) then
begin
35
//creation de la fiche de visualisation
ecran1:=Tecran1.Create(ecran1);
ecran1.Show;
rect1.Left:=0;
//
dimensions
rect1.Top:=0;
//
et
rect1.Right:=320; // position
rect1.Bottom:=240; // de panel1,zone d affichage du mediaplayer
with ecran1 do begin
lelecteur.FileName:=src;//charge la vidéo
//pour afficher la vidéo dans panel1
lelecteur.display:=hwndvisioneur;
lelecteur.open;//ouvre le périphérique de lecture
//commande mmsystem pour recuperer les coordonnées de la video chargée
mcisendcommand(lelecteur.deviceid,mci_where,mci_anim_where_source,
longint(@rectparm));
rect:=rectparm.rc;//affecte les coordonnées de la video à rect
//recupère les coordonnées de la zone d affichage du mediaplayer
inputparm.rc:=rect1;
//commande mmsystem pour forcer la video à se dessiner entièrement
//dans panel1
mcisendcommand(lelecteur.deviceid,mci_put,MCI_ANIM_PUT_DESTINATION,
longint(@inputparm));
lelecteur.Play;
Timer1.Enabled:=true;
end;
terminer:=false;
end ;
while not terminer do Application.ProcessMessages;
end;
procedure Tecran1.Timer1Timer(Sender: TObject);
begin
if (lelecteur.position>=lelecteur.Length-5) and not terminer
then Close ;
end;
6.3 En conclusion :
La video d'introduction a été entièrement réalisée et intégrée au jeu. La video bonus qui n'était pas
prévue a été lmé lors des nombreuses nuits blanches de la n de l'année. Tout est intégré, et le rendu
est très satisfaisant.
Partie Vidéos rédigée par Jean-Alexandre IRAGNE
36
7 Achage
L'interface n'a pas changé dans la forme mais des modications ont été en revanche apportées dans
le fond.
7.1 Les dernières modications :
Les dernières modications apportées à l'interface sont :
Les sauvegardes
L'accès au site web sélection automatique
7.1.1 Les sauvegardes :
Les sauvegardes sont crées à chaque n de partie si on termine le niveau . Leurs implementations
sont très simple car en réalité on ne sauvegarde qu'un entier dans le chier (son nom est niveau.sav).
Réellement, l'entier sert juste à savoir quelle est la map à charger car le nom de la map est obligatoirement
map(entier).map.
Il est facile d'aller à un niveau supérieur enn, de tricher, mais le but est de terminer le jeu d'un coup
d'autant plus que les membres du projet.
7.1.2 L'accès au site web :
Quand au site web, lorsque l'on clique sur le bouton visiter, on arrive maintenant sur le site internet.
Pour faire cela on lance la fonction shellexecute avec comme paramètre l'adresse du site. Mais nous
avions rencontré un autre problème légèrement plus compliqué que celui-ci.
L'interface était prioritaire sur toutes les autres mais on ne pouvait pas voir s'il y avait l'explorateur
internet lancé.
Pour résoudre ce problème, nous avions minimisé la fenêtre. A ce moment là, on voyait une petite
forme qui quant on double-cliquait, on revenait sur l'interface.
Self.WindowState:= wsMinimized;
ShellExecute(Handle,'Open','http://xmas2007.free.fr',nil,nil,SW_SHOWDEFAULT);
7.2 Le fonctionnement de l'interface :
7.2.1 Les diérents composants Delphi utilisés :
Toute l'interface fonctionne par l'intermédiaire d'une pile et tout est représenté à l'aide des composants
de Delphi :
Une forme pour la fenêtre
Des images pour les boutons et le fond
Des listbox pour la résolution et la play list mp3
Une table pour la conguration des inputs
des tvirtualtext pour acher du texte
7.2.2 Fonctionnement de la pile :
Comme expliqué dans les soutenances précédentes, la pile qui gère l'interface se divise en deux parties.
Les éléments qui s'empilent représente l'entrée dans les sous fenêtres de la sélection précédente. Dans ces
éléments, on retrouve son groupe qui va de 1 à 5, ce qui veut dire qu'il y a 5 possibilités de fonction dans
chaque élément.
37
Pour exemple dans l'interface au lancement il y en a 5 soit :
lancer
charger
option
visiter
quitter
Tout ces éléments possèdent des propriétés et des fonctions qui leurs sont propre. Voila comment
fonctionne cette interface.
7.2.3 Avantages de notre interface :
Elle est modulable car elle peut être modiée selon le vouloir des gens juste en modiant les images
de l'interface situées dans le répertoire IMAGES en gardant les mêmes dimensions. Avec ceci le joueur
peut personnaliser toute son interface.
7.2.4 les boutons :
Fig.
3 Création de la vidéo de bonus
Le bouton lancer, qui lorsque l'on clique dessus ,il y a apparition du bouton lancer qui lui lance le jeu
au premier niveau. Le bouton charger, qui ache une liste box avec à l'intérieur les numéros des niveaux
déjà atteint en double cliquant dessus cela lance le jeu au niveau sélectionné.
38
Le bouton option, où l'on trouve toutes les options indispensables pour le jeu. De plus il y a une play
liste mp3, pour ajouter un mp3 il faut cliquer sur l'image au dessus et pour supprimer un chier dans la
play liste il faut double cliquer sur le nom. Ensuite il y a le réglage du volume, celui de la résolution puis
des touches du clavier.
Le bouton visiter, qui minimise la fenêtre et lance le client web à l'adresse du site d'XmaS.
Le bouton quitter, quitte le jeu ou le sous menu.
Voici maintenant la fonction très utile qui nous permet de trouver toute les résolutions
procedure rechercheresolution(var res:T_resolution);
var
d:TDevicemode;
p:^TDeviceMode;
n:integer;
begin
res.nbres:=0;
n:=0;
while EnumDisplaySettings(nil,n,d) do begin
new(p);
p^:=d;
res.reso[res.nbres]:=d;
res.x[res.nbres]:=(d.dmPelsWidth);
res.y[res.nbres]:= (d.dmPelsheight);
res.bit[res.nbres]:= (d.dmBitsPerPel);
if (res.nbres > 1)and (res.x[res.nbres]>600)
then begin
if (res.bit[res.nbres-1]<>res.bit[res.nbres])and
(res.x[res.nbres]>600)
then inc(res.nbres)
end
else if (res.x[res.nbres]>600) then inc(res.nbres);
inc(n);
end;
end;
Voici maintenant la fonction très utile qui nous permet de trouver si le chier de conguration existe,
sinon on le crée et l'initialise.
if not FileExists('conf.cfg')
then begin intconfig(conf);
AssignFile(f,'conf.cfg');
Rewrite(f,1);
BlockWrite(f,conf,sizeof(T_config));
CloseFile(f);
end
else begin
AssignFile(f,'conf.cfg');
Reset(f,1);
BlockRead(f,conf,sizeof(T_config));
closefile(f);
end;
Et l'interface n'a plus rien à envier à celle de Counter-Strike ou de Quake 3 : elle est sublime et elle
fonctionne très bien.
Partie Achage rédigée par Jean-Alexandre IRAGNE
39
8 Intelligence Articielle
8.1 Ce qui avait déjà été fait
8.1.1 Première approche
L'Intelligence Articielle n'est pas une fonction servant à habiller le jeu contrairement à la partie du
son. Au même titre que le Moteur 3D ou les Inputs, c'est un des éléments indispensables du jeu.
C'est elle qui donne vie à tous les bots6 du jeu, leur conférant divers comportements. Elle gère
également tous les types de collisions diérents.
Puisque qu'aucun des membres du groupe de projet n'avaient de connaissances en la matière, nous
étions face à ce sujet, tous de ,niveau égale. Il nous a donc fallut étudier comment fonctionnait l'Intelligence
Articielle d'un jeu, l'ensemble de ses principes fondamentaux, etc. . .
Il était nécessaire tout d'abord de savoir comment nous allions adapter une Intelligence Articielle
dans notre jeu, déterminer ce qu'elle allait permettre, et analyser ses capacités ainsi que ses limites.
8.1.2 Les domaines de l'Intelligence Articielle
CDu fait que Xmas est un jeu en 3D avec un unique mode : le mode solo, l'Intelligence Articielle
devait entièrement gérer le comportement des ennemis et gérer les diverses collisions, notamment avec
ceux-ci. Nous avons donc décidé de séparer les tâches an de bien cerner ensemble des travaux à réaliser.
La gestion des ennemis Nous avions choisi de traiter les quatre parties suivantes :
Les déplacements des ennemis
Le champ de vision des ennemis
La réaction des ennemis face au Père Noël
Les déplacements des ennemis Les principaux modes de déplacements que nous pensions utiliser
concernant les ennemis était : la marche et la course.
Nous avions l'intention d'utiliser la marche davantage pour les patrouilles et utiliser principalement
la course lorsque l'ennemi faisait face à notre héros. Au cours du jeu, an lui donner vie et crédibilité, les
ennemis ne devaient pas rester statiques.
La course devait être employée essentiellement pour parvenir à s'approcher du Père Noël et pour se
positionner an de pouvoir l'attaquer mais également pour le pourchasser lors de sa fuite.
Le champ de vision des ennemis Nous avions envisagé deux types de champs de vision : un
champ de vision type cercle et un autre de type angle de vue. Nous nous étions imposé de réaliser
au minimum le champ de vision de type cercle, et de compléter par l'angle de vue, si le temps nous le
permettait.
Le champ de vision de type cercle était le plus simple a concevoir. Il fallait juste délimiter un
rayon d'action : Une distance entre le Père Noël et l'ennemi inférieure à ce rayon prédéterminé
devait entraîner une récation de la part de l'ennemi.
Le champ de vision de type angle de vue, était plus complexe comme son nom l'indique et faisait
intervenir un angle de vue et un rayon. Celui-ci etait basé sur le principe de l'autre champ de vision
à la diérence près que celui-ci ne se faisait pas sur 360◦ mais sur un angle de moins de 180◦ . Ainsi
on pouvais être très proche de l'ennemi sans que celui-ci ne nous aperçoive.
La réaction des ennemis Nous avions l'intention de créer une attaque, une poursuite et éventuellement une fuite. Ainsi, lors d'une attaque, si le Père Noël venait à fuir, l'ennemi ne devait pas cesser
de l'attaquer ni rester statique, c'est dans ce but que nous avons pensé à intéger la poursuite au sein le
jeu. La seule réaction à implémenter impérativement était l'attaque, car des ennemis amicaux n'avaient
aucun intérêt dans un jeu.
6 Personnages gérés par l'ordinateur. Ce sont les ennemis que vous aronterez
40
Les diérentes collisions An également de mieux comprendre et créer toutes les réacions aux colli-
sions, nous avions déterminé trois types de collisions : map/Père Noël, map/ennemis, ennemis/Père Noël.
Ces collisions devaient être réalisées, par soucis de réalisme et de jouabilité.
8.1.3 Les premières lignes de code
La gestion des ennemis An de tester facilement les eets de l'Intelligence Articielle, et puisque
le jeu proprement dit n'avait pas assez d'avance pour la tester directement, nous avons créé une petite
application Delphi contenant dans une fenêtre : un shape rose que l'on pouvais déplacer et qui devait
représenter le Père Noël , ainsi qu'un shape bleu statique qui devait représenter l'ennemi.
Fig.
4 Exemple d'utilisation du programme (la poursuite)
Grâce à ce programme, nous avons pu créer et tester la poursuite, la fuite et les champs de visions.
La poursuite a été implémentée sans problème. Tout fonctionnait selon le champ de vision sur 360◦ .
On pouvait même déterminer la vitesse de poursuite de l'ennemi.
En utilisant le code de la poursuite, nous avons pu créer la fuite de l'ennemi : Cette fois-ci, lorsque
l'on s'approchait de l'ennemi, celui-ci fuyait.
Le champ de vision en angle de vue avait été implémenté parallèlement. Nous avions rencontré
quelques problèmes mais ceux-ci ont été relativement facile à résoudre.
41
Les collisions entre les personnages :
Les collisions ennemi/Père Noël Nous avions commencé à réaliser tous les types de collisions.
Ainsi dans cette application, nous avons du prendre en compte le fait que le Père Noël et l'ennemi ne
pouvaient pas se superposer. Nous avons donc conçu les collisions entre l'ennemi et celui-ci.
Malgré tout, nous avions rencontré un bug assez tenace : les collisions devaient se faire mais quelques
fois (après plusieurs essais), il était cependant possible de faire superposer les deux personnages. Nous
avons alors tenté tant bien que mal de corriger ce bug, qui, nallement avait totalement disparu.
Les collisions Père Noël/map : En ce qui concerne les collisions les plus importantes, c'est-à-dire
celles qui s'appliquent entre le Père Noël et tous les éléments de la map, elles on été réalisées directement
dans jeu puisque le Père Noël avait été conçu et intégré. Ainsi le Père Noël n'avait pas une consistance
de fantôme mais était comme une personne réelle, en se heurtant aux murs et autre obstacles.
Principe :
Pour ce qui est de la gestion des collisions avec le Père Noël et les diérents élément de la map, nous
avions utilisé une méthode bien particulière : Chaque objet, personnages compris a été matérialisé par
trois rectangles sécants (un dans chaque plan du repère (O,x,y,z) de la 3 dimension) si les rectangles du
personnage entraient en collision avec un des rectangles des objets, on réattribuait, alors, les anciennes
coordonnées au Père Noël. Pour ce faire les collisions n'étaient vériées qu'après chaque mouvement en
vériant en permanence une éventuelle collision du personnage avec tous les objets de la map.
8.1.4 Les collisions Ennemis/map :
Il ne restait plus que les collisions entre les ennemis et la map à naliser : nous avions créé le code
responsable des dites collisions, il à été intégré à celui de l'application Delphi. Tout compilait et il ne
nous restait plus qu'a appliquer le code au jeu (en y apportant quelques modications si nécessaires) an
que tout fonctionne ; non seulement les collisions ennemi/map mais aussi tout l'ensemble.
Explication du principe Le principe de collision Map/ennemis était assez complexe. On utilisait un
chier .bmp représentant la map vu de dessus, en noir et blanc. Le noir matérialisant tous les obstacles :
murs et autres objets ; le blanc matérialisant les endroits où le Père Noël pouvais se déplacer. Une
procédure a créé, à partir de la map, un matrice de booléns de la taille réelle de la map en tenant compte
du coecient de proportionnalité. Ainsi, le noir était en quelque sorte remplacé par True et le blanc par
False : il nous restait simplement à vérier dans quel cas les collisions étaient à Fasle ou True.
8.2 Une Intelligence Articielle peaunée
8.2.1 Int
gration dans le jeu
Toute l'intégration de l'Intelligence Articielle déjá codée a été réalisée. Cependant, nous avions
rencontré quelques problèmes lors des tests du jeu. Lorsque, l'ennemi devait fuir, celui-ci fuyait dans
n'importe quelle direction. Le même problème apparaissait lors de la poursuite : Tout cela n'était donc
pas très concluant quant au réalisme du comportement des ennemis dans le jeu.
Nous avions ajouté la poursuite et la fuite en même temps, ce qui faisait que l'ennemi nous poursuivait lorsque l'on fuyait et il fuyait lorsqu'on le poursuivait. Comme nous avions rencontré un obstacle
important, le comportement des ennemis était pour le moins étrange.
En plus de cela, les collisions ennemi/Père Noël ne fonctionnaient plus. Il nous a donc fallut nous
pencher sérieusement sur cela.
Aprés avoir recalculé toutes les disjonctions de cas possibles, les angles, coordonées, etc. . .nous avons
réussi à corriger toutes les erreurs.
8.2.2 Les collisions avec les .bmp
Le code a été intégré totalement dans le jeu et completé. Toutes les maps .bmp ont été créées grâce
au logiciel de traitement d'image Photoshop v7.
42
Nous avons eectué un screenshot de chaque map vue de dessus dans 3D STUDIO MAX 5, puis nous
avons modié cette image an d'avoir au nal la même image en noir (R : 0, V : 0, B : 0) et blanc (R :
255, V : 255, B : 255).
L'ensemble du code créé étant juste, tout s'est mis à bien fonctionner du premier coup.
8.2.3 Manque de jouabilité à corriger
A chaque fois que nous devions executer le jeu pour de tester les corrections apportées et les nouveaux
éléments, nous nous heurtions à un bug gênant : Le jeu était très peu maniable, en raison des collisions
qui ne semblaient pas avoir été faites avec une extrême précision.
Détails du problème Lors de la conception de la map, nous avions remarqué que la jouabilité manquait
cruellement de uidité. Nous avons donc opté pour élargir les ouvertures des pièces de la première map
ainsi que celles des maisons de la deuxième map. Les ouvertures étaient légerement disproportionnées en
rapport à des portes de taille normale. Ce négligeable manque de réalisme avait été imaginé an de faire
passer le Père Noël sans encombre, d'autant plus que l'écartement avait été calculé selon l'épaisseur du
personnage.
Malgré ces tentatives, cela ne laissait pas assez de manoeuvres pour un correct déplacement à travers
toutes les maps. Cela était beaucoup plus gênant car certain endroits de la map étaient assez étroits et
demandaient une certaine précision.
Ainsi, dans la première map, le joueur est amenés à entrer dans une salle à manger, il fallait faire
attention à ne pas entrer en collisions avec un des côtés de l'ouverture ou avec la table et les chaises qui
étaient situées juste devant et les murs adjacents.
5 Ce passage posait particulièrement problème (derrière le Père Noël, se trouvent la table et les
chaises)
Fig.
Dans tous les recoins de la map, des exceptions étaient générées et l'on cognait dans le vide. Comme
les collisions gérées par l'Intelligence Articielle bloquait le presonnage lorsque celui-ci entrait en collision
avec un objet de la map, il nous arrivait de mettre plusieurs dizaines de secondes pour aller d'une pièce
à l'autre en passant par l'ouverture
Nous avons étudié tout le code concernant les collisions map/Père Noël. Cela étant, nous avons
pu dterminer que tout était dû à un scalaire dont la valeur réelle était inapropriée. Nous avons tout
simplement légèrement changé cette valeur pour obtenir un résultat parfait et rassurant.
8.2.4 des collisions en mouvement
Cette grande victoire sur la maniabilé nous a stimulé et nous nous sommes donné comme dé de faire
en sorte que, lorsque le Pére Noël était en collision avec un élément de la map, au lieu de rester bloqué
puis de reculer, il glisse le long de l'obstacle. Cette amélioration avec rapidement été évoqu'ee lors de
l'avant-dernière soutenance par Mr. Boullay.
43
Puisque nous voulions sans cesse améliorer plusieurs détails du jeu, nous avons choisi de développer
ce bonus. Nous avions un avantage pour rendre possible cet ajout : Tous les murs et obstacles de chaque
map étaient parallèles aux axes Ox, et Oz. Pour le glissement, il fallait uniquement ajouter ou oter 1
pour les nouvelles coordonnées, en abscisse ou en ordonnées.
Une importante disjonction de cas se pr±entait devant nous : Nous savions que cela allait faire intervenir
l'angle de vue du Père Noël mais pour chaque angle de vue, deux collisions étaient possibles : Une collision
avec un plan parallèle à l'axe Ox, une collision avec un plan parallèle à l'axe Oz. Il fallait donc déterminer,
dans quel cas la collision se faisait de telle façon plutôt que l'autre. Ceci était déjà utilisé dans le code des
autres collisions donc cette tâche a donc été relativement simple à implémenter une fois tous les outils en
main et ce malgré quelques petites erreurs.
8.2.5 L'attaque
En ce qui concerne les ennemis, nous devions implémenter l'attaque. La grande diculté de cette tâche
résidait dans le fait de savoir si le personnage était bien en face de l'ennemi an de devoir le toucher
réellement. Il nous a donc fallu déterminer cette visée.
Nous avions comme donnée la distance de entre l'ennemi et le Pére Noël qui était simple à déterminer
à partir des coordonnées des deux personnages. Nous connaissions également l'épaisseur de l'ennemi.
Grâce à ces deux paramètres et à une formule trigonométrique, nous avons pu déterminer un angle entre
les deux demi-droites passant par le Père Noël et chaque extrémité du segment délimitant l'épaisseur de
l'ennemi.
Ainsi, le Pre Noël visait juste, lorsque l'angle de cette visée était inclue dans l'angle entre l'ennemi
et le Pére Noël qui est en permanence calculé dans le jeu pour plusieurs applications de l'Intelligence
Articielle. Dans cette situation, si le Père Noël tirait sur l'ennemi, il blessait celui-ci dont la vie baissais.
44
9 Installation / Désinstallation
9.1 Installation
9.1.1 Saisie
Utilité :
Tous les programmes ne se contentant pas d'un chier ont besoin d'une procédure d'installation an
de créer les autres chiers nécéssaires à l'exécution. Un installateur est un programme qui copie les
chiers nécessaires pour le déploiement sur un ordinateur. Ensuite, l'utilisateur sera capable d'utiliser le
programme.
Il est certain que l'on peut utiliser un grand nombre de programmes standards d'installation, mais nous
avions décidé de créer notre propre programme. Ceci avait permis de perfectionner notre expérience dans
la programmation en Delphi, et nous avons créé une procédure d'installation bien adaptée à notre jeu.
Principe :
L'installation copie les chiers à l'endroit désiré. Cependant, elle ne possède comme chiers qu'elle
même en exécutable. Il faut donc inclure des chiers dans cet exécutable et avoir la possibilité de les
ressortir.
Cependant, comment le faire ? Pour savoir quels chiers y sont inclus, nous avions pensé à ajouter un
petit chier texte en plus dans notre exécutable. Celui-ci serait le seul chier que l'on connaîtrait, et que
l'on saurai extraire tout seul de l'exécutable.
Ce chier texte contient à son début les diérents repertoire à créer. Puis contient alternativement
un identiant et le nom du chier que l'on veut extraire (le nom que l'on donnera au chier en faisant
l'extraction de l'exécutable). L'identiant sert à retrouver dans les ressources le bon chier.
De ce fait, il devenait facile d'installer à partir de l'exécutable, tous les chiers qui serait nécéssaires
pour jouer.
9.1.2 Ressources
On déni par ressources les chiers que l'on inclue dans l'executable. Ces ressources peuvent être de
tout type :
Des images,
Des sons,
Des textes,
Des chiers entiers
Ou encore des icônes,
Des curseurs
etc. . .
Bref, toutes les ressources que vous pouvez imaginer peuvent s'inclure dans un exécutable et ainsi ne
pas avoir besion de chiers externes pour leur utilisation.
Processus de création de ressources :
Le processus à suivre pour l'inclusion se fait en plusieurs parties :
Le chier .rc :
Il faut tout d'abord créer un chier .rc. Ce chier contient pour chaque chier : un identiant, un
type de donnée (RCDATA pour un type de chier quelconque) et le chemin d'accès vers le chier que
l'on souhaite ajouter à l'exécutable.
45
Compilation du .rc :
Ensuite, Il faut compiler ce chier pour le transformer en un chier ressource .res. Pour cela, Delphi
ore le programme brcc32.exe qui eectue lui-même cette compilation.
Intégration des chiers :
Une fois le chier .res obtenu, il va falloir dire à Delphi de l'inclure dans notre programme. Pour
cela, il faut rajouter dans une unité, dans la partie interface, cette commande : $R chier.res. Lors de
la compilation, il ajoutera alors à l'executable, ce chier.
Résultat obtenu :
monprogramme.exe : programme compilé et contenant les ressources (la taille de l'exécutable est plus
grande). L'exécutable est autonome, les autres chiers ne sont plus nécessaires pour la distribution du
package.
Organisation possible des ressources :
Notons aussi qu'un chier ressource peut contenir diérents types de données dans le même chier. Il
n'y a pas besoin d'en créer un pour les images, un pour les sons. . .Un seul sut. Néanmoins, il est parfois
plus clair pour la maintenance du programme de ne pas tout mélanger !
Extraction des chiers ressources :
C'est un algorithme simple qui utilise les ux. Il a été trouvé sur le site http ://www.phidels.com,
dans le tutorial sur les ressources.
PROCEDURE utilis_fichier_inclu (Identificateur, nom : string) ;
var resstream:TResourceStream;
dest:TFileStream;
BEGIN
resstream:=TResourceStream.Create(hinstance, Identificateur, RT_RCDATA);
try
dest:=TFileStream.Create(nom, fmCreate);
try
dest.Position:=0;
dest.CopyFrom(resstream, resstream.Size);
finally
dest.Free;
end
finally
resstream.Free;
end;
END ;
Intérêt des ressources :
Les ressources orent des possibilités très intéressantes pour nous, développeurs d'applications. On
retiendra surtout les avantages suivants :
Risque d'erreur de chier non trouvé, réduit à néant
Ressources mieux cachées des hackers que pour l'utilisation de chiers
Possibilité de mieux organiser ses ressources
Avantages pour la création d'applications multi-langues (non utilisé dans notre programme, mais
étant possible)
9.1.3 Application pratique
Stéphane PROTIN avait créé au départ un programme qui ne faisait que copier des chiers d'un endroit
à un autre. Cependant, cela ne correspondant pas à l'idée qu'il se faisait d'un programme d'installation, il a
préféré utiliser les ressources. Aucune dicultés n'est apparue pour l'installation, malgré le fait qu'il fallait
faire attention de ne pas écrire sur le lecteur courant. . .Du coup, les chiers que l'on a besoin d'extraire
juste temporairement comme la licence, etc. . .sont écris dans le répertoire temporaire. Le programme crée
46
aussi dans certains cas une icône sur le bureau qui est un raccourci vers le programme. Nous avions alors,
notre interface unique et bien développée.
9.1.4 Les points importants
Ici sont décris certains détails de notre programme, qui, méritent une attention particulière.
À la mise en marche de l'installation nous rappelons les droits d'auteur
Nous publions les conditions d'utilisation de notre jeu, le chier se trouvant dans les ressources. Il
est extrait dans les repertoire temporaire de Windows uniquement pour l'achage, puis celui-ci est
supprimé
Nous proposons le choix entre 3 types d'installations : typique, compacte et à votre sauce
L'utilisateur peut choisir où il installera le programme
L'installation se déroule selon un processus prédéni
On ache le bon déroulement de l'installation (lorsque c'est le cas) et une barre de progression
avance au fur et à mesure de l'avancement
Il est écrit durant l'installation quel chier est copier et où
Un chier de log est créé pour rappeler tout ce qui à été écrit
A chaque étape du programme, il y a une possibilité de revenir vers l'étape précédente ou de sortir
de l'installation sans la terminer.
9.1.5 Les diérentes installations possibles
Typique :
En choisissant ce type d'installation, toutes les options proposées par une installation A votre sauce
sont cochées. L'utilisateur obtient alors l'installation la plus complète !
Compacte :
Assimilable à l'installation de la version Lite, le minimum pour l'execution est installalé. L'utilisateur
ne pourra alors pas bénecier de toutes les fonctionalités.
A votre sauce :
En choisissant se type d'installation, l'utilisateur peut choisir d'installer des options :
Installer
Installer
Installer
Installer
un raccourci sur le bureau
un raccourci dans le menu Démarrer
les vidéos (incluant la vidéo de bonus)
l'aide du jeu
9.1.6 Diérence version lite et version normale
Plusieurs chiers ressources ont été utilisés dans notre programme d'installation. Dont un, seulement
pour les options. Ainsi, le programme d'installation version lite ne contient pas les chiers des options.
L'autre modication est la désactivation des menus Typique et A votre sauce. L'utilisateur n'ayant
le choix que de l'installation compacte se retrouve alors avec le minimum d'installé.
9.1.7 Préparation de la désinstallation
Un programme qui s'installe est tout à fait correct, mais c'est tout aussi bien s'il peut se désinstaller.
De plus, un programme de désinstallation doit pouvoir s'auto-supprimer.
C'est cette idée qui nous a donné du l à retordre. En eet, on ne peut pas supprimer un executable
qui est lancé. Ne sachant pas comment faire, Stéphane PROTIN en a discuté longuement sur un forum
an de résoudre le problème.
La solution qu'il a trouvée est de créer un petit chier .bat (les seuls chiers capables de se suicider)
qui va supprimer le désinstalleur, supprimer le dossier s'il a été créé, et se supprimer.
47
Un tutorial sur le sujet à été publié suite à cela à cette adresse par Stéphane PROTIN an d'en faire
proter d'autres personnes :
http ://www.phidels.com/php/index.php3 ?page=../commun/voirexemples.inc.php3
&ColorId=431&ChoixMenu=divers#id431
Cependant, cela avait beau très bien fonctionner dans le tutorial de Stéphane PROTIN, lorsque celui-ci
a créé le programme de désinstallation Xmas, celui-ci refusait d'écrire le chier (I/O Error). Le problème
a été corrigé en créant le chier suicidaire à l'installation, puisqu'áprès plusieurs jours d'acharnement
pour corriger l'erreur, celle-ci subsistait7 .
9.2 Désinstallation
Ce programme réalise les opérations inverses au processus d'installation. Il détruit les chiers qui ont
été installés à l'installation.
9.2.1 Principe du programme
Destruction de chiers :
Après l'installation du jeu dans un répertoire, on peut trouver le chier ìnstall.log'. Dans ce chier, on
trouve toutes les informations sur les chiers qui ont été installés. La procédure de désinstallation lit ce
chier et détruit un à un tous les chiers qui sont listés dans ce chier ìnstall.log'.
Le problème pouvant survenir est que les dossiers sont en début de chier (normal, puisque lors de
l'installation, on créé d'abord les dossiers) et qu'il ne faut pas les supprimer en premier. Pour ceci, nous
utilisons une pile. Ce qui aide à résoudre le problème. Ainsi, les dossiers sont empilés, et on supprimera alors les répertoire en respectant l'arborescence, c'est à dire que l'on supprimera d'abord les sous
répertoires avant les repertoires.
L'utilisation de la pile nous permet donc de supprimer en premier les chiers, et ensuite de supprimer
les répertoires une fois que ceux-ci sont vides.
9.3 Conclusion
Finalement, les programmes d'installations sont moins facile qu'ils ne semblent être, et pour réaliser
entièrement le tout, Stéphane PROTIN a du consacrer de nombreuses heures. Grâce à tout ce travail
fourni, le résultat est très convivial, avec une petite touche d'humour.
Partie Inputs rédigée par Alexandra Valakhanovich
7 Pour note, c'est la commande Rewrite qui ne passait pas, toutes les solutions ont été envisagés pour corriger le
problème, mais sans succès
48
10 Site Internet
Quasiment tout le site Internet a été réalisé par Stéphane PROTIN. Des mentions contraires précises
quelles sont les autres personnes qui y ont participées.
10.1 Intérêt d'un site Internet
Nous avons créé le site Internet non pas parce qu'il est obligatoire d'en faire un, mais plutôt pour
permettre une meilleure communication dans le groupe, mais aussi pour nous faire connaître, et permettre
aux autres groupes de voir leur évolution par rapport à notre groupe, de nous poser des questions et de,
peut-être, apprendre des choses. . .Cependant, c'est aussi un bon moyen de communication.
Le site Internet est visible à partir de l'adresse suivante :
http ://xmas2007.free.fr ou http ://www.xmas.ht.st8
10.2 Découpage du site Internet
Pour commencer, le site à été découpé en plusieurs parties :
Présentation du projet : Présentation des membres
Historique
Histoire
Planning de réalisation
Problèmes rencontrés
Liens
Téléchargement : Chez notre hébergeur
Sur notre serveur
Concepteurs
Forums
10.3 Logiciels utilisés, et apprentissage
Nous avons travaillé avec trois logiciels :
Claris Home Page9 en début d'année
Dreamwaver 4
Dreamwaver MX
Flash MX
Filezilla pour le transfert de chier vers le serveur FTP
Nous avons apprécié Dreamweaver pour son double achage Aperçu / code source.
10.4 Les diérentes parties du site Internet
10.4.1 Présentation du projet
Présentation des membres :
Cette page présente rapidement les diérents membres avec leurs rôle dans le projet. Également
présent : une icône précisant si nous sommes connecté au résau ICQ, puisque tous les membres s'y
connectent régulièrement. Depuis la seconde soutenance a été prévu un lien qui ouvre une pop-up pour
chaque membre, pour assurer quelque chose de plus conviviale, et permettre aux visiteurs de mieux nous
connaître. Cependant, le petit mot personnel n'a été dans l'ensemble rajouté quà la n par les membres.
8 Lien redirigé vers http ://xmas2007.free.fr par Ulimit
9 Logiciel livré avec un ancien CD d'installation de connection à Wanadoo
49
Historique :
C'est en quelque sorte le journal de notre projet. . .On y écrit de temps en temps ce qui se passe dans
le groupe, etc. . .mais il faut avouer que plus généralement, on écrit dedans au moment des soutenances,
pour dire où l'on en est, etc. . ., tout en pensant à y mettre la date.
Cette page a plusieurs intérêts :
Permettre aux visiteurs du site de voir l'avancement de notre projet.
Faciliter la rédaction des rapports. Cela vous paraît une idée bizarre ? Pas du tout, les soutenances
étant quand même bien espacées, on en arrive à ne plus savoir ce qui à été fait depuis la dernière
soutenance. . .Plus de panique, puisque c'est trié par date, il devient alors plus simple de synthétiser
l'avancement, an d'éviter les redondances dans le rapport.
Histoire du jeu :
Comme son nom l'indique, elle contient l'histoire qui est à l'origine de notre jeu. Pour la rendre
vivante, nous y avons intégré quelques images animées (au format Gif10 ), on a mis un peut tout cela en
forme, et ça rend du plus bel eet. Cependant, c'est un peu long à charger pour quelqu'un ne possédant
pas de réseau à haut débit. . .Il a fallu faire un choix, mais on s'est dit que ça valait le coup d'attendre la
n du chargement. Et puis, pour patienter, un script a été intégré pour faire patienter le visiter :
<STYLE> v\:* {
BEHAVIOR: url(#default#VML) } </STYLE>
<SCRIPT language="JavaScript1.2">
/* PARAMETRAGE */
news_larg=400;
news_haut=50;
news_box_color='#FFFFFF'; // couleur du tableau
news_cache_color='#666666'; // couleur arrière plan
news_ligne_color='#FFFFFF'; // couleur des lignes
news_box_font="Verdana"; // police du texte
news_box_fontcolor = "#000000"; //couleur du texte
news_box_fontsize = 12; // taille du texte
news_html = "<B>Veuillez patienter...<BR>Chargement de la page<BR></B>";
/* FONCTIONS */
function news_step_one()
{
if(news_mode == 1)
{
news_hligne_long += 1;
news_vligne_long += 1;
if(news_hligne_long > (news_larg+100))
news_mode = 2;
}
else
{
news_hligne_long -= 1;
news_vligne_long -= 1;
if(news_hligne_long < news_larg)
news_mode = 1;
}
var tempX = Math.round((news_sreen_X-news_hligne_long)/2);
vartempY = Math.round((news_sreen_Y-news_vligne_long)/2);
document.getElementById("ligne1").from=news_lign_X+","+tempY
document.getElementById("ligne1").to=news_lign_X+","+(tempY+news_vligne_long)
document.getElementById("ligne2").from=(news_lign_X+news_larg)+","+tempY
document.getElementById("ligne2").to=(news_lign_X+news_larg)+","+
(tempY+news_vligne_long)
10 Graphics Interchange Format
50
document.getElementById("ligne3").from=tempX+","+news_lign_Y
document.getElementById("ligne3").to=(tempX+news_hligne_long)+","+news_lign_Y
document.getElementById("ligne4").from=tempX+","+(news_lign_Y+news_haut)
document.getElementById("ligne4").to=(tempX+news_hligne_long)+","+
(news_lign_Y+news_haut)
if(!news_load)
setTimeout("news_step_one()",1)
else
{
document.getElementById("news_cache").innerHTML = '';
document.getElementById("news_cache").style.visibility = 'hidden';
}
}
function news_stop()
{
news_load=true
}
/* ACTIONS */
news_html_haut = '<TABLE WIDTH='+(news_larg-2)+' HEIGHT='+(news_haut-2)+'>
<TR><TD STYLE="font-family:'+news_box_font+';color:'+news_box_fontcolor+';
font-size:'+news_box_fontsize+'px" ALIGN=center>';
news_html_bas = "</TD></TR></TABLE>";
news_hligne_long = news_larg+20;
news_vligne_long = news_haut+20;
news_alpha = 50;
news_mode = 1;
news_load = false;
news_sreen_X=document.body.clientWidth;
news_sreen_Y=document.body.clientHeight;
news_lign_X = Math.round((news_sreen_X-news_larg)/2);
news_lign_Y = Math.round((news_sreen_Y-news_haut)/2);
if(document.getElementById && document.all)
{
document.write('<DIV ID=news_cache STYLE="position:absolute;top:0;
left:0;width:'+news_sreen_X+';height:'+news_sreen_Y+';z-index:5;
background:'+news_cache_color+'">');
document.write('<DIV ID=news_box STYLE="position:absolute;
top:'+news_lign_Y+';left:'+news_lign_X+';width:'+news_larg+';
height:'+news_haut+';background:'+news_box_color+';z-index:30">');
document.write(news_html_haut+news_html+news_html_bas)
document.write('</DIV></DIV>');
code="<v:line id=ligne1 style='LEFT:0;POSITION:absolute;TOP:0;
z-index:50' strokeweight='1pt' strokecolor='"+news_ligne_color+"'></v:line>";
code+="<v:line id=ligne2 style='LEFT:0;POSITION:absolute;TOP:0;
document.getElementById("news_cache").insertAdjacentHTML("afterBegin",code)
51
news_step_one();
window.onload = news_stop;
}
</SCRIPT>
Planning de réalisation :
Cette page a l'intérêt de montrer de manière claire et précise l'étalement de notre projet tout au
long de l'année. Oranisée comme un tableau à deux entrées, le visiteur peut rapidement comprendre
l'organisation temporelle de notre groupe.
Problèmes rencontrés :
Nous référençons sur cette pages tous les problèmes qui se sont posés lors du développement de
notre projet, et nous y exposons les solutions trouvées, si tenté qu'ils y en aient. Cette page est plus
principalement dédiée aux visiteurs qui pourront ainsi peut-être trouver des réponses à leurs problèmes.
10.4.2 Liens
Les liens :
Je pense qu'il n'y a pas excessivement à développer sur ce sujet car le titre est susamment explicite.
Cependant, précisons qu'il y a plusieurs types de lien :
Vers notre serveur FTP (des explications sont apportés un peu plus loin)
Vers les sites des membres du projet
Vers les sites que nous avons utilisé pour une raison ou pour une autre. A noté qu'un petit commentaire est suivi du lien an d'expliquer en quoi le site nous a été utile, et des petites précisions
sur la langue et le sujet du site.
Les diérents liens sont regroupés par thèmes :
Création Internet
Delphi
DirectX
LATEX
Open GL
10.4.3 Download
Les téléchargements :
Ce sera sûrement l'une des pages les plus visitées de notre site internet. De ce fait, cette page a été
peaunée. Présentation claire et agréable, lisible, où l'on trouve tout de suite ce que l'on cherche. Par
ailleurs, dans un souci de satisfaire pleinement le visiteur, pour chaque chier à télécharger, celui-ci aura
l'embarras du choix dans le type du chier.
Voici la liste des extensions disponibles :
Pour les rapports : .tex , .pdf , .dpi , .rar
Pour les executables : .rar
Pour les sources : .rar
Pour les vidéos : .avi
Pour le projet complet : .rar
Nous avons choisi de compresser via Winrar car ce logiciel est puissant en compression tout en étant
très répendu
Les diérents chiers télechargeables :
Il est possible de télécharger l'ensemble des rapports ou chacun des rapports, indépendamment
Téléchargement du jeu
Téléchargement du jeu en version allégé
Téléchargement des programmes d'installation et de désinstallation indépendamment
Téléchargement des vidéos
Téléchargement, bien évidement, du package complet
52
Le serveur FTP :
Pour pouvoir avoir toujours à disposition ce que l'on souhaite pour pouvoir travailler, quoi de mieux
que pouvoir accéder à son ordinateur depuis l'extérieur ? C'est dans cette optique qu'a été créé le serveur
FTP. Centralisation des données, sauvegarde qui plus est, cela a tous les atoûts ! Durant le développement
du projet, il va de soit que pour le public, le téléchargement n'était pas authorisé, mais ce n'est plus le
cas maintenant que le projet est terminé. Voici son adresse :
ftp ://[email protected]
Le serveur est très souvent ouvert. Lorsqu'il ne l'est pas, c'est soit parce que l'ordinateur a planté (et
oui. . .ça arrive), soit parce que l'ordinateur a été déconnecté prématurément, soit, dernière possibilité,
parce que le propriétaire est parti en vacances (ça arrive aussi. . .). Sinon, le serveur est ouvert 24h/24,
7j/7.
10.4.4 Espace concepteurs
Espace réservé aux concepteurs du projet et du site Internet. Cet espace créé au départ pour échanger
entre développeur a été un échec, elle n'a jamais rééllement servi. De ce fait, cette partie du site a disparu.
10.4.5 Forums
Le premier mai11 sont sortis nos forums. Espace de discutions par excellence, il permet au visiteurs
de poser leurs questions, d'apporter leurs remarques, etc. . .à propos de notre jeu. Plusieurs forums ont
été créés, regroupés par catégories :
Xmas - Le jeu Discution sur Xmas
Développement / Programmation sur la version ocielle
How To
Hotline technique : Questions / Réponses sur Xmas
Les bugs d'Xmas
Programmation language Pascal Développement en Pascal
Open GL
Direct X
A propos du forum ou du site Une critique, un conseil sur le forum ou le site
Une idée d'amélioration pour le forum ou le site
Le site ou le forum ont une erreur ?
Accessoirement, notre forum a été un espace de discutions sur les partiels de n d'année.
10.5 Les événements majeurs de son développement
10.5.1 La première soutenance
La première version du site a été mise en ligne. Elle ressemble assée à ce qu'est le site maintenant,
même si des changements importants y ont tout de même étés apportés.
10.5.2 La seconde soutenance
Une petite mise à jour avait rafraîchit le site. An de rendre le code un peu plus léger et d'accéder à
un outil graphique plus important, des feuilles de styles CSS ont été créé.
Également, une page pour chaque membres détaillant un peu plus son expérience informatique avait
été créé. Cela contribuait à la convivialité de site.
Évidement, le rapport avait été mis en ligne. A part ces petites retouches, rien de majeur n'avait marqué
son évolution.
11 Eh oui, il y a des gens qui travaillent le jour de la fête du travail
53
10.5.3 La troisième soutenance
La page d'accueil est la page la plus importante d'un site Internet. C'est par cette page que la majorité
des visiteurs vont découvrir le site, et vont se faire leur première impression. On juge souvent à première
vue un site par sa qualité de présentation. C'est pourquoi, un menu tout en Flalsh a été réalisé. Pour
cette réalisation, Aurélie Debeyter12 m'a fortement aidée.
Un site internet se doit d'être régulièrement actualisé, parfois même faire un peu peau neuve. La
couleur d'ambiance générale, un peu trop proche du rosé pouvait paraître un peu choquante venant d'un
jeu plutôt violent. Pour cette raison, l'ambiance générale est passé dans un ton plus foncé : le noir.
10.5.4 La soutenance nale
Reposant déjà sur une bonne base, le site Internet Xmas n'avait pas grande évolution à subir. Stéphane
PROTIN a tout de même eût le temps d'installer un forum. Le choix du forum s'est penché pour le forum
gratuit et open sources : Invision Board13 . La raison est simple, Stéphane PROTIN va régulièrement
sur un forum de ce type sur un autre site, il en a donc l'habitude, et l'apparence esthétique est plutôt
sympathique.
Partie Site Internet rédigée par Stéphane Protin
13 http ://www.ibf-french.com/
54
11 Le générique
Celui-ci a n'a été conçu qu'entre les deux dernières soutenance. Il n'était pas prévue quelques jours
avant celle-ci. Aucune boîte À propos n'avait également été imaginée. Un membre du projet a proposé
ainsi cette idée et de se consacrer à celle-ci.
11.1 Le choix des musiques
Nous avons cherché la musique la plus adéquate pour ce générique et notre choix c'est porté sur une
musique de 1 minute et 29 secondes : Fêtons Noël(cf. Partie Musiques)
Pour créer le générique proprement dit, nous avons utilisé des splashes que nous créions avec PhotoShop v7 et que nous diusions, dans le jeu, les un à la suite des autres en détermiant leur temps d'achage
selon la durée de la musique.
11.2 Création du générique
11.2.1 L'image
Nous avons choisi pour ce générique de évoquer principalement l'esprit de Noël. Le gén'erique est
constitué de 18 splashes qui sont des chier .bmp en 256*256 sur lesquels nous avons inscrit les crédits.
Nous avons choisi d'avoir comme couleur de fond de chaque splash du noir car celle-ci était une couleur
relativement passe-partout et quasiment tous les génériques de lms sont de cette couleur.
11.2.2 Le Texte
Cependant il fallait que la couleur et la police du texte évoque le plus l'esprit de Noël. Nous avons
ainsi opté pour la police happy.ftt recueilli sur http ://www.netgehog.com/index.php ?Recherche=happy
car c'est une police amusante qui incline chaque lettre soit vers la gauche, soit vers la droite. Pour plus de
fantaisie nous avons choisi d'écrire une majuscule une fois sur deux (CoMmE cEcI) ainsi que de colorer
toutes les majuscules en rouge foncé et les minuscule en vert foncé.
11.3 Les problèmes rencontrés
11.3.1 La qualité des images
Un problème que nous pensions rencontrer : avant le générique, le splash de victoire, contenant
quelques images, n'était pas de bonne qualité. Ceci était du au fait qu'une image de taille 256*256, étant
agrandie en 800*600 ou 1024*768, voire davantage, perd de sa qualité graphique. Cependant comme les
splashes du générique ne contiennent que du texte, l'image n'est pas réellement dégradée.
11.3.2 La synchronisation
Nous avons rencontré malgré tout, un probléme de synchronisation entre la durée du génerique et
celle de la musique utilisée. Nous avions calculé le temps que devait mettre chaque splash pour s'acher
en fonction de la durée de celle-ci . Nous voulions ainsi que certains événements de cette musique soit
synchronisés avec la diusion soudaine de certains splashes. Cependant la musique ne débutait pas en
même temps que la diusion du premier splash. Il y avait un décalage de quelques dizièmes de secondes
mais ceci était malheureusement susant pour le remarquer à l'oreille.
Ce problème étant du au temps de chargement de la musique et des splashes, qui diére d'un PC à
l'autre, ceci n'a pu être réellement corrigé, nous n'avons pu que prévoir une marge de sécurité pour que
le décalage ne soit pas choquant.
55
12 Conclusion
12.1 Bilan général de l'année
12.1.1 Progression
Pris sur toute l'année, le groupe a été plutôt dynamique, motivé, et en général plutôt travailleur. Le
projet est parti sur les châpeaux de roues dès le départ. Nous n'avons pas attendu d'être proche des
impératifs pour travailler. Ce qui nous a permis de prendre au départ une confortable avance, que nous
avons concervé tout au long de l'année.
12.1.2 Entente dans le groupe
Au tout départ, l'entente dans le groupe de projet était très bonne. Au l des soutenance, l'exapsérance
de la disparité de quatité de travail fourni par les diérents membres du groupe a commencé à créer des
petites tensions qui ne sont présente que lors des périodes de pré-soutenance. L'ambiance bon-enfant
revient ensuite.
12.1.3 Intéraction cours / projet
Mis à part le début d'année, le travail sur le projet n'a pas été très régulier. En eet, le travail s'est
fréquement eectué pendant les vacances uniquement, faute de temps le reste du temps.
Il est vrai que les week-end auraient dû nous permettre de travailler un peu plus régulièrement, mais
de temps à autre, il faut tout de même pouvoir se changer les idées. . .
12.2 Bilan par rapport au cahier des charges
Lors de l'établissement du cahier des charges, il avait été demandé de dénir les apports personnels
ainsi que les buts et intérêts de ce projet. Globalement, voici la liste des choses que nous a rééllement
approtés ce projet :
Travailler en groupe.
Découvrir les API (ce que c'est, utilisation, etc. . .).
Apprendre ou comprendre des langages : HTML, JAVA / Javascript pour l'application à Internet et
le langage : Pascal (Delphi) pour la programmation.
Mener à terme un projet de A à Z, c'est-à-dire de l'établissement du cahier des charges jusqu'à ce
qu'il soit terminer et fonctionne correctement, avec une contrainte de temps.
Apprendre à utiliser LATEX.
Apprendre à s'organiser.
Apprendre à devenir plus ecace et autonome à prendre des décisions, etc. . .
Devenir polyvalent, en pouvant travailler aussi bien sur le graphisme, la trois dimensions, l'Intelligence Articielle, la musique, le traitement de texte, etc. . .
Acquérir l'esprit d'équipe, et savoir aider les membres de son groupe qui seraient en diculté.
Apprendre à découper un problème en plusieurs parties an de le mener à bien.
Apprendre à chercher d'autres solutions à un problème.
Comprendre le rôle d'un chef de projet.
Se former à la communication devant un jury.
12.3 Qui a fait exactement quoi ?
12.3.1 Cahier des charges
Le cahier des charges avait était entièrement réalisé par Stéphane PROTIN. La correction orthographique et synthaxique avait quand à elle était eectué par Florent RÉTIF, ainsi que l'histoire du
jeu.
56
12.3.2 1re soutenance
Le moteur 3D
Travail sur les sources :
Jean-Alexandre IRAGNE et Florent RÉTIF ont travaillé dessus. Jean-Aleaxandre IRAGNE ayant
déjà de bonnes connaissances sur le sujet est partie très rapidement, alors que Florent RÉTIF devait
passer son temps à étudier le fonctionnement.
Rédaction du rapport :
Jean-Alexandre IRAGNE
Inputs
Alexandra VALAKHANOVICH et Stéphane PROTIN ont tout deux lu les parties concernés dans un
livre spécialisé. De plus, Stéphane PROTIN avait cherché s'il ne pouvait rien trouver sur Internet.
Alexandra VALAKHANOVICH
Intelligence Articielle
Florent RÉTIF s'était occupé de faire toutes les études nécéssaires, et de chercher quelles méthodes
seraient adoptés dans le jeu.
Florent RÉTIF
Site Internet
C'est Stéphane PROTIN qui a tout fait sur le site Internet :
La réexion sur la structure
Le language à utiliser
La conception
La recherche d'un hébergeur
La mise en ligne
Stéphane PROTIN
Vidéos
Jean-Alexandre IRAGNE s'était occupé de comprendre comment on réalise une vidéo, et a été aidé
par Stéphane PROTIN dans l'établissement des diérents scénarios des vidéos.
57
Mapping
Tandis qu'Alexandra VALAKHANOVICH avait étuidé 3DS Max, Jean-Alexandre IRAGNE avait en
plus, créé une map d'essai, et le père noël.
Rapport de soutenance :
Stéphane PROTIN s'est chargé de l'introduction et de la conclusion, et du plan de la soutenance. La
retranscription LATEX s'est eectuée par Stéphane PROTIN, ainsi que la mise en forme et les retouches.
De plus, Florent RÉTIF s'est occupé de la correction orthographique et syntaxique.
12.3.3 2e soutenance
Moteur 3D
Jean-Alexandre IRAGNE et Florent RÉTIF ont beaucoup travaillé dessus. Recherches, implementation, corrections, etc. . .Ils se sont complétes.
Mapping
Alexandra VALAKHANOVICH a récupéré des objets pour pouvoir les utiliser. De plus, Jean-Alexandre
IRAGNE s'est occupé de créer des textures et de les appliquer, toujours pour la même raison.
Musique et bruitages
Alexandra VALAKHANOVICH avait passé à Florent RÉTIF une bibliothèque de son sur CD. Florent
RÉTIF s'est chargé d'étudier quels types de sons correspondraient le mieux à notre jeu. Il a également
fait une recherche supplémentaire de son :
sur Internet
dans ses jeux
sur ses CD
sur le CD d'Alexandra VALAKHANOVICH
Florent RÉTIF
Input
Alexandra VALAKHANOVICH a téléchargé un exemple tout fait de Direct Input sur Internet. Stéphane PROTIN et Jean-Alexandre IRAGNE se sont débrouillés pour l'utiliser et pour l'adapter à notre
jeu.
58
Interface
Jean-Alexandre IRAGNE s'en est entièrement occupé.
Florent RÉTIF et Stéphane PROTIN ont fait un travail complémentaire l'un sur l'attaque / fuite,
l'autre sur le champ de vision.
Florent RÉTIF
Stéphane PROTIN s'est chargé de l'introduction et de la conclusion, et du plan de la soutenance. La
retranscription LATEX s'est eectuée par Stéphane PROTIN, ainsi que la mise en forme et les retouches.
De plus, Florent RTEIF
s'est occupé de la correction orthographique et syntaxique.
12.3.4 3e soutenance
Moteur 3D
Jean-Alexandre IRAGNE a travaillé sur l'optimisation et la réduction de la map.
Mapping
Alexandra VALAKHANOVICH a récupéé des objets inutilisables (beaucoup trop de points). JeanAlexandre IRAGNE s'est occupé de faire des objets utiles, et permettant d'avoir une uidité dans le
jeu.
Musique
Florent RÉTIF a terminé de trouver les diérents sons et musiques du jeu. Il a été aidé par JeanAlexandre IRAGNE pour l'intégration dans le jeu.
Florent RÉTIF
59
Input
Stéphane PROTIN et Jean-Alexandre IRAGNE se sont penchés sur les dernières erreurs d'implémentation et d'intégration.
Stéphane PROTIN
Achage
Jean-Alexandre IRAGNE s'est occupé de tout.
Florent RÉTIF a implémeté les collisions map-ennemi. Stéphane PROTIN a implémenté les collisions
ennemi-héros, et préparé la gestion de plusieurs ennemis. Jean-Alexandre IRAGNE a fait les collisions
héros-map.
Florent RÉTIF
Vidéos
Jean-Alexandre IRAGNE et Stéphane PROTIN ont travaillé en même temps dessus, de manière égale.
Installation / désinstallation
Stéphane PROTIN a tout fait.
Stéphane PROTIN s'est chargé de l'introduction et du plan de la soutenance. La retranscription LATEX
s'est eectuée par Stéphane PROTIN, ainsi que la mise en forme et les retouches. De plus, Florent RÉTIF
s'est occupé de la conclusion, de la correction orthographique et syntaxique.
12.3.5 Soutenance nale
Moteur 3D
60
On a été à trois à travailler ensemble dessus : Stéphane PROTIN , Jean-Alexandre IRAGNE et Florent
RÉTIF.
Florent RÉTIF
Mapping
Alexandra VALAKHANOVICH a réalisé une seconde map. Jean-Alexandre IRAGNE a corrigé les
nombreuses erreurs de map, et fait le placement des ennemis. Il s'est également occupé de diverses choses
comme des cadeaux de couleurs diérentes, etc. . .
Alexandra VALAKHANOVICH, complété par Stéphane PROTIN (insusance de volume)
Musique
Jean-Alexandre IRAGNE et Florent RÉTIF ont travaillé de pair pour refaire tout le son, pour le
rendre plus réaliste, pour qu'il soit en 3D, etc. . .Ils ont également rajouté des nouveaux sons.
Florent RÉTIF
Vidéos
Pour la vidéo d'introduction, Stéphane PROTIN et Jean-Alexandre IRAGNE ont travaillé de pair
que ce soit dans la réalisation ou dans l'intégration. Pour la vidéo de bonus, Jean-Alexandre IRAGNE
et Stéphane PROTIN ont joués les caméra-man, et Jean-Alexandre IRAGNE s'est chargé de faire le
montage. Ce dernier s'est aussi occupé des animations dans le jeu.
Interface
Florent RÉTIF s'est chargé de tout ce qui est des images de n de jeu. Jean-Alexandre IRAGNE et
Stéphane PROTIN ont ni les diérentes fonctionnalités de l'interface.
Inputs
61
Installation / désinstallation
Stéphane PROTIN a tout réalisé.
Site Internet
Stéphane PROTIN a installé le forum, et mis a jour des pages en collaboration avec Aurélie Debeyter14 .
Chaque membre a rempli une page perso.
Stéphane PROTIN
Annexes :
Les annexes ont été rédigés par Jean-Alexandre IRAGNE et Stéphane PROTIN. Tous deux se sont
divisés les tâches à se sujet.
Stéphane PROTIN s'est chargé de l'introduction, de la conclusion et du plan de la soutenance.Il a
également centralisé ainsi que mis en forme, corrigé (pour que ça compile) et les uniformisé le rapport. De
plus, Florent RÉTIF et Stéphane PROTIN se sont occupés de la correction orthographique et syntaxique.
Dossier d'exploitation :
Français et espagnol ont été réalisé par Florent RÉTIF. Stéphane PROTIN s'est occupé de la transcription en LATEX. Alexandra VALAKHANOVICH a traduit en anglais et en russe, mais ses parties se
sont révélés inexploitables, car les caractères russes ne passaient pas sur nos ordinateurs.
Le CD-ROM :
Jean-Alexandre IRAGNE s'est occupé de l'arrangement du CD. Aurélie Debeyter s'est occupée de
la jaquette du CD. La réalisation du gravage sous le CD (fonction T@2) s'est eectuée par Stéphane
PROTIN.
12.3.6 Conclusion
On remarque que trois personnes se sont démarqués par leur quantité de travail fourni. La palme,
dans notre groupe, du codeur le plus acharné revient sans conteste à Jean-Alexandre IRAGNE qui a
participé à toutes les intégrations, et a donc touché à toutes les parties du jeu.
12.4 Récits de réalisation
12.4.1 Nos joies
Notre plus grande joie est d'avoir nie notre jeu, et d'avoir pu y rajouter des bonus qui le rend conviviale
et sympathique. On est arrivé à un résultat qui nous satisfait pleinement, sûrtout au vu du peu de temps
qui nous était imparti.
Également, nous avons pu exprimer notre joie de réaliser ce projet en lmant tous les bons moments.
C'est des extraits de ces moments qu'est tiré notre vidéo de bonus.
62
12.4.2 Nos peines
On est beaucoup dans notre groupe a penser que seul trois membres ont trouvé de l'intérêt dans sa
réalisation.
On a pas assez de temps en fait pour penser à optimiser chacun de nos algorithmes
On trouve dommage que le jury ne regarde pas assez qui fait quoi
12.5 Ouverture
Quelles sont les choses qui auraient pu être fait en supplément, si nous avions eu par exemple une
année supplémentaire ?
faire plus de map
faire un éditeur de map
corriger encore certaines petites erreurs de map
diérencier les pas sur un sol carrelé et dans la neige
changer les textures et les éloigner pour les faire plus dessin animée
possiblilité d'avoir plusieurs armes
mettre des objets qui peuvent bouger : des portes qui s'ouvrent, etc. . .
possibilité de recharger une arme
plusieurs types d'ennemis aussi et un boss
plusieurs niveaux de diculté
un mode en réseau
que les bots puissent faire des rondes, et si possibles qu'ils parcourent la map pour trouver le Père
noël.
NB : L'intégralité cette répartition des tâches ne reète que la réalité, nous avons essayé de traiter
cette partie avec la plus grande honnêteté. Nous ne nous somme, en aucun cas, acharné sur quiconque
sans justication.
12.6 Remarques face aux jurys
Nous avons quelques remarques à faire face au jury. Chronométrant nos soutenances pour garder un
repère temporel durant celles-ci, il nous est arrivé de nous faire reprocher un dépassement de temps
impartie, tandis que le chronomètre indiquais le contraire. . .
D'autre part, nous pensons qu'il serait utile d'avoir des retours après les soutenances de ce qui n'a pas
été, où et pourquoi nous avons perdu des points sur telle ou telle chose. Bref, un petit retour qui nous
permettrait d'obtenir une meilleure note.
Une autre idée qui à notre avis peut-être utile pour les nouveaux venus est une liste de tous les sites
Internet d'une promotion. Les promotions futures pourraient ainsi facilement connaître les projets réalisés
et connaître les attentes des jurys.
Partie Conclusion rédigée par Stéphane Protin
63
13 Jeu d'essais
Durant l'implémentation du jeu nous avons été obligé de vérier pas à pas la justesse des algorithmes.
An de s'assurer qu'ils étaient bon, nous avons dû créer des petits exemples de map ou des situations
simples. Ensuite nous compliquions tout et nous revérions les algorithmes. Le plus compliqué était de
reproduire des situations de bogue. Pour ce faire on a tout particulièrement vérié ces algorithmes :
Collisions - rédigé par Jean-Alexandre Iragne
La détection de problèmes :
Pour les collisions nous avons eu un petit problème : dans certaines situations nous arrivions à rentrer
à l'intérieur des murs et a les traverser. Le plus dur dans ce problème fût de recréer les situations ayant
des problèmes, après quelques minutes et une bonne réexion nous nous sommes rendu compte que ces
situations arrivaient en présence d'un mur moins large que nous.
Mise en évidence :
Nous avons réalisé une map d'essai avec des situations comme celles-ci et là, à notre bonheur, c'était
celles là que nous traversions avec facilité.
La méthode de résolution :
La meilleure méthode que nous avons trouvé est celle que nous avons utilisé pour chaque problème,
cette méthode est de réécrire le problème sur papier puis de faire une vérication avec celui écrit et par
chance avec ce bogue on avait juste oublié ce cas particulier. Enn, après la réécriture on l'a testé sur
cette map de test et plus aucun bogue. Donc, nous avons relancé le jeu avec la map initiale et encore
refait des tests et rééchit à d'autres cas particuliers mais il n'y en avait plus.
Gestion des ennemis - rédigé par Stéphane Protin
Poursuite et fuite
L'une des premières choses de l'IA que nous avons implémenté. En ce qui concerne les champs de vue,
nous avons essayé avec diverses ennemis, en leur tournant autour, en s'approchant par derrière, etc, ils
ont toujours bien respecté cela ! Enn, quand nos axes étaient dans le bon sens. . .
Pour tester la poursuite, on a placé diverses ennemis à des endroits très variés de nos map, et on a
essayé un peu toutes les directions pour voir s'ils nous suivaient bien, etc. . .Ils prennent d'après nos tests
toujours bien la diagonale en nous poursuivant sur la ligne droite que l'on peut former par les deux points
que forment le père noël et l'ennemi.
La fuite, lorsqu'elle est possible concerne l'empêchement du père noël de traverser l'ennemi. Ainsi,
celui-ci recule. Cependant, s'il se retrouve coincé, dans ce cas, il ne bouge pas. Le teste est assez simple,
on lui fonce dedans, on essai encore et toujours de le pousser contre la map, etc. . .
Collisions Ennemis - Héros
Cette opération n'est pas très dicile, il sut d'essayer de foncer dans l'ennemi. Pour faire un test de
qualité, nous avions désactivé la baisse de nos points de vie lorsque l'ennemi nous tire dessus.
Nous avons ainsi pu nous défouler en essayer de traverser l'ennemi de toute part, soit en le bousculant,
soit en essayant de le coincer dans un coin, ou contre un mur. Extrêmement rare sont les fois où nous
sommes parvenu à le traverser. Les seules fois sont lorsque l'on peut se retrouver coincé, et donc pour
que le jeu continue, on puisse bouger.
64
Ce cas ne devrait pas se produire avec un joueur, car le temps d'arontement avec un ennemi étant
assez rapide, il n'est pas possible de se retrouver dans cette situation.
Collisions Map - Ennemis
En même temps que les collisions Ennemi-Héros, on a put tester les collisions Map - Ennemis. En eet
lorsque l'on tente de coincer l'ennemi contre un mur ou dans un coin, l'ennemi interagit avec la map. On
voit tout de suite s'il traverse la surface ou non.
Également, nous avons essayer de faire traverser aux ennemis les murs des maisons, les surfaces vitrées,
etc. . .Rien d'invraisemblable nous est apparu. Même en essayant avec des objets de forme un peu bizarre
comme le sapin.
Le petit bug qui pourrait arriver, c'est que le chier BMP d'ou l'on tire les informations de la map
soit mal fait, et qu'il y ai des points blancs à des mauvais endroits, dans ce cas, il pourrait commencer à
traverser.
Moteur 3D - rédigé par Jean-Alexandre Iragne
La détection de problèmes :
Le premier problème lié au moteur 3D est une vibration des personnages et une vision des jambes
uniquement. Ensuite un autre problème fût le déplacement des personnages qui se déplaçait à l' opposé
des données envoyées.
Mise en évidence :
Pour le premier problème, nous avons enlevé l'achage, du monde, de la tête des ennemis, de l'arme du
torse. Mais cela ne changeait rien alors nous avons ralentit la boucle d'achage et enlevé tout les inputs
et là, nous nous sommes rendu compte qu'il y avait bien une animation mais que le réel problème était la
vitesse de cette animation qui était trop rapide et donc donnait une impression de vibration. Puis pour
l'achage où l'on ne voyait que des jambes, nous avons supprimé l'achage de celle-ci et nous avons
remit l'achage du torse, de la tête et de l'arme et nous nous sommes rendu compte que tout était bien
aché mais que tout était aché en zéro. Et nalement pour le dernier problème, nous avons regardé le
code et rééchit sur l'orientation des axes.
La méthode de résolution :
Le premier problème lié au moteur 3d fût simple a résoudre. Au lieu d'acher une image diérente à
chaque image, j'ai autorisé un changement d'image toutes les 70 millièmes de seconde, et cela fonctionnait
très bien.
En revanche, pour le problème d'achage des diérentes parties du personnage, nous avons posté sur
plusieurs forums. Et après plusieurs jours des personnes nous ont dit qu'il y avait dans le chier md3
une matrice de position et de rotation integer mais nous ne l'avions pas donc on a refait des recherches
et remarqué que dans notre lecture nous sautions cette donnée (enn, elle était lue mais stockée dans un
tableau de byte) alors en refaisant mieux le type de donnée nous avons pu intégrer le bon type, celui de la
matrice. Finalement pour le dernier problème, nous avons refait les fonctions sur un papier et en fonction
des axes d'openGl nous nous sommes rendu compte que nous avions inversé tout simplement les axes xz.
La maniabilité - rédigé par Stéphane Protin
Les inputs
La maniabilité passe par la facilité avec laquelle on peut se déplacer dans l'espace du jeu. Cela dépend
directement des inputs.
65
Nous avons testé tout d'abord les réglages de déplacement par rapport aux mouvements que l'on essai
de produire avec la souris ou le clavier. Par dichotomie, on a trouvé un juste milieu qui nous semble
agréable pour le joueur.
Est venu par la suite le test de changer les paramétrages. Comme c'est possible dans notre jeu. Une fois
des nouvelles touches choisies, on les a testés dans un peu toutes les situations sur la map (c'est-à-dire,
dans tous les endroits, voir si cela gardais bien les collisions, etc. . .).
Distances de collisions
Le problème lorsque l'on règle les distances de collisions, c'est qu'il faut un juste milieu pour que l'on
puisse facilement être autorisé à se déplacer sans pour autant traverser les objets.
Un premier réglage avait été fait, cependant, on s'est aperçu que, certes, on ne risquait pas d'avoir de
problèmes en traversant la map (c'était impossible), cependant, c'était bien la galère pour passer par les
portes !
Nous avons rapproché la caméra du père noël, et nous avons réduit les distances de collisions. La
maniabilité du jeu s'en est fortement ressentie. On a testé sur toutes nos maps, dans tous les coins,
tous les endroits susceptibles de provoquer une exception dans notre algorithme (et donc autoriser le
déplacement alors que cela ne devrait pas être le cas). Nous n'avons eu aucune mauvaise surprise.
Glissades sur les murs
Je dois dire que cette partie nous a bien ennervé. En eet, nous trouvions dommage de ne pas pouvoir
le faire, et le jury nous a dit qu'il nous féliciterai si nous réussissions à réaliser cette partie. Plusieurs
problèmes se sont posés :
Distinguer les diérents cas possibles
Faire en sorte que ce soit possible pour avancer et reculer
Dans la diérenciation des cas possibles, il s'est avéré que d'après les donnés que l'on possédais, on
avait deux cas diérents qui avaient les mêmes conditions, pour autoriser un déplacement sur un
axe diérent
Une fois la disjonction de cas faite, le problème a persisté pour le recul, car s'est un cas un peu à part,
puisque tout doit être inversé.
Une fois que cela commençait on a essayé tous les endroits des maps, on a essayé tous les sens, contre
tous les objets, et il s'est avéré que seul sur certaines petites erreurs de maps persistantes on avait des
problèmes (on n'a pas le déplacement d'autorisé) . Mais sinon, cela marche très bien.
66
Dessins Originaux
Fig.
6 Dessins d'origine du pèr noël
67

Projet Xmas Rapport de projet

Transcription

Documents pareils

Est-ce que Josephine Ange Gardien est aussi un lutin du Père

Fonctionnalités

concours FFTL du 13 mars 2016

LE PÈRE NOËL EST UNE ORDURE

La dernière lettre d`information

26.11.16 Cologne Marché de Noel

Marché de Noël 2008

Noël en Espagne Navidad en España

Catalogue des cadeaux Arbre de Noël ASPACAM 2015

02 - marche de noel castres