Le moteur du jeu :

  Le modèle objet du moteur se décompose en plusieurs grandes parties :

• la gestion de la grille du jeu,
•  la gestion des acteurs,
•  la gestion du déplacement des acteurs pour ceux qui sont mobiles,
•  la gestion de l'affichage, de l'animation et de la projection de la scène. 

  Le modèle que nous avons choisi permet de représenter un acteur comme un élément abstrait pouvant avoir deux comportements :

•  soit il est mobile,
•  soit il ne l'est pas.

  Chaque acteur, qu'il soit mobile ou non, dispose d'attributs qui lui sont propres :
 

• d'une part il dispose d'attributs de vie qui permettent de connaître s'il est immortel, le nombre de vie qu'il lui reste, la valeur qu'il représente (dans le cas où celui-ci se fait manger) et le temps de qu'il lui faut pour se regénérer;
•  d'autre part il dispose d'un attribut graphique que nous avons appelé sprite : ce sprite peut être soit statique soit animé (nous reviendrons en détail sur la gestion des sprites.

Les gestionnaire de déplacement des acteurs mobiles:

      Les classes mises en jeu :

  La gestion des déplacements est assez complexe car elle doit permettre le maximum de flexibilité : en somme, elle doit fournir
un certain nombre de services qui garantissent de pouvoir controller un acteur mobile de différentes façons. Il y a donc
au sein des différentes gestions possibles pour réaliser des déplacments une hierarchie qui émane et qui reflète l'efficacité
de la programmation objet.

      Les déplacements qui réagissent aux évènements :

  Typiquement, un pacman dans un jeu réagit à certaines touches qui permettent de spécifier un direction de déplacement. L'utilisateur
se sert du clavier pour contrôller le pacman.

      Les évènements peuvent être de nature différentes :

•  les touches du clavier,
•  le réseau,
•  un joystick,
• ...

       Les stratégies de déplacement :

  Celles-ci permettent d'automatiser le déplacement d'un acteur grâce à des calculs effectués par le programme : par exemple les fantômes se
déplacent selon des stratégies bien déterminées. Pour créer une nouvelle stratégie il suffit de dériver la classe StrategyActorMover
et d'écrire la méthode determinateNextGridPosition qui permet de déterminer la future position de l'acteur auquel est rattaché le
gestionnaire de déplacement.

  La méthode determinateNextGridPosition peut être très complexe car elle permet de spécifier à elle seule la stratégie : l'utilisateur
peut utiliser les différents services que lui fournit la classe abstraite ActorMover qui consistent á connaître la position des autres
acteurs sur la grille, les interactions potentielles avec les autres acteurs, ...
 

La gestion des interactions entre les acteurs :

  La gestion des interactions est liée au déplacement des acteurs sur la grille. Lorsqu'un acteur se dirige dans une case qui contient déjà un
autre acteur, des interactions peuvent surgir. Tout un système permettant de gérer les états de ``mangeage'' entre acteurs a été mis en place.
Ainsi si un acteur est mangé, un certain nombre de méthodes qui lui sont propres vont être appelées. Le mécanisme est à peu près le même lorsque
celui-ci mange ...

L'affichage des scènes:

  Le travail d'affichage des scènes se répartit entre deux classes : celle qui dessine l'image de la scène à un instant donné et celle qui la
projette sur la fenêtre graphique.

     La classe de dessin des scènes :

Cette classe permet donc de dessiner les différents composants graphiques qui composent la scène :

• la grille du jeu avec ses différents sprites (les murs, les sols, ...),
•  les sprites des différents acteurs,
•  les attributs des acteurs contrôlés par les joueurs (le score, le nombre de vie, ...)

       La classe de projection des images de la scène

La classe \textit{Projector} permet de créer un objet qui tourne en tâche de fond : celle-ci va, à interval de temps régulier (ce qui permet
donc de définir la vitesse de rafraîchissement), demander au dessinateur l'image de la scène et la ``projette'' dans la fenêtre du jeu.

       Les sprites

  Comme nous l'avons déjà dit, les acteurs possèdent un attribut graphique qui est un sprite. La grille possede egalement pour chaque case un
sprite (soit un mur, le sol, ...).

  Les sprites ne sont rien d'autre que l'association d'une image et d'une position sur l'écran. Cependant les sprites peuvent être animés.
Ainsi la classe Sprite possède la classe fille AnimatedSprite qui permet de changer de manière autonome l'image pour ainsi
réaliser une animation. Les sprites animés possèdent des attributs supplémentaires qui permettent de réaliser des séquences d'animation. Aussi
un sprite animé nécessite une tâche de fond pour permettre de réaliser tout ceci de manière transparente : l'utilisateur peut donc
utiliser soit des sprites statiques soit des sprites animés sans changer une ligne dans son code. La seule différence est qu'il devra tôt ou
tard demander a un sprite animé de commencer son exécution : il réalise ceci via la methode activate.