Cartouche

Notation

Notes :

• Conception haut niveau, étude de faisabilité (note groupée)
  • Règles du jeu
  • Comportement général de la logique de jeu (application d’un move, conditions de victoire)
  • État du jeu (phase, plateau, rôles)
  • Données nécessaires à l’affichage du jeu pour un joueur ou un mode spectateur
  • Test de bibliothèques et d’outils
• Conception bas niveau : Interfaces et abstractions (note groupée)
  • Interface C++ logique de jeu
  • Interface C++ afficheur
  • Interface C++ joueur
• Implémentation (note par composants)
  • Fenêtre graphique (afficheur + joueur)
  • Terminal (afficheur + joueur)
  • Réseau (afficheur + joueur)
  • Logique de jeu (avec ou sans classe de coordination)

Règlement

Au sein d’un même groupe vous pouvez partager la même base de code et vous entraider, même si vous ne travaillez pas sur le même composant (lors de la phase d’implémentation.)

Vous pouvez vous entraider d’un groupe à l’autre sur les phases de conception.

Vous n’avez pas le droit de copier le code de l’autre groupe.

La réalisation de cet exercice est assujettie aux règles en vigueur dans l’école en matière de triche et de normalisation. Tricher vous expose à de graves sanctions.

Étapes

Conception haut niveau

La première étape, c’est le choix de votre jeu et la définition de ses règles. Votre choix de jeu doit être validé, et le sera sur plusieurs critères :

• la complexité de la modélisation de son état ;
• la complexité derrière la validation et l’application d’un mouvement de joueur ;
• le fait d’être en tour-par-tour ;
• le fait de bénéficier d’un mode en réseau.

Livrable : cahier des charges format libre (word, markdown, etc.) :

• règles du jeu
  • s’il a un plateau, des classes de joueurs ?
  • quels mouvements sont possibles, et à quelles phases ?
  • l’état initial de la partie ?
  • les conditions de victoire ?
• les données de l’état du jeu
  • ce que la classe de la logique de jeu dois stocker ?
  • ce dont un afficheur a besoin ?
  • ce qu’un ordre de jouer dois contenir ?
  • ce qu’une action doit contenir ?
  • quelles données doivent être transmises en réseau entre un client et un serveur ?
• Exemple complet d’une ou plusieurs parties
  • Coup par coup, le déroulé d’une ou plusieurs partie
• Test et recherches bibliothèques et outils
  • Si vous en avez fait, décrivez-vos résultats dans cette section

Conception bas niveau

Votre groupe doit se mettre d’accord sur les interfaces C++ que vous aller tous utiliser. Les interfaces vous permettent d’implémenter votre jeu sans qu’il soit cantonné à n’utiliser qu’un type d’affichage.

C’est d’autant plus pratique pour implémenter une classe qui permet à quelqu’un de jouer en réseau, car la logique de jeu n’a pas besoin de savoir que le joueur est a distance, elle peut juste utiliser les fonctions membres de l’interface “joueur” pour lui demander de jouer, puis consulter s’il a joué.

Livrable : dépôt git de votre jeu avec les interfaces C++ que vous avez conçu.

Exemple de main pour deux joueurs

Soit :

• GameManager une classe qui fait office de coordinateur de jeu ;
• SfmlWindowsDisplay une classe qui peut recevoir les ordres de jeu et l’état du jeu à afficher dans une fenêtre pour un joueur spécifique ;
• NetworkClient une classe qui peut recevoir les ordres de jeu et l’état du jeu à envoyer sur le réseau pour un joueur distant.

int main(void)
	GameManager gm;
	SfmlWindowDisplay window;
	NetworkClient net_client;

	gm.add_player(window);
	while (!net_client.ready()) {
		net_client.cycle_once();
	}
	gm.add_player(net_client);

	gm.start_loop();
}	

Implémentation