%870 624 ==> spank
%870 627 ==> search
%870 629 ==> Bambi Eyes
%870 826 ==> Aaaaaaaaaaaaaaaaaa
%870 214 ==> Wake up, saturday

\documentclass[18pt]{report}

\usepackage[francais]{babel}
\usepackage[cyr]{aeguill}
\usepackage[T1]{fontenc}
\usepackage{dcolumn}
\usepackage[pdftex,colorlinks=true,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref}
\usepackage{anysize}
\usepackage[right]{eurosym}
\usepackage[Glenn]{fncychap} % Sonny, Lenny, Glenn, Rejne, Bjarne
\usepackage[pdftex]{graphicx}
\usepackage{color}
\usepackage{alltt}

\DeclareGraphicsExtensions{.jpg,.pdf}

\topmargin -3cm \textheight 27cm \setlength\extrarowheight{4pt}

\begin{document}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% DEBUT %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\vskip2cm

\begin{tabular}{c}
\\
\\
\\
\includegraphics[height=140mm]{twilight_of_khanerat_page}
\end{tabular}


\begin{center}
\vskip10mm \Huge Rapport de Soutenance \vskip2cm \Large Cédric
Durand \vskip2mm Alexandre Cyprien \vskip2mm Adrien Debos
\\ \vskip2mm Benoît Guillemaille \vskip9mm InfoSup C2 \normalsize
\end{center}

\tableofcontents

\chapter{Introduction}
Voici arrivée la première soutenance. Après avoir codé tous
ensemble, même les week-ends et jours feriés\ldots
\begin{center}
\includegraphics[height=4cm]{calvin_1}
\end{center}
Petit rappel, Twilight of Khanerat, ou ToK pour les intimes, est un
jeu développé par 4 élèves d'InfoSup C2. Ce jeu est un tactical rpg,
le but du jeu étant de capturer tous les points stratégiques
présents sur une carte 2D. Pour ce faire, des combats 3D au tour par
tour auront lieu lors d'une attaque. \vskip1cm Cependant, le jeu
n'en est qu'à ses débuts et nous allons faire le point sur ce qui
est fait, ainsi que sur ce qu'il reste à faire. \vskip1cm L'heure
est venue de faire le point sur ce qui a été fait jusqu'à présent !
\begin{center}
\includegraphics[height=8cm]{vaillant_1}
\end{center}



\chapter{Moteur Graphique : Alexandre}
\vskip1cm
\section{DirectX VS OpenGL}
\vskip1cm A l'époque fort lointaine du cahier des charges, nous
avions longuement hésité sur le choix de la librairie graphique à
utiliser. Peu aidés par les trolls en tout genre, nous avions choisi
DirectX. Cependant, après 3 semaines d'efforts, le résultat était au
même point : nul. J'ai alors tenté OpenGL : le résultat ne s'est pas
fait attendre. Tout était plus simple, plus rapide. Nous avons donc
continué avec OpenGl : assez tergiversé comme cela. \vskip2cm
\begin{center}
\includegraphics[height=4cm]{leonard_1}
\end{center}
\vskip2cm
\section{GLFW VS GLUT}
\vskip1cm Après moultes recherches sur le net, nous avons décidé
d'utiliser la bibliothèque glfw et cela pour deux raisons :
\begin{itemize}
  \item Le nombre de
tutoriaux impressionnant sur le net.
  \item La mauvaise réputation de
GLUT.
\end{itemize}
\vskip3cm
\section{Les débuts}
\vskip1cm
\subsection{La fenêtre OpenGL}
\vskip8mm J'ai démarré par la base de la base, c'est-à-dire
l'ouverture d'une fenêtre OPENGL. Après avoir sauté de joie suite à
l'affichage de mon premier écran noir\ldots \vskip15mm
\begin{center}
\includegraphics[height=4cm]{spirou_4}
\end{center}\vskip1cm \ldots nous avons décidé d'afficher
des\ldots \vskip2cm
\subsection{Primitives}
\vskip8mm Nous avons commencé par tracer trois lignes, qui, reliées
entre elles, dessinent un magnifique triangle rouge. Par la suite
nous sommes rapidement passés à la 3D avec notre premier cube
multicolore. \vskip12mm
\begin{center}
\includegraphics[height=4cm]{graph_1} \includegraphics[height=4cm]{graph_2}
\end{center}
\vskip12mm
\subsection{Animations}
Un cube immobile c'est bien, mais un cube en mouvement c'est mieux.
De fil en aiguilles, nous avons dû animer notre beau cube :
rotation, translation, agrandissement\ldots Apres quelques essais
nous avons essentiellement utilisé : \vskip5mm
\begin{itemize}
  \item GlRotate
  \item GlTranslate
  \item GlScale
\end{itemize}
\vskip15mm
\subsection{Et la lumière fût !}
 Après avoir animé notre cube, nous avons décidé de faire
deux choses : \begin{itemize}
    \item incorporer les effets de lumières.
    \item dessiner une première skybox de couleur uniforme.
  \end{itemize}
\vskip8mm Ici, nous avons un léger problème au niveau de la lumière
: les couleurs ont disparu. A part ce petit bémol, l'ensemble est
déjà joli à regarder\ldots
\begin{center}
\includegraphics[height=6cm]{graph_3}
\end{center}
\vskip5mm
\subsection{les quadrics}
Dans notre jeu, chaque joueur a une zone de déplacement, nous
voulions représenter celle-ci par un cercle transparent évoluant en
même temps que les déplacements des personnages. Mais, nous nous
sommes rendu compte qu'il était impossible avec glfw d'afficher des
objets circulaires, cylindriques, sphériques. Donc, après quelques
recherches nous avons découvert les Quadrics. Nous avons alors
décidé d'afficher (pour commencer) un disque.

\begin{alltt}
    disk := gluNewQuadric();
    gluDisk(disk,rayoni,rayone,30,1);
\end{alltt} Avec rayoni le rayon interne, et rayone le rayon externe.

Passons à l'affichage d'une sphère.
\begin{center}
\includegraphics[height=6cm]{graph_4}
\end{center}
Que vois-je ? La sphère est... transparente !
\begin{center}
\includegraphics[height=4cm]{spirou_5}
\end{center}
\subsection{La Transparence}
\vskip3mm Et oui, l'objectif principal était d'avoir un disque de
déplacement transparent. La transparence est obtenue grâce au dessin
(dans un ordre précis : du plus opaque au plus transparent) des
formes. Jusqu'ici tout allait bien, jusqu'à l'apparition des
textures \ldots \vskip2cm
\subsection{Les Textures}
\vskip3mm Les textures ont été un réel problème. En effet, les seuls
codes qui n'étaient pas en Delphi Form étaient soit orientés objet,
soit en C/C++ . N'ayant pas appris la programmation orientée objet
ni la manière de déclarer des variables en C, nous avons eu beaucoup
de mal à avoir quelque chose de convenable et d'à peu près
compréhensible . Mais  après trois jours de recherches, de tests de
code, d'échecs, de bugs, de plantage, la solution était là.
\vskip4mm Nous avons décidé d'utiliser comme première texture notre
logo. \vskip5mm
\begin{center}
\includegraphics[height=6cm]{graph_5}
\end{center}
\vskip15mm
\section{Le moteur graphique actuel}
En effet, tout cela n'était essentiellement que de l'apprentissage
en vue de créer réellement un moteur graphique. Nous nous sommes
posés plusieurs questions sur ce que devait contenir notre moteur
graphique. Nous avons conclu qu'il y avait trois grands points :
\vskip 4mm
\begin{enumerate}
  \item Afficher des formes diverses et variées à
  l'écran
  \item De loader une texture
  \item de loader un objet 3D (3DS Max)
\end{enumerate}
\vskip1cm
\subsection{Une façon simple d'afficher des formes}
En effet, après la batterie de tests effectués lors de
l'apprentissage d'OPENGL, nous nous sommes aperçus  de deux choses
lorsqu'il fallait  tracer un cube, un triangle ou n'importe quoi
d'autre : \vskip3mm
\begin{itemize}
  \item Soit cela prend beaucoup de place
  \item Soit on crée un nouveau .pas avec une fonction de traçage.
\end{itemize}
\vskip3mm Voyant que la première allait être désastreuse, nous nous
sommes penchés sur la seconde. De ce fait, bibli.pas a vu le jour.
\vskip2cm
\subsubsection{Le bibli.pas}
\vskip8mm Bibli.pas est un immense .pas me permettant de tracer
toutes les formes de bases, elles sont pré-codées de façon générale.
Mais la il y a un 'hic'. En effet comment faire pour choisir la
couleur .Dans l'état actuel des choses ce .pas gère cinq types de
formes differentes (les pavés, les maisons, les disques, les
sabliers, et les skybox). Les fonctions appartenant à ce .pas sont
de cette forme : \vskip3mm
\begin{alltt}
    forme(x,y,z,longeur, largeur, hauteur, couleur, alpha); (pour les polygones)
    forme(rayoni,rayone,couleur,alpha; (pour les quadrics)
\end{alltt}
 où x, y et z sont les coordonnées du centre de la base,
 longeur, largeur et hauteur sont la largeur, la longeur et la hauteur de la forme,
 la couleur est gérée par color.pas et la valeur alpha (pour les
 transparences). \vskip1cm
Pour les Quadric, les coordonnées x, y, z, sont gérées par un :
\vskip3mm gltranslate( x, y, z) ; ( déplace du point 0,0,0 vers x,
y, z) \\ Exemple d'appel de procédure avec bibli.pas : \vskip3mm
\begin{alltt}
        pave(-10,-20,0,4,4,4,'vert',200);
        maison(10,-20,0,6,4,6,'vert',200);
\end{alltt}
\vskip8mm
\subsubsection{Le color.pas}
\vskip3mm Color.pas est un ensemble de fonction qui à partir d'un
string ('bleu', 'vert', 'rouge',\ldots.) renvoie un pseudo tableau.
Ainsi, bibli.pas et color.pas travaillent de concert pour afficher
les formes à l'écran. Actuellement, il gère huit couleurs (bleu,
rouge, vert, jaune, noir, blanc, gris, gris foncé) et si la valeur
donné en paramètre est incorrecte, la couleur  change constamment.
\vskip3mm Exemple d'application de couleurs (avec la fonction
tocolor) : \vskip3mm
\begin{alltt}
    color1 :=tocolor(couleur,0);
    color2 := tocolor(couleur,1);
    color3 := tocolor(couleur,2);
    color[0]:=color1;
    color[1]:=color2;
    color[2]:=color3;
    glColor4ub(color[0],color[1],color[2],alpha);
\end{alltt}
\vskip1cm
\begin{center}
\includegraphics[height=9cm]{moteuractuel}
\end{center}
\vskip6cm
\subsection{Loader une texture}
\vskip1cm Dans l'état actuel du projet, le loader de texture n'est
pas prêt. En effet, pour être opérationnel il doit être fusionné
avec bibli.pas. \vskip8mm Actuellement, nous avons un cube texturé
ayant sur chaque face le logo de Twilight of Khanerat. Le fait de
pouvoir appliquer une texture sur presque n'importe quoi est un des
grands objectifs pour la prochaine soutenance. \vskip1cm
\subsection{Loader un modèle 3D}
\vskip1cm Sans Loader de texture, difficile de passer à un loader de
modèle 3D. Cependant, nous nous sommes initiés à l'utilisation de
3DS Max 8.
\\
\begin{center}
\includegraphics[height=8cm]{graph_6} \vskip1cm \includegraphics[height=8cm]{graph_7}
\end{center}


\chapter{Moteur Physique : Adrien}
\section{Introduction}
Si un tactical RPG n'a pas besoin d'un moteur physique très avancé,
il reste nécessaire pour pouvoir gérer les déplacements sur la
carte. Ces déplacements ne dépendent que des touches que le joueur
va presser, excepté si le déplacement est impossible. Le monde dans
lequel le joueur va évoluer a beau être fantastique, il incarnera un
personnage réel qui doit se déplacer normalement sans sortir des
limites de la carte.
\section{Déplacements, gestion des touches : Alexandre}
Notre personnage, pour le moment représenté par un cube, doit
pouvoir se déplacer vers l'avant, l'arrière, la droite et la gauche
car nous avons décidé de ne pas permettre le déplacement en
diagonale.
\subsection{Ce qui a été fait}
La gestion du déplacement est pour le moment assez sommaire. Nous
nous sommes servis de GLFW qui gère les inputs claviers de façon
assez simple. Pour savoir si une touche est appuyée, on se sert de
glfwGetKey(valeur de la touche) la valeur de la touche étant la
désignation de la touche : \\
\begin{description}
  \item[Touche Haut :] \begin{alltt}GLFW_KEY_UP \end{alltt}
  \item[Touche Bas :] \begin{alltt}GLFW_KEY_DOWN \end{alltt}
  \item[Touche Droite :] \begin{alltt}GLFW_KEY_RIGHT \end{alltt}
  \item[Touche Gauche :] \begin{alltt}GLFW_KEY_LEFT \end{alltt}
\end{description}
\vskip8mm Le code utilisé ressemble donc à celui-ci : \vskip5mm
\begin{alltt}
        {\bf if} glfwGetKey(GLFW_KEY_UP) = GLFW_PRESS {\bf then}\\
            {\bf begin}
                x:=x+1;
                y:=y+1;
            {\bf end;}

        {\bf if} glfwGetKey(GLFW_KEY_LEFT) = GLFW_PRESS {\bf then} \\
            {\bf begin}
                cote:=cote+1;
                y:=y+1;
            {\bf end;}
\end{alltt}
 La variable  x correspond à l'abscisse et la variable cote
correspond à l'ordonnée du point central de la surface de base du
cube que nous déplaçons. Pour les touches bas et droite, on utilise
un algorithme similaire. Pour le moment, le déplacement droite et
gauche est un déplacement latéral du cube. Si on le remplaçait par
un personnage, celui-ci se déplacerait en pas chassés\ldots Pas très
réaliste, mais ce déplacement latéral sera modifié prochainement.
\\ La variable y correspond au cercle de déplacement cité plus haut. \vskip1cm

\subsection{Ce qu'il reste à faire}
Les prochaines modifications seront donc de faire tourner le cube
sur lui-même quand les touches droite ou gauche seront enfoncées
afin que le déplacement du personnage soit réaliste.

\section{Les Collisions : Adrien}
Le personnage devra obligatoirement rester sur la carte et donc il
ne doit pas dépasser les murs de la skybox : le personnage étant
vivant il ne devra donc pas pouvoir traverser un obstacle tel un
fantôme.
\begin{center}
\includegraphics[height=6cm]{Mphysique_1}
\end{center}
\subsection{Ce qui a été fait}
Les déplacements du cube ont donc été modifiés pour pouvoir calculer
les coordonnées des points du cube en même temps qu'il se déplace.
Ces coordonnées sont rentrées dans un tableau à deux dimensions :
\begin{alltt}
{\bf cube} : array[0..3] {\bf of} array[0..1] {\bf of} integer;
\end{alltt}

\begin{itemize}
  \item Numéros des Coins : \\
    \begin{itemize}
      \item 0 => coin bas gauche
      \item 1 => coin bas droite
      \item 2 => coin haut droite
      \item 3 => coin haut gauche
    \end{itemize}
  \item Coordonnées des points
\end{itemize}
    \begin{itemize}
      \item 0 => x
      \item 1 => cote
    \end{itemize}

\begin{alltt}
{\bf if} glfwGetKey(GLFW_KEY_UP) = GLFW_PRESS  {\bf then}   \\
    {\bf begin} \\
            x:=x+1;\\
            cube[0,0]:= cube[0,0] + 1; \\
            cube[1,0]:= cube[1,0] + 1; \\
            cube[2,0]:= cube[2,0] + 1; \\
            cube[3,0]:= cube[3,0] + 1; \\
            y:=y+1; \\
    {\bf end}\\

{\bf if} glfwGetKey(GLFW_KEY_LEFT) = GLFW_PRESS {\bf then} \\
    {\bf begin} \\
            cote:=cote+1; \\
            cube[0,1]:= cube[0,1] + 1; \\
            cube[1,1]:= cube[1,1] + 1; \\
            cube[2,1]:= cube[2,1] + 1; \\
            cube[3,1]:= cube[3,1] + 1; \\
            y:=y+1; \\
    {\bf end}\\
\end{alltt}
On peut ainsi comparer avant de faire le mouvement les coordonnées
du cube et les coordonnées maximum de la carte, car elle a une
taille constante. Cela nous permet donc de ne pas traverser la
skybox, au cas ou le personnage tente de le faire.
\begin{center}
\includegraphics[height=6cm]{Mphysique_2}
\end{center}
\subsection{Ce qu'il reste à faire}
L'objectif est maintenant de gérer non plus les collisions contre la
skybox mais contre tous les obstacles qui seront présents sur la
carte en utilisant probablement un tableau pour répertorier toutes
les coordonnées des obstacles.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Réseau %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\chapter{Réseau : Cédric}
\section{Choix principal}
Nous avons été assez vagues dans le cahier des charges à propos du
réseau. En effet, nous avons juste défini ses objectifs. Voici donc
notre choix en matière de réseau. \\ Nous avons opté pour ICS : nos
choix ont été motivés par la grande quantité de sources sur internet
ainsi qu'auprès de nos spés préférés, mais aussi par des avis plus
favorables pour ICS que pour Indy, apparemment trop limité en nombre
de connexions et en rapidité.

\section{Ce qui a été fait}
Comment s'initier au réseau ? Ics gère le transfert de deux types :
les strings et les autres. La conclusion est simple. Et si on
faisait un chat ? \vskip 5mm Premier objectif : le DelphiForm. Nous
avons tout d'abord créé la structure du chat.
\begin{center}
\includegraphics[height=12cm]{Reseau_1}
\end{center}
\vskip2cm Le plus simple était fait. Il ne restait plus qu'à coder
la partie réseau...
\begin{center}
\includegraphics[height=4cm]{tintin_1}
\end{center} Voilà le chat
opérationel. Voici ses principales caractéristiques, séparées en
deux catégories : Serveur et Client. \vskip15mm
\subsection{Serveur}
Nous avons mis en place un serveur "officiel" du jeu, pour l'instant
hosté par Benoît. N'importe qui, doté d'une connexion internet, peut
joindre ce serveur. \vskip5mm Les utilisateurs du chat ont également
la possibilité de créer leur propre serveur pour parler librement
entre eux. Ils leur faudra débloquer les ports de leurs routeurs en
cas de besoin. \\
La différence d'affichage entre le mode Serveur et le mode Client
est la gestion des clients connectés. En effet, en mode Serveur, la
liste des gens connectés est présente.  \vskip15mm
\subsection{Client}
Le mode Client offre quant à lui deux possibilités : le serveur ToK
 et un autre Serveur. Pour se connecter à un autre serveur, il faut
bien évidemment avoir l'ip de ce serveur. Une fois connecté,
plusieurs interactions sont possibles : \vskip4mm
\begin{description}
  \item[Envoi de Messages :] l'envoi de messages textes est bien
  évidemment possible, soit en cliquant sur le bouton envoyer, soit
  en appuyant sur Entrée. \vskip4mm
  \item[Changement de Pseudo :]  il est possible de
changer de Pseudo. Le changement est donc envoyé à tous les
utilisateurs.\vskip4mm
  \item[Commandes :] il est possible, à l'image d'IRC, d'utiliser
  quelques commandes  du type {\bf quit}, {\bf here} (affiche le nombre de
  clients connectés), {\bf afk} et {\bf abs}, {\bf re},
  etc\ldots \vskip4mm
  \item[Déconnexion :] lors de la déconnexion, un message est envoyé
  au serveur annoncant notre déconnexion. L'ensemble des gens
  connectés sont donc avertis du départ.
\end{description}
\vskip1cm
\section{Ce qu'il reste à faire}
Le chat est disponible sur internet depuis quelque jours et jusqu'à
présent aucun bug n'a été remarqué. Au cas où il y en aurait un, il
est évident que je ferais mon possible pour le résoudre. Cependant,
j'estime qu'il est assez complet pour pouvoir passer à autre
chose\ldots \\
La prochaine étape sera donc l'envoi de pointeurs, le deuxième type
de données géré par ics.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% IA %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\chapter{IA : Benoît}
\vskip5mm
\section{Introduction}
\vskip3mm Un jeu sans IA n'est pas un vrai jeu. Pour notre projet,
il faut pouvoir se déplacer simplement et rapidement d'un point à
l'autre tout en s'intégrant au gameplay que nous voulions créer pour
Twilight of Khanerat. Il nous a alors fallu coder un algorithme de
plus court chemin : le pathfinding, pour que l'ordinateur puisse
déterminer rapidement et simplement le chemin idéal d'un point à
l'autre.
\begin{center}
\includegraphics[height=4cm]{akira_1}
\end{center}
\vskip1cm
\section{Ce qui a été fait}
\vskip3mm A ce stade du développement, le pathfinding doit être
terminé à plus de 90\% car c'est l'une des bases du futur
comportement des personnages et donc du gameplay qu'aura notre jeu
(dans sa partie solo tout du moins). Dans un premier temps, j'ai
créé une matrice représentant la carte et codé une fonction pour
mettre au point une carte de jeu où se trouvent des murs et des
cases vides, chacune comprenant une valeur numérique. Enfin, j'ai
créé une procédure pour rendre visible cette carte. \vskip 3mm
\begin{center}
\begin{alltt}
{\bf type}
    carte = Array[0..(taille_y-1)] of Array[0..(taille_x-1)] of integer; \\
{\bf Function} initialisation_map() : carte ; \\
{\bf Procedure} visible(map : carte) ;
\end{alltt}
\end{center}
\vskip3mm Ensuite, pour arriver à coder le pathfinding, je me suis
tout d'abord inspiré de l'algorithme de Dijkstra, puis d'un dérivé
de cet algorithme : l'algorithme A*. Mais ces deux algorithmes ne me
satisfaisaient pas. \vskip3mm J'ai alors  trouvé sur internet un
autre principe : il faut imaginer la carte comme un labyrinthe que
l'on enflamme. Le feu part du point de départ et se propage de
proche en proche jusqu'au point d'arrivée et ce en donnant à chaque
case une valeur croissante. Une fois le point d'arrivée atteint, on
trace le chemin parcouru en sens inverse, reliant ainsi le point
d'arrivée au départ. On obtient alors (et à coup sûr) le chemin
idéal et le plus court possible. \vskip4cm J'ai alors codé une
fonction modifiant la carte de jeu et qui rentre dans chaque case du
tableau (différente d'un mur) une valeur correspondant à sa distance
par rapport au point de départ (de coordonnée ix et iy), puis trace
le chemin le plus court en soustrayant les valeurs dans chacune des
cases du chemin le plus court, entre le point d'arrivée (de
coordonnées x, y) et le point de départ. \vskip 1cm
\begin{center}
\begin{alltt}
{\bf function} flamme(map : carte; ix, iy, x, y : integer) : carte;
\end{alltt}
\end{center}
\vskip2cm
\section{Ce qui reste à faire}
Pour les prochaines soutenances, il me faudra adapter mon
pathfinding à la carte générée par Alexandre et créer ainsi un
personnage de jeu dirigé par l'ordinateur capable de se déplacer
d'un point à un autre. Il faudra bien sûr faire en sorte que cette
entité s'intègre au gameplay que l'on essaye de créer.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% WEB %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\chapter{Site Web : Benoît}
\vskip2cm Pour notre première soutenance, nous avons rapidement
uploadé un skin pour notre site, afin de nous permettre de mettre en
ligne notre cahier des charges, nos sources et ainsi pouvoir (où que
nous soyons) avoir accès à nos données. Nous avons d'ailleurs mis en
place un serveur pour le chat de Cédric et mis le client en
téléchargement.

Pour la seconde soutenance, il nous faudra revoir, en commun, ce que
l'on cherche à montrer, l'interface que l'on veut créer et surtout,
sécuriser nos données et simplifier la mise en place des news. Il
nous faudra aussi créer un forum de discussions et chercher à
connaître des personnes volontaires voulant jouer à notre jeu afin
de trouver nos bugs (bêta-testeurs).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Gestion du Groupe %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Affichage de la map 2D}
\vskip2cm Nous avons dit précédemment que l'interface du jeu passait
par une map 2D. Nous avons donc représentée celle-ci comme cela :
\vskip1cm
\begin{center}
\includegraphics[height=6cm]{carte_1}
\end{center}
\vskip2cm Cependant, nous ne nous sommes pas arretés à un simple
affichage de l'image. Lorsque le curseur passe par dessus une icone,
elle change de couleur pour indiquer quel joueur possède la ville.
\vskip5mm
\begin{center}
\includegraphics[height=2cm]{carte_2}
\end{center}
\vskip1cm De plus, si nous cliquons sur une ville ennemie, on
démarre le moteur graphique !
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Gestion du Groupe %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\chapter{Gestion du groupe}
Lors du cahier des charges, nous nous étions fixés des objectifs.
Pour les atteindre, nous étions convenus de faire chacun une partie
bien distincte. En parlant de la gestion du travail, nous mettons le
doigt sur un point douloureux. Avec du recul, il est évident que
nous avons eu des problèmes d'organisation. Le groupe s'est réuni
pour travailler en vue de la soutenance dès le lendemain des
partiels. Nous avons alors constaté deux types de personnes : celles
qui avaient déjà fait quelque chose de concret et celles qui
n'avaient pas commencé à coder. \vskip8mm
\begin{center}
\includegraphics[height=38mm]{spirou_2}
\end{center}
\vskip8mm Dans la première catégorie : Cédric et Alexandre, qui
avaient presque fini leurs parties respectives : le Chat et le
Moteur Graphique. Quant à Adrien et Benoit, ils s'étaient certes
documentés, mais à part le skin internet uploadé par Benoît, rien
n'était fait. Pour quelles raisons ? Plusieurs excuses ont été
évoquées : difficultés en algo, concentration sur les partiels,
problèmes personels, absence de travail en vacances\ldots
\\ Alexandre et Cédric se sont donc partagés différentes tâches,
respectivement la gestion de touches et l'affichage de la carte 2D.
A la vue de la deadline, nous avons donc tous accéléré la cadence.
\vskip8mm
\begin{center}
\includegraphics[height=38mm]{spirou_3}
\end{center}
\vskip5mm et tous les efforts effectués ont abouti au résultat
actuel !

\chapter{Les objectifs pour la prochaine soutenance}
\begin{itemize}
  \item Pour le moteur graphique, la prochaine étape sera la maitrise de
l'application de textures ainsi qu'une bonne maitrise de 3DS Max 8.
\vskip1cm
  \item Ensuite, pour le moteur physique, le prochain objectif sera de gérer
les collisions avec n'importe quel objet présent sur le terrain.
\vskip1cm
  \item Pour le réseau, nous nous essaierons à l'envoi de pointeurs.
\vskip1cm
  \item Enfin, pour le pathfinding, le but sera d'adapter notre algorithme à
un environnement 3D. \vskip1cm
  \item Nous coderons également un magnifique
(ou pas) site internet. \vskip1cm

  \item  Quand à la gestion du groupe, l'objectif  sera donc une
meilleure préparation avant la période de soutenance, d'autant plus
que nous connaissons nos tâches, et nous avons tous une idée sur la
réalisation. Pour ma part, Cédric, chef de projet, j'ai quelques
idées quant à la manière de motiver mes troupes\ldots \vskip1cm
\begin{center}
\includegraphics[height=38mm]{spirou_1}
\end{center}

\end{itemize}

\end{document}
