Othello. Audélia Bertaina Marine Vallée Rémi Plantade Antoine Pellieux. Projet tutoré Semestre 2 IUT Rodez. Othello

Transcription

1 Othello Projet tutoré Semestre 2 IUT Rodez Audélia Bertaina Marine Vallée Rémi Plantade Antoine Pellieux Othello

2 Tables des matières I. Plan projet Introduction Présentation du projet... 1 Cahier des charges... 1 Charte du projet... 8 Diagrammes des cas d utilisations... 9 Cas numéro 1 : Cas numéro 2 : Cas numéro 3 : Cas numéro 4 : Cas numéro 5 : Cas numéro 6 : Organisation du projet Rôles Plan de communication Modèle de compte rendu de réunion MOE Comité de pilotage Politique d assurance qualité Ressources matérielles et logicielles Pilotage du projet Estimation des tâches Liste des tâches (initiale) Diagramme de Gantt initial Suivi du projet Diagramme de Gantt final Conclusion Résultat du projet Gestion de projet Conclusion générale Glossaire Annexes Comptes rendu réunion MOE Compte rendu comité de pilotage II. Spécifications détaillées Diagramme des cas d utilisation Cas numéro 1 : Cas numéro 2 : Othello

3 Cas numéro 3 : Cas numéro 4 : Cas numéro 5 : Cas numéro 6 : III. Conception Diagramme des classes IV. Codage V. Tests Test unitaires Test d intégration VI. Conclusion VII. Manuel utilisateur Othello

4 IUT Rodez université Toulouse capitole I I. Plan projet 1. Introduction Ce dossier concerne la conduite de projet. Il expliquera de façon précise et détaillée les différentes méthodes suivies, ainsi que la planification et répartition des tâches issues de l analyse du besoin du client. Ce projet a été mené conjointement avec notre chef MOA Corinne Servières et étant donné le contexte universitaire dans lequel il s inscrit certains aspects varieront par rapport à un plan projet mené au sein d une entreprise. 2. Présentation du projet Nous avons choisis de travailler sur le sujet d Othello proposé par Mme Servières. L Othello est un jeu de société combinatoire abstrait qui oppose deux joueurs ou un joueur et un ordinateur. Chacun de ces joueurs joue à tour de rôle. Ce jeu se présente sur un plateau appelé «Othellier». Cahier des charges Vous trouverez ci-après le cahier des charges du projet : 1 Othello

5 IUT Rodez université Toulouse capitole I Le jeu d'othello Le but de ce projet est d'écrire un programme qui permette à ses utilisateurs de jouer au jeu d'othello, en respectant les règles officielles décrites sur le site de la FFO (Fédération Française d Othello. PARTIE 1 : Présentation du jeu d'othello Règle du jeu ( Othello est un jeu de stratégie à deux joueurs : Noir et Blanc. Il se joue sur un plateau unicolore de 64 cases, 8 sur 8, appelé othellier. Ces joueurs disposent de 64 pions bicolores, noirs d'un côté et blancs de l'autre. Par commodité, chaque joueur a devant lui 32 pions mais ils ne lui appartiennent pas et il doit en donner à son adversaire si celui-ci n'en a plus. Un pion est noir si sa face noire est visible et blanc si sa face blanche est sur le dessus. But du jeu Avoir plus de pions de sa couleur que l'adversaire à la fin de la partie. Celle-ci s'achève lorsqu aucun des deux joueurs ne peut plus jouer de coup légal. Cela intervient généralement lorsque les 64 cases sont occupées. Position de départ Au début de la partie, deux pions noirs sont placés en e4 et d5 et deux pions blancs sont placés en d4 et e5 (voir figure 1). othello 2

6 IUT Rodez université Toulouse capitole I La pose d'un pion A son tour de jeu, le joueur doit poser un pion de sa couleur sur une case vide de l'othellier, adjacente à un pion adverse. Il doit également, en posant son pion, encadrer un ou plusieurs pions adverses entre le pion qu'il pose et un pion à sa couleur, déjà placé sur l'othellier. Il retourne alors de sa couleur le ou les pions qu'il vient d'encadrer. Les pions ne sont ni retirés de l'othellier, ni déplacés d'une case à l'autre. Le premier coup de Noir est, par exemple, en f5 (voir figure 2). En jouant f5, il encadre le pion blanc e5 entre le pion qu'il pose et un pion noir déjà présent (ici d5) ; il retourne alors ce pion (voir figure 3). Noir aurait aussi pu jouer en e6, c4 ou d3. Notons que ces quatre coups de Noir sont parfaitement symétriques ; Noir n'a donc pas à réfléchir pour choisir son premier coup. C'est maintenant à Blanc de jouer. Il a trois coups possibles (voir figure 4). En effet, il est obligatoire de retourner au moins un pion adverse à chaque coup. Blanc peut donc jouer en f4, f6 ou en d6. On peut encadrer des pions adverses dans les huit directions. Par ailleurs, dans chaque direction, plusieurs pions peuvent être encadrés (voir figures 6 et 7). On doit alors tous les retourner. othello 3

7 IUT Rodez université Toulouse capitole I Le joueur Noir a joué en c6. Il retourne alors les pions b6 (encadré grâce à a6), b5 (encadré grâce à a4), d7 (encadré grâce à e8), c5 et c4 (encadrés grâce à c3). Notons que ni d6, ni e6 ne sont retournés à cause de la case vide en f6. Il n'y a pas de réaction en chaîne : les pions retournés ne peuvent pas servir à en retourner d'autres lors du même tour de jeu. Ainsi, sur la figure 8, Noir joue en a5 : Noir retourne b5 et c5 qui sont encadrés. Bien que c4 soit alors encadré, il n'est pas retourné (voir figure 9). En effet, il n'est pas encadré entre le pion que l'on vient de poser et un autre pion. Si, à votre tour de jeu, vous ne pouvez pas poser un pion en retournant un pion adverse suivant les règles, vous devez passer votre tour et c'est à votre adversaire de jouer. Mais si un retournement est possible, vous ne pouvez-vous y soustraire. Fin de la partie La partie est terminée lorsqu aucun des deux joueurs ne peut plus jouer. Cela arrive généralement lorsque les 64 cases sont occupées. Mais il se peut qu'il reste des cases vides où personne ne peut plus jouer : par exemple lorsque tous les pions deviennent d'une même couleur après un retournement. Ou bien comme sur cette position (voir figure 10). othello 4

8 IUT Rodez université Toulouse capitole I PARTIE 2 : DEROULEMENT D'UNE PARTIE Ecrire un programme Java qui permette de jouer au jeu d'othello en respectant, bien sûr, la règle du jeu. Ce programme devra proposer deux modes de fonctionnement aux joueurs : Un joueur joue contre l'ordinateur Un joueur joue contre un autre joueur Dans le cas d'une partie contre l'ordinateur, on prévoira au moins trois niveaux de jeu, l'un facile et l'autre moyen et le dernier difficile. Il faudra donc implémenter trois stratégies de jeu, au moins, pour l'ordinateur : la première sera un simple tirage aléatoire parmi les différents coups possibles, la deuxième devra être plus évoluée, la troisième pourra être une version améliorée de la troisième. Déroulement global d'une partie Au commencement d une nouvelle partie, le joueur sélectionne le mode de fonctionnement (joueur contre ordinateur ou joueur contre joueur), et si nécessaire le niveau de jeu, ces options sont accessibles via un menu unique. Les couleurs sont attribuées aléatoirement à chacun des adversaires. La partie proprement dite peut alors commencer. Dès qu'elle est terminée, le programme indique le score final et la couleur du gagnant, sachant que les deux adversaires peuvent être ex aequo. Dans le cas d une partie contre l ordinateur, les meilleurs scores seront enregistrés dans un tableau affiché en fin de partie ou accessible via le menu. Il propose ensuite à l'utilisateur de recommencer une partie. Commandes possibles après avoir lancer le jeu Un fois le jeu lancé le joueur aura accès via le menu aux commandes suivantes : Lancer une partie Charger une partie sauvegardée Régler le niveau de difficulté Consulter le tableau des scores Consulter les règles du jeu Voir la liste des sauvegardes Commandes possibles en cours de partie En cours de partie, un joueur peut effectuer l'une des opérations suivantes : quitter le jeu (avec possibilités de sauvegarder passer son tour. On tolère qu'un joueur passe son tour même s'il a la possibilité de jouer jouer un coup, en désignant la case sur laquelle il souhaite placer un pion de sa couleur. La case pourra être repérée par ses coordonnées. othello 5

9 IUT Rodez université Toulouse capitole I De plus, le joueur pourra décider d'interrompre le déroulement de la partie, et de la reprendre ultérieurement dans l'état où il l'avait laissée. Affichage en cours de partie Tout au long de la partie, les informations suivantes doivent apparaître clairement à l'écran : le damier et les pions des deux couleurs qui y sont posés le score la couleur du joueur qui doit jouer un message quand la case pointée n est pas jouables un message quand aucun coup n est jouable un bouton pour passer son tour le menu du jeu Sauvegarde d'une partie L'application devra permettre au joueur d'interrompre une partie et éventuellement de la poursuivre ultérieurement. Au lancement du jeu, il aura la possibilité de continuer une partie interrompue qui aurait été sauvegardée. Dans ce cas-là, les parties sauvegardées lui seront proposées, et il choisira celle qu'il veut poursuivre. Les parties pourront être identifiées par un nom. Bien sûr, la question de la restauration d'une partie interrompue ne sera accessible que si effectivement il existe au moins une telle partie. PARTIE 3 : TRAVAIL A FAIRE Etablir un cahier des charges précis Rédiger et dessiner des cas d'utilisation avec UML Réaliser la conception de l'application en utilisant notamment un diagramme de classes UML Développer l'application dans le langage Java et effectuer les tests Documents à rendre A l'issue du projet, un dossier technique devra être rendu. Il comportera : le cahier des charges et les documents d'analyse un document de conception comportant le diagramme des classes et des explications pour les éléments les plus complexes la répartition des tâches au sein de l'équipe la liste des objectifs atteints et non atteints un dossier de tests comportant le code source des programmes écrits pour réaliser les tests unitaires le résultat de l'exécution de ces programmes les programmes d Othello écrits pour tester l'application finale, et les résultats obtenus les scénarios de tests (avec les résultats) effectués pour tester globalement l'environnement de développement. othello 6

10 IUT Rodez université Toulouse capitole I le code source (imprimé sur 2 colonnes) bien écrit et commenté. un bilan La qualité de la rédaction (clarté, précision, mise en forme, orthographe) sera prise en compte dans l'évaluation du projet. othello 7

11 IUT Rodez université Toulouse capitole I Charte du projet En accord avec la MOA, les objectifs principaux de ce projet sont de pouvoir fournir un jeu d Othello fonctionnel, offrant la possibilité au joueur d affronter un autre joueur ou bien d affronter l ordinateur. L ordinateur devra proposer plusieurs stratégies de jeu. Enfin une interface graphique sera développée si l avancement du projet le permet. Les critères d évaluation de ce projet sont divers, nous pouvons noter : Le bon fonctionnement du programme en situation de jeu ainsi que lors des différentes phases de tests. Le respect des règles du jeu comme décrites dans le cahier des charges. La présence de tous les livrables demandés. La finalité de ce projet est d introduire dans notre cycle universitaire un mode de fonctionnement professionnel, une rigueur et une organisation en groupe telles que nous pourrions y être confrontés en entreprise. Quant à la nomination du chef de projet, afin de faire bénéficier de cette expérience à tous les membres du groupe, il nous est apparu pertinent de mettre en place un roulement bihebdomadaire. Le rôle du chef de projet a été défini dès le départ, à savoir il coordonne les différentes tâches, veille au respect du planning général, et se fait le porte-parole du groupe auprès des différents acteurs extérieurs (chef MOA, professeurs). Dans notre équipe projet, chaque membre s est vue attribuer un rôle, nous comptions : Un secrétaire : rédaction des comptes rendus de réunion, tenue des différents documents projet Un gestionnaire de configuration : tenu du calendrier (Google agenda), du Redmine, suivi des différentes versions du Workspace projet et partage par l intermédiaire du logiciel DropBox. A l aide du cahier des charges, nous avons pu identifier les différents livrables à fournir, soit l exécutable et les programmes de tests sur le CD ainsi que les codes sources. Enfin nous devrons rédiger un dossier (ainsi qu un plan projet). En ce qui concerne le plan QCD (Qualité Coûts Délais), il est difficile d établir un réel plan QCD du fait du contexte universitaire dans lequel ce projet s inscrit. Tout de même en ce qui concerne les délais, une date précise a été émise, et ce pour le 2 juin dernier délais. L aspect qualité du projet a malgré tout constitué un motif de réflexion, en effet que ce soit au niveau de notre désir initial concernant l implémentation d une interface graphique, ou au niveau du rajout d une méthode pour l intelligence artificielle, la qualité du logiciel a été impactée de par nos décisions qui se sont basées sur notre capacité à assumer la charge de développement en marge de notre travail quotidien à l IUT. othello 8

12 IUT Rodez université Toulouse capitole I Diagrammes des cas d utilisations Nous pouvons voir sur ce diagramme un acteur principal, qui est l utilisateur de notre logiciel, identifié ici comme un joueur. Dans le cadre du lancement d une partie en mode deux joueurs un second acteur entre en jeu. Si le joueur désire jouer seul, alors l ordinateur et plus particulièrement l intelligence artificielle (IA) a son rôle à jouer. othello 9

13 IUT Rodez université Toulouse capitole I Cas numéro 1 : Identification Nom : Lancer une nouvelle partie un joueur Objectif : Détaille les étapes permettant à un joueur de jouer une nouvelle partie contre l ordinateur. Acteur principal : Joueur Date : 19/04/2014 Responsable : Joueur Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 1 dans le menu principal Enchaînement nominal : 1. Le joueur saisit son pseudo 2. Le joueur choisi une méthode (1, 2 ou 3) ou fait retour 3. La partie se lance (affichage du plateau), le joueur commence 4. Le joueur saisit une case s il y a des coups possibles, point 6 sinon 5. La case est jouée, affichage du plateau, du tour de jeu et du score 6. L ordinateur joue une case à son tour en fonction de la méthode choisie en 2, affichage du plateau, du tour de jeu et du score 7. Si le jeu n est pas terminé, il faut boucler au point 4 8. Le jeu est terminé, affichage du gagnant 9. Affichage du tableau des scores Enchaînement alternatif : Point 2 de la séquence nominale : le joueur saisit 0 - Retour au menu principal Point 4 de la séquence nominale : le joueur saisit m ou M - Le jeu demande s il veut quitter - Si le joueur tape 1, le jeu lui demande s il veut sauvegarder le partie, sinon retour à la partie, point 4 - S il veut sauvegarder, il saisit un nom puis retour au menu principal, sinon retour au menu principal sans sauvegarde Point 4 de la séquence nominale : le joueur saisit p ou P - L enchainement reprend au point 6 Point 4 de la séquence nominale : le joueur saisit une case valide mais le coup n est pas jouable - Un message lui indique que le coup n est pas jouable - L enchainement reprend au point 4 Point 8 de la séquence nominale : Le joueur a effectué un nouveau meilleur score - Le pseudo du joueur et son score sont inscrits dans le tableau des scores - L enchainement reprend au point 9 othello 10

14 IUT Rodez université Toulouse capitole I Enchainement d exception : Point 1 de la séquence nominale : le joueur saisit une chaine vide - Message d erreur - Le jeu demande un pseudo tant que le joueur ne saisit rien Point 2 de la séquence nominale : le joueur ne saisit pas 0, 1,2 ou 3 - Message d erreur - Le jeu demande un niveau tant que le joueur ne saisit pas 0, 1, 2 ou 3 Point 4 de la séquence nominale : le joueur saisit une chaine invalide - Message d erreur - Le jeu demande une case tant que le joueur ne saisit pas une chaine valide (case, p ou m) Postcondition : Retour au menu principal Cas numéro 2 : Identification Nom : Lancer une nouvelle partie deux joueurs Objectif : Détaille les étapes permettant à un joueur de jouer une nouvelle partie contre un autre joueur. Acteur principal : Le joueur qui lance la partie Date : 19/04/2014 Responsable : Le joueur qui lance la partie Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 2 dans le menu principal Enchaînement nominal : 1. Le joueur 1 saisit son pseudo 2. Le joueur 2 saisit son pseudo 3. Tirage au sort des couleurs 4. La partie se lance (affichage du plateau), les noirs commencent 5. Le joueur noir saisit les coordonnées d une case s il y a des coups possibles, point 7 sinon 6. La case est jouée, affichage du plateau, du tour de jeu et du score 7. Si le jeu n est pas terminé, on continu au point 8, sinon point Le joueur blanc saisit les coordonnées d une case s il y a des coups possibles, point 10 sinon 9. La case est jouée, affichage du plateau du tour de jeu et du score 10. Si le jeu n est pas terminé, il faut boucler au point Le jeu est terminé, affichage du gagnant 12. Affichage du tableau des scores Enchaînement alternatif : othello 11

15 IUT Rodez université Toulouse capitole I Point 5 et 8 de la séquence nominale : le joueur saisit m ou M - Le jeu demande s il veut quitter - Si le joueur tape 1, le jeu lui demande s il veut sauvegarder le partie, sinon retour à la partie, point 5 ou 8 - S il veut sauvegarder, il saisit un nom puis retour au menu principal, sinon retour au menu principal sans sauvegarde Point 5 et 8 de la séquence nominale : le joueur saisit p ou P - L enchainement reprend au point 7 ou 10 Point 5 et 8 de la séquence nominale : le joueur saisit une case valide mais le coup n est pas jouable - Un message lui indique que le coup n est pas jouable - L enchainement reprend au point 5 ou 8 Point 11 de la séquence nominale : Un des deux joueurs a effectué un nouveau meilleur score - Le pseudo du joueur et son score sont inscrits dans le tableau des scores - L enchainement reprend au point 12 Enchainement d exception : Point 1 et 2 de la séquence nominale : le joueur saisit une chaine vide - Message d erreur - Le jeu demande un pseudo tant que le joueur ne saisit rien Point 5 et 8 de la séquence nominale : le joueur saisit une chaine invalide - Message d erreur - Le jeu demande une case tant que le joueur ne saisit pas une chaine valide (case, p ou m) Postcondition : Retour au menu principal Cas numéro 3 : Identification Nom : Chargement d une sauvegarde Objectif : Détaille les étapes permettant à un joueur de charger une sauvegarde Acteur principal : Le joueur qui lance la sauvegarde Date : 19/04/2014 Responsable : Le joueur qui lance la sauvegarde Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 3 dans le menu principal Enchaînement nominal : 1. La liste des parties sauvegardées avec le jour et l heure de la sauvegarde est affichée othello 12

16 IUT Rodez université Toulouse capitole I 2. Le joueur choisit une sauvegarde 3. La partie sauvegardée se lance (affichage du plateau, du tour de jeu et des scores Enchaînement alternatif : Point 1 de la séquence nominale : La liste est vide - Message indiquant au joueur qu aucune partie n est sauvée - Retour au menu Point 2 de la séquence nominale : le joueur saisit 0 - Retour au menu principal Enchainement d exception : Point 2 de la séquence nominale : le joueur saisit une chaine invalide - Message d erreur - Le jeu demande un chiffre tant que le joueur ne saisit pas une chaine valide Postcondition : Une partie est lancée Cas numéro 4 : Identification Nom : Affichage du tableau des scores Objectif : Détaille les étapes permettant à un joueur de consulter le tableau des scores Acteur principal : Le joueur qui consulte le tableau des scores Date : 19/04/2014 Responsable : Le joueur qui consulte le tableau des scores Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 4 dans le menu principal Enchaînement nominal : 1. Le tableau des scores est affiché Enchaînement alternatif : Point 1 de la séquence nominale : La liste est vide - Page vide - Retour au menu principal Postcondition : Retour au menu principal othello 13

17 IUT Rodez université Toulouse capitole I Cas numéro 5 : Identification Nom : Consulter l aide Objectif : Détaille les étapes permettant à un joueur de consulter l aide Acteur principal : Le joueur qui consulte l aide Date : 19/04/2014 Responsable : Le joueur qui consulte l aide Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 5 dans le menu principal Enchaînement nominal : 1. Le jeu propose de consulter les règles ou le «A propos du jeu» 2. Le joueur saisit 1 : l enchainement reprend au point 4 3. Le joueur saisit 2 : l enchainement reprend au point 4. Les règles du jeu s affichent, l enchainement reprend au point 6 5. Le «A propos du jeu» s affiche, l enchainement reprend au point 6 6. Affichage du menu principal Enchaînement alternatif : Point 1 de la séquence nominale : Le joueur saisit 0 - Retour au menu principal Enchainement d exception : Point 1 de la séquence nominale : le joueur saisit une chaine invalide - Message d erreur - Le jeu demande un chiffre tant que le joueur ne saisit pas 1, 2 ou 0 Postcondition : Retour au menu principal Cas numéro 6 : Identification Nom : Quitter le jeu Objectif : Détaille les étapes permettant à un joueur de quitter le jeu en sauvegardant les données Acteur principal : Le joueur qui quitte le jeu Date : 19/04/2014 Responsable : Le joueur qui quitte le jeu Version : 2.0 othello 14

18 IUT Rodez université Toulouse capitole I Séquencement Précondition : le jeu est lancé et le joueur a tapé 6 dans le menu principal Enchaînement nominal : 1. Le jeu propose de quitter 2. Le joueur saisit oui (1) 3. Les données sont sauvées dans des fichiers «.dat» Enchaînement alternatif : Point 2 de la séquence nominale : Le joueur saisit 2 ou 0 - Retour au menu principal Postcondition : L invite de commandes se ferme othello 15

19 IUT Rodez université Toulouse capitole I 3. Organisation du projet Pour l organisation des postes nous avons décidés de mettre en place un planning tournant. En effet nous pensions que cette expérience devait profiter à chaque membre du groupe. Ainsi chacun a pu expérimenter chaque poste pendant 2 semaines. Voici le planning des postes : chef de projet technique secrétaire Marine Antoine Audélia Changement + transmission des compétences avec un compte rendu chef de projet secrétaire technique Remi Marine Audélia Changement + transmission des compétences avec un compte rendu chef de projet secrétaire technique Audélia Antoine Remi Changement + transmission des compétences avec un compte rendu chef de projet secrétaire technique Antoine Remi Marine Rôles Nous avons définis les rôles pour chacun des différents postes. Ainsi le chef de Projet avait pour mission de vérifier le respect des échéances pour les tâches en cours. Le rôle de secrétaire avait lui pour but la rédaction des documents (Compte Rendu) ainsi que la prise de note lors des réunions. Pour finis le Gestionnaire de configuration devait gérer les sauvegardes et mettre en commun les Workspace. othello 16

20 IUT Rodez université Toulouse capitole I Plan de communication Lors des périodes scolaires, nous étions tous à Rodez sauf les weekends, ou bien encore pour les vacances scolaires. C est pourquoi notre plan de communication c est très vite porté sur des réunions mais surtout sur des Audioconférence Skype. Lorsque que le besoin s en faisait ressentir nous avons organisé des réunions MOE, afin de mettre en commun les différents documents ou les avancés de chacun des binômes. Toutes les 2 semaines nous avions une réunion avec la MOA, ce qui a permis de juger notre avancer dans le projet ainsi que d éclaircir certaines interrogations pouvant voir le jour durant l avancée du projet. En ce qui concerne les réunions MOE, notre fréquence était à peu près de une par semaine, voire toute les 2 semaines, d un durée variant de 30min à 2h. Ces réunions avaient comme objectif de mettre au point l avancement du projet, et des binômes dans leur travail. Concernant l organisation de notre communication, nous l avons décentralisé afin de permettre des échanges spontanés et réactifs entre les différents membres du groupe, cela nous a paru pertinent du fait de la rotation des différents rôles qui nécessitait à chaque membre d être en perpétuel échange avec les autres organes du projet. othello 17

21 IUT Rodez université Toulouse capitole I Modèle de compte rendu de réunion MOE othello 18

22 IUT Rodez université Toulouse capitole I Modèle de compte rendu réunion MOA othello 19

23 IUT Rodez université Toulouse capitole I Comité de pilotage Pour les Comité pilotage, nous avons eu rendez-vous toute les 2 semaines, les réunions concernait les membres projet et la MOA (en la personne de Mme Servières). Le but de ces réunions était la validation de documents ainsi que celle de l avancement, la durée a toujours été d une trentaine de minutes. Politique d assurance qualité Pour notre politique d assurance qualité nous avons décidé d utiliser les normes vu tout au long de cette première année d étude soit, pour la modélisation, un formalisme UML. Pour les conventions de codes, nous avons pris en comptes les conventions standards du langage JAVA. Quand a la gestion même du projet nous avons choisis de suivre un cycle de vie itératif. Ressources matérielles et logicielles Nous avons utilisés de nombreuses ressources matérielles et logicielles. Parmi les ressources matérielles nous avons utilisés nos ordinateurs personnels, nos Smartphones ainsi que le matérielle mis à notre disposition au sein de l IUT. Pour les ressources logicielles, nous pouvons déjà citer les OS utilisés qui sont Microsoft Windows et Mac OS. Nous avons utilisé Eclipse comme outil de génie logiciel. Afin de permettre une meilleure organisation du projet nous avons mis en place un logiciel de gestion et de suivis de projet : Redmine. Ce logiciel, hébergé par nos soins, nous permet de suivre l avancement du projet en temps réel, d attribuer des rôles à chacun et de partager les comptes rendu. Pour partager les workspace nous avons utilisé DropBox, et pour pouvoir coder par binôme l utilisation de Team Viewer nous était primordial. En effet ce programme permet de travailler en collaboration sur un seul ordinateur partagé. 4. Pilotage du projet Pour ce projet nous avons choisis un cycle de vie itératif. C est celui qui nous semblait le plus approprié, si l on se réfère aux conseils que nous ont prodigués nos différents professeurs. De par notre approche certainement trop procédurale, il nous a été difficile de mettre réellement en pratique les concepts d une approche itérative, et cela transparait d ailleurs sur l allure de notre diagramme de Gantt. En effet, une étape du projet en amenant une autre, nous n avons que rarement pris un réel recul sur l aspect conception et avons enchainé les étapes dans un souci de cohérence comme nous l avions toujours fait jusqu ici. othello 20

24 IUT Rodez université Toulouse capitole I Estimation des tâches Pour réaliser la liste des tâches, il nous a fallu anticiper sur l avancée du projet et estimer avec plus ou moins de précision le temps qu allait nous prendre telle ou telle tâche. Il a donc fallu mettre à jour cette liste régulièrement, afin de coller avec la réalité du projet. Nous avons abouti à la liste des tâches suivante (voir page suivante) Liste des tâches (initiale) Définition des besoins (cahier des charges) 3 H Réunion de validation du cahier des charges (v2.0) 1 H Liste des tâches 2 H Scénarios d utilisations 3 H Définition des objets 3 H Réalisation des diagrammes UML 3 H Comité de pilotage avec le tuteur 1 H Échéancier du projet 2 H Mise en place de l'environnement de développement 1 H 1 ère itération : Réalisation des algorithmes et fonction de bases du mode 2 joueurs 1 er niveau IA, tirage aléatoire parmi les coups possibles avec affichage sur console texte o Programmation des entêtes de classes (Plateau, Cases, Joueur) 4 H o Programmation des algorithmes et fonctions 44 H o Tests unitaires avec affichage des résultats sur console texte 16 H 2 ème itération : 2 ème niveau IA sélection du coup engendrant un maximum de retournement 3 er niveau IA algorithme min/max Conception des outils de gestion des données o Programmation des entêtes de classes 2 H o Programmation des algorithmes et fonctions 30 H o Tests unitaires avec affichage des résultats sur console texte 10 H Réunion de validation du prototype 2 H 3 ème itération : interface graphique o Analyse de l interface graphique 4 H Conception d un prototype non fonctionnel avec menu surface de jeu emplacement des boutons. o Conception de la charte graphique 2 H o Programmation des entêtes de classes 8 H o Programmation des tests avec suivis du scénario de tests 4 H o Programmation des algorithmes et fonctions 80 H Réunion de validation du prototype 2 H Test d'intégration 40 H Total : 266H Soit 33 jours Hommes othello 21

25 IUT Rodez université Toulouse capitole I Diagramme de Gantt initial othello 22

26 IUT Rodez université Toulouse capitole I Suivi du projet Notre cycle de vie s est décomposé en trois itérations, correspondant aux grandes étapes de la conception de notre projet. Il nous est apparu au fur et à mesure que notre cycle de développement s est échelonné à la manière d un cycle en cascade. Nous utiliserons tout de même le terme d itération pour qualifier chaque grande étape du projet. 1 ère itération : Réalisation des algorithmes et fonction de bases du mode 2 joueurs Ecart avec le planning initial : 1 semaine Problème : Stockage et appel des coups possible par la méthode 1 de l IA Solution : Création d une Liste Contigüe de coups jouables Modification du planning : Aucune 2 ème itération : 2 ème niveau IA sélection du coup engendrant un maximum de retournement Ecart avec le planning initial : 1 semaine Problème : Anticipation du retournement sans modification du plateau de jeu Solution : Création de coups virtuels Modification du planning : Augmentation du nombre d heure de travail par semaine 3ème itération : interface graphique Ecart avec le planning initial : 2 semaines Problème : o Manque de temps pour l intégration d une interface graphique o Problème de modification des plateaux de jeu gérés par l IA Solution : o Basculer l affichage en mode console o Création d une méthode Clone dans la classe Plateau Modification du planning : Voir nouveau diagramme de Gantt othello 23

27 IUT Rodez université Toulouse capitole I Diagramme de Gantt final othello 24

28 IUT Rodez université Toulouse capitole I 5. Conclusion Résultat du projet A l issu de notre projet et après avoir effectué tous les tests qui nous ont paru nécessaire, notre produit fini réponds bien aux attentes telles que définies dans le diagramme des cas d utilisation, diagramme validé par l équipe MOA. Du point de vue des aspects non fonctionnels, et notamment de la gestion de projet, nous avons fait de notre mieux compte tenu du peu d expérience que nous avons dans le domaine pour effectuer un suivi régulier du projet, ainsi qu une répartition harmonieuse des tâches. La correspondance régulière que nous avons entretenu avec le chef de projet MOA, ainsi que la dernière réunion en date du 18/05/2014, nous incite à penser que notre projet répond aux attente de la dite MOA, et ceux après revue et corrections des différents livrables fournis. Gestion de projet Cette première expérience en matière de gestion de projet nous a permis d appréhender l importance d une vision d ensemble sur la démarche de suivi des tâches et planning. En effet dès la première semaine nous avons accusé un retard qui s est répercuté sur notre planning et nous a conduit à revoir le cadre qualité de notre projet. Quant à la gestion de la communication, l utilisation de divers outil de vidéoconférence/partage de fichiers/planning partagés nous a permis une réactivité et une adaptation correcte tout en favorisant les échanges réguliers et un suivi permanent de l avancement des tâches réparties entre les deux binômes. Du point de vue de la gestion des ressources humaines, de l entente entre les membres du groupe ainsi que de la gestion des incidents, cela n a pas été trop difficile et peu de problèmes sont apparus. Cela peut s expliquer du fait de la possibilité de choisir ses coéquipiers de fait nous avons constitué notre équipe en fonction des affinités. En ce qui concerne les différents formalismes utilisés (UML, JAVA), leurs applications strictes nous ont permis de maximiser la lisibilité de nos sources et d uniformiser nos travaux. othello 25

29 IUT Rodez université Toulouse capitole I Conclusion générale Le but premier de ce projet a été de s immerger dans une démarche professionnelle en se rapprochant un maximum des exigences et conditions de travail du monde de l entreprise. Que ce soit au niveau de l étude du besoin, de l organisation de l équipe ou des exigences en matière de qualités, nous nous sommes imposé une rigueur afin de nous préparer à notre futur de développeur logiciel. Le fait d avoir pu expériementer chaque rôle tout au long du processus de developpement nous a permis d appréhender tous les aspects de la gestion de projet. Malgré tout notre projet a pu souffrir d un manque de coordination, d une estimation approximative de la charge de travail et ce du fait de notre manque d expérience. Cela nous aura permis de mieux cerner les enjeux d une telle démarche. En effet, la phase de développement nous avait paru au départ comme étant primordiale, à retrouver sa place dans l ordre de nos priorités. Ainsi les aspects de conception ainsi que de la phase de tests nous paraissent aujourd hui plus importants qu ils ne l étaient avant le projet. L importance d une vision d ensemble, ainsi que le respect d une démarche clairement établie en avant-projet est un facteur que nous ne négligerons pas lors d un futur projet de ce type. Malgré tous les problèmes rencontrés, nous nous félicitons d avoir pu livrer un produit fini qui s il n est pas parfait respecte le cahier des charges soumis par la MOA. C est au prix de beaucoup de temps et d efforts mutuels que nous sommes parvenu à finaliser ce projet qui comptera comme une des plus importantes expériences de coopération lors de cette première année de DUT. Nous tenons à remercier toutes les personnes qui nous ont apportées leur soutien, ainsi que les enseignants qui nous ont guidés au fil de ce projet. 6. Glossaire DUT = Diplôme Universitaire Technique IA = Intelligence Artificielle IUT = Institut Universitaire Technologique JAVA = Just Another Vague Acronym MOA = Maitrise d ouvrage MOE = Maitrise d œuvre UML = Unified Modeling Language othello 26

30 IUT Rodez université Toulouse capitole I 7. Annexes Comptes rendu réunion MOE othello 27

31 IUT Rodez université Toulouse capitole I othello 28

32 IUT Rodez université Toulouse capitole I othello 29

33 IUT Rodez université Toulouse capitole I othello 30

34 IUT Rodez université Toulouse capitole I othello 31

35 IUT Rodez université Toulouse capitole I othello 32

36 IUT Rodez université Toulouse capitole I othello 33

37 IUT Rodez université Toulouse capitole I othello 34

38 IUT Rodez université Toulouse capitole I othello 35

39 IUT Rodez université Toulouse capitole I othello 36

40 IUT Rodez université Toulouse capitole I Compte rendu comité de pilotage othello 37

41 IUT Rodez université Toulouse capitole I othello 38

42 IUT Rodez université Toulouse capitole I othello 39

43 IUT Rodez université Toulouse capitole I II. Spécifications détaillées Diagramme des cas d utilisation Cas numéro 1 : Identification Nom : Lancer une nouvelle partie un joueur Objectif : Détaille les étapes permettant à un joueur de jouer une nouvelle partie contre l ordinateur. Acteur principal : Joueur Date : 19/04/2014 Responsable : Joueur Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 1 dans le menu principal Enchaînement nominal : othello 40

44 IUT Rodez université Toulouse capitole I 1. Le joueur saisit son pseudo 2. Le joueur choisi une méthode (1, 2 ou 3) ou fait retour 3. La partie se lance (affichage du plateau), le joueur commence 4. Le joueur saisit une case s il y a des coups possibles, point 6 sinon 5. La case est jouée, affichage du plateau, du tour de jeu et du score 6. L ordinateur joue une case à son tour en fonction de la méthode choisie en 2, affichage du plateau, du tour de jeu et du score 7. Si le jeu n est pas terminé, il faut boucler au point 4 8. Le jeu est terminé, affichage du gagnant 9. Affichage du tableau des scores Enchaînement alternatif : Point 2 de la séquence nominale : le joueur saisit 0 - Retour au menu principal Point 4 de la séquence nominale : le joueur saisit m ou M - Le jeu demande s il veut quitter - Si le joueur tape 1, le jeu lui demande s il veut sauvegarder le partie, sinon retour à la partie, point 4 - S il veut sauvegarder, il saisit un nom puis retour au menu principal, sinon retour au menu principal sans sauvegarde Point 4 de la séquence nominale : le joueur saisit p ou P - L enchainement reprend au point 6 Point 4 de la séquence nominale : le joueur saisit une case valide mais le coup n est pas jouable - Un message lui indique que le coup n est pas jouable - L enchainement reprend au point 4 Point 8 de la séquence nominale : Le joueur a effectué un nouveau meilleur score - Le pseudo du joueur et son score sont inscrits dans le tableau des scores - L enchainement reprend au point 9 Enchainement d exception : Point 1 de la séquence nominale : le joueur saisit une chaine vide - Message d erreur - Le jeu demande un pseudo tant que le joueur ne saisit rien Point 2 de la séquence nominale : le joueur ne saisit pas 0, 1,2 ou 3 - Message d erreur - Le jeu demande un niveau tant que le joueur ne saisit pas 0, 1, 2 ou 3 Point 4 de la séquence nominale : le joueur saisit une chaine invalide - Message d erreur - Le jeu demande une case tant que le joueur ne saisit pas une chaine valide (case, p ou m) Postcondition : Retour au menu principal othello 41

45 IUT Rodez université Toulouse capitole I Cas numéro 2 : Identification Nom : Lancer une nouvelle partie deux joueurs Objectif : Détaille les étapes permettant à un joueur de jouer une nouvelle partie contre un autre joueur. Acteur principal : Le joueur qui lance la partie Date : 19/04/2014 Responsable : Le joueur qui lance la partie Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 2 dans le menu principal Enchaînement nominal : 1. Le joueur 1 saisit son pseudo 2. Le joueur 2 saisit son pseudo 3. Tirage au sort des couleurs 4. La partie se lance (affichage du plateau), les noirs commencent 5. Le joueur noir saisit les coordonnées d une case s il y a des coups possibles, point 7 sinon 6. La case est jouée, affichage du plateau, du tour de jeu et du score 7. Si le jeu n est pas terminé, on continu au point 8, sinon point Le joueur blanc saisit les coordonnées d une case s il y a des coups possibles, point 10 sinon 9. La case est jouée, affichage du plateau du tour de jeu et du score 10. Si le jeu n est pas terminé, il faut boucler au point Le jeu est terminé, affichage du gagnant 12. Affichage du tableau des scores Enchaînement alternatif : Point 5 et 8 de la séquence nominale : le joueur saisit m ou M - Le jeu demande s il veut quitter - Si le joueur tape 1, le jeu lui demande s il veut sauvegarder le partie, sinon retour à la partie, point 5 ou 8 - S il veut sauvegarder, il saisit un nom puis retour au menu principal, sinon retour au menu principal sans sauvegarde Point 5 et 8 de la séquence nominale : le joueur saisit p ou P - L enchainement reprend au point 7 ou 10 Point 5 et 8 de la séquence nominale : le joueur saisit une case valide mais le coup n est pas jouable - Un message lui indique que le coup n est pas jouable - L enchainement reprend au point 5 ou 8 Point 11 de la séquence nominale : Un des deux joueurs a effectué un nouveau othello 42

46 IUT Rodez université Toulouse capitole I meilleur score - Le pseudo du joueur et son score sont inscrits dans le tableau des scores - L enchainement reprend au point 12 Enchainement d exception : Point 1 et 2 de la séquence nominale : le joueur saisit une chaine vide - Message d erreur - Le jeu demande un pseudo tant que le joueur ne saisit rien Point 5 et 8 de la séquence nominale : le joueur saisit une chaine invalide - Message d erreur - Le jeu demande une case tant que le joueur ne saisit pas une chaine valide (case, p ou m) Postcondition : Retour au menu principal othello 43

47 IUT Rodez université Toulouse capitole I Cas numéro 3 : Identification Nom : Chargement d une sauvegarde Objectif : Détaille les étapes permettant à un joueur de charger une sauvegarde Acteur principal : Le joueur qui lance la sauvegarde Date : 19/04/2014 Responsable : Le joueur qui lance la sauvegarde Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 3 dans le menu principal Enchaînement nominal : 1. La liste des parties sauvegardées avec le jour et l heure de la sauvegarde est affichée 2. Le joueur choisit une sauvegarde 3. La partie sauvegardée se lance (affichage du plateau, du tour de jeu et des scores Enchaînement alternatif : Point 1 de la séquence nominale : La liste est vide - Message indiquant au joueur qu aucune partie n est sauvée - Retour au menu Point 2 de la séquence nominale : le joueur saisit 0 - Retour au menu principal Enchainement d exception : Point 2 de la séquence nominale : le joueur saisit une chaine invalide - Message d erreur - Le jeu demande un chiffre tant que le joueur ne saisit pas une chaine valide Postcondition : Une partie est lancée othello 44

48 IUT Rodez université Toulouse capitole I Cas numéro 4 : Identification Nom : Affichage du tableau des scores Objectif : Détaille les étapes permettant à un joueur de consulter le tableau des scores Acteur principal : Le joueur qui consulte le tableau des scores Date : 19/04/2014 Responsable : Le joueur qui consulte le tableau des scores Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 4 dans le menu principal Enchaînement nominal : 1. Le tableau des scores est affiché Enchaînement alternatif : Point 1 de la séquence nominale : La liste est vide - Page vide - Retour au menu principal Postcondition : Retour au menu principal othello 45

49 IUT Rodez université Toulouse capitole I Cas numéro 5 : Identification Nom : Consulter l aide Objectif : Détaille les étapes permettant à un joueur de consulter l aide Acteur principal : Le joueur qui consulte l aide Date : 19/04/2014 Responsable : Le joueur qui consulte l aide Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 5 dans le menu principal Enchaînement nominal : 1. Le jeu propose de consulter les règles ou le «A propos du jeu» 2. Le joueur saisit 1 : l enchainement reprend au point 4 3. Le joueur saisit 2 : l enchainement reprend au point 4. Les règles du jeu s affichent, l enchainement reprend au point 6 5. Le «A propos du jeu» s affiche, l enchainement reprend au point 6 6. Affichage du menu principal Enchaînement alternatif : Point 1 de la séquence nominale : Le joueur saisit 0 - Retour au menu principal Enchainement d exception : Point 1 de la séquence nominale : le joueur saisit une chaine invalide - Message d erreur - Le jeu demande un chiffre tant que le joueur ne saisit pas 1, 2 ou 0 Postcondition : Retour au menu principal othello 46

50 IUT Rodez université Toulouse capitole I Cas numéro 6 : Identification Nom : Quitter le jeu Objectif : Détaille les étapes permettant à un joueur de quitter le jeu en sauvegardant les données Acteur principal : Le joueur qui quitte le jeu Date : 19/04/2014 Responsable : Le joueur qui quitte le jeu Version : 2.0 Séquencement Précondition : le jeu est lancé et le joueur a tapé 6 dans le menu principal Enchaînement nominal : 1. Le jeu propose de quitter 2. Le joueur saisit oui (1) 3. Les données sont sauvées dans des fichiers «.dat» Enchaînement alternatif : Point 2 de la séquence nominale : Le joueur saisit 2 ou 0 - Retour au menu principal Postcondition : L invite de commandes se ferme othello 47

51 IUT Rodez université Toulouse capitole I III. Conception Les grandes lignes de la conception de notre logiciel ont été motivées au grès des différentes fonctions que nous avons dû implémenter. De fait notre réflexion c est tout d abord axée autour de la représentation que l on pouvait se faire d une partie d Othello. Ce jeu est constitué d un plateau muni de cases et de pions que les joueurs disposent à tour de rôle sur le plateau. Partant de ce simple constat, il nous a fallu imaginer et concevoir les classes qui reflèteraient au mieux cet état de fait. «Un plateau contient des cases et chaque case peut contenir un pion ou peut être vide.» Nous avons donc travaillé dans un premier temps sur le trio plateau/cases/pions. Rapidement, le concept de case et de pion ont été réinterprétés, pour ne garder que des cases qui auraient un statut différent selon qu elles soient occupées ou non. Nous avons mené en parallèle un travail d expérimentation en ce qui concerne la future interface graphique, sans aller trop dans les détails afin de prendre les devants dans ce domaine où nous n étions pas formés. «Un plateau contient 64 cases (8x8)» Pour matérialiser le lien fort entre un plateau et les cases qui le composent, nous nous sommes naturellement tournés vers un tableau à deux dimensions. Ce tableau destiné à contenir des «Cases» permet non seulement de se représenter simplement une situation de jeu, mais permet aussi par le biais du système d indice d avoir accès à une Case à l aide de coordonnées comme si nous jouions sur un vrai plateau. «Bien appréhender les règles du jeu» L étude précise des règles de positionnement d un pion ainsi que le mécanisme de retournement a été une étape importante afin de concevoir les algorithmes inhérents à la gestion d une partie. Des recherches sur internet et notamment sur le site officiel de la FFO (Fédération Française d Othello) nous ont permis de mieux définir les conditions de retournement et la logique même du jeu. «La pose d un pion peut affecter le statut de beaucoup d autres» Dans ce jeu, l action fondamentale qui conditionne le déroulement d une partie est la pose d un pion. Cette action entraine une modification du statut des cases adjacentes et ce selon une règle simple mais importante : «seront impactées les cases se situant sur la même ligne ou colonne ainsi que celles présentes sur une des diagonales dont le centre est la case othello 48

52 IUT Rodez université Toulouse capitole I jouée». «8 directions, 8 parcours» Afin de vérifier le statut des cases adjacentes après la pose d un pion, nous avons conçu 8 boucles de parcours du tableau, une pour chaque direction, et ce à l aide des indices du tableau de «Cases». Ainsi, pour une situation de jeu donnée, nous pouvions, à ce stade, détecter si un retournement de pion était induit par la pose d un pion de la couleur adverse. «Un pion n est jamais posé au hasard» L autre aspect fondamental des règles de ce jeu est le fait qu une case n est jouable que si la pose d un pion sur la dite case entraine le retournement d au moins un pion adverse. De fait, l algorithme de parcours du tableau que nous avons évoqué précédemment pouvait alors nous servir de base pour décider si une case était jouable ou non, c est-à-dire, si la pose d un pion sur celle-ci allait entrainer un retournement. «Une case, beaucoup d attributs» Au départ, nous pensions doter les «Cases» du plateau de bon nombre d attributs. Le statut (vide, noir, ou blanc), la position (adjacente à une autre case occupée), la jouabilité, la position (indices du tableau), nous avons au fur et à mesure réduit le nombre de ces attributs afin de simplifier la conception. Une case se composa alors de son statut, et de sa position. Il nous restait alors à distinguer les cases jouable par chacun des joueurs et ce à tout moment de la partie. «Avoir toujours un coup d avance» Au commencement d une partie d Othello, 4 pions sont d ores et déjà disposés sur le plateau (2 noirs, 2 blancs), et c est à partir de cette situation de jeu que le joueur ayant les pions noirs doit décider du coup à jouer. Il nous fallait donc prendre les devants et calculer avant même que le joueur ait joué la liste des coups possibles afin de la comparer avec la case choisie par le joueur. Nous avons choisi de parcourir toutes les cases du tableau, au vue de leur faible nombre, à l aide des 8 algorithmes de parcours. Une simple instruction conditionnelle portant sur le statut des différentes cases, nous a alors permis d écarter toutes les cases non jouables. «Comment stocker tous les coups jouables» Ne voulant pas surcharger la classe Cases avec des attributs supplémentaires nous avons choisi de stocker toutes les cases jouables dans deux listes, une pour les cases jouables par les noirs, et une pour celles jouables par les blancs. Ayant codé une classe de liste contigüe en cour de POO, il nous a semblé naturel de la réutiliser, étant donné que nous maitrisions mieux son fonctionnement que celles déjà implémentées dans le JDK. De plus nous avions déjà conçu les tests pour cette classe. othello 49

53 IUT Rodez université Toulouse capitole I A ce stade, nous avions donc tous les ingrédients nécessaires au déroulement d une partie composée de deux joueurs. «L IA, une intelligence à trois vitesses» Le cahier des charges spécifiait que 2 «niveaux d IA» étaient requis, l un à l aide d un tirage aléatoire d un des coups jouables, l autre en déterminant simplement quel coup allait engendrer directement un retournement maximum de pions adverses. Ces deux niveaux ont été simples à concevoir, mais des recherches sur internet ont orientées notre réflexion sur un troisième «niveau», l algorithme Min/Max. «Parcours d arbre et profondeur» Pour l algorithme Min/Max, il nous a fallu nous représenter les possibilités de jeu comme un arbre des possibles, ou chaque branche constituait un coup joué, entrainant la possibilité de jouer plusieurs autres cases, elles-mêmes représentées par des sous-branches. Ainsi, notre algorithme devait parcourir cet arbre jusqu à une certaine profondeur afin d anticiper les coups de l adversaire et de calculer, à l aide d un système de pondérations des différentes cases du tableau, quel coup serait le plus avantageux. La pondération des cases n a pas été choisie au hasard, en fonction de l avantage stratégique qu octroie la pose d un pion sur une certaine case, on attribue un nombre de points à cette case othello 50

54 IUT Rodez université Toulouse capitole I On voit ici que les cases situées sur le bord du plateau et plus particulièrement dans les angles ont une pondération importante au vue de leurs avantages stratégiques. L algorithme ici ne se base pas sur le nombre de pions retournés pour un coup donné mais sur le nombre de points affectés à chaque case. «To be graphic, or not to be» Concernant l implémentation d une interface graphique, au vue des délais et du temps que nous avait pris la conception et le développement à ce stade, nous avons choisi de nous en passer. Nous nous sommes donc orientés vers un jeu en console texte, et ce qui au début nous paraissait simple et rapide à implémenter s est révélé plus chronophage que nous l aurions pensé. Pour gérer l affichage nous avons donc conçu une classe «OutilsInterface», afin de formater les menus du jeu. Pour ce qui est du déroulement des différentes parties les fonctions se situent dans une classe «DeroulementJeu», et enfin le programme principal de lancement du jeu se situe dans la classe «Jeu». «And the last one» La dernière fonctionnalité à être intégrée a été celle de la sauvegarde des parties et des scores. Pour cela, nous avons créé une classe «Partie», qui regroupait principalement comme attributs, deux objets «Joueurs», et un objet «Plateau». Nous avons également créé une classe «Score» qui permettait le stockage en mémoire des 10 meilleurs scores en partie 2 joueurs. Afin de stocker les parties sauvegardées, nous avons utilisé une «ListeContigue», la sauvegarde et la restauration de la liste des parties et du tableau des scores ont été gérées par la méthode de la classe «GestionPartie» à l aide de fonctions d inscription et de lecture d objets dans des fichiers binaires. othello 51

55 IUT Rodez université Toulouse capitole I Diagramme des classes initiale othello 52

56 IUT Rodez université Toulouse capitole I Diagramme des classes final othello 53

57 IUT Rodez université Toulouse capitole I IV. Codage othello 54

58 * Case.java 21 avr * IUT Info Groupe3 package partie; import java.io.serializable; * Classe de gestion d'une case du plateau de jeu Groupe AMRA 0.2 public class Case implements Serializable{ Position de la case sur le plateau private final int[] position; Statut de la case (0 si inoccupee, 1 si pion noir, 2 si pion blanc) private int statut; * Constructeur d'une case vide x coordonne de la case pour le parcours vertical y coordonne de la case pour le parcours vertical IllegalArgumentException si 0 <= x,y <= 7 public Case(int x, int y) throws IllegalArgumentException{ // precondition if( (0 > x x > 7) (0 > y y > 7) ){ throw new IllegalArgumentException("Coordonnees impossible " + "pour l'initialisation d'une case"); position = new int[2]; this.position[0]=x; this.position[1]=y; this.statut = 0; * Renvoie 0 si la case est non occupee, 1 si elle contient un pion noir, * 2 si le pion est blanc statut de la case public int getstatut() { return statut; * Met a jour le statut de la case statut IllegalArgumentException si le statut de la cae est incorrect public void setstatut(int statut) throws IllegalArgumentException{ // precondition if(statut!= 0 && statut!= 1 && statut!= 2){ throw new IllegalArgumentException("Valeur de statut impossible " + "pour une case"); this.statut = statut; * Renvoi la position de la case (indice x,y dans le tableaau Plateau de * GestionPlateau) sous la forme d'un tableau de 2 entiers le position public int[] getposition() { return position; * Renvoi la coordonnee x de cette case la coordonnees x correspondant a l'indice dans le tableau Plateau public int getx() { return position[0]; * Renvoi la coordonnee y de cette case la coordonnees x correspondant a l'indice dans le tableau Plateau public int gety() { return position[1]; /* (non-javadoc) IUT Rodez université Toulouse capitole I Othello

59 public String tostring() { if (this.getstatut() == 0) { return " "; else if (this.getstatut()==1){ return "x"; else { return "o"; /* * Plateau.java 21 avr * IUT Info Groupe3 package partie; import java.io.serializable; import utilitaire.listecontigue; * Gestion du plateau de jeu avec mise a jour des attributs des cases du plateau * en fonction des coups joues. * Methodes de jouabilite d'une case avec inscription de la case dans une liste. * Retournement des pions induit par la pose d'un pion de la meme couleur. Groupe AMRA 0.4 public class Plateau implements Serializable{ Tableau des cases composant le plateau private Object[][] plateau; Nombre de pions noirs sur le plateau private int nbpionnoir = 2; Nombre de pions blancs sur le plateau private int nbpionblanc = 2; Nombre total de pion sur le plateau private int nombretotalpion = 4; Liste des coups possibles pour un pion noir private ListeContigue coupspossiblesnoir; Liste des coups possibles pour un pion blanc private ListeContigue coupspossiblesblanc; Nombre de pions noirs retournes apres un coup virtuel private int virtuelpionnoir; Nombre de pions blancs retournes apres un coup virtuel private int virtuelpionblanc; * Construit un plateau de 8x8 cases et

60 public Plateau() { plateau = new Case[8][8]; this.initialisationplateau(); * Initialise l'etat du plateau conformement a la situation de depart pour * une partie d'otthelo. private void initialisationplateau(){ // Initialisation de toutes les cases du tableau avec le statut innocupe for(int x = 0 ; x < 8 ; x++){ for(int y = 0 ; y < 8 ; y++){ plateau[x][y] = new Case(x, y); // On place les 4 pion de depart sur le plateau (2 blancs, 2 noirs) getcase(3,3).setstatut(2); getcase(3,4).setstatut(1); getcase(4,3).setstatut(1); getcase(4,4).setstatut(2); coupsjouables(1); nbpionblanc = 2; nbpionnoir = 2; nombretotalpion = 4; * Place la case selectionne sur le plateau et lui attribut la couleur * du joueur si possible. Apelle la fonction coupsjouable pour indiquer * au joueur suivant les coups possibles. casejouee case jouee par le joeur a ce tour de jeu couleurjouee couleur des pions du joueur <ul><li>true si la case a pu etre jouee.</li> * <li>false sinon</li></ul> IllegalArgumentException si la couleur n'est pas correcte public boolean jouer(case casejouee, int couleurjouee) throws IllegalArgumentException{ // precondition if (couleurjouee!= 1 && couleurjouee!= 2) { throw new IllegalArgumentException("Valeur de la couleur incorrecte."); if (isjouable(casejouee, couleurjouee)) { casejouee.setstatut(couleurjouee); parcourstableau(casejouee, true, true); coupsjouables(casejouee.getstatut() == 1? 2 : 1); return true; System.out.println("\t \t Coup non jouable\n \t \t ~~~~~~~~~~~~~~~~"); return false; * Determine si une case est jouable casejouee case jouee par le joeur a ce tour de jeu couleur couleur des pions du joueur <ul><li>true si la case est jouable</li> * <li>false sinon</li></ul> IllegalArgumentException si <ul><li>casejouee n'est pas une Case </li> * <li>la couleur n'est pas correcte</li></ul> private boolean isjouable(case casejouee, int couleur) throws IllegalArgumentException { // precondition if (!(casejouee instanceof Case)) { throw new IllegalArgumentException("Type du parametre casejouee" + " incorrect."); else if (couleur!= 1 && couleur!= 2) { throw new IllegalArgumentException("Valeur de la couleur incorrecte."); if (couleur == 1) { for (int i = 0 ; i < coupspossiblesnoir.longueur() ; i++) { if (casejouee.getx() == ((Case)coupsPossiblesNoir.elementA(i)).getX() && casejouee.gety() == ((Case)coupsPossiblesNoir.elementA(i)).getY()) { return true; else { for (int i = 0 ; i < coupspossiblesblanc.longueur() ; i++) { if (casejouee.getx() == ((Case)coupsPossiblesBlanc.elementA(i)).getX()

61 && casejouee.gety() == ((Case)coupsPossiblesBlanc.elementA(i)).getY()) { return true; return false; * Parcours tout le tableau dans les 4 directions * (verticale, horizontale et diagonales), et met a jour * le statut des cases parcourues selon si elles sont * jouables par les noirs ou les blancs couleur des pions du joueur dont on determine les coups jouables IllegalArgumentException si la valeur couleur est incorrecte public void coupsjouables(int couleur) throws IllegalArgumentException{ //precondition if (couleur!= 1 && couleur!= 2) { throw new IllegalArgumentException("Valeur de la couleur incorrecte."); coupspossiblesnoir = new ListeContigue(); coupspossiblesblanc = new ListeContigue(); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++ ) { if (this.getcase(x,y).getstatut() == 0) { this.getcase(x,y).setstatut(couleur); parcourstableau(this.getcase(x, y), false, false); if(coupspossiblesnoir == null){ System.out.println("Le joueur noir passe sont tour"); else if (coupspossiblesblanc == null){ System.out.println("Le joueur blanc passe sont tour"); * Parcours les cases adjacentes a la case testee et appelle la fonction * retournerpion si le coup est joue et stocke la case jouable dans la liste * de coups Possibles. casetestee case jouee par le joeur a ce tour de jeu retournement <ul><li>true si la fonction est appele apres avoir joue</li> * <li>false si la fonction est appele avant de jouer * (calcul des coups possible)</li></ul> coupreel <ul><li>true si le coup entraîne un reel retournement de pions</li> * <li>false sinon (cas d'une simulation de jeu pour l'ia)</li></ul> IllegalArgumentException si casetestee n'est pas uen Case public void parcourstableau(case casetestee, boolean retournement, boolean coupreel) throws IllegalArgumentException{ // precondition if (!(casetestee instanceof Case)) { throw new IllegalArgumentException("Type du parametre casejouee" + " incorrect."); int statut = casetestee.getstatut(); if (!coupreel) { virtuelpionnoir = nbpionnoir; virtuelpionblanc = nbpionblanc; /* * Si un retournement est induit par la pose d'un pion alors le total * de pion sur le plateau est augmente de 1. nombretotalpion = retournement && coupreel? nombretotalpion + 1 : nombretotalpion; nbpionnoir = retournement && coupreel && statut == 1? nbpionnoir + 1 : nbpionnoir; nbpionblanc = retournement && coupreel && statut == 2? nbpionblanc + 1 : nbpionblanc; /* * Parcours de toute les directions du plateau depuis la case jouee * et dans le sens horaire avec mise a jour du statut des cases parcoursvb(casetestee, retournement, coupreel); parcoursdbg(casetestee, retournement, coupreel); parcourshg(casetestee, retournement, coupreel); parcoursdhg(casetestee, retournement, coupreel); parcoursvh(casetestee, retournement, coupreel); parcoursdhd(casetestee, retournement, coupreel);

62 parcourshd(casetestee, retournement, coupreel); parcoursdbd(casetestee, retournement, coupreel); // Si la fonction est appele pour tester la jouabilite du coup, // on remet le statut de la case a 0 pour indiquer qu'elle est vide if (!retournement) { casetestee.setstatut(0); * Parcours du plateau en ligne droite jusqu'au bord inferieur casetestee case jouee par le joeur a ce tour de jeu retournement <ul><li>true si la fonction est appele apres avoir joue </li> * <li>false si la fonction est appele avant de jouer</li> * (calcul des coups possible)</li></ul> coupreel <ul><li>true si le coup entraîne un reel retournement de pions</li> * <li>false sinon (cas d'une simulation de jeu pour l'ia)</li></ul> private void parcoursvb(case casetestee, boolean retournement, boolean coupreel) { final int x = casetestee.getx(); // Coordonnees de la case en X final int y = casetestee.gety(); // et y dans le tableau Plateau int statut = casetestee.getstatut(); for(int i = x + 1; i < 8 && this.getcase(i,y).getstatut()!= statut && this.getcase(i,y).getstatut()!= 0; i++){ // Encadrement par deux case de la couleur de casetestee if(i < 7 && this.getcase(i+1,y).getstatut() == statut) { if (retournement) { retournervb(casetestee, this.getcase(i+1,y), coupreel); else { if (statut == 1) { coupspossiblesnoir.inserer(casetestee, 0); else { coupspossiblesblanc.inserer(casetestee, 0); * Parcours du plateau en diagonale gauche jusqu'au bord inferieur casetestee case jouee par le joeur a ce tour de jeu retournement <ul><li>true si la fonction est appele apres avoir joue</li> * <li>false si la fonction est appele avant de jouer * (calcul des coups possible)</ul></li> coupreel <ul><li>true si le coup entraîne un reel retournement de pions</li> * <li>false sinon (cas d'une simulation de jeu pour l'ia)</ul></li> private void parcoursdbg(case casetestee, boolean retournement, boolean coupreel) { final int x = casetestee.getx(); // Coordonnees de la case en X final int y = casetestee.gety(); // et y dans le tableau Plateau int statut = casetestee.getstatut(); for(int i = x + 1, j = y - 1; i < 8 && j > 0 && this.getcase(i,j).getstatut()!= statut && this.getcase(i,j).getstatut()!= 0; i++,j--){ // Encadrement par deux case de la couleur de casetestee if(i < 7 && this.getcase(i+1,j-1).getstatut() == statut) { if (retournement) { retournerdbg(casetestee, this.getcase(i+1,j- 1), coupreel); else { if (statut == 1) { coupspossiblesnoir.inserer(casetestee, 0); else { coupspossiblesblanc.inserer(casetestee, 0); * Parcours du plateau en ligne droite jusqu'au bord gauche casetestee case jouee par le joeur a ce tour de jeu

63 retournement TRUE si la fonction est appele apres avoir joue * FALSE si la fonction est appele avant de jouer * (calcul des coups possible) coupreel TRUE si le coup entraîne un reel retournement de pions * FALSE sinon (cas d'une simulation de jeu pour l'ia) private void parcourshg(case casetestee, boolean retournement, boolean coupreel) { final int x = casetestee.getx(); // Coordonnees de la case en X final int y = casetestee.gety(); // et y dans le tableau Plateau int statut = casetestee.getstatut(); for(int j = y - 1; j > 0 && this.getcase(x,j).getstatut()!= statut && this.getcase(x,j).getstatut()!= 0; j--){ // Encadrement par deux case de la couleur de casetestee if(this.getcase(x,j-1).getstatut() == statut) { if (retournement) { retournerhg(casetestee, this.getcase(x,j-1), coupreel); else { if (statut == 1) { coupspossiblesnoir.inserer(casetestee, 0); else { coupspossiblesblanc.inserer(casetestee, 0); * Parcours du plateau en diagonale gauche jusqu'au bord superieur casetestee case jouee par le joeur a ce tour de jeu retournement TRUE si la fonction est appele apres avoir joue * FALSE si la fonction est appele avant de jouer * (calcul des coups possible) coupreel TRUE si le coup entraîne un reel retournement de pions * FALSE sinon (cas d'une simulation de jeu pour l'ia) private void parcoursdhg(case casetestee, boolean retournement, boolean coupreel) { final int x = casetestee.getx(); // Coordonnees de la case en X final int y = casetestee.gety(); // et y dans le tableau Plateau int statut = casetestee.getstatut(); for(int i = x - 1, j = y - 1; i > 0 && j > 0 && this.getcase(i,j).getstatut()!= statut && this.getcase(i,j).getstatut()!= 0; i--,j--){ // Encadrement par deux case de la couleur de casetestee if(this.getcase(i-1,j-1).getstatut() == statut) { if (retournement) { retournerdhg(casetestee, this.getcase(i-1,j- 1), coupreel); else { if (statut == 1) { coupspossiblesnoir.inserer(casetestee, 0); else { coupspossiblesblanc.inserer(casetestee, 0); * Parcours du plateau en ligne droite jusqu'au bord superieur casetestee case jouee par le joeur a ce tour de jeu retournement TRUE si la fonction est appele apres avoir joue * FALSE si la fonction est appele avant de jouer * (calcul des coups possible) coupreel TRUE si le coup entraine un reel retournement de pions * FALSE sinon (cas d'une simulation de jeu pour l'ia) private void parcoursvh(case casetestee, boolean retournement, boolean coupreel) { final int x = casetestee.getx(); // Coordonnees de la case en X final int y = casetestee.gety(); // et y dans le tableau Plateau int statut = casetestee.getstatut();

64 for(int i = x - 1; i > 0 && this.getcase(i,y).getstatut()!= statut && this.getcase(i,y).getstatut()!= 0; i--){ // Encadrement par deux case de la couleur de casetestee if(this.getcase(i-1,y).getstatut() == statut) { if (retournement) { retournervh(casetestee, this.getcase(i-1,y), coupreel); else { if (statut == 1) { coupspossiblesnoir.inserer(casetestee, 0); else { coupspossiblesblanc.inserer(casetestee, 0); * Parcours du plateau en diagonale droite jusqu'au bord superieur casetestee case jouee par le joeur a ce tour de jeu retournement TRUE si la fonction est appele apres avoir joue * FALSE si la fonction est appele avant de jouer * (calcul des coups possible) coupreel TRUE si le coup entraine un reel retournement de pions * FALSE sinon (cas d'une simulation de jeu pour l'ia) private void parcoursdhd(case casetestee, boolean retournement, boolean coupreel) { final int x = casetestee.getx(); // Coordonnees de la case en X final int y = casetestee.gety(); // et y dans le tableau Plateau int statut = casetestee.getstatut(); for(int i = x - 1, j = y + 1; i > 0 && j < 8 && this.getcase(i,j).getstatut()!= statut && this.getcase(i,j).getstatut()!= 0; i--,j++){ // Encadrement par deux case de la couleur de casetestee if(j < 7 && this.getcase(i-1,j+1).getstatut() == statut) { if (retournement) { retournerdhd(casetestee, this.getcase(i- 1,j+1), coupreel); else { if (statut == 1) { coupspossiblesnoir.inserer(casetestee, 0); else { coupspossiblesblanc.inserer(casetestee, 0); * Parcours du plateau en diagonale droite jusqu'au bord inferieur casetestee case jouee par le joeur a ce tour de jeu retournement TRUE si la fonction est appele apres avoir joue * FALSE si la fonction est appele avant de jouer * (calcul des coups possible) coupreel TRUE si le coup entraine un reel retournement de pions * FALSE sinon (cas d'une simulation de jeu pour l'ia) private void parcourshd(case casetestee, boolean retournement, boolean coupreel) { final int x = casetestee.getx(); // Coordonnees de la case en X final int y = casetestee.gety(); // et y dans le tableau Plateau int statut = casetestee.getstatut(); for(int j = y + 1; j < 8 && this.getcase(x,j).getstatut()!= statut && this.getcase(x,j).getstatut()!= 0; j++){ // Encadrement par deux case de la couleur de casetestee if(j < 7 && this.getcase(x,j+1).getstatut() == statut) { if (retournement) { retournerhd(casetestee, this.getcase(x,j+1), coupreel); else { if (statut == 1) { coupspossiblesnoir.inserer(casetestee, 0);

65 else { coupspossiblesblanc.inserer(casetestee, 0); * Parcours du plateau en ligne droite jusqu'au bord droit casetestee case jouee par le joeur a ce tour de jeu retournement TRUE si la fonction est appele apres avoir joue * FALSE si la fonction est appele avant de jouer * (calcul des coups possible) coupreel TRUE si le coup entraine un reel retournement de pions * FALSE sinon (cas d'une simulation de jeu pour l'ia) private void parcoursdbd(case casetestee, boolean retournement, boolean coupreel) { final int x = casetestee.getx(); // Coordonnees de la case en X final int y = casetestee.gety(); // et y dans le tableau Plateau int statut = casetestee.getstatut(); for(int i = x + 1, j = y + 1 ; i < 8 && j < 8 && this.getcase(i,j).getstatut()!= statut && this.getcase(i,j).getstatut()!= 0 ; i++,j++){ // Encadrement par deux case de la couleur de casetestee if(i < 7 && j < 7 && this.getcase(i+1,j+1).getstatut() == statut) { if (retournement) { retournerdbd(casetestee, this.getcase(i+1,j+1), coupreel); else { if (statut == 1) { coupspossiblesnoir.inserer(casetestee, 0); else { coupspossiblesblanc.inserer(casetestee, 0); * Retournement des pions en ligne droite vers le bord inferieur case1 case de depart pour le retournement case2 case d'arrivee pour le retournement coupreel TRUE si la fonction est appelle pour retourner des pions * FALSE en cas d'appel pour simuler un retournement (IA) private void retournervb(case case1, Case case2, boolean coupreel) { int x1 = case1.getx(), y1 = case1.gety(), x2 = case2.getx(), y2 = case2.gety(); int statut = case1.getstatut(); for (int x = x1 + 1; x < x2; x++){ if (coupreel) { this.getcase(x,y1).setstatut(statut); nbpionnoir = statut == 1? nbpionnoir + 1 : nbpionnoir - 1; nbpionblanc = statut == 2? nbpionblanc + 1 : nbpionblanc - 1; else { virtuelpionnoir = statut == 1? virtuelpionnoir + 1 : virtuelpionnoir - 1; virtuelpionblanc = statut == 2? virtuelpionblanc + 1 : virtuelpionblanc - 1; * Retournement des pions en diagonale vers le bord inferieur gauche case1 case de depart pour le retournement case2 case d'arrivee pour le retournement coupreel TRUE si la fonction est appelle pour retourner des pions * FALSE en cas d'appel pour simuler un retournement (IA) private void retournerdbg(case case1, Case case2, boolean coupreel) { int x1 = case1.getx(), y1 = case1.gety(), x2 = case2.getx(), y2 = case2.gety();

66 int statut = case1.getstatut(); for (int x = x1 + 1, y = y1-1; x < x2 && y > y2; x++, y-- ){ if (coupreel) { this.getcase(x,y).setstatut(statut); nbpionnoir = statut == 1? nbpionnoir + 1 : nbpionnoir - 1; nbpionblanc = statut == 2? nbpionblanc + 1 : nbpionblanc - 1; else { virtuelpionnoir = statut == 1? virtuelpionnoir + 1 : virtuelpionnoir - 1; virtuelpionblanc = statut == 2? virtuelpionblanc + 1 : virtuelpionblanc - 1; * Retournement des pions en ligne droite vers le bord gauche case1 case de depart pour le retournement case2 case d'arrivee pour le retournement coupreel TRUE si la fonction est appelle pour retourner des pions * FALSE en cas d'appel pour simuler un retournement (IA) private void retournerhg(case case1, Case case2, boolean coupreel) { int x1 = case1.getx(), y1 = case1.gety(), x2 = case2.getx(), y2 = case2.gety(); int statut = case1.getstatut(); for (int y = y1-1; y > y2 ; y--){ if (coupreel) { this.getcase(x1,y).setstatut(statut); nbpionnoir = statut == 1? nbpionnoir + 1 : nbpionnoir - 1; nbpionblanc = statut == 2? nbpionblanc + 1 : nbpionblanc - 1; else { virtuelpionnoir = statut == 1? virtuelpionnoir + 1 : virtuelpionnoir - 1; virtuelpionblanc = statut == 2? virtuelpionblanc + 1 : virtuelpionblanc - 1; * Retournement des pions en diagonale vers le bord superieur gauche case1 case de depart pour le retournement case2 case d'arrivee pour le retournement coupreel TRUE si la fonction est appelle pour retourner des pions * FALSE en cas d'appel pour simuler un retournement (IA) private void retournerdhg(case case1, Case case2, boolean coupreel) { int x1 = case1.getx(), y1 = case1.gety(), x2 = case2.getx(), y2 = case2.gety(); int statut = case1.getstatut(); for (int x = x1-1, y = y1-1; x > x2 && y > y2; x--, y-- ){ if (coupreel) { this.getcase(x,y).setstatut(statut); nbpionnoir = statut == 1? nbpionnoir + 1 : nbpionnoir - 1; nbpionblanc = statut == 2? nbpionblanc + 1 : nbpionblanc - 1; else { virtuelpionnoir = statut == 1? virtuelpionnoir + 1 : virtuelpionnoir - 1; virtuelpionblanc = statut == 2? virtuelpionblanc + 1 : virtuelpionblanc - 1; * Retournement des pions en ligne droite vers le bord superieur case1 case de depart pour le retournement case2 case d'arrivee pour le retournement coupreel TRUE si la fonction est appelle pour retourner des pions * FALSE en cas d'appel pour simuler un retournement (IA) private void retournervh(case case1, Case case2, boolean coupreel) { int x1 = case1.getx(), y1 = case1.gety(),

67 x2 = case2.getx(), y2 = case2.gety(); int statut = case1.getstatut(); for (int x = x1-1; x > x2 ; x--){ if (coupreel) { this.getcase(x,y1).setstatut(statut); nbpionnoir = statut == 1? nbpionnoir + 1 : nbpionnoir - 1; nbpionblanc = statut == 2? nbpionblanc + 1 : nbpionblanc - 1; else { virtuelpionnoir = statut == 1? virtuelpionnoir + 1 : virtuelpionnoir - 1; virtuelpionblanc = statut == 2? virtuelpionblanc + 1 : virtuelpionblanc - 1; * Retournement des pions en diagonale vers le bord superieur droit case1 case de depart pour le retournement case2 case d'arrivee pour le retournement coupreel TRUE si la fonction est appelle pour retourner des pions * FALSE en cas d'appel pour simuler un retournement (IA) private void retournerdhd(case case1, Case case2, boolean coupreel) { int x1 = case1.getx(), y1 = case1.gety(), x2 = case2.getx(), y2 = case2.gety(); int statut = case1.getstatut(); for (int x = x1-1, y = y1 + 1; x > x2 && y < y2; x--, y++){ if (coupreel) { this.getcase(x,y).setstatut(statut); nbpionnoir = statut == 1? nbpionnoir + 1 : nbpionnoir - 1; nbpionblanc = statut == 2? nbpionblanc + 1 : nbpionblanc - 1; else { virtuelpionnoir = statut == 1? virtuelpionnoir + 1 : virtuelpionnoir - 1; virtuelpionblanc = statut == 2? virtuelpionblanc + 1 : virtuelpionblanc - 1; * Retournement des pions en ligne droite vers le bord droit case1 case de depart pour le retournement case2 case d'arrivee pour le retournement coupreel TRUE si la fonction est appelle pour retourner des pions * FALSE en cas d'appel pour simuler un retournement (IA) private void retournerhd(case case1, Case case2, boolean coupreel) { int x1 = case1.getx(), y1 = case1.gety(), x2 = case2.getx(), y2 = case2.gety(); int statut = case1.getstatut(); for (int y = y1 + 1; y < y2; y++){ if (coupreel) { this.getcase(x1,y).setstatut(statut); nbpionnoir = statut == 1? nbpionnoir + 1 : nbpionnoir - 1; nbpionblanc = statut == 2? nbpionblanc + 1 : nbpionblanc - 1; else { virtuelpionnoir = statut == 1? virtuelpionnoir + 1 : virtuelpionnoir - 1; virtuelpionblanc = statut == 2? virtuelpionblanc + 1 : virtuelpionblanc - 1; * Retournement des pions en diagonale vers le bord droit case1 case de depart pour le retournement case2 case d'arrivee pour le retournement coupreel TRUE si la fonction est appelle pour retourner des pions * FALSE en cas d'appel pour simuler un retournement (IA) private void retournerdbd(case case1, Case case2, boolean coupreel) { int x1 = case1.getx(),

68 y1 = case1.gety(), x2 = case2.getx(), y2 = case2.gety(); int statut = case1.getstatut(); for (int x = x1 + 1, y = y1 + 1; x < x2 && y < y2; x++, y++){ if (coupreel) { this.getcase(x,y).setstatut(statut); nbpionnoir = statut == 1? nbpionnoir + 1 : nbpionnoir - 1; nbpionblanc = statut == 2? nbpionblanc + 1 : nbpionblanc - 1; else { virtuelpionnoir = statut == 1? virtuelpionnoir + 1 : virtuelpionnoir - 1; virtuelpionblanc = statut == 2? virtuelpionblanc + 1 : virtuelpionblanc - 1; * Renvoi la case situee a la position (x, y) dans le tableau plateau x indice de la case pour le parcour vertical y indice de la case pour le parcours horizontal la case a la position(x, y) public Case getcase(int x, int y) { return (Case) plateau[x][y]; * Renvoi le nombre de pions noir sur le plateau nbpionnoir le nombre de pions noir public int getnbpionnoir(){ return nbpionnoir; * Renvoi le nombre de pion blanc sur le plateau nbpionblanc le nombre de pion blanc public int getnbpionblanc(){ return nbpionblanc; * Modifie le nombre de pions noir sur le plateau nbnoir : nouveau nombre de pions noirs public void setnbpionnoir(int nbnoir){ nbpionnoir = nbnoir; Modifie le nombre de pion blanc sur le plateau nbblanc : nouveau nombre de pions blancs public void setnbpionblanc(int nbblanc){ nbpionblanc = nbblanc; * Renvoi le nombre de pion noir apres un coup virtuel nbpionnoir le nombre de pion noir public int getvirtuelpionnoir(){ return virtuelpionnoir; * Renvoi le nombre de pion blanc apres un coup virtuel nbpionblanc le nombre de pion blanc public int getvirtuelpionblanc(){ return virtuelpionblanc; * Renvoi le nombre total de pion sur le plateau nombretotalpion le nombre total de pion sur le plateau public int gettotalpion(){ return nombretotalpion; * Modifie le nombre total de pion sur le plateau totpion nombretotalpion le nombre total de pion sur le plateau public void settotalpion(int totpion){ nombretotalpion = totpion; * Renvoi la liste des cases jouables

69 la liste des coups possibles public ListeContigue getcoupspossiblesnoir() { return coupspossiblesnoir; * Renvoi la liste des cases jouables la liste des coups possibles public ListeContigue getcoupspossiblesblanc() { return coupspossiblesblanc; /* (non-javadoc) public Object clone() throws CloneNotSupportedException { Plateau plateau = new Plateau(); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { plateau.getcase(x, y).setstatut(this.getcase(x, y).getstatut()); return public String tostring() { char[] lettre = {'8','7','6','5','4','3','2','1'; StringBuilder tableau = new StringBuilder(); for (int x = 0; x < 8; x++){ tableau.append("\t \n\t" + lettre[x] + " "); for (int y = 0; y < 8; y++){ tableau.append(" " + ((Case)plateau[x][y]).toString() + " "); tableau.append(" \n"); tableau.append("\t \n" + "\t A B C D E F G H"); return tableau.tostring(); /* * CoupsIA.java 28 avr * IUT Info Groupe3 package partie; import utilitaire.listecontigue; * Gestion des coups joues par l'ia. * Trois niveaux de jeux pris en compte : * <ul><li>coups aleatoires</li> * <li>coups retournant le maximum de pions</li> * <li>coups utilisant l'algorithme min/max</li></ul> Groupe AMRA 0.4 public class CoupsIA { Tableau des cases ponderees pour le niveau 3 private final static int[][] ponderation = { {500, -150, 30, 10, 10, 30, -150, 500, {-150, -200, 0, 0, 0, 0, -250, -150, {30, 0, 1, 2, 2, 1, 0, 30, {10, 0, 2, 16, 16, 2, 0, 10, {10, 0, 2, 16, 16, 2, 0, 10, {30, 0, 1, 2, 2, 1, 0, 30, {-150, -200, 0, 0, 0, 0, -250, -150, {500, -150, 30, 10, 10, 30, -150, 500; // Listes des ponderations pour le niveau 3 Liste des ponderations pour le niveau de profondeur 11 private static ListeContigue listeponderations11 = new ListeContigue(); Liste des ponderations pour le niveau de profondeur 12 private static ListeContigue listeponderations12 = new ListeContigue(); Liste des ponderations pour le niveau de profondeur 21 private static ListeContigue listeponderations21 = new ListeContigue(); Liste des ponderations pour le niveau de profondeur 22 private static ListeContigue listeponderations22 = new ListeContigue(); * Choix aleatoire de la prochaine case a jouer plateaujeu le plateau sur lequel on joue couleuria couleur de l'ia la case choisis aleatoirement dans listejouable

70 public static Case niveau1(plateau plateaujeu, int couleuria) { ListeContigue listejouable = new ListeContigue(); listejouable = couleuria == 1? plateaujeu.getcoupspossiblesnoir() : plateaujeu.getcoupspossiblesblanc(); int taille = listejouable.longueur(); // Choix d un nombre random entre 0 et la longueur de la liste donnee // en parametre int alea = (int)(math.random() * ) % (taille); return (Case) listejouable.elementa(alea); * Calcule le nombre de pions retournes pour chaque coup jouable present * dans la liste en parametre puis choisit celui qui en retourne le plus plateaujeu le plateau sur lequel on joue couleuria couleur de l'ia la case qui propose le plus grand nombre de retournement public static Case niveau2(plateau plateaujeu, int couleuria) { ListeContigue listejouable = new ListeContigue(); listejouable = couleuria == 1? plateaujeu.getcoupspossiblesnoir() : plateaujeu.getcoupspossiblesblanc(); int retournes; // Nombre de pions retournes par la pose d'un pion // On stocke le nombre de pions retournes par case int[] caseretournee = new int[listejouable.longueur()]; int indicenbmaximum; // L'indice du nombre max present dans tableau if (couleuria == 1) { for (int i = 0 ; i < listejouable.longueur() ; i++) { // On joue un a un les coups (dans l'ordre de la liste) ((Case) plateaujeu.getcoupspossiblesnoir().elementa(i)).setstatut(1); // Coup virtuel plateaujeu.parcourstableau((case) plateaujeu.getcoupspossiblesnoir().elementa(i), true, false); ((Case) plateaujeu.getcoupspossiblesnoir().elementa(i)).setstatut(0); // Calcul du nombre de pions retournes retournes = plateaujeu.getvirtuelpionnoir() - plateaujeu.getnbpionnoir(); caseretournee[i] = retournes; else if (couleuria ==2) { for (int i=0 ; i < listejouable.longueur() ; i++) { // on joue un a un les coups (dans l'ordre de la liste) ((Case) plateaujeu.getcoupspossiblesblanc().elementa(i)).setstatut(2); // Coup virtuel plateaujeu.parcourstableau((case) plateaujeu.getcoupspossiblesblanc().elementa(i), true, false); ((Case) plateaujeu.getcoupspossiblesblanc().elementa(i)).setstatut(0); // Calcul du nombre de pions retournes retournes = plateaujeu.getvirtuelpionblanc() - plateaujeu.getnbpionblanc(); caseretournee[i] = retournes; // Recupere le nombre max de cases retournees par le meilleur coup joue indicenbmaximum = maxtab(caseretournee); /* * Si IA a les pions noirs alors on retourne la meilleure case a jouer * presente dans la liste des coups possibles return couleuria == 1? (Case) plateaujeu.getcoupspossiblesnoir().elementa(indicenbmaximum) : (Case) plateaujeu.getcoupspossiblesblanc().elementa(indicenbmaximum); * Utilise l'algorithme MinMax pour calculer le meilleur coup possible

71 * a jouer pour l'ia suivant l'etat du Plateau actuel et de la liste des * coups possibles (profondeur = 2) plateaujeu le plateau sur lequel on joue couleur de l'ia la case jouee public static Case niveau3(plateau plateaujeu, int couleur) { // Mise a jour de coups possibles IA (plateaujeu) ListeContigue listecoupsjouables = new ListeContigue(); plateaujeu.coupsjouables(couleur); listecoupsjouables = couleur == 1? plateaujeu.getcoupspossiblesnoir() : plateaujeu.getcoupspossiblesblanc(); if (listecoupsjouables.longueur() == 1) { return (Case)listeCoupsJouables.elementA(0); // Sauve du nombre de pions noirs et blancs sur le plateaujeu int pionblanc = plateaujeu.getnbpionblanc(); int pionnoir = plateaujeu.getnbpionnoir(); int piontot = plateaujeu.gettotalpion(); /* ALGO MinMax int couleuradverse = couleur == 1? 2 : 1; Plateau plateaucourant = new Plateau(); // Copie du plateau de jeu actuel try { plateaucourant = (Plateau) plateaujeu.clone(); catch (CloneNotSupportedException e3) { e3.printstacktrace(); plateaucourant = null; Plateau plateau11 = new Plateau(); // Plateau apres le 1ercoups IA Plateau plateau12 = new Plateau(); // Plateau apres le 1er coup adverse Plateau plateau21 = new Plateau(); // Plateau apres le 2eme coup IA // Mise a jour plateaucourant plateaucourant.coupsjouables(couleur); listecoupsjouables = couleur == 1? plateaucourant.getcoupspossiblesnoir() : plateaucourant.getcoupspossiblesblanc(); int longueur11 = 0; int longueur12 = 0; int longueur21 = 0; int longueur22 = 0; 11 // Reinitialisation de la liste contigue des ponderations listeponderations11 = new ListeContigue(); for (int i = 0 ; i < listecoupsjouables.longueur() ; i++) { try { plateau11 = (Plateau) plateaucourant.clone(); catch (CloneNotSupportedException e2) { e2.printstacktrace(); plateau11 = null; // Coups possibles pour l'ia (mise a jour plateau11) plateau11.coupsjouables(couleur); listecoupsjouables = couleur == 1? plateau11.getcoupspossiblesnoir() : plateau11.getcoupspossiblesblanc(); couleur); longueur11 = listecoupsjouables.longueur(); // On joue un a un les cases de listejouable pour l'ia plateau11.jouer((case)listecoupsjouables.elementa(i), // Calcul des coups possibles pour l'adversaire listecoupsjouables = couleur == 1? plateau11.getcoupspossiblesblanc() : plateau11.getcoupspossiblesnoir(); longueur12 = listecoupsjouables.longueur(); // Bloque l'adversaire (0 coups possibles pour lui) if (longueur12 == 0) { listeponderations12.inserer(1000, 0); for (int j = 0 ; j < longueur12 ; j++) { try { plateau12 = (Plateau) plateau11.clone(); catch (CloneNotSupportedException e1) { e1.printstacktrace(); plateau12 = null; // Coups possibles pour l'adversaire (mise a jour plateau12) plateau12.coupsjouables(couleuradverse); listecoupsjouables = couleur == 1? plateau12.getcoupspossiblesblanc() : plateau12.getcoupspossiblesnoir();

72 l'adversaire // Joue un a un les cases de listejouable pour plateau12.jouer((case)listecoupsjouables.elementa(j), couleuradverse); // Calcul des coups possibles pour l'ia listecoupsjouables = couleur == 1? plateau12.getcoupspossiblesnoir() : plateau12.getcoupspossiblesblanc(); longueur21 = listecoupsjouables.longueur(); // On ne va pas pouvoir jouer ensuite if (longueur21 == 0) { listeponderations21.inserer(-1000, 0); for (int k = 0 ; k < longueur21 ; k++) { try { plateau21 = (Plateau) plateau12.clone(); catch (CloneNotSupportedException e) { e.printstacktrace(); plateau21 = null; // Coups possibles pour l'ia (mise a jour plateau21) plateau21.coupsjouables(couleur); listecoupsjouables = couleur == 1? plateau21.getcoupspossiblesnoir() : plateau21.getcoupspossiblesblanc(); l'ia // Joue un a un les cases de listejouable pour plateau21.jouer((case)listecoupsjouables.elementa(k), couleur); // Calcul des coups possibles pour l'adversaire listecoupsjouables = couleur == 1? plateau21.getcoupspossiblesblanc() : plateau21.getcoupspossiblesnoir(); longueur22 = listecoupsjouables.longueur(); if (longueur22 == 0) { listeponderations22.inserer(1000, 0); for (int l = 0 ; l < longueur22 ; l++) { listeponderations22.inserer(eval((case)listecoupsjouables.elementa( l)), l); listeponderations21.inserer(min(listeponderations22), k); listeponderations22 = new ListeContigue(); listeponderations12.inserer(max(listeponderations21), j); listeponderations21 = new ListeContigue(); listeponderations11.inserer(min(listeponderations12), i); listeponderations12 = new ListeContigue(); // Coups possibles pour l'ia (mise a jour plateaucourant) plateaucourant.coupsjouables(couleur); listecoupsjouables = couleur == 1? plateaucourant.getcoupspossiblesnoir() : plateaucourant.getcoupspossiblesblanc(); // Mise a jour de coups possibles IA (plateaujeu) plateaujeu.coupsjouables(couleur); listecoupsjouables = couleur == 1? plateaujeu.getcoupspossiblesnoir() : plateaujeu.getcoupspossiblesblanc(); // Restitution du contexte des nombres de pions plateaujeu.setnbpionblanc(pionblanc); plateaujeu.setnbpionnoir(pionnoir); plateaujeu.settotalpion(piontot); return (Case)listeCoupsJouables.elementA(indiceMax(listePonderations11)); * Retourne la ponderation de la placee en argument caseaponderer : la case a evaluer la ponderation de la case placee en argument private static int eval(case caseaponderer) { return ponderation[caseaponderer.getx()][caseaponderer.gety()]; * Cherche l'indice de la valeur maximale d'un tableau tableau le tableau dont on cherche le maximum l'indice du maximum

73 private static int maxtab(int[] tableau) { // int max = tableau[0]; int indice = 0; // emplacement du maximum dans le tableau for (int i = 0 ; i < tableau.length ; i++) { // parcours du tableau if (tableau[indice] < tableau[i]) { indice = i; return indice; * Cherche l'indice de la valeur maximale d'un tableau tableau la liste dont on cherche le maximum la valeur du maximum private static int max(listecontigue tableau) { // int max = tableau[0]; int indice = 0; // Emplacement du maximum dans le tableau for (int i = 0 ; i < tableau.longueur() ; i++) { // Parcours du tableau if ((int)tableau.elementa(indice) < (int)tableau.elementa(i)) { indice = i; return (int) tableau.elementa(indice); tableau la liste dont on cherche le maximum l'indice du maximum private static int indicemax(listecontigue tableau) { // int max = tableau[0]; ListeContigue egalite = new ListeContigue(); int indice = 0; // Emplacement du maximum dans le tableau for (int i = 0 ; i < tableau.longueur() ; i++) { // Parcours du tableau if ((int)tableau.elementa(indice) < (int)tableau.elementa(i)) { indice = i; for (int i = 0 ; i < tableau.longueur() ; i++) { // Parcours du tableau if ((int)tableau.elementa(indice) == (int)tableau.elementa(i)) { egalite.inserer(i, 0); // Renvoi un indice d'une ponderation maximale return (int)egalite.elementa((int)(math.random() * ) % (egalite.longueur())); * Cherche l'indice de la valeur minimale d'un tableau tableau le tableau dont on cherche le minimum la valeur du minimum private static int min(listecontigue tableau) { // int min = tableau[0]; int indice = 0; // Emplacement du minimum dans le tableau for (int i = 0 ; i < tableau.longueur() ; i++) { // Parcours du tableau if ((int)tableau.elementa(indice) > (int)tableau.elementa(i)) { indice = i; return (int) tableau.elementa(indice); * Cherche l'indice de la valeur maximale d'un tableau

74 /* * Joueur.java 29 avr * IUT Info Groupe3 package partie; import java.io.serializable; * Definit un joueur pour le jeu Othello avec : * <lu><li>son pseudo</li> * <li>son tour</li> * <li>sa couleur de pion</li></ul> groupe AMRA 0.2 public class Joueur implements Serializable{ Pseudo du joueur private String pseudo; Couleur des pions du joueurs : 1 pour noir, 2 pour blanc private int couleur; * Est a TRUE si le joueur est humain, et a FALSE si les coups joues * sont geres par l'ia private boolean humain; * Definit un Joueur par defaut avec : * <ul><li>pseudo => "inconnu"</li> * <li>couleur => "2"</li> * <li>humain => "true"<li></ul> public Joueur() { pseudo = "inconnu"; couleur = 2; this.humain = true; * Definit un joueur avec son pseudo, son tour de jeu a l'instant t * et sa couleur de pion pseudochoisi nom choisi par l'utilisateur couleurchoisie couleur de pion choisi par le joueur humain <ul><li>true si le joueur est un humain</li> * <li>false si ses coups sont geres par l'ia</li></ul> public Joueur(String pseudochoisi, int couleurchoisie, boolean humain) { this.pseudo = pseudochoisi; this.couleur = couleurchoisie; this.humain = humain; le pseudo public String getpseudo() { return pseudo; pseudo le pseudo du joueur IllegalArgumentException si le pseudo est vide public void setpseudo(string pseudo) throws IllegalArgumentException { if (pseudo == "" pseudo == null pseudo == " ") { throw new IllegalArgumentException("Le pseudo du joueur ne peut " + "pas etre nul ni vide"); this.pseudo = pseudo; la couleur public int getcouleur() { return couleur; couleur la couleur du joueur IllegalArgumentException si la couleur saisi est incorecte public void setcouleur(int couleur) throws IllegalArgumentException { if (couleur!= 1 && couleur!= 2 ) { throw new IllegalArgumentException("Valeur incorrecte " + "pour la couleur."); else if (this.couleur == couleur) { throw new IllegalArgumentException("La couleur choisi est la meme"

75 + " que celle deja attribuee"); this.couleur = couleur; Renvoi :<ul><li>true si le joueur est humain</li> * <li>false si ses coups sont geres par l'ia</li> public boolean ishumain() { return humain; * Permet de definir si les coups seront gere par un humain ou l'ia humain <ul><li>true si c'est un humain</li> * <li>false si ses coups sont geres par l'ia</li> public void sethumain(boolean humain) { this.humain = humain; /* (non-javadoc) public String tostring() { return "Pseudo : " + this.pseudo + ", couleur : " + this.getcouleur() + ", Humain? " + this.ishumain(); /* * Scores.java 24 mai 2014 * IUT Info Groupe3 package jeuothello; import java.io.serializable; * Sauvagarde du nom des joueurs et de leurs scores respectifs groupe AMRA 0.2 public class Scores implements Serializable { Nombre de scores inscrits dans le tableau private int nbelem = 0; Taille du tableau des scores private final static int TAILLE = 10; Tableau des scores private Object[][] scores = new Object[TAILLE][2]; * Insere un score dans le tableau des scores score nombre de pion du joeur en fin de partie pseudo nom du gagnant public void inserer(int score, String pseudo) { trierscores(); if(nbelem < TAILLE){ scores[nbelem][0] = pseudo; scores[nbelem][1] = new Integer(score); nbelem++; else if (nbelem == TAILLE && score > (int)scores[nbelem- 1][1]) { scores[nbelem-1][0] = pseudo; scores[nbelem-1][1] = new Integer(score); trierscores(); * Trie les scores du tableau par ordre decroissant * dans le tableau des scores private void trierscores() {

76 Object[] score = new Object[2]; // Tampon // Tri par insertion des scores for (int i = 1 ; i < nbelem ; i++){ for (int rang = i ; rang > 0 ; rang--) { if((int)this.scores[rang][1] > (int)this.scores[rang-1][1]){ score = this.scores[rang]; this.scores[rang] = this.scores[rang-1]; this.scores[rang-1] = score; /* (non-javadoc) public String tostring() { StringBuilder tabscore = new StringBuilder(); tabscore.append("\ntableau des scores :\n~~~~~~~~~~~~~~~~~~~~\n"); for(int i = 0 ; i < nbelem; i++){ tabscore.append(scores[i][0] + " -> " + scores[i][1] + "\n"); return tabscore.tostring(); /* * Partie.java 17 mai 2014 * IUT Info Groupe3 package jeuothello; import java.io.serializable; import partie.joueur; import partie.plateau; * Une partie est composee de 2 joueurs (dont un qui peut-etre l'ia) * et d'un plateau (contenant des cases) Groupe AMRA 0.2 public class Partie implements Serializable{ Nom de l apartie pour la sauvegarde private String nompartie; Joueur 1 private Joueur joueur1; Joueur 2 private Joueur joueur2; Plateau de 64 cases private Plateau plateaudejeu; * Tour de jeu qui definit si c'est aux noir * ou aux blancs de jouer private int tourdejeu; Niveau de l'ia, 0 pour une partie deux joueurs, 1, 2, ou 3 si c'est * une partie contre l'ordinateur private int niveauia = 0; * Definit une partie avec ses joueurs, le plateau de jeu * et son nom de partie. joueur1 un humain ou une IA qui joue joueur2 un humain ou une IA qui joue public Partie(Joueur joueur1, Joueur joueur2) { this.joueur1 = joueur1;

77 this.joueur2 = joueur2; this.plateaudejeu = new Plateau(); this.tourdejeu = 0; the nompartie public String getnompartie() { return nompartie; nompartie le nom de la partie IllegalArgumentException public void setnompartie(string nompartie) throws IllegalArgumentException { if ((nompartie == null) (nompartie == " ") (nompartie == "")) { throw new IllegalArgumentException("Le nom de partie ne doit " + "pas etre vide."); this.nompartie = nompartie; the joueur1 public Joueur getjoueur1() { return joueur1; joueur1 the joueur1 to set IllegalArgumentException public void setjoueur1(joueur joueur1) throws IllegalArgumentException { if(joueur1 == null) { throw new IllegalArgumentException("Le parametre joueur1 ne peut pas" + " etre nul."); this.joueur1 = joueur1; the joueur2 public Joueur getjoueur2() { return joueur2; joueur2 the joueur2 to set IllegalArgumentException public void setjoueur2(joueur joueur2) throws IllegalArgumentException { if(joueur2 == null) { throw new IllegalArgumentException("Le parametre joueur2 ne peut pas" + " etre nul."); this.joueur2 = joueur2; the plateaudejeu public Plateau getplateaudejeu() { return plateaudejeu; the niveauia public int getniveauia() { return niveauia; niveauia the niveauia to set public void setniveauia(int niveauia) { this.niveauia = niveauia; plateaudejeu defini un objet plateau IllegalArgumentException public void setplateaudejeu(plateau plateaudejeu) throws IllegalArgumentException { if (plateaudejeu == null) { throw new IllegalArgumentException("Le parametre plateaudejeu" + " ne peut pas etre nul.");

78 this.plateaudejeu = plateaudejeu; the tourdejeu public int gettourdejeu() { return tourdejeu; tourdejeu the tourdejeu to set IllegalArgumentException public void settourdejeu(int tourdejeu) throws IllegalArgumentException { if (tourdejeu!= 1 && tourdejeu!= 2 && tourdejeu!= 0) { throw new IllegalArgumentException("Valeur incorrecte pour " + "le tour de jeu."); this.tourdejeu = tourdejeu; /* (non-javadoc) public String tostring() { return "--> PARTIE " + getnompartie() + " avec :\nj1 : " + getjoueur1() + "\nj2 : " + getjoueur2() + "\ntour de Jeu : " + gettourdejeu() + "\n" + getplateaudejeu(); /* * GestionPartie.java 17 mai 2014 * IUT Info Groupe3 package utilitaire; import java.io.fileinputstream; import java.io.fileoutputstream; import java.io.ioexception; import java.io.objectinputstream; import java.io.objectoutputstream; import jeuothello.scores; * Methode d'inscrition des informations sur les parties et les scores * dans des fichiers, ainsi que restauration des objets inscrit a partir * des fichiers sauvegarde.dat et scrore.dat. Groupe AMRA 0.3 public class GestionPartie { Nom du fichier contenant la sauvegarde du tableau de clic private static String LIBELLE_FICHIER = "sauvegardes.dat"; Fichier de sauvegarde du tableau des scores private static String LIBELLE_SCORE = "score.dat"; * Appel de la methode d'ecriture de la listecontigue dans un fichier tableauscore IOException public static void enregistrerscore(scores tableauscore) throws IOException{ try { // Declaration et creation d'un fichier binaire (mode ecriture) ObjectOutputStream flotecriture = new ObjectOutputStream( new FileOutputStream(LIBELLE_SCORE)); // ecriture de l'objet tableau de clics dans le fichier flotecriture.writeobject(tableauscore); flotecriture.close() ; // fermeture du fichier catch (IOException e) {

79 throw new IOException(); * Appel de la methode d'ecriture de la listecontigue dans un fichier partiesauvegardees IOException public static void enregistrerpartie(listecontigue partiesauvegardees) throws IOException{ try { catch (IOException e) { throw new IOException(); catch (ClassCastException err) { // le fichier ne contient pas un tableau de clics throw new ClassCastException(); catch (ClassNotFoundException err) { // le fichier ne contient pas un objet throw new ClassNotFoundException(); return partiesauvegardees; // Declaration et creation d'un fichier binaire (mode ecriture) ObjectOutputStream flotecriture = new ObjectOutputStream( new FileOutputStream(LIBELLE_FICHIER)); // ecriture de l'objet tableau de clics dans le fichier flotecriture.writeobject(partiesauvegardees); flotecriture.close() ; // fermeture du fichier catch (IOException e) { throw new IOException(); * Methode permettant de restaurer les clics prealablement enregistres * dans le fichier FICHIER_LIBELLE partiesauvegardees partiesauvegardees IOException ClassCastException ClassNotFoundException public static ListeContigue restaurerpartie(listecontigue partiesauvegardees) throws IOException, ClassCastException, ClassNotFoundException { try { * Methode permettant de restaurer les clics prealablement enregistres * dans le fichier FICHIER_LIBELLE tableauscore tableauscores tableau contenant les meilleurs scores IOException ClassCastException ClassNotFoundException public static Scores restaurerscore(scores tableauscore) throws IOException, ClassCastException, ClassNotFoundException { try { // Declaration et creation d'un fichier binaire (mode lecture) ObjectInputStream flotlecture = new ObjectInputStream( new FileInputStream(LIBELLE_SCORE)); Object partiesauvegardeestemp = flotlecture.readobject(); tableauscore = (Scores) partiesauvegardeestemp; flotlecture.close() ; catch (IOException e) { throw new IOException(); catch (ClassCastException err) { // le fichier ne contient pas un tableau de clics throw new ClassCastException(); // Declaration et creation d'un fichier binaire (mode lecture) ObjectInputStream flotlecture = new ObjectInputStream( new FileInputStream(LIBELLE_FICHIER)); Object partiesauvegardeestemp = flotlecture.readobject(); partiesauvegardees = (ListeContigue) partiesauvegardeestemp; flotlecture.close() ; catch (ClassNotFoundException err) { // le fichier ne contient pas un objet throw new ClassNotFoundException(); return tableauscore;

80 /* * ListeContigue.java 24 mars 2014 * IUT info1 Groupe package utilitaire; import java.io.serializable; import java.util.collections; import java.util.arrays; * Liste lineaire = collection indicee d'elements <br/> * fondee sur une representation contigue conseillee pour des acces * aux element mais deconseillee pour la misa a jour (decalage) groupe AMRA 0.5 public class ListeContigue implements Serializable{ Capacite par defaut d'une liste public final static int CAPACITE_DEFAUT = 10; Coeefiscient d'agrandissement par defaut public final static double COEFDEFAUT = 1.2; Coeffcient d'agrandissement du tableau private static int coefficient; * Tableau (zone contigue) pour stocker des elements reference private Object[] corps; * Nombre d'elements contenus dans la liste private int nbelement; * Initialise une liste vide de capacite CAPACITE_DEFAUT public ListeContigue() { corps = new Object[CAPACITE_DEFAUT]; nbelement = 0; * Initialise une liste vide de capacite longueur longueur public ListeContigue(int longueur) { corps = new Object[longueur]; nbelement = 0; * Insere un element ainserer a la position pos dans cette liste<br /> * Commande modifiant l'etat de cette liste ainserer reference de l'element a inserer pos position dans la liste reference de la liste modifiee IndexOutOfBoundsException si pos < 0 ou pos > longueur() public ListeContigue inserer(object ainserer, int pos) throws IndexOutOfBoundsException { if (pos < 0 pos > longueur()+1) { throw new IndexOutOfBoundsException("Insertion impossible a la position pos"); if (ainserer == null){ throw new NullPointerException("Impossible d'inserer un NULL"); // Si le tableau est plein avant insertion if (nbelement == corps.length) { agrandir(); System.arraycopy(corps,pos,corps,pos+1,nbElement - pos); corps[pos] = ainserer; nbelement++; return this; * Cree un nouveau tableau de taille * this.longueur() + coeeficient d'agrandissement * Copie le contenue de this dans ce nouveau tableau et * l'affecte a cette liste (this) private void agrandir() { int capacite = (int)math.ceil(corps.length * COEFDEFAUT); corps = Arrays.copyOf(corps, capacite); * Supprime un element asupprimer de cette liste a la position pos<br /> * Commande modifiant l'etat de cette liste

81 pos position de l'element a supprimer dans cette liste la reference de cette liste IndexOutOfBoundsException si pos < 0 ou pos > longueur() public ListeContigue supprimer(int pos) throws IndexOutOfBoundsException { if (pos <0 pos >= longueur()) { throw new IndexOutOfBoundsException("Suppression impossible a la " + "position pos"); System.arraycopy(corps,pos + 1,corps, pos, nbelement - pos - 1); nbelement--; return this; * Renvoi la reference de l'element a la position pos pos position de l'element la reference de l'element a la position pos IndexOutOfBoundsException si pos < 0 ou pos > longueur() public Object elementa(int pos) throws IndexOutOfBoundsException { if (pos < 0 pos > longueur()-1) { throw new IndexOutOfBoundsException("Erreur d'acces a l'element a " + "cette position"); return corps[pos]; * Retourne la longueur de cette liste (this) longueur de la liste (0 si vide) public int longueur() { return nbelement; * Predicat de test d'une liste vide true si cette liste ne reference aucun element<br /> * false sinon public boolean estvide() { return longueur() == 0; /* * (non-javadoc) public boolean equals(object arg0) { return this.equals(arg0); /* * (non-javadoc) public String tostring(){ StringBuilder chaine = new StringBuilder(); for (int i = 0; i < nbelement && corps[i]!= null; i++ ) { chaine.append("[ " + corps[i] + " ]"); return chaine.tostring();

82 /* * OutilInterface.java 24 mai 2014 * IUT Info Groupe3 package jeuothello; import java.util.scanner; * Methodes d'affichage des menus sur la console texte standard groupe AMRA 0.3 public class OutilInterface { * Object scanner pour les operations d'entree private static Scanner entree = new Scanner(System.in); * Affichage du menu principal public static void menuprincipal() { System.out.println("\n\t ~~~~~~~~~~~~~~~~\n\t Menu Principal \n\t" + " ~~~~~~~~~~~~~~~~"); System.out.println(" 1 - Nouvelle partie contre l'ordinateur\n" + " 2 - Nouvelle partie contre une personne\n" + " 3 - Charger une sauvegarde\n" + " 4 - Tableau des scores\n" + " 5 - Aide\n" + " 6 - Quitter\n"); * Demande a l'utilisateur son pseudo le pseudo de l'utilisateur public static String nommer() { String pseudo; do { System.out.print("Saisissez votre pseudo : "); pseudo = entree.nextline(); System.out.println(); if (pseudo.equals("")) { System.out.println("Saisissez votre pseudo non vide"); while (pseudo.equals("")); return pseudo; * Affichage du menu de selection du menu de difficultes de l'ia public static void menuniveau() { System.out.println("Selection du niveau de difficulte\n" + "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); System.out.println("1 - Methode 1 (tirage aleatoire)\n" + "2 - Methode 2 (retournement maximum)\n" + "3 - Methode 3 (algorithme MinMax)\n" + "0 - Retour\n"); * Demande a l'utilisateur son pseudo le pseudo de l'utilisateur public static String[] nommer2joueurs() { String[] pseudos = new String[2]; do { System.out.print("Joueur 1, votre pseudo : "); pseudos[0] = entree.nextline(); System.out.println(); if (pseudos[0].equals("")) { System.out.println("Vous devez saisir au moins un caractere"); while (pseudos[0].equals("")); do { System.out.print("Joueur 2, votre pseudo : "); pseudos[1] = entree.nextline(); System.out.println(); if (pseudos[1].equals("")) { System.out.println("Vous devez saisir au moins un caractere"); else if (pseudos[0].equals(pseudos[1])) { System.out.println("Veuillez saisir un pseudo different du joueur 1"); pseudos[1] = ""; while (pseudos[1].equals("")); return pseudos;

83 * Fonction de verifiaction de la saisie d'un choix de menu sous la forme * d'un entier nbchoix nombre de choix disponible pour l'utilisateur l'entier saisi public static int choixmenu(int nbchoix) { int choix = -1; do { System.out.print("Saisissez votre choix : "); choix = entree.hasnextint()? entree.nextint() : -1; System.out.println(); if (choix < 0 choix > nbchoix) { System.out.println("Le nombre doit etre compris entre : 0 et " + nbchoix); entree.nextline(); // On vide le tampon while (choix < 0 choix > nbchoix); entree.nextline(); // On vide le tampon return choix; * Affiche les differentes sauvegardes public static void chargerpartie() { // Affichage des differentes sauvegardes System.out.println("Liste des parties sauvegardees :\n~~~~~~~~~~~~~~~~" + "~~~~~~~~~~~~~~~~~"); for (int i = 0 ; i < Jeu.partieSauvegardees.longueur() ; i++) { System.out.println(i+1 + " -> " + ((Partie)Jeu.partieSauvegardees.elementA(i)).getNomPartie()); System.out.println(); * Affiche le menu d'aide du jeu public static void menuaide() { System.out.println("\nAide :\n~~~~~~"); System.out.println("1 - Regles du jeu\n" + "2 - A propos du jeu...\n" + "0 - Retour\n"); * Affiche les regles du jeu de l'othello public static void regles() { System.out.println("\nRegles du jeu :\n~~~~~~~~~~~~~~~"); System.out.println("Le but de ce jeu est de disposer du plus grand " + "nombre de pion\nde sa couleur sur le plateau de jeu a la fin" + " d'une partie.\n\n- Un pion ne peut etre dispose sur le " + "plateau que si il permet \nl'encadrement d'un ou plusieurs pion(s) adverse(s).\n" + "Cet encadrement provoque le retournement du ou des pions adverses,\n" + "qui prendront la couleur du joueur.\n" + "- Chaque joueur joue a tour de role. Si a son tour de jeu\n" + "un joueur ne souhaite pas jouer, il peut passer son tour.\n" + "De meme, s'il ne peut pas jouer, alors son tour sera passe automatiquement.\n" + "- Si aucun des deux joueurs ne peut poser de pions, alors la partie se termine.\n" + "Le vainqueur est celui qui dispose du plus grand nombre de pions sur le plateau.\n"); * Affiche les informations a propos du jeu public static void apropos() { System.out.println("\nA propos du jeu...\n~~~~~~~~~~~~~~~~~~~"); System.out.println("\nCe jeu a ete developpe par un groupe d'etudiants,\n" + "de DUT Informatique a l'iut de Rodez.\n"); System.out.println("Il reprend les regles officielles du jeu d'othello \n" + "comme explique sur le site web de la FFO (Federation Francaise d'othello).\n" + "\nauteurs :\n\n" + "Groupe AMRA\n" + "- Audelia Bertaina\n" + "- Marine Vallee\n" + "- Remi Plantade\n" + "- Antoine Pellieux\n\n" + "Remerciements :\n" + "\n" + "Chef MOA, et chef de departement informatique :\n" + "- Corinne Serviere\n"

84 + "Surperviseur gestion de projet :\n" + "- Federic Barrios\n\n" + "Nous tenons egalement a remercier l'ensemble du staff \n" + "de l'iut de Rodez, pour les ressources materielles et logicielles \n" + "qu'ils ont mis a notre disposition"); + * public static void menuquitter() { System.out.println(" Etes-vous sur de vouloir quitter? \n" " 1 - Oui\n 2 - Non\n"); * Saisie des coordonnees de la case a jouer par l'utilisateur les coordonnees a jouer public static int[] coordonnees() { boolean ok = true; int[] valeurchoisie = new int[2]; valeurchoisie[0] = -10; valeurchoisie[1] = -10; String reponse; do { ok = true; System.out.print("\nMenu : M Passer votre tour : P\n" + "\ncoordonnees de la case : "); reponse = entree.nextline(); System.out.println(); if (reponse.length() == 0){ ok = false; else if (reponse.length()!= 2 && reponse.charat(0)!= 'm' && reponse.charat(0)!= 'M' && reponse.charat(0)!= 'p' && reponse.charat(0)!= 'P' ) { ok = false; else { // Premiere lettre switch (reponse.charat(0)) { case 'M' : case 'm' : valeurchoisie[0] = -2; valeurchoisie[1] = -2; -10) { break; case 'P' : case 'p' : valeurchoisie[0] = -1; valeurchoisie[1] = -1; break; case 'A' : case 'a' : valeurchoisie[1] = 0; break; case 'B' : case 'b' : valeurchoisie[1] = 1; break; case 'C' : case 'c' : valeurchoisie[1] = 2; break; case 'D' : case 'd' : valeurchoisie[1] = 3; break; case 'E' : case 'e' : valeurchoisie[1] = 4; break; case 'F' : case 'f' : valeurchoisie[1] = 5; break; case 'G' : case 'g' : valeurchoisie[1] = 6; break; case 'H' : case 'h' : valeurchoisie[1] = 7; break; default : ok = false; // Deuxieme lettre if (valeurchoisie[1] == -10 valeurchoisie[0] == switch (reponse.charat(1)) { case '1' : valeurchoisie[0] = 7; break; case '2' : valeurchoisie[0] = 6; break;

85 case '3' : valeurchoisie[0] = 5; break; case '4' : valeurchoisie[0] = 4; break; case '5' : valeurchoisie[0] = 3; break; case '6' : valeurchoisie[0] = 2; break; case '7' : valeurchoisie[0] = 1; break; case '8' : valeurchoisie[0] = 0; break; default : ok = false; if (!ok) { System.out.println("Entrez une lettre suivi d'un chiffre\nex : A6 ou a6\n"); while (!ok); return valeurchoisie; /* * DeroulementJeu.java 24 mai 2014 * IUT Info Groupe3 package jeuothello; import java.text.dateformat; import java.text.simpledateformat; import java.util.date; import java.util.scanner; import partie.case; import partie.coupsia; import partie.plateau; * Methodes de déroulement d'une partie selon le mode de jeu selectionné * <ul><li>mode 2 joueurs</li> * <li>joueur contre l'ordinateur * <ul><li>ia methode 1 (coups aléatoire)</li> * <li>ia methode 2 (retournement maximum)</li> * <li>ia methode 3 (algorithme Min/Max)</li></li></ul></ul> groupe AMRA 0.3 public class DeroulementJeu { * Object scanner pour les operations d'entree private static Scanner entree = new Scanner(System.in); * Deroulement d'une partie deux joueurs partie public static void partiedeuxjoueurs(partie partie) { // Copie de la partie en argument Partie jeu = new Partie(partie.getJoueur1(), partie.getjoueur2()); jeu.settourdejeu(partie.gettourdejeu()); Plateau plateaucopie = new Plateau(); try { plateaucopie = (Plateau) partie.getplateaudejeu().clone(); catch (CloneNotSupportedException e) { plateaucopie = null; jeu.setplateaudejeu(new Plateau());

86 jeu.setplateaudejeu(plateaucopie); jeu.setniveauia(partie.getniveauia()); Plateau tableaujeu = jeu.getplateaudejeu(); int[] coordonnees = new int[2]; int tourdejeu = jeu.gettourdejeu() == 0? 0 : (jeu.gettourdejeu() == 1? 2 : 1); int coupimpossible = 0; int choix; boolean menu = false; System.out.println(tableauJeu.toString()); tableaujeu.coupsjouables(tourdejeu == 1? 2 : 1); do { tourdejeu = (tourdejeu % 2) + 1; if (tourdejeu == jeu.getjoueur1().getcouleur()) { System.out.println("\n\t A vous de jouer " + jeu.getjoueur1().getpseudo() + (jeu.getjoueur1().getcouleur() == 1? " (noirs : x )" : " (blancs : o )") + "!"); else { System.out.println("\n\t A vous de jouer " + jeu.getjoueur2().getpseudo() + (jeu.getjoueur2().getcouleur() == 1? " (noirs : x )" : " (blancs : o )") + "!"); System.out.println(""); if ((tourdejeu == 1 && (tableaujeu.getcoupspossiblesnoir()).longueur()!= 0) ( tourdejeu == 2 && (tableaujeu.getcoupspossiblesblanc()).longueur()!= 0)) { 1); == -2) { partie? : \n" la partie? : \n" // Au moins un coup possible coupimpossible = 0; coordonnees = OutilInterface.coordonnees(); if (coordonnees[0] == -1 coordonnees[1] == -1) { // Passe son tour = P tableaujeu.coupsjouables(tourdejeu == 1? 2 : else if (coordonnees[0] == -2 coordonnees[1] // Choix du menu = M System.out.println("Voulez-vous quitter la + " 1 - Oui\n 2 - Non\n"); if (OutilInterface.choixMenu(2) == 1) { System.out.println("Voulez-vous sauvegarder + " 1 - Oui\n 2 - Non\n"); if (OutilInterface.choixMenu(2) == 1) { // appel de la sauvegarde jeu.settourdejeu(tourdejeu); sauvegarder(jeu); menu = true; // Fin du jeu et retour au menu principal break; tourdejeu -=1; else if (!(tableaujeu.jouer(tableaujeu.getcase(coordonnees[0],coordonnees[1 ]), tourdejeu))){ tourdejeu -= 1; // Erreur, coup non jouable else { // Aucun coup possible coupimpossible ++; System.out.println("Aucun coup jouable!\n~~~~~~~~~~~~~~~~~~~~"); tableaujeu.coupsjouables(tourdejeu == 1? 2 : 1); System.out.println(tableauJeu.toString()); // Affichage du plateau tourdejeu += 2; // Joueur suivant // Scores System.out.println("Scores :\n" + "~~~~~~~~"); System.out.println("Noirs : " + tableaujeu.getnbpionnoir()); System.out.println("Blancs : " + tableaujeu.getnbpionblanc()); while(tableaujeu.gettotalpion() < 64 && coupimpossible!= 2); // Fin du jeu ou aucun coup possible ou retour au menu if (!menu) { System.out.println("\nFin de la partie :\n" + "~~~~~~~~~~~~~~~~~~"); if (tableaujeu.getnbpionnoir() > tableaujeu.getnbpionblanc()) { System.out.println("\n\t======================================\n" + "\t Le gagnant est " + (jeu.getjoueur1().getcouleur() == 1? jeu.getjoueur1().getpseudo() : jeu.getjoueur2().getpseudo()) + "! Bravo! \n"

87 + "\t======================================\n"); // Insertion dans le tableau des scores if (jeu.getjoueur1().getcouleur() == 1) { Jeu.tableauScores.inserer(tableauJeu.getNbPionNoir(),jeu.getJoueur1 ().getpseudo()); else { Jeu.tableauScores.inserer(tableauJeu.getNbPionNoir(),jeu.getJoueur2 ().getpseudo()); else if (tableaujeu.getnbpionnoir() == tableaujeu.getnbpionblanc()) { System.out.println("\n\t=============================\n" + "\t Stricte egalite : bravo! \n" + "\t============================="); joueurs // Insertion dans le tableau des scores des deux Jeu.tableauScores.inserer(tableauJeu.getNbPionBlanc(),jeu.getJoueur 2().getPseudo()); Jeu.tableauScores.inserer(tableauJeu.getNbPionBlanc(),jeu.getJoueur 1().getPseudo()); else { System.out.println("\n\t======================================\n" + "\t Le gagnant est " + (jeu.getjoueur1().getcouleur() == 2? jeu.getjoueur1().getpseudo() : jeu.getjoueur2().getpseudo()) + "! Bravo! \n" + "\t======================================\n"); // Insertion dans le tableau des scores if (jeu.getjoueur1().getcouleur() == 2) { Jeu.tableauScores.inserer(tableauJeu.getNbPionBlanc(),jeu.getJoueur 1().getPseudo()); else { Jeu.tableauScores.inserer(tableauJeu.getNbPionBlanc(),jeu.getJoueur 2().getPseudo()); // Affichage du tableau des scores System.out.println(Jeu.tableauScores.toString()); * Deroulement d'une partie : joureur contre ordinateur de niveau 1 partie niveau (niveau de l'ia) public static void partieia(partie partie, int niveau) { // Copie de la partie en argument Partie jeu = new Partie(partie.getJoueur1(), partie.getjoueur2()); jeu.settourdejeu(partie.gettourdejeu()); Plateau plateaucopie = new Plateau(); try { plateaucopie = (Plateau) partie.getplateaudejeu().clone(); catch (CloneNotSupportedException e) { plateaucopie = null; jeu.setplateaudejeu(new Plateau()); jeu.setplateaudejeu(plateaucopie); jeu.setniveauia(niveau); Plateau tableaujeu = jeu.getplateaudejeu(); int[] coordonnees = new int[2]; int tourdejeu = jeu.gettourdejeu() == 0? 0 : (jeu.gettourdejeu() == 1? 2 : 1); int coupimpossible = 0; int choix; boolean menu = false; System.out.println(tableauJeu.toString()); tableaujeu.coupsjouables(tourdejeu == 1? 2 : 1); do { tourdejeu = (tourdejeu % 2) + 1; if (tourdejeu == 1) { // joueur System.out.println("\n\tA vous de jouer " + jeu.getjoueur1().getpseudo() + " (noirs : x )!"); if (tableaujeu.getcoupspossiblesnoir().longueur()!= 0) { 1) { // Au moins un coup possible coupimpossible = 0; coordonnees = OutilInterface.coordonnees(); if (coordonnees[0] == -1 coordonnees[1] == -

88 // Passe son tour = P tableaujeu.coupsjouables(tourdejeu == 1? 2 : 1); else if (coordonnees[0] == -2 coordonnees[1] == -2) { // Choix du menu = M System.out.println("Voulez-vous quitter la partie? : \n" + " 1 - Oui\n 2 - Non\n"); if (OutilInterface.choixMenu(2) == 1) { System.out.println("Voulez-vous sauvegarder la partie? : \n" + " 1 - Oui\n 2 - Non\n"); if (OutilInterface.choixMenu(2) == 1) { // appel de la sauvegarde jeu.settourdejeu(tourdejeu); sauvegarder(jeu); menu = true; // Fin du jeu et retour au menu principal break; tourdejeu -=1; else if (!(tableaujeu.jouer(tableaujeu.getcase(coordonnees[0],coordonnees[1 ]), tourdejeu))){ tourdejeu -= 1; // Erreur, coup non jouable else { // Aucun coup possible coupimpossible ++; System.out.println("Aucun coup jouable!\n~~~~~~~~~~~~~~~~~~~~"); tableaujeu.coupsjouables(2); else { // ordinateur if (tableaujeu.getcoupspossiblesblanc().longueur() == 0) { coupimpossible ++; System.out.println("Aucun coup jouable!\n~~~~~~~~~~~~~~~~~~~~"); tableaujeu.coupsjouables(1); else { // Joue selon la methode de jeu choisi if (niveau == 1) { tableaujeu.jouer(coupsia.niveau1(tableaujeu, tourdejeu), tourdejeu); else if (niveau == 2) { tableaujeu.jouer(coupsia.niveau2(tableaujeu, tourdejeu), tourdejeu); else { tableaujeu.jouer(coupsia.niveau3(tableaujeu, tourdejeu), tourdejeu); System.out.println(tableauJeu.toString()); // Affichage du plateau tourdejeu += 2; // Changement de joueur // Scores System.out.println("Scores :\n" + "~~~~~~~~"); System.out.println("Noirs : " + tableaujeu.getnbpionnoir()); System.out.println("Blancs : " + tableaujeu.getnbpionblanc()); 2); while(tableaujeu.gettotalpion() < 64 && coupimpossible!= // Fin du jeu ou aucun coup possible ou retour au menu if (!menu) { System.out.println("\nFin de la partie : \n" + "~~~~~~~~~~~~~~~~~~"); if (tableaujeu.getnbpionnoir() > tableaujeu.getnbpionblanc()) { System.out.println("\n\t=========================\n" + "\t Vous gagnez! Bravo! \n" + "\t========================="); // Insertion dans le tableau des scores Jeu.tableauScores.inserer(tableauJeu.getNbPionNoir(), jeu.getjoueur1().getpseudo()); else if (tableaujeu.getnbpionnoir() == tableaujeu.getnbpionblanc()) { System.out.println("\n\t=============================\n" + "\t Stricte egalite : bravo! \n" + "\t=============================");

89 // Insertion dans le tableau des scores Jeu.tableauScores.inserer(tableauJeu.getNbPionNoir(), jeu.getjoueur1().getpseudo()); else { System.out.println("\n\t======================\n" + "\t Vous avez perdu... \n" + "\t======================"); // Affichage du tableau des scores System.out.println(Jeu.tableauScores); * Fonction d'insertion d'une partie dans la liste de sauvegarde partie que l'on veut sauvegarder private static void sauvegarder(partie partie) { int choix; Date actuelle = new Date(); DateFormat dateformat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); String nompartie = dateformat.format(actuelle); System.out.print("Saisissez le nom de la partie a sauvegarder : "); nompartie = entree.nextline() + " " + nompartie; partie.setnompartie(nompartie); // Tableau des sauvegardes plein if(jeu.partiesauvegardees.longueur() >= 10){ System.out.println("La liste contient deja 10 sauvegardes\n" + "Selectionnez la partie a ecraser.\n"); OutilInterface.chargerPartie(); choix = OutilInterface.choixMenu(Jeu.partieSauvegardees.longueur()); Jeu.partieSauvegardees.supprimer(choix-1); // Sauvegarde Jeu.partieSauvegardees.inserer(partie,0); System.out.println("Partie sauvegardee");

90 /* * Jeu.java 17 mai 2014 * IUT Info Groupe3 package jeuothello; import java.io.ioexception; import java.io.serializable; import java.util.scanner; import jeuothello.deroulementjeu; import partie.joueur; import partie.plateau; import utilitaire.gestionpartie; import utilitaire.listecontigue; * Programme principal du jeu d'othello groupe AMRA 0.2 public class Jeu { Liste des parties sauvegardees protected static ListeContigue partiesauvegardees; Tableau des meilleurs scores protected static Scores tableauscores; * Object scanner pour les operations d'entree private static Scanner entree = new Scanner(System.in); * Classe principale de lancement du jeu args public static void main(string[] args) { String[] pseudos = new String[2]; boolean fin = false; boolean restauration = true; // True s'il existe des sauvegardes int choix; // Choix de l'utilisateur partiesauvegardees = new ListeContigue(); tableauscores = new Scores(); System.out.println("==========================================\n" + " Bienvenue dans notre jeu d'othello! " + "\n=========================================="); try { tableauscores = GestionPartie.restaurerScore(tableauScores); catch (IOException e) { catch (ClassCastException err) { // Le fichier ne contient pas un tableau de score System.out.println("Contenu du fichier errone."); catch (ClassNotFoundException err) { // Le fichier ne contient pas un objet try { partiesauvegardees = GestionPartie.restaurerPartie(partieSauvegardees); catch (IOException e) { catch (ClassCastException err) { // Le fichier ne contient pas un tableau de partie System.out.println("Contenu du fichier errone."); catch (ClassNotFoundException err) { // Le fichier ne contient pas un objet do { restauration = partiesauvegardees.longueur()!= 0; OutilInterface.menuPrincipal(); switch (OutilInterface.choixMenu(6)) { case 1 : // Nouvelle partie contre l'ordinateur Partie jeu; jeu = new Partie(new Joueur(OutilInterface.nommer(), 1, true), new Joueur("Ordinateur", 2, false)); OutilInterface.menuNiveau(); choix = OutilInterface.choixMenu(3); if (choix == 1) { // Methode 1 DeroulementJeu.partieIa(jeu, 1); else if (choix == 2) { // Methode 2 DeroulementJeu.partieIa(jeu, 2); else if (choix == 3) { // Methode 3 DeroulementJeu.partieIa(jeu, 3); break; case 2 : // Nouvelle partie deux joueurs pseudos = OutilInterface.nommer2Joueurs(); int couleur1 = ((int)(math.random() * )%2)+1;

91 jeu = new Partie(new Joueur(pseudos[0], couleur1, true), new Joueur(pseudos[1], ((int)(couleur1 == 1? 2 : 1)), true)); DeroulementJeu.partieDeuxJoueurs(jeu); break; case 3 : // Restauration d'une partie if (!restauration) { System.out.println("Desole, aucune partie sauvegardee"); else { OutilInterface.chargerPartie(); System.out.println("0 - Retour\n"); choix = OutilInterface.choixMenu(partieSauvegardees.longueur()); if (choix!= 0) { int niveauia = ((Partie)partieSauvegardees.elementA(choix-1)).getNiveauIA(); if(niveauia == 0) { // Partie deux joueurs DeroulementJeu.partieDeuxJoueurs((Partie)partieSauvegardees.element A(choix-1)); else { // Partie contre l'ia DeroulementJeu.partieIa((Partie)partieSauvegardees.elementA(choix- 1),niveauIA); break; case 4 : // Affichage du tableau des scores System.out.println(tableauScores.toString()); break; case 5 : // Aide OutilInterface.menuAide(); choix = OutilInterface.choixMenu(2); if (choix == 1) { // Regles OutilInterface.regles(); else if (choix == 2){ // A propos OutilInterface.aPropos(); break; case 6 : // Quitter OutilInterface.menuQuitter();!");!"); if (OutilInterface.choixMenu(2) == 1) { fin = true; break; while (!fin); System.out.println("\nAu revoir, a bientot! \n"); try { GestionPartie.enregistrerPartie(partieSauvegardees); catch (IOException e) { System.out.println("Oh-Oh quelque chose s'est mal passe try { GestionPartie.enregistrerScore(tableauScores); catch (IOException e) { System.out.println("Oh-Oh quelque chose s'est mal passe

92 /* * testunitairefonctionsplateau.java 5 mai 2014 * IUT Info Groupe3 package test; import java.io.ioexception; import java.util.scanner; import jeuothello.partie; import jeuothello.scores; import partie.case; import partie.coupsia; import partie.joueur; import partie.plateau; import utilitaire.gestionpartie; import utilitaire.listecontigue; * Methodes de test des différentes classes du progrmamme * Ces methodes sont appelees par le biais * du programme des test TestUnitairePrincipal.java. Groupa AMRA 1.2 public class TestFonctions { * Test des methodes parcourstableau et retournerpion public static void testretourner() { boolean ok = true; // True si le resultat est bien celui attendu ListeContigue CaseNonModifiee = new ListeContigue(); String ancienplateau; // Sauve de l'ancien plateau (avant changement) System.out.println(" " + " \ndebut du test de retournercase!\n"); // Premier test Plateau plateau = new Plateau(); (plateau.getcase(3, 3)).setStatut(0); (plateau.getcase(4, 2)).setStatut(2); (plateau.getcase(3, 2)).setStatut(2); (plateau.getcase(2, 2)).setStatut(2); (plateau.getcase(2, 3)).setStatut(2); (plateau.getcase(2, 4)).setStatut(2); (plateau.getcase(3, 4)).setStatut(2); (plateau.getcase(4, 3)).setStatut(2); for (int x = 1, y = 1 ; x < 6 ; x++ ) { (plateau.getcase(x, y)).setstatut(1); for (int x = 1, y = 5 ; x < 6 ; x++ ) { (plateau.getcase(x, y)).setstatut(1); for (int x = 1, y = 2 ; y < 5 ; y++ ) { (plateau.getcase(x, y)).setstatut(1); for (int x = 5, y = 2 ; y < 5 ; y++ ) { (plateau.getcase(x, y)).setstatut(1); System.out.println(plateau); (plateau.getcase(3, 3)).setStatut(1); plateau.parcourstableau(plateau.getcase(3, 3), true, true); System.out.println(plateau); if ((plateau.getcase(4, 4)).getStatut() == 1 && (plateau.getcase(4, 2)).getStatut() == 1 && (plateau.getcase(3, 2)).getStatut() == 1 && (plateau.getcase(2, 2)).getStatut() == 1 && (plateau.getcase(2, 3)).getStatut() == 1 && (plateau.getcase(2, 4)).getStatut()== 1) { System.out.println("OK, le retournement a bien fonctionne"); else { System.out.println("Erreur, le retournement n'a pas bien fonctionne"); // Deuxieme test Plateau plateau2 = new Plateau(); for(int x = 1 ; x < 7 ; x++){ for(int y = 1 ; y < 7 ; y++){ (plateau2.getcase(x, y)).setstatut(2); for (int x = 0, y = 0 ; y < 8 ; y++) { (plateau2.getcase(x, y)).setstatut(1); for (int x = 1, y = 0 ; x < 8 ; x++) { (plateau2.getcase(x, y)).setstatut(1); for (int x = 7, y = 1 ; y < 8 ; y++) { (plateau2.getcase(x, y)).setstatut(1); for (int x = 1, y = 7 ; x < 7 ; x++) { (plateau2.getcase(x, y)).setstatut(1); (plateau2.getcase(3, 3)).setStatut(0);

93 true); System.out.println(plateau2); (plateau2.getcase(3, 3)).setStatut(1); plateau2.parcourstableau(plateau2.getcase(3, 3), true, System.out.println(plateau2); CaseNonModifiee.inserer(plateau2.getCase(1, 2), 0); CaseNonModifiee.inserer(plateau2.getCase(1, 4), 0); CaseNonModifiee.inserer(plateau2.getCase(1, 6), 0); CaseNonModifiee.inserer(plateau2.getCase(2, 1), 0); CaseNonModifiee.inserer(plateau2.getCase(2, 5), 0); CaseNonModifiee.inserer(plateau2.getCase(2, 6), 0); CaseNonModifiee.inserer(plateau2.getCase(4, 1), 0); CaseNonModifiee.inserer(plateau2.getCase(4, 5), 0); CaseNonModifiee.inserer(plateau2.getCase(4, 6), 0); CaseNonModifiee.inserer(plateau2.getCase(5, 2), 0); CaseNonModifiee.inserer(plateau2.getCase(5, 4), 0); CaseNonModifiee.inserer(plateau2.getCase(5, 6), 0); CaseNonModifiee.inserer(plateau2.getCase(6, 1), 0); CaseNonModifiee.inserer(plateau2.getCase(6, 2), 0); CaseNonModifiee.inserer(plateau2.getCase(6, 4), 0); CaseNonModifiee.inserer(plateau2.getCase(6, 5), 0); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++ ) { if ((plateau2.getcase(x, y)).getstatut()!= 1) { ok = false; for (int i = 0 ; i < CaseNonModifiee.longueur() &&!ok ; i++) { if (plateau2.getcase(x, y) == ((Case)CaseNonModifiee.elementA(i))) { ok = true; if (ok) { System.out.println("OK, le retournement a bien fonctionne"); else { System.out.println("Erreur, le retournement n'a pas bien fonctionne"); // Troisieme test Plateau plateau3 = new Plateau(); (plateau3.getcase(3, 3)).setStatut(0); (plateau3.getcase(4, 3)).setStatut(2); (plateau3.getcase(4, 2)).setStatut(2); true); lieu"); (plateau3.getcase(3, 2)).setStatut(2); (plateau3.getcase(3, 4)).setStatut(2); (plateau3.getcase(2, 2)).setStatut(2); (plateau3.getcase(2, 3)).setStatut(2); (plateau3.getcase(2, 4)).setStatut(2); for (int x = 0, y = 0 ; y < 7 ; y++) { (plateau3.getcase(x, y)).setstatut(1); for (int x = 1, y = 0 ; x < 7 ; x++) { (plateau3.getcase(x, y)).setstatut(1); for (int x = 6, y = 1 ; y < 7 ; y++) { (plateau3.getcase(x, y)).setstatut(1); for (int x = 1, y = 6 ; x < 6 ; x++) { (plateau3.getcase(x, y)).setstatut(1); plateau3.coupsjouables(1); System.out.println(plateau3); (plateau3.getcase(3, 3)).setStatut(1); plateau3.parcourstableau(plateau3.getcase(3, 3), true, System.out.println(plateau3); ok = true; for (int x = 1, y = 1 ; y < 6 ; y++) { if ((plateau3.getcase(x, y)).getstatut() == 1) { ok = false; for (int x = 2, y = 1 ; x < 6 ; x++) { if ((plateau3.getcase(x, y)).getstatut() == 1) { ok = false; for (int x = 5, y = 1 ; y < 6 ; y++) { if ((plateau3.getcase(x, y)).getstatut() == 1) { ok = false; for (int x = 1, y = 5 ; x < 6 ; x++) { if ((plateau3.getcase(x, y)).getstatut() == 1) { ok = false; if (ok) { System.out.println("OK, aucun retournement n'a eu

94 lieu"); true); else { System.out.println("Erreur, un retournement a eu // Quatrieme test Plateau plateau4 = new Plateau(); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { (plateau4.getcase(x, y)).setstatut(2); (plateau4.getcase(3, 3)).setStatut(0); System.out.println(plateau4); (plateau4.getcase(3, 3)).setStatut(1); plateau4.parcourstableau(plateau4.getcase(3, 3), true, System.out.println(plateau4); ok = true; for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if ((plateau4.getcase(x, y)).getstatut() == 1 && x!= 3 && y!= 3) { ok = false; if (ok) { System.out.println("OK, aucun retournement n'a eu lieu"); else { System.out.println("Erreur, un retournement a eu lieu"); true); true); // Test des cas de la regle du jeu officielle Plateau plateau5 = new Plateau(); (plateau5.getcase(2, 3)).setStatut(1); plateau5.parcourstableau(plateau5.getcase(2, 3), true, (plateau5.getcase(2, 2)).setStatut(2); plateau5.parcourstableau(plateau5.getcase(2, 2), true, plateau5.coupsjouables(1); System.out.println(plateau5); if (plateau5.getcase(2, 3).getStatut() == 1 && plateau5.getcase(2, 2).getStatut() == 2 && plateau5.getcase(3, 3).getStatut() == 2 && plateau5.getcase(3, 4).getStatut() == 1 && plateau5.getcase(4, 3).getStatut() == 1 && plateau5.getcase(4, 4).getStatut() == 2 ) { System.out.println("Ok, les premiers retournements ont fonctionnes"); else { System.out.println("Erreur, les premiers retournements n'ont pas fonctionnes"); true); (plateau5.getcase(3, 2)).setStatut(1); plateau5.parcourstableau(plateau5.getcase(3, 2), true, plateau5.coupsjouables(2); System.out.println(plateau5); if (plateau5.getcase(2, 3).getStatut() == 1 && plateau5.getcase(2, 2).getStatut() == 2 && plateau5.getcase(3, 2).getStatut() == 1 && plateau5.getcase(3, 3).getStatut() == 1 && plateau5.getcase(3, 4).getStatut() == 1 && plateau5.getcase(4, 3).getStatut() == 1 && plateau5.getcase(4, 4).getStatut() == 2 ) { System.out.println("Ok, les retournements ont fonctionnes"); else { System.out.println("Erreur, les retournements n'ont pas fonctionnes"); (plateau5.getcase(2, 4)).setStatut(2); plateau5.parcourstableau(plateau5.getcase(2, 4), true, true); plateau5.coupsjouables(1); System.out.println(plateau5); if (plateau5.getcase(2, 3).getStatut() == 2 && plateau5.getcase(2, 2).getStatut() == 2 && plateau5.getcase(2, 4).getStatut() == 2 && plateau5.getcase(3, 2).getStatut() == 1 && plateau5.getcase(3, 3).getStatut() == 1 && plateau5.getcase(3, 4).getStatut() == 2 && plateau5.getcase(4, 3).getStatut() == 1 && plateau5.getcase(4, 4).getStatut() == 2 ) { System.out.println("Ok, les retournements ont fonctionnes"); else { System.out.println("Erreur, les retournements n'ont pas fonctionnes");

95 true); true); true); false); // Cas d'un coup virtuel Plateau plateau6 = new Plateau(); (plateau6.getcase(2, 3)).setStatut(1); plateau6.parcourstableau(plateau6.getcase(2, 3), true, (plateau6.getcase(2, 2)).setStatut(2); plateau6.parcourstableau(plateau6.getcase(2, 2), true, plateau6.coupsjouables(1); (plateau6.getcase(3, 2)).setStatut(1); plateau6.parcourstableau(plateau6.getcase(3, 2), true, plateau6.coupsjouables(2); System.out.println(plateau6); ancienplateau = plateau6.tostring(); (plateau6.getcase(2, 4)).setStatut(2); plateau6.parcourstableau(plateau6.getcase(2, 4), true, (plateau6.getcase(2, 4)).setStatut(0); System.out.println(plateau6); if ((plateau6.tostring()).equals(ancienplateau) && plateau6.getvirtuelpionblanc() - plateau6.getnbpionblanc() == 2) { // -1 pour le pion qui vient d'etre pose System.out.println("OK, le retournement virtuel a bien fonctionne"); else { System.out.println("Erreur, le retournement virtuel n'a pas bien fonctionne"); System.out.println("\nFin du test de retournercase!\n " + " "); * Test de la methode tostring de Case public static void testtostringcase() { boolean ok = true; // True si le resultat est bien celui attendu System.out.println(" " + " \ndebut du test de tostring de Case!\n"); Plateau plateau = new Plateau(); System.out.println(plateau); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if ((x == 2 && y == 3) (x == 3 && y == 2) (x == 4 && y == 5) (x == 5 && y == 4)) { if (!(plateau.getcase(x, y).tostring().equals("x"))) { ok = false; else if ((x == 3 && y == 3) (x == 4 && y == 4)) { if (!(plateau.getcase(x, y).tostring().equals("o"))) { ok = false; else if ((x == 3 && y == 4) (x == 4 && y == 3)) { if (!(plateau.getcase(x, y).tostring().equals("\u2022"))) { ok = false; else { if (!(plateau.getcase(x, y).tostring().equals("_"))){ ok = false; if (ok) { System.out.println("Ok, le tostring fonctionne"); else { System.out.println("Erreur, le tostring ne fonctionne pas"); System.out.println("\nFin du test de tostring de Case!\n " + " "); * Test de la methode tostring de Case public static void testtostringplateau() {

96 StringBuilder plateau2 = new StringBuilder(); System.out.println(" " + " \ndebut du test de tostring de Plateau!\n"); 4)) { 3)) { pas"); Plateau plateau = new Plateau(); System.out.println(plateau); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if ((x == 2 && y == 3) (x == 3 && y == 2) (x == 4 && y == 5) (x == 5 && y == 4)) { plateau2.append("[?]"); else if ((x == 3 && y == 3) (x == 4 && y == plateau2.append("[o]"); else if ((x == 3 && y == 4) (x == 4 && y == plateau2.append("[x]"); else { plateau2.append("[_]"); plateau2.append("\n"); if (plateau.tostring().equals(plateau2.tostring())) { System.out.println("Ok, le tostring fonctionne"); else { System.out.println("Erreur, le tostring ne fonctionne System.out.println("\nFin du test de tostring de Plateau!\n " + " "); * Test de getnbpionnoir, getnbpionblanc et gettotalpion public static void testnbpions() { System.out.println(" " + " \ndebut du test du nombre de pions!\n"); Plateau plateau = new Plateau(); System.out.println(plateau); if (plateau.getnbpionnoir() == 2 && plateau.getnbpionblanc() == 2 && plateau.gettotalpion() == 4) { System.out.println("Ok, le nombre de pions est correct a l'initialisation"); else { System.out.println("Erreur, le nombre de pions est incorrect a l'initialisation"); (plateau.getcase(2, 3)).setStatut(1); plateau.parcourstableau(plateau.getcase(2, 3), true, true); (plateau.getcase(2, 2)).setStatut(2); plateau.parcourstableau(plateau.getcase(2, 2), true, true); plateau.coupsjouables(1); System.out.println(plateau); if (plateau.getnbpionnoir() == 3 && plateau.getnbpionblanc() == 3 && plateau.gettotalpion() == 6) { System.out.println("Ok, le nombre de pions est correct"); else { System.out.println("Erreur, le nombre de pions est incorrect"); (plateau.getcase(3, 2)).setStatut(1); plateau.parcourstableau(plateau.getcase(3, 2), true, true); plateau.coupsjouables(2); System.out.println(plateau); if (plateau.getnbpionnoir() == 5 && plateau.getnbpionblanc() == 2 && plateau.gettotalpion() == 7) { System.out.println("Ok, le nombre de pions est correct"); else { System.out.println("Erreur, le nombre de pions est incorrect"); (plateau.getcase(2, 4)).setStatut(2); plateau.parcourstableau(plateau.getcase(2, 4), true, true); plateau.coupsjouables(1); System.out.println(plateau); if (plateau.getnbpionnoir() == 3 && plateau.getnbpionblanc() == 5 && plateau.gettotalpion() == 8) {

97 System.out.println("Ok, le nombre de pions est correct"); else { System.out.println("Erreur, le nombre de pions est incorrect"); System.out.println("\nFin du test du nombre de pions!\n " + " "); des * Test de l'analye du jeu pour determiner les coups jouables * Initialisation de diverses situation de jeu et comparaison * cases presente dans la liste des coups jouables public static void testcoupsjouables(){ // Test pour les noirs // Initialisation du plateau Plateau plateautestnoir = new Plateau(); plateautestnoir.getcase(3,3).setstatut(1); plateautestnoir.getcase(3,4).setstatut(2); plateautestnoir.getcase(4,3).setstatut(0); plateautestnoir.getcase(4,4).setstatut(2); plateautestnoir.getcase(1,4).setstatut(1); plateautestnoir.getcase(2,4).setstatut(2); plateautestnoir.getcase(2,5).setstatut(1); // Declaration de la liste qui contiendra les coups reellement jouables ListeContigue coupreeljouablesnoir = new ListeContigue(6); // Variable validant la presence d'une case effectivement jouables dans // la liste cupreeljouablesnoir et dans celle genere par le programme; boolean CasePresente = false; noirs // Analyse du jeu et stockage des coups jouables par les plateautestnoir.coupsjouables(1); System.out.println(" " + " \ndebut du test de la methode coupjouables()!\n"); System.out.println(" Appel de la fonction coupjouables() avec differents " + "parametres corrects ou non"); try{ plateautestnoir.coupsjouables(2); System.out.println("OK appel possible de la fonction coupjouable() " + "avec en parametre une couleur correcte "); catch(illegalargumentexception e){ System.out.println("NOK appel impossible de la fonction coupjouable()" + " avec en parametre une couleur correcte "); try{ plateautestnoir.coupsjouables(1); System.out.println("OK appel possible de la fonction coupjouable()" + " avec en parametre une couleur correcte "); catch(illegalargumentexception e){ System.out.println("NOK appel impossible de la fonction coupjouable()" + " avec en parametre une couleur correcte "); try{ plateautestnoir.coupsjouables(0); System.out.println("NOK appel possible de la fonction coupjouable()" + " avec en parametre une couleur incorrecte "); catch(illegalargumentexception e){ System.out.println("OK appel impossible de la fonction coupjouable()" + " avec en parametre une couleur incorrecte "); try{ plateautestnoir.coupsjouables(20); System.out.println("NOK appel possible de la fonction coupjouables() " + "avec en parametre une couleur incorrecte "); catch(illegalargumentexception e){ System.out.println("OK appel impossible de la fonction coupjouables() " + " avec en parametre une couleur incorrecte "); try{ plateautestnoir.coupsjouables(-40); System.out.println("NOK appel possible de la fonction coupjouable()" + " avec en parametre une couleur incorrecte "); catch(illegalargumentexception e){

98 System.out.println("OK appel impossible de la fonction coupjouable()" + " avec en parametre une couleur incorrecte "); // Affichage du plateau System.out.println(plateauTestNoir); System.out.println("Sur ce plateau les noirs peuvent jouer" + " 6 coups differents"); if(plateautestnoir.getcoupspossiblesnoir().longueur() == 6){ System.out.println("OK nombre de coups possibles correct"); else { System.out.println("NOK nombre de coups possibles incorrect"); System.out.println("Comparaison des coordonnees des cases jouables\n" + "stocke par le programme avec la liste suivantes :"); // Initialisation d'une liste contenant les coups effectivement jouables coupreeljouablesnoir.inserer(new Case(1,5), 0); coupreeljouablesnoir.inserer(new Case(2,3), 0); coupreeljouablesnoir.inserer(new Case(3,5), 0); coupreeljouablesnoir.inserer(new Case(4,3), 0); coupreeljouablesnoir.inserer(new Case(5,4), 0); coupreeljouablesnoir.inserer(new Case(5,5), 0); for (int i = 0; i <= 5 ; i++){ // parcour de coupreeljouablesnoir for (int j = 0; j <= 5 ; j++){ if (((Case) coupreeljouablesnoir.elementa(i)).getx() == ((Case) plateautestnoir.getcoupspossiblesnoir().elementa(j)).getx() && ((Case) coupreeljouablesnoir.elementa(i)).gety() == ((Case) plateautestnoir.getcoupspossiblesnoir().elementa(j)).gety() ){ CasePresente = true; if(casepresente){ System.out.println("OK case jouable a l'indice " + i + " presente dans la liste generee par le programme"); else { System.out.println("NOK case jouable a l'indice " + i + " non presente presente dans la lsite generee par le programme"); // Test pour les blancs // Initialisation du plateau Plateau plateautestblanc = new Plateau(); plateautestblanc.getcase(3,3).setstatut(2); plateautestblanc.getcase(3,4).setstatut(1); plateautestblanc.getcase(4,3).setstatut(0); plateautestblanc.getcase(4,4).setstatut(1); plateautestblanc.getcase(1,4).setstatut(2); plateautestblanc.getcase(2,4).setstatut(1); plateautestblanc.getcase(2,5).setstatut(2); // Declaration de la liste qui contiendra les coups reellement jouables ListeContigue coupreeljouablesblanc = new ListeContigue(6); // Variable validant la presence d'une case effectivement jouables dans // la liste cupreeljouablesnoir et dans celle genere par le programme; CasePresente = false; noirs jouer" // Analyse du jeu et stockage des coups jouables par les plateautestblanc.coupsjouables(2); // Affichage du plateau System.out.println(plateauTestBlanc); System.out.println("Sur ce plateau les blancs peuvent + " 6 coups differents"); System.out.println(plateauTestBlanc.getCoupsPossiblesBlanc().longue ur()); if(plateautestblanc.getcoupspossiblesblanc().longueur() == 6){ System.out.println("OK nombre de coups possibles correct"); else { System.out.println("NOK nombre de coups possibles incorrect");

99 System.out.println("Comparaison des coordonnees des cases jouables\n" + "stocke par le programme avec la liste suivantes :"); // Initialisation d'une liste contenant les coups effectivement jouables coupreeljouablesblanc.inserer(new Case(1,5), 0); coupreeljouablesblanc.inserer(new Case(2,3), 0); coupreeljouablesblanc.inserer(new Case(3,5), 0); coupreeljouablesblanc.inserer(new Case(4,3), 0); coupreeljouablesblanc.inserer(new Case(5,4), 0); coupreeljouablesblanc.inserer(new Case(5,5), 0); for (int i = 0; i <= 5 ; i++){ // parcour de coupreeljouablesblanc for (int j = 0; j <= 5 ; j++){ if (((Case) coupreeljouablesblanc.elementa(i)).getx() == ((Case) plateautestblanc.getcoupspossiblesblanc().elementa(j)).getx() && ((Case) coupreeljouablesblanc.elementa(i)).gety() == ((Case) plateautestblanc.getcoupspossiblesblanc().elementa(j)).gety() ){ CasePresente = true; if(casepresente){ System.out.println("OK case jouable a l'indice " + i + " presente dans la liste generee par le programme"); else { System.out.println("NOK case jouable a l'indice " + i + " non presente presente dans la lsite generee par le programme"); System.out.println(" " + " \nfin du test de la methode coupjouables()!\n"); System.out.println(); Test Commentés car isjouales() est private // // * Test de la fonction qui permet de savoir si une case est jouables ou non // * On reutilisera la meme situation de jeu que celle du test de coupjouables // // public static void testisjouables() { // // Test pour les noirs // // Initialisation du plateau // // // Plateau plateautestnoir = new Plateau(); // plateautestnoir.getcase(3,3).setstatut(0); // plateautestnoir.getcase(3,4).setstatut(0); // plateautestnoir.getcase(4,3).setstatut(0); // plateautestnoir.getcase(4,4).setstatut(0); // // plateautestnoir.getcase(1,1).setstatut(1); // plateautestnoir.getcase(1,2).setstatut(1); // plateautestnoir.getcase(1,3).setstatut(1); // plateautestnoir.getcase(1,4).setstatut(1); // plateautestnoir.getcase(1,5).setstatut(1); // plateautestnoir.getcase(1,6).setstatut(1); // plateautestnoir.getcase(2,1).setstatut(1); // plateautestnoir.getcase(3,1).setstatut(1); // plateautestnoir.getcase(4,1).setstatut(1); // plateautestnoir.getcase(5,1).setstatut(1); // plateautestnoir.getcase(6,1).setstatut(1); // plateautestnoir.getcase(2,2).setstatut(2); // plateautestnoir.getcase(2,3).setstatut(2); // plateautestnoir.getcase(2,4).setstatut(2); // plateautestnoir.getcase(2,5).setstatut(2); // plateautestnoir.getcase(2,6).setstatut(2); // plateautestnoir.getcase(3,2).setstatut(2); // plateautestnoir.getcase(4,2).setstatut(2); // plateautestnoir.getcase(5,2).setstatut(2); // plateautestnoir.getcase(6,2).setstatut(2); // // // Declaration de la liste qui contiendra les coups reellement jouables // ListeContigue coupreeljouablesnoir = new ListeContigue(6); // // // Est a true si une case est decrite comme non-jouable // boolean casenonjouable; // // Nombres de cases non jouables sur le plateau // int nbcasesnonjouables = 0; // // // Analyse du jeu et stockage des coups jouables par les noirs // plateautestnoir.coupsjouables(1); //

100 // System.out.println(" " // + " \ndebut du test de la methode isjouable()!\n"); // System.out.println(" Appel de la fonction isjouable avec differents " // + "parametres corrects ou non"); // try{ // Plateau.isJouable(new Case(5,5), 1); // System.out.println("OK appel possible de la fonction isjouable() avec" // + " en parametre une couleur correcte "); // catch(illegalargumentexception e){ // System.out.println("NOK appel impossible de la fonction isjouable() " // + "avec en parametre une couleur correcte "); // // try{ // Plateau.isJouable(new Case(5,5), 2); // System.out.println("OK appel possible de la fonction isjouable() avec" // + " en parametre une couleur correcte "); // catch(illegalargumentexception e){ // System.out.println("NOK appel impossible de la fonction isjouable() " // + "avec en parametre une couleur correcte "); // // try{ // Plateau.isJouable(new Case(0,0), 0); // System.out.println("NOK appel possible de la fonction isjouable() avec" // + " en parametre une couleur incorrecte "); // catch(illegalargumentexception e){ // System.out.println("OK appel impossible de la fonction isjouable() " // + "avec en parametre une couleur incorrecte "); // // try{ // Plateau.isJouable(new Case(0,0), 20); // System.out.println("NOK appel possible de la fonction isjouable() avec" // + " en parametre une couleur incorrecte "); // catch(illegalargumentexception e){ // System.out.println("OK appel impossible de la fonction isjouable() " // + "avec en parametre une couleur incorrecte "); // // try{ // Plateau.isJouable(new Case(0,0), -10); // System.out.println("NOK appel possible de la fonction isjouable() avec" // + " en parametre une couleur incorrecte "); // catch(illegalargumentexception e){ // System.out.println("OK appel impossible de la fonction isjouable() " // + "avec en parametre une couleur incorrecte "); // // // // Affichage du plateau // System.out.println("\n" + plateautestnoir); // System.out.println("Sur ce plateau les noirs peuvent jouer 9 coups" // + "differents"); // // // Intitialisation de la liste contenant toutes les cases jouables // // pour les noirs // coupreeljouablesnoir.inserer(new Case(3,3), 0); // coupreeljouablesnoir.inserer(new Case(3,4), 0); // coupreeljouablesnoir.inserer(new Case(3,5), 0); // coupreeljouablesnoir.inserer(new Case(3,6), 0); // coupreeljouablesnoir.inserer(new Case(3,7), 0); // coupreeljouablesnoir.inserer(new Case(4,3), 0); // coupreeljouablesnoir.inserer(new Case(5,3), 0); // coupreeljouablesnoir.inserer(new Case(6,3), 0); // coupreeljouablesnoir.inserer(new Case(7,3), 0); // coupreeljouablesnoir.inserer(new Case(2,7), 0); // coupreeljouablesnoir.inserer(new Case(7,2), 0); // // // Parcours de la liste des coup reelement jouable // // et verification de leur jouabilite par la fonction isjouable // for(int i = 0 ; i < 11 ; i++){ // if(plateau.isjouable((case) coupreeljouablesnoir.elementa(i), 1)){ // System.out.println("OK la case aux coordonnees (" + // ((Case) coupreeljouablesnoir.elementa(i)).getx() + // ", " + ((Case) coupreeljouablesnoir.elementa(i)).gety() + // ") est jouables"); // else { // System.out.println("NOK la case aux coordonnees (" + // ((Case) coupreeljouablesnoir.elementa(i)).getx() + // ", " + ((Case) coupreeljouablesnoir.elementa(i)).gety() +

101 // ") n'est pas jouables"); // // // // /* // * Parcours de toute les cases du tableau exceptees celles // * ayant les memes coordonnees que les case stokees // * dans coupreeljouablesnoir et test de leur nonjouabilite // * par la fonction isjouables // // for (int i = 0; i < 8 ; i++) { // for (int j = 0 ; j < 8 ; j++) { // casenonjouable = false; // for (int k = 0 ; k < 11; k++) { // if ((plateautestnoir.getcase(i, j).getx()!= // ((Case) coupreeljouablesnoir.elementa(k)).getx() && // plateautestnoir.getcase(i, j).gety()!= // ((Case) coupreeljouablesnoir.elementa(k)).gety()) && //!Plateau.isJouable(plateauTestNoir.getCase(i, j),1)) { // casenonjouable = true; // // // if(casenonjouable){ // nbcasesnonjouables++; // // // // if(nbcasesnonjouables == 64 - coupreeljouablesnoir.longueur()){ // System.out.println("OK toutes les autres cases du plateau " // + "ne sont pas jouables par les noirs"); // else { // System.out.println("NOK toutes les autres cases du plateau " // + "ne sont pas injouables par les noirs"); // // // // Test pour les blancs // // Initialisation du plateau // Plateau plateautestblanc = new Plateau(); // plateautestblanc.getcase(3,3).setstatut(0); // plateautestblanc.getcase(3,4).setstatut(0); // plateautestblanc.getcase(4,3).setstatut(0); // plateautestblanc.getcase(4,4).setstatut(0); // // plateautestblanc.getcase(1,1).setstatut(2); // plateautestblanc.getcase(1,2).setstatut(2); // plateautestblanc.getcase(1,3).setstatut(2); // plateautestblanc.getcase(1,4).setstatut(2); // plateautestblanc.getcase(1,5).setstatut(2); // plateautestblanc.getcase(1,6).setstatut(2); // plateautestblanc.getcase(2,1).setstatut(2); // plateautestblanc.getcase(3,1).setstatut(2); // plateautestblanc.getcase(4,1).setstatut(2); // plateautestblanc.getcase(5,1).setstatut(2); // plateautestblanc.getcase(6,1).setstatut(2); // plateautestblanc.getcase(2,2).setstatut(1); // plateautestblanc.getcase(2,3).setstatut(1); // plateautestblanc.getcase(2,4).setstatut(1); // plateautestblanc.getcase(2,5).setstatut(1); // plateautestblanc.getcase(2,6).setstatut(1); // plateautestblanc.getcase(3,2).setstatut(1); // plateautestblanc.getcase(4,2).setstatut(1); // plateautestblanc.getcase(5,2).setstatut(1); // plateautestblanc.getcase(6,2).setstatut(1); // // // Declaration de la liste qui contiendra les coups reellement jouables // ListeContigue coupreeljouablesblanc = new ListeContigue(6); // // // reinitialisation du nombre de cases non jouables a 0 // nbcasesnonjouables = 0; // // // Analyse du jeu et stockage des coups jouables par les noirs // plateautestnoir.coupsjouables(2); // // // Affichage du plateau // System.out.println(plateauTestBlanc); // System.out.println("Sur ce plateau les blancs peuvent jouer 11 coups" // + "differents"); // // // Intitialisation de la liste contenant toutes les cases jouables // // pour les blancs // coupreeljouablesblanc.inserer(new Case(3,3), 0); // coupreeljouablesblanc.inserer(new Case(3,4), 0); // coupreeljouablesblanc.inserer(new Case(3,5), 0); // coupreeljouablesblanc.inserer(new Case(3,6), 0); // coupreeljouablesblanc.inserer(new Case(3,7), 0); // coupreeljouablesblanc.inserer(new Case(4,3), 0); // coupreeljouablesblanc.inserer(new Case(5,3), 0); // coupreeljouablesblanc.inserer(new Case(6,3), 0);

102 // coupreeljouablesblanc.inserer(new Case(7,3), 0); // coupreeljouablesblanc.inserer(new Case(2,7), 0); // coupreeljouablesblanc.inserer(new Case(7,2), 0); // // // Parcours de la liste des coup reelement jouable // // et verification de leur jouabilite par la fonction isjouable // for(int i = 0 ; i < 11 ; i++){ // if(plateau.isjouable((case) coupreeljouablesblanc.elementa(i), 2)){ // System.out.println("OK la case aux coordonnees (" + // ((Case) coupreeljouablesblanc.elementa(i)).getx() + // ", " + ((Case) coupreeljouablesblanc.elementa(i)).gety() + // ") est jouables"); // else { // System.out.println("NOK la case aux coordonnees (" + // ((Case) coupreeljouablesblanc.elementa(i)).getx() + // ", " + ((Case) coupreeljouablesblanc.elementa(i)).gety() + // ") n'est pas jouables"); // // // // /* // * Parcours de toute les cases du tableau exceptees celles // * ayant les memes coordonnees que les case stokees // * dans coupreeljouablesnoir et test de leur nonjouabilite // * par la fonction isjouables // // for (int i = 0; i < 8 ; i++) { // for (int j = 0 ; j < 8 ; j++) { // casenonjouable = false; // for (int k = 0 ; k < 11; k++) { // if ((plateautestblanc.getcase(i, j).getx()!= // ((Case) coupreeljouablesblanc.elementa(k)).getx() && // plateautestblanc.getcase(i, j).gety()!= // ((Case) coupreeljouablesblanc.elementa(k)).gety()) && //!Plateau.isJouable(plateauTestBlanc.getCase(i, j),2)) { // casenonjouable = true; // // // if(casenonjouable){ // nbcasesnonjouables++; // // // // if(nbcasesnonjouables == 64 - coupreeljouablesblanc.longueur()){ // System.out.println("OK toutes les autres cases du plateau " // + "ne sont pas jouables par les blancs"); // else { // System.out.println("NOK toutes les autres cases du plateau " // + "ne sont pas injouables par les noirs"); // // System.out.println(" " // + " \nfin du test de la methode isjouable()!\n"); // System.out.println(); // * Test de la fonction jouer de la classe Plateau public static void testjouer(){ System.out.println(" " + " \ndebut du test de la methode jouer()!\n"); /* Test de jouabilite d'un coup pour les noirs * * Initialisation d'un plateau et ajustement du statut des cases, par * rapport a celles initialise par defaut Plateau plateautestnoir = new Plateau(); plateautestnoir.getcase(3,3).setstatut(1); plateautestnoir.getcase(3,4).setstatut(0); plateautestnoir.getcase(4,3).setstatut(0); plateautestnoir.getcase(4,4).setstatut(2); plateautestnoir.coupsjouables(1); System.out.println(" Appel de la fonction jouer avec differents " + "parametres corrects ou non"); try{ plateautestnoir.jouer(new Case(5,5), 1); System.out.println("OK appel possible de la fonction jouer() avec"

103 + " en parametre une couleur correcte "); catch(illegalargumentexception e){ System.out.println("NOK appel impossible de la fonction jouer() " + "avec en parametre une couleur correcte "); try{ plateautestnoir.jouer(new Case(5,5), 2); System.out.println("OK appel possible de la fonction jouer() avec" + " en parametre une couleur correcte "); catch(illegalargumentexception e){ System.out.println("NOK appel impossible de la fonction jouer() " + "avec en parametre une couleur correcte "); try{ plateautestnoir.jouer(new Case(0,0), 0); System.out.println("NOK appel possible de la fonction jouer() avec" + " en parametre une couleur incorrecte "); catch(illegalargumentexception e){ System.out.println("OK appel impossible de la fonction jouer() " + "avec en parametre une couleur incorrecte "); try{ plateautestnoir.jouer(new Case(0,0), 20); System.out.println("NOK appel possible de la fonction jouer() avec" + " en parametre une couleur incorrecte "); catch(illegalargumentexception e){ System.out.println("OK appel impossible de la fonction jouer() " + "avec en parametre une couleur incorrecte "); try{ plateautestnoir.jouer(new Case(0,0), -10); System.out.println("NOK appel possible de la fonction jouer() avec" + " en parametre une couleur incorrecte "); catch(illegalargumentexception e){ System.out.println("OK appel impossible de la fonction jouer() " + "avec en parametre une couleur incorrecte "); System.out.println("Test de jouabilite d'un coup pour les noirs\n"); System.out.println(plateauTestNoir); System.out.println("Appel de la fonction jouer avec en parametre \n" + "les coordonnees de la case marque d'une croix"); plateautestnoir.jouer(plateautestnoir.getcase(5,5), 1); System.out.println(plateauTestNoir); System.out.println("OK le coup a ete jouee\n"); /* Test de jouabilite d'un coup pour les blancs * * Initialisation d'un plateau et ajustement du statut des cases, par * rapport a celles initialise par defaut Plateau plateautestblanc = new Plateau(); plateautestblanc.getcase(3,3).setstatut(2); plateautestblanc.getcase(3,4).setstatut(0); plateautestblanc.getcase(4,3).setstatut(0); plateautestblanc.getcase(4,4).setstatut(1); plateautestblanc.coupsjouables(2); System.out.println("Test de jouabilite d'un coup pour les blancs\n"); System.out.println(plateauTestBlanc); System.out.println("Appel de la fonction jouer avec en parametre \n" + "les coordonnees de la case marque d'une croix"); plateautestnoir.jouer(plateautestblanc.getcase(5,5), 2); System.out.println(plateauTestBlanc); System.out.println("OK le coup a ete jouee\n"); System.out.println(" " + " \nfin du test de la methode jouer()!\n"); System.out.println(); attendu * Test des setters et getters de la classe Case public static void testcase() { Plateau plateau = new Plateau(); boolean ok = true; // True si le resultat est bien celui System.out.println(" " + " \ndebut du test de la classe Case!\n");

104 System.out.println(" Test d'initialisation d'une case avec des " + "valeurs permises ou non "); try{ Case case1 = new Case(0,0); System.out.println("OK, initialisation d'une case possible avec " + "des coordonnees correctes"); catch (IllegalArgumentException e){ System.out.println("NOK, impossible d'initialiser une Case " + "avec des coordonnees correctes"); try{ Case case2 = new Case(3,4); System.out.println("OK, initialisation d'une case possible avec " + "des coordonnees correctes"); catch (IllegalArgumentException e){ System.out.println("NOK, impossible d'initialiser une Case " + "avec des coordonnees correctes"); try{ Case case3 = new Case(7,7); System.out.println("OK, initialisation d'une case possible avec " + "des coordonnees correctes"); catch (IllegalArgumentException e){ System.out.println("NOK, impossible d'initialiser une Case " + "avec des coordonnees correctes"); try{ Case case6 = new Case(new Integer(6),0); System.out.println("OK, initialisation d'une case possible avec " + "des coordonnees correctes"); catch (IllegalArgumentException e){ System.out.println("NOK, impossible d'initialiser une Case " + "avec des coordonnees correctes"); try{ Case case4 = new Case(63,67); System.out.println("NOK, possible d'initialiser une Case " + "avec des coordonnees incorrectes"); catch (IllegalArgumentException e){ System.out.println("OK, initialisation impossible d'une case avec " + "des coordonnees incorrectes"); try{ Case case5 = new Case(-1,-1); System.out.println("NOK, possible d'initialiser une Case " + "avec des coordonnees incorrectes"); catch (IllegalArgumentException e){ System.out.println("OK, initialisation impossible d'une case avec " + "des coordonnees incorrectes"); try{ Case case7 = new Case(2,Integer.MAX_VALUE); System.out.println("NOK, possible d'initialiser une Case " + "avec des coordonnees incorrectes"); catch (IllegalArgumentException e){ System.out.println("OK, initialisation impossible d'une case avec " + "des coordonnees incorrectes"); System.out.println("\n Test des getters "); System.out.println(plateau); 3)) { pas"); // Test de getstatut for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if ((x == 3 && y == 3) (x == 4 && y == 4)) { if (plateau.getcase(x, y).getstatut()!= 2) { ok = false; else if ((x == 3 && y == 4) (x == 4 && y == if (plateau.getcase(x, y).getstatut()!= 1) { ok = false; else { if (plateau.getcase(x, y).getstatut()!= 0){ ok = false; if (ok) { System.out.println("Ok, le getstatut fonctionne"); else { System.out.println("Erreur, le getstatut ne fonctionne

105 // Test de setstatut ok = true; for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { plateau.getcase(x, y).setstatut(0); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if (!(plateau.getcase(x, y).getstatut() == 0)) { ok = false; if (ok) { System.out.println("Ok, le getstatut fonctionne pour 0"); else { System.out.println("Erreur, le getstatut ne fonctionne pas pour 0"); ok = true; for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { plateau.getcase(x, y).setstatut(1); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if (!(plateau.getcase(x, y).getstatut() == 1)) { ok = false; if (ok) { System.out.println("Ok, le getstatut fonctionne pour 1"); else { System.out.println("Erreur, le getstatut ne fonctionne pas pour 1"); ok = true; for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { plateau.getcase(x, y).setstatut(2); for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if (!(plateau.getcase(x, y).getstatut() == 2)) { ok = false; if (ok) { System.out.println("Ok, le getstatut fonctionne pour 2"); else { System.out.println("Erreur, le getstatut ne fonctionne pas pour 2"); pas"); pas"); // Test de getx ok = true; for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if (plateau.getcase(x, y).getx()!= x) { ok = false; if (ok) { System.out.println("Ok, le getx fonctionne"); else { System.out.println("Erreur, le getx ne fonctionne // Test de gety ok = true; for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if (plateau.getcase(x, y).gety()!= y) { ok = false; if (ok) { System.out.println("Ok, le gety fonctionne"); else { System.out.println("Erreur, le gety ne fonctionne // Test de getposition ok = true; int[] position = new int[2];

106 for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { position[0] = x; position[1] = y; if ((plateau.getcase(x, y).getposition())[0]!= position[0] (plateau.getcase(x, y).getposition())[1]!= position[1]) { ok = false; if (ok) { System.out.println("Ok, le getposition fonctionne"); else { System.out.println("Erreur, le getposition ne fonctionne pas"); // Test de getcase Plateau plateau2 = new Plateau(); ok = true; for (int x = 0 ; x < 8 ; x++) { for (int y = 0 ; y < 8 ; y++) { if (plateau2.getcase(x, y).gety()!= y) { ok = false; 3)) { if (plateau2.getcase(x, y).getx()!= x) { ok = false; if ((x == 3 && y == 3) (x == 4 && y == 4)) { if (plateau2.getcase(x, y).getstatut()!= 2) { ok = false; else if ((x == 3 && y == 4) (x == 4 && y == if (plateau2.getcase(x, y).getstatut()!= 1) { ok = false; else { if (plateau2.getcase(x, y).getstatut()!= 0){ ok = false; if (ok) { System.out.println("Ok, le getcase fonctionne"); else { System.out.println("Erreur, le getcase ne fonctionne pas"); System.out.println("\nFin du test de la classe Case!\n " + " "); * Test de la classe Gestionfichier * Sauvegarde d'une liste de partie * Restauration de la liste de parties * Acces aux attributs de la liste public static void testgestionfichier(){ // Test de la sauvegarde et de l'importation d'une partie System.out.println("\nDebut du test de la classe GestionPartie!\n " + " "); // Creation de la liste des parties ListeContigue savetest = new ListeContigue(); ListeContigue savetestcopiee = new ListeContigue(); int testok = 0; Partie test1 = new Partie(new Joueur("Jean", 1, true), new Joueur("Michel", 2, false)); test1.setnompartie("test1"); Partie test2 = new Partie(new Joueur("Ludo", 1, true), new Joueur("Ludo2", 2, false)); test2.setnompartie("test2"); Partie test3 = new Partie(new Joueur("blabla", 1, true), new Joueur("bloblo", 2, false)); test3.setnompartie("test3"); Partie test4 = new Partie(new Joueur("Jeanine", 1, true), new Joueur("Marcel", 2, false)); test4.setnompartie("test4"); Partie test5 = new Partie(new Joueur("Paul", 1, true), new Joueur("Jacques", 2, false)); test5.setnompartie("test5"); //Ajout des parties dans la liste savetest.inserer(test1,0); savetest.inserer(test2,0); savetest.inserer(test3,0); savetest.inserer(test4,0); savetest.inserer(test5,0); try { GestionPartie.enregistrerPartie(saveTest); catch (IOException e) {

107 System.out.println("Erreur dans le test de sauvegarde"); e.printstacktrace(); try { savetestcopiee = GestionPartie.restaurerPartie(saveTestCopiee); catch (ClassCastException e) { System.out.println("Erreur dans le test de restauration"); e.printstacktrace(); catch (ClassNotFoundException e) { System.out.println("Erreur dans le test de restauration"); e.printstacktrace(); catch (IOException e) { System.out.println("Erreur dans le test de restauration"); e.printstacktrace(); //Tests de restauration des noms de parties for(int i = 0; i < 5 ; i++) { if(!(((partie) savetest.elementa(i)).getnompartie().equals(((partie) savetestcopiee.elementa(i)).getnompartie()))){ testok++; if(testok!= 5){ System.out.println("OK tous les noms de partie ont bien ete " + "sauvegardees et restaurees"); else { System.out.println("NOK tous les noms de partie n'ont pas bien ete" + "sauvegardees et restaurees "); //Tests de restauration des noms des joueurs testok =0; for(int i = 0; i < 5 ; i++) { if(!(((partie) savetest.elementa(i)).getjoueur1().getpseudo().equals(((partie) savetestcopiee.elementa(i)).getjoueur1().getpseudo()))!(((partie) savetest.elementa(i)).getjoueur2().getpseudo().equals(((partie) savetestcopiee.elementa(i)).getjoueur2().getpseudo()))){ testok++; if(testok!= 5){ System.out.println("OK tous les noms des Joueurs ont bien ete " + "sauvegardees et restaurees"); else { System.out.println("NOK tous les noms de Joueurs n'ont pas bien ete" + "sauvegardees et restaurees "); // Test testok = 0; for(int i = 0; i < 5 ; i++) { if(((partie) savetest.elementa(i)).getplateaudejeu().getcase(3,3).getstatut()!= 2 ((Partie) savetest.elementa(i)).getplateaudejeu().getcase(3,4).getstatut()!= 1 ((Partie) savetest.elementa(i)).getplateaudejeu().getcase(4,3).getstatut()!= 1 ((Partie) savetest.elementa(i)).getplateaudejeu().getcase(4,4).getstatut()!= 2){ testok++; if(testok!= 5){ System.out.println("OK tous les cases ont bien ete " + "sauvegardes et restaures"); else { System.out.println("NOK tous les cases n'ont pas bien ete" + "sauvegardes et restaures "); * Methode de test de la classe Joueur public static void testjoueur() { // Variables de tests Joueur joueur1 = new Joueur("Toto",2,true); System.out.println(" " + " \n" + " TEST : verification fonctionnement des sets " + "de Joueur ");

108 System.out.println(" " + " "); // Affiche les modifications effectuees System.out.println(joueur1.toString()); joueur1.setpseudo("jean"); System.out.println(joueur1.toString()); joueur1.setcouleur(1); System.out.println(joueur1.toString()); joueur1.sethumain(false); System.out.println(joueur1.toString()); System.out.println("\n " + " \n" + " TEST : exceptions sur les sets de Joueur " + " "); System.out.println(" " + " "); System.out.println(" Appel aux sets de Joueur() avec differents " + "parametres \n corrects ou non."); System.out.println(" " + " "); // TEST : setpseudo() try { joueur1.setpseudo("marcel"); System.out.println("OK : appel a setpseudo() possible avec parametre" + " correct"); catch (IllegalArgumentException e) { System.out.println("NOK : appel a setpseudo() impossible avec parametre" + " correct"); try { joueur1.setpseudo(""); System.out.println("NOK : appel a setpseudo() possible avec parametre" + " incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel a setpseudo() impossible avec parametre" + " incorrect"); try { joueur1.setpseudo(" "); System.out.println("NOK : appel a setpseudo() possible avec parametre" + " incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel a setpseudo() impossible avec parametre" + " incorrect"); try { joueur1.setpseudo(null); System.out.println("NOK : appel a setpseudo() possible avec parametre" + " incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel a setpseudo() impossible avec parametre" + " incorrect"); // TEST : setcouleur() try { joueur1.setcouleur(1); // changer une couleur par la meme couleur System.out.println("NOK : appel a setcouleur() possible avec parametre" + " incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel a setcouleur() impossible avec parametre" + " incorrect"); try { joueur1.setcouleur(2); System.out.println("OK : appel a setcouleur() possible avec parametre" + " correct"); catch (IllegalArgumentException e) { System.out.println("NOK : appel a setcouleur() impossible avec parametre" + " correct"); try { joueur1.setcouleur(0); System.out.println("NOK : appel a setcouleur() possible avec parametre" + " incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel a setcouleur() impossible avec parametre" + " incorrect");

109 try { joueur1.setcouleur(-40); System.out.println("NOK : appel a setcouleur() possible avec parametre" + " incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel a setcouleur() impossible avec parametre" + " incorrect"); try { joueur1.setcouleur(400); System.out.println("NOK : appel a setcouleur() possible avec parametre" + " incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel a setcouleur() impossible avec parametre" + " incorrect"); * Methode de test de la classe partie public static void testpartie() { // Variables de tests Joueur j1 = new Joueur("Toto",1,true); Joueur j2 = new Joueur("Tutu",2,false); Plateau plateautest = new Plateau(); Partie partietest = new Partie(j1,j2); System.out.println(" " + " \n" + "--- TEST : verification fonctionnement des gets" + " \n--- (avec le tostring) et sets " + "de Partie "); System.out.println(" " + " "); System.out.println(); // Affiche les modifications effectuees System.out.println(partieTest.toString()); partietest.setjoueur1(j2); System.out.println(partieTest.toString()); partietest.setjoueur2(j1); System.out.println(partieTest.toString()); partietest.setnompartie("numero 2 "); System.out.println(partieTest.toString()); partietest.setplateaudejeu(plateautest); partietest.settourdejeu(2); System.out.println(partieTest.toString()); System.out.println("\n " + " \n" + " TEST : les sets de Partie " + " "); System.out.println(" " + " "); System.out.println(" Appel aux sets de Partie() avec differents " + "parametres \n corrects ou non."); System.out.println(" " + " "); // TEST : setjoueur1() try { partietest.setjoueur1(j2); System.out.println("OK : appel au setjoueur1() possible avec " + "parametre correct"); catch (IllegalArgumentException e) { System.out.println("NOK : appel au setjoueur1() impossible avec " + "parametre correct"); try { partietest.setjoueur1(null); System.out.println("NOK : appel au setjoueur1() possible avec " + "parametre incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel au setjoueur1() impossible avec " + "parametre incorrect"); // TEST : setjoueur2() try { partietest.setjoueur2(j1); System.out.println("OK : appel au setjoueur2() possible avec " + "parametre correct"); catch (IllegalArgumentException e) {

110 System.out.println("NOK : appel au setjoueur2() impossible avec " + "parametre correct"); try { partietest.setjoueur2(null); System.out.println("NOK : appel au setjoueur2() possible avec " + "parametre incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel au setjoueur2() impossible avec " + "parametre incorrect"); // TEST : setnompartie() try { partietest.setnompartie("partie Toto VS Tutu");; System.out.println("OK : appel au setnompartie() possible avec " + "parametre correct"); catch (IllegalArgumentException e) { System.out.println("NOK : appel au setnompartie() impossible avec " + "parametre correct"); try { partietest.setnompartie(null);; System.out.println("NOK : appel au setnompartie() possible avec " + "parametre incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel au setnompartie() impossible avec " + "parametre incorrect"); try { partietest.setnompartie("");; System.out.println("NOK : appel au setnompartie() possible avec " + "parametre incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel au setnompartie() impossible avec " + "parametre incorrect"); try { partietest.setnompartie(" ");; System.out.println("NOK : appel au setnompartie() possible avec " + "parametre incorrect"); catch (IllegalArgumentException e) { System.out.println("OK : appel au setnompartie() impossible avec " + "parametre incorrect"); System.out.println(); System.out.println(); * Methode de test de la classe Score public static void testscore() { Scores test = new Scores(); test.inserer(1, "test"); test.inserer(3, "test"); test.inserer(2, "test"); test.inserer(4, "test"); System.out.println(test); String score = "\ntableau des scores :\n~~~~~~~~~~~~~~~~~~~~\n" + "test -> 4\ntest -> 3\ntest -> 2\ntest -> 1\n"; if (test.tostring().equals(score)) { System.out.println("Ok, la fonction inserer fonctionne"); else { System.out.println("Erreur, la fonction inserer ne fonctionne pas"); * Tests unitaires du niveau 1 public static void testnvl1() { // Initialisation d'un plateau de jeu Plateau tableautest = new Plateau(); // Liste dans laquelle inserer les cases jouables de l'ia ListeContigue liste = tableautest.getcoupspossiblesnoir(); System.out.println("liste abstraite des coups possibles : " +liste.tostring()); /* Affichage de la liste System.out.print("liste des coups possibles lisibles : "); for (int i = 0 ; i < liste.longueur() ; i++) { System.out.print("(" + ((Case)liste.elementA(i)).getX()

111 "); + ", " + ((Case)liste.elementA(i)).getY() + ") /* --- TEST DU CHOIX ALEATOIRE => NIVEAU1 --- System.out.println(""); System.out.println("\n---- TEST methode niveau1() : ---- "); for (int j = 0; j < 5; j++) { Case casealea = CoupsIA.niveau1(tableauTest, 1); System.out.println("Indice de la prochaine" + " case jouee (choisie aleatoirement <=> Test "+ j + " ) : " + " ( " +casealea.getx() + ", " +casealea.gety() + ") "); * Tests unitaires du niveau 2 public static void testnvl2() { /* --- TEST DE LA METHODE PAR LE MAX DE RETOURNER => NIVEAU2 --- System.out.println("\n --- TEST niveau2() : --- \n"); System.out.println("\n/* --- Avec meme nombre de pions retournes pour chaque coup --- "); // Cas d'un coup virtuel Plateau plateautest = new Plateau(); System.out.println("Initial : \n" + plateautest); Case max; (plateautest.getcase(2, 3)).setStatut(1); System.out.println("Case(2,3) passee en noir : \n" + plateautest); plateautest.parcourstableau(plateautest.getcase(2, 3), true, true); System.out.println("Cases entre (2,3) - noirs retournes : \n" + plateautest); (plateautest.getcase(2, 2)).setStatut(2); System.out.println("Case(2,2) passee en blanc : \n" + plateautest); plateautest.parcourstableau(plateautest.getcase(2, 2), true, true); System.out.println("Cases entre (2,2) - blancs retournes : \n" + plateautest); plateautest.coupsjouables(1); // noir System.out.println("Mise a jour des coups jouables noir effectuee : \n" + plateautest); (plateautest.getcase(3, 2)).setStatut(1); System.out.println("Case(3,2) en noir : \n" + plateautest); plateautest.parcourstableau(plateautest.getcase(3, 2), true, true); System.out.println("Cases entre (3,2) - noirs retournes : \n" + plateautest); plateautest.coupsjouables(2); // blanc System.out.println("Mise a jour des coups jouables blanc effectuee : \n"+ plateautest); // Appel a niveau2() max = CoupsIA.niveau2(plateauTest, 2); // Affiche la liste des coups possibles System.out.print("Liste des coups possibles lisibles : "); for (int i = 0 ; i < plateautest.getcoupspossiblesblanc().longueur() ; i++) { System.out.print("(" + ((Case)plateauTest.getCoupsPossiblesBlanc().elementA(i)).getX() + ", " + ((Case)plateauTest.getCoupsPossiblesBlanc().elementA(i)).getY() + ") "); // TEST de la methode niveau2() if ( max == plateautest.getcoupspossiblesblanc().elementa(0)) { System.out.println("\nOK : Premiere case retournee. "); // Affiche la case choisi System.out.println("---> Case jouee :" + " (" + max.getx() + ", " + max.gety() + ") "); else { System.out.println("NOK : Erreur, la case retournee devrait etre la premiere."); /* * Cas avec un plateau ou les differents coups possibles * ont un nombre de retournement de pions different Plateau plateautest2 = new Plateau(); System.out.println("\n/* --- Avec nombre de pion retournes differents pour chaque coup --- "); System.out.println("Initial : \n" + plateautest2); Case max2; (plateautest2.getcase(3, 2)).setStatut(1); System.out.println("Case(3,2) passee en noir : \n" + plateautest2); plateautest2.parcourstableau(plateautest2.getcase(3, 2), true, true); System.out.println("Cases entre (3,2) - noirs retournes : \n" + plateautest2);

112 (plateautest2.getcase(4, 2)).setStatut(2); System.out.println("Case(4,2) passee en blanc : \n" + plateautest2); plateautest2.parcourstableau(plateautest2.getcase(4, 2), true, true); System.out.println("Cases entre (4,2) - blancs retournes : \n" + plateautest2); plateautest2.coupsjouables(1); // noir System.out.println("Mise a jour des coups jouables noirs effectuee : \n" + plateautest2); max2 = CoupsIA.niveau2(plateauTest2, 1); // Affiche la liste des coups possibles System.out.print("Liste des coups possibles lisibles : "); for (int i = 0 ; i < plateautest2.getcoupspossiblesnoir().longueur() ; i++) { System.out.print("(" + ((Case)plateauTest2.getCoupsPossiblesNoir().elementA(i)).getX() + ", " + ((Case)plateauTest2.getCoupsPossiblesNoir().elementA(i)).getY() + ") "); // TEST de la methode niveau2() if ( max2 == plateautest2.getcoupspossiblesnoir().elementa(1)) { System.out.println("\nOK : Bonne case retournee. "); // Affiche la case choisi System.out.println("---> Case jouee :" + " (" + max2.getx() + ", " + max2.gety() + ") "); else { System.out.println("\nNOK : Erreur, la case retournee n'est pas la bonne."); * Tests unitaires du niveau 3 public static void testnvl3() { /* --- TEST DE LA METHODE MINMAX => NIVEAU System.out.println("\n --- TEST niveau3() : --- \n"); int nbpionsblancs; int nbpionsnoirs; Plateau plateau = new Plateau(); nbpionsnoirs = plateau.getnbpionnoir(); plateau.jouer(coupsia.niveau3(plateau, 1), 1); if (plateau.getnbpionnoir() > nbpionsnoirs) { System.out.println("Ok, un pion noir a bien ete depose"); else { System.out.println("Erreur, aucun pion noir n'a ete depose"); nbpionsblancs = plateau.getnbpionblanc(); plateau.jouer(coupsia.niveau3(plateau, 2), 2); if (plateau.getnbpionnoir() > nbpionsnoirs) { System.out.println("Ok, un pion blanc a bien ete depose"); else { System.out.println("Erreur, aucun pion blanc n'a ete depose"); * Scenarios de jeu IA contre Ia public static void testiavsia() { System.out.println("\nDeroulement d'une partie Max retournement contre random : "+ "\nattention, ce test peut prendre quelques secondes..."); int victoirenvl1 = 0; int victoirenvl2 = 0; int victoirenvl3 = 0; int victoire; for (int i = 0 ; i < 10 ; i++) { victoire = partiesia(2, 1); if (victoire == 2) { victoirenvl2++; else if (victoire == 1) { victoirenvl1++; System.out.println("victoire random : " + victoirenvl1); System.out.println("victoire Max retournement : " + victoirenvl2); System.out.println("\nDeroulement d'une partie MinMax contre random : "+ "\nattention, ce test peut prendre quelques secondes..."); victoirenvl1 = 0;

113 victoirenvl2 = 0; victoirenvl3 = 0; for (int i = 0 ; i < 10 ; i++) { victoire = partiesia(3, 1); if (victoire == 3) { victoirenvl3++; else if (victoire == 1) { victoirenvl1++; System.out.println("victoire MinMax : " + victoirenvl3); System.out.println("victoire random : " + victoirenvl1); System.out.println("\nDeroulement d'une partie MinMax contre Max retournement : "+ "\nattention, ce test peut prendre quelques secondes..."); victoirenvl1 = 0; victoirenvl2 = 0; victoirenvl3 = 0; for (int i = 0 ; i < 10 ; i++) { victoire = partiesia(3, 2); if (victoire == 3) { victoirenvl3++; else if (victoire == 2) { victoirenvl2++; System.out.println("victoire MinMax : " + victoirenvl3); System.out.println("victoire Max retournement : " + victoirenvl2); * Manipulation des listes lineaire avec affichage sur la console public static void testlistes(){ ListeContigue liste; // axiome A0 liste = new ListeContigue(); System.out.println("Longueur de la liste = " + liste.longueur()); if (liste.estvide()) { System.out.println("Ok liste vide apres creation"); else { System.out.println("NOk liste non vide apres creation"); // Axiome A1 liste.inserer(new Integer(1), 0); if (liste.estvide()) { System.out.println("NOk liste vide apres insertion"); else { System.out.println("OK liste non vide apres insertion d'un element"); // pre-inserer try { liste.inserer(new Integer(2), -2); System.out.println("Nok insere possible en position impossible"); catch (IndexOutOfBoundsException e) { System.out.println("Ok inserer impossible en position impossible"); try { liste.inserer(new Integer(2), 1); System.out.println("Ok inserer possible en position possible"); System.out.println("Liste \"liste\" : " + liste); catch (IndexOutOfBoundsException e) { System.out.println("Nok inserer impossible en position possible"); System.out.println("Longueur de la liste = " + liste.longueur()); // Axiome A4 if (liste.longueur() == 2) { System.out.println("Ok longueur correcte apres insersion"); else { System.out.println("longueur incorrecte apres insertion"); liste.inserer(new Integer(3),2); System.out.println("Liste \"liste\" : " + liste); System.out.println("Longueur de la liste = " + liste.longueur()); if (liste.longueur() == 3) { System.out.println("Ok longueur correcte apres insersion");

114 else { System.out.println("NOK longueur incorrecte apres insertion"); liste.supprimer(1); System.out.println("Liste \"liste\" : " + liste); ListeContigue bazar; bazar = new ListeContigue(); bazar.inserer(new String("une chaine au pif"), 0); bazar.inserer(new Double(3.14), 1); bazar.inserer(liste, 2); System.out.println("Voici une liste en bazar : " + bazar); if (liste.longueur() == 2) { System.out.println("Ok longueur correcte apres suppression"); else { System.out.println("NOK longueur incorrecte apres suppression"); // Axiome A5 -> elementa if (liste.elementa(1).equals(new Integer(3))) { System.out.println("Ok element a la position pos correct"); else { System.out.println("Nok mauvais element a la position pos"); if (liste.elementa(0).equals(new Integer(1))) { System.out.println("Ok element a la position pos correct"); else { System.out.println("Nok mauvais element a la position pos"); liste.inserer(new Integer(21), 2); System.out.println("Liste \"liste\" : " + liste); // Axiome A6 liste.supprimer(1); System.out.println("Liste \"liste\" : " + liste); if (liste.elementa(1).equals(new Integer(21))) { System.out.println("Ok element a la position pos correct"); else { System.out.println("Nok mauvais element a la position pos"); System.out.println("1 :Liste \"liste\" : " + liste); // liste d'objet non sure en type (not type safe) * Deroulement d'une partie Ia contre Ia joueur1 : niveau de l'ia pour le joueur 1 joueur2 : niveau de l'ia pour le joueur 2 le niveau qui a gagne : * <ul><li>1 si le random a gagne</li> * <li>2 si le max retournement a gagne, 3 si le MinMax a gagne</li> * <li>et 0 s'il y a egalite</li></ul> public static int partiesia(int joueur1, int joueur2) { Plateau tableautest = new Plateau(); int[] coordonnees = new int[2]; int tourdejeu = 0; int coupimpossible = 0; do { tourdejeu = (tourdejeu % 2) + 1; if ((tourdejeu == 1 && (tableautest.getcoupspossiblesnoir()).longueur()!= 0) ( tourdejeu == 2 && (tableautest.getcoupspossiblesblanc()).longueur()!= 0)) { coupimpossible = 0; if (tourdejeu == 1) { // joueur1 : Noirs if (joueur1 == 1) { tableautest.jouer(coupsia.niveau1(tableautest, tourdejeu), tourdejeu); else if (joueur1 == 2) { tableautest.jouer(coupsia.niveau2(tableautest, tourdejeu), tourdejeu); else { tableautest.jouer(coupsia.niveau3(tableautest, tourdejeu), tourdejeu); else { // joueur2 : Blancs if (joueur2 == 1) {

115 tableautest.jouer(coupsia.niveau1(tableautest, tourdejeu), tourdejeu); else if (joueur2 == 2) { tableautest.jouer(coupsia.niveau2(tableautest, tourdejeu), tourdejeu); else { tableautest.jouer(coupsia.niveau3(tableautest, tourdejeu), tourdejeu); else { coupimpossible ++; tableautest.coupsjouables(tourdejeu == 1? 2 : 1); tourdejeu += 2;!= 2); while(tableautest.gettotalpion() < 64 && coupimpossible // Fin de partie if (tableautest.getnbpionnoir() > tableautest.getnbpionblanc()) { // Joueur 1 gagne return joueur1; else if (tableautest.getnbpionnoir() == tableautest.getnbpionblanc()) { // Egalite return 0; // Else => joueur2 gagne return joueur2; /* * testunitaireplateau.java 5 mai 2014 * IUT Info Groupe3 package test; import java.util.scanner; import partie.plateau; * Programme principal de test de la classe Case et Plateau groupe AMRA * public class TestUnitairePrincipal { * L'utilisateur a le choix d'executer tous les tests a la fois * ou de les visualiser un par un. args non utilise public static void main(string[] args) { // Variable de stockage du choix du menu int choixmenu = -1; // Initialisation du tampon d'entree standard Scanner entree = new Scanner(System.in); do { do{ System.out.println("Programme principal de test."); System.out.println("Saisissez l'entier correspondant a une des" + " methodes suivantes pour la tester :\n" + "0 -> tous les tests.\n" + "1 -> getters et setters (classe Case)\n" + "2 -> getters et setters (classe Joueur)\n" + "3 -> getters and setters (classe Partie)\n" + "4 -> tostring() (classe Case)\n" + "5 -> tostring() (classe Plateau)\n" + "6 -> nbpion() (classe Plateau)\n" + "7 -> retournerpion() (classe Plateau)\n" + "8 -> coupsjouables() (classe Plateau)\n" + "9 -> jouer() (classe Plateau)\n" + "10 -> gestion des Sauvegarde (classe GestionPartie)\n"

116 Scores)\n" maximal)" methode 2)" listecontigue)" + "11 -> gestion des Scores (classe + "12 -> IA methode 1 (tirage aléatoire)" + "13 -> IA methode 2 (retournement + "14 -> IA methode 3 (algorithme min/max" + "15 -> affrontement IA (methode 1 VS + "16 -> tests liste (Classe + "17 -> Quitter le programme de test.\n"); System.out.print("Saisissez votre choix : "); if(entree.hasnextint()){ choixmenu = entree.nextint(); if(choixmenu < 0 choixmenu > 17) { System.out.println("Le nombre saisi ne correspond a aucun" + " choix du menu.\n"); choixmenu = -1; else { System.out.println("Vous devez saisir un entier.\n"); entree.nextline(); while ( choixmenu == -1); switch(choixmenu) { case 0: TestFonctions.testCase(); TestFonctions.testJoueur(); TestFonctions.testPartie(); TestFonctions.testToStringCase(); TestFonctions.testToStringPlateau(); TestFonctions.testNbPions(); TestFonctions.testRetourner(); TestFonctions.testCoupsJouables(); TestFonctions.testJouer(); TestFonctions.testGestionfichier(); TestFonctions.testNvl1(); TestFonctions.testNvl2(); TestFonctions.testNvl3(); TestFonctions.testIaVsIa(); TestFonctions.testListes(); break; case 1: TestFonctions.testCase(); break; case 2: TestFonctions.testJoueur(); break; case 3: TestFonctions.testPartie(); break; case 4: TestFonctions.testToStringCase(); break; case 5: TestFonctions.testToStringPlateau(); break; case 6: TestFonctions.testNbPions(); break; case 7: TestFonctions.testRetourner(); break; case 8: TestFonctions.testCoupsJouables(); break; case 9: TestFonctions.testJouer(); break; case 10: TestFonctions.testGestionfichier(); break; case 11: TestFonctions.testScore(); break; case 12: TestFonctions.testNvl1(); break; case 13: TestFonctions.testNvl2(); break; case 14: TestFonctions.testNvl3(); break; case 15: TestFonctions.testIaVsIa(); break; case 16: TestFonctions.testListes(); break; case 17: System.out.println("\nFin du programme de test\n"); while(choixmenu!= 12);

117 V. Tests Othello 114

118 IUT Rodez université Toulouse capitole I Test unitaires Programme principal de test. Saisissez l'entier correspondant a une des methodes suivantes pour la tester : 0 -> tous les tests. 1 -> getters et setters (classe Case) 2 -> getters et setters (classe Joueur) 3 -> getters and setters (classe Partie) 4 -> tostring() (classe Case) 5 -> tostring() (classe Plateau) 6 -> nbpion() (classe Plateau) 7 -> retournerpion() (classe Plateau) 8 -> coupsjouables() (classe Plateau) 9 -> jouer() (classe Plateau) 10 -> gestion des Sauvegarde (classe GestionPartie) 11 -> gestion des Scores (classe Scores) 12 -> IA methode 1 (tirage aléatoire) 13 -> IA methode 2 (retournement maximal) 14 -> IA methode 3 (algorithme min/max) 15 -> affrontement IA (methode 1 VS methode 2) 16 -> tests liste (Classe listecontigue) 17 -> Quitter le programme de test. Saisissez votre choix : Debut du test de la classe Case! Test d'initialisation d'une case avec des valeurs permises ou non OK, initialisation d'une case possible avec des coordonnees correctes OK, initialisation d'une case possible avec des coordonnees correctes OK, initialisation d'une case possible avec des coordonnees correctes OK, initialisation d'une case possible avec des coordonnees correctes OK, initialisation impossible d'une case avec des coordonnees incorrectes OK, initialisation impossible d'une case avec des coordonnees incorrectes OK, initialisation impossible d'une case avec des coordonnees incorrectes Test des getters o x 4 x o A B C D E F G H Ok, le getstatut fonctionne Ok, le getstatut fonctionne pour 0 Ok, le getstatut fonctionne pour 1 Ok, le getstatut fonctionne pour 2 Ok, le getx fonctionne Ok, le gety fonctionne Ok, le getposition fonctionne Ok, le getcase fonctionne Fin du test de la classe Case! TEST : verification fonctionnement des sets de Joueur IUT Rodez université Toulouse capiotle 115

119 Pseudo : Toto, couleur : 2, Humain? true Pseudo : Jean, couleur : 2, Humain? true Pseudo : Jean, couleur : 1, Humain? true Pseudo : Jean, couleur : 1, Humain? false TEST : exceptions sur les sets de Joueur Appel aux sets de Joueur() avec differents parametres corrects ou non OK : appel a setpseudo() possible avec parametre correct OK : appel a setpseudo() impossible avec parametre incorrect OK : appel a setpseudo() impossible avec parametre incorrect OK : appel a setpseudo() impossible avec parametre incorrect OK : appel a setcouleur() impossible avec parametre incorrect OK : appel a setcouleur() possible avec parametre correct OK : appel a setcouleur() impossible avec parametre incorrect OK : appel a setcouleur() impossible avec parametre incorrect OK : appel a setcouleur() impossible avec parametre incorrect TEST : verification fonctionnement des gets (avec le tostring) et sets de Partie > PARTIE null avec : J1 : Pseudo : Toto, couleur : 1, Humain? true J2 : Pseudo : Tutu, couleur : 2, Humain? false Tour de Jeu : o x 4 x o A B C D E F G H --> PARTIE null avec : J1 : Pseudo : Tutu, couleur : 2, Humain? false J2 : Pseudo : Tutu, couleur : 2, Humain? false Tour de Jeu : o x 4 x o A B C D E F G H IUT Rodez université Toulouse capiotle 116

120 --> PARTIE null avec : J1 : Pseudo : Tutu, couleur : 2, Humain? false J2 : Pseudo : Toto, couleur : 1, Humain? true Tour de Jeu : o x 4 x o A B C D E F G H --> PARTIE NUMERO 2 avec : J1 : Pseudo : Tutu, couleur : 2, Humain? false J2 : Pseudo : Toto, couleur : 1, Humain? true Tour de Jeu : o x 4 x o A B C D E F G H --> PARTIE NUMERO 2 avec : J1 : Pseudo : Tutu, couleur : 2, Humain? false J2 : Pseudo : Toto, couleur : 1, Humain? true Tour de Jeu : o x 4 x o A B C D E F G H TEST : les sets de Partie Appel aux sets de Partie() avec differents parametres corrects ou non OK : appel au setjoueur1() possible avec parametre correct OK : appel au setjoueur1() impossible avec parametre incorrect OK : appel au setjoueur2() possible avec parametre correct OK : appel au setjoueur2() impossible avec parametre incorrect OK : appel au setnompartie() possible avec parametre correct OK : appel au setnompartie() impossible avec parametre incorrect 117

121 OK : appel au setnompartie() impossible avec parametre incorrect OK : appel au setnompartie() impossible avec parametre incorrect Debut du test du nombre de pions! o x 4 x o A B C D E F G H Ok, le nombre de pions est correct a l'initialisation o x 5 o x 4 x o A B C D E F G H Ok, le nombre de pions est correct o x 5 x x x 4 x o A B C D E F G H Ok, le nombre de pions est correct o o o 5 x x o 4 x o A B C D E F G H Ok, le nombre de pions est correct 118

122 Fin du test du nombre de pions! Debut du test de retournercase! 8 7 x x x x x 6 x o o o x 5 x o o x 4 x o o o x 3 x x x x x 2 1 A B C D E F G H 8 7 x x x x x 6 x x x x x 5 x x x x x 4 x x x x x 3 x x x x x 2 1 A B C D E F G H OK, le retournement a bien fonctionne 8 x x x x x x x x 7 x o o o o o o x 6 x o o o o o o x 5 x o o o o o x 4 x o o o o o o x 3 x o o o o o o x 2 x o o o o o o x 1 x x x x x x x x A B C D E F G H 8 x x x x x x x x 7 x x o x o x o x 6 x o x x x o o x 5 x x x x x x x x 4 x o x x x o o x 3 x x o x o x o x 2 x o o x o o x x 1 x x x x x x x x A B C D E F G H OK, le retournement a bien fonctionne 119

123 8 x x x x x x x 7 x x 6 x o o o x 5 x o o x 4 x o o o x 3 x x 2 x x x x x x x 1 A B C D E F G H 8 x x x x x x x 7 x x 6 x o o o x 5 x o x o x 4 x o o o x 3 x x 2 x x x x x x x 1 A B C D E F G H OK, aucun retournement n'a eu lieu 8 o o o o o o o o 7 o o o o o o o o 6 o o o o o o o o 5 o o o o o o o 4 o o o o o o o o 3 o o o o o o o o 2 o o o o o o o o 1 o o o o o o o o A B C D E F G H 8 o o o o o o o o 7 o o o o o o o o 6 o o o o o o o o 5 o o o x o o o o 4 o o o o o o o o 3 o o o o o o o o 2 o o o o o o o o 1 o o o o o o o o A B C D E F G H OK, aucun retournement n'a eu lieu 120

124 8 7 6 o x 5 o x 4 x o A B C D E F G H Ok, les premiers retournements ont fonctionnes o x 5 x x x 4 x o A B C D E F G H Ok, les retournements ont fonctionnes o o o 5 x x o 4 x o A B C D E F G H Ok, les retournements ont fonctionnes o x 5 x x x 4 x o A B C D E F G H 121

125 8 7 6 o x 5 x x x 4 x o A B C D E F G H OK, le retournement virtuel a bien fonctionne Fin du test de retournercase! Debut du test de la methode coupjouables()! Appel de la fonction coupjouables() avec differents parametres corrects ou non OK appel possible de la fonction coupjouable() avec en parametre une couleur correcte OK appel possible de la fonction coupjouable() avec en parametre une couleur correcte OK appel impossible de la fonction coupjouable() avec en parametre une couleur incorrecte OK appel impossible de la fonction coupjouables() avec en parametre une couleur incorrecte OK appel impossible de la fonction coupjouable() avec en parametre une couleur incorrecte 8 7 x 6 o x 5 x o 4 o A B C D E F G H Sur ce plateau les noirs peuvent jouer 6 coups differents OK nombre de coups possibles correct Comparaison des coordonnees des cases jouables stocke par le programme avec la liste suivantes : OK case jouable a l'indice 0 presente dans la liste generee par le programme OK case jouable a l'indice 1 presente dans la liste generee par le programme OK case jouable a l'indice 2 presente dans la liste generee par le programme OK case jouable a l'indice 3 presente dans la liste generee par le programme OK case jouable a l'indice 4 presente dans la liste generee par le programme OK case jouable a l'indice 5 presente dans la liste generee par le programme 122

126 8 7 o 6 x o 5 o x 4 x A B C D E F G H Sur ce plateau les blancs peuvent jouer 6 coups differents 6 OK nombre de coups possibles correct Comparaison des coordonnees des cases jouables stocke par le programme avec la liste suivantes : OK case jouable a l'indice 0 presente dans la liste generee par le programme OK case jouable a l'indice 1 presente dans la liste generee par le programme OK case jouable a l'indice 2 presente dans la liste generee par le programme OK case jouable a l'indice 3 presente dans la liste generee par le programme OK case jouable a l'indice 4 presente dans la liste generee par le programme OK case jouable a l'indice 5 presente dans la liste generee par le programme Fin du test de la methode coupjouables()! Debut du test de la methode jouer()! Appel de la fonction jouer avec differents parametres corrects ou non OK appel possible de la fonction jouer() avec en parametre une couleur correcte Coup non jouable ~~~~~~~~~~~~~~~~ OK appel possible de la fonction jouer() avec en parametre une couleur correcte OK appel impossible de la fonction jouer() avec en parametre une couleur incorrecte OK appel impossible de la fonction jouer() avec en parametre une couleur incorrecte OK appel impossible de la fonction jouer() avec en parametre une couleur incorrecte Test de jouabilite d'un coup pour les noirs x 4 x A B C D E F G H Appel de la fonction jouer avec en parametre les coordonnees de la case marque d'une croix Coup non jouable ~~~~~~~~~~~~~~~~

127 x 4 x A B C D E F G H OK le coup a ete jouee Test de jouabilite d'un coup pour les blancs o 4 x A B C D E F G H Appel de la fonction jouer avec en parametre les coordonnees de la case marque d'une croix Coup non jouable ~~~~~~~~~~~~~~~~ o 4 x A B C D E F G H OK le coup a ete jouee Fin du test de la methode jouer()! Debut du test de la classe GestionPartie! OK tous les noms de partie ont bien ete sauvegardees et restaurees OK tous les noms des Joueurs ont bien ete sauvegardees et restaurees OK tous les cases ont bien ete sauvegardes et restaures liste abstraite des coups possibles : [ ][ ][ ][ ] liste des coups possibles lisibles : (5, 4) (4, 5) (3, 2) (2, 3) ---- TEST methode niveau1() :

128 Indice de la prochaine case jouee (choisie aleatoirement <=> Test 0 ) : ( 2, 3) Indice de la prochaine case jouee (choisie aleatoirement <=> Test 1 ) : ( 5, 4) Indice de la prochaine case jouee (choisie aleatoirement <=> Test 2 ) : ( 2, 3) Indice de la prochaine case jouee (choisie aleatoirement <=> Test 3 ) : ( 4, 5) Indice de la prochaine case jouee (choisie aleatoirement <=> Test 4 ) : ( 2, 3) --- TEST niveau2() : --- /* --- Avec meme nombre de pions retournes pour chaque coup - -- Initial : o x 4 x o A B C D E F G H Case(2,3) passee en noir : x 5 o x 4 x o A B C D E F G H Cases entre (2,3) - noirs retournes : x 5 x x 4 x o A B C D E F G H Case(2,2) passee en blanc : 125

129 8 7 6 o x 5 x x 4 x o A B C D E F G H Cases entre (2,2) - blancs retournes : o x 5 o x 4 x o A B C D E F G H Mise a jour des coups jouables noir effectuee : o x 5 o x 4 x o A B C D E F G H Case(3,2) en noir : o x 5 x o x 4 x o A B C D E F G H Cases entre (3,2) - noirs retournes : 126

130 8 7 6 o x 5 x x x 4 x o A B C D E F G H Mise a jour des coups jouables blanc effectuee : o x 5 x x x 4 x o A B C D E F G H Liste des coups possibles lisibles : (4, 2) (4, 2) (2, 4) (2, 4) OK : Premiere case retournee. ---> Case jouee : (4, 2) /* --- Avec nombre de pion retournes differents pour chaque coup --- Initial : o x 4 x o A B C D E F G H Case(3,2) passee en noir : x o x 4 x o A B C D E F G H 127

131 Cases entre (3,2) - noirs retournes : x x x 4 x o A B C D E F G H Case(4,2) passee en blanc : x x x 4 o x o A B C D E F G H Cases entre (4,2) - blancs retournes : x x x 4 o o o A B C D E F G H Mise a jour des coups jouables noirs effectuee : x x x 4 o o o A B C D E F G H 128

132 Liste des coups possibles lisibles : (5, 5) (5, 4) (5, 4) (5, 3) (5, 2) (5, 2) (5, 1) OK : Bonne case retournee. ---> Case jouee : (5, 4) 1 :Liste "liste" : [ 1 ][ 21 ] Voici une liste en bazar : [ une chaine au pif ][ 3.14 ][ [ 1 ][ 21 ] ] --- TEST niveau3() : --- Ok, un pion noir a bien ete depose Ok, un pion blanc a bien ete depose Deroulement d'une partie Max retournement contre random : Attention, ce test peut prendre quelques secondes... victoire random : 3 victoire Max retournement : 7 Deroulement d'une partie MinMax contre random : Attention, ce test peut prendre quelques secondes... victoire MinMax : 7 victoire random : 3 Deroulement d'une partie MinMax contre Max retournement : Attention, ce test peut prendre quelques secondes... victoire MinMax : 8 victoire Max retournement : 2 Longueur de la liste = 0 Ok liste vide apres creation OK liste non vide apres insertion d'un element Ok inserer impossible en position impossible Ok inserer possible en position possible Liste "liste" : [ 1 ][ 2 ] Longueur de la liste = 2 Ok longueur correcte apres insersion Liste "liste" : [ 1 ][ 2 ][ 3 ] Longueur de la liste = 3 Ok longueur correcte apres insersion Liste "liste" : [ 1 ][ 3 ] Ok longueur correcte apres suppression Ok element a la position pos correct Ok element a la position pos correct Liste "liste" : [ 1 ][ 3 ][ 21 ] Liste "liste" : [ 1 ][ 21 ] Ok element a la position pos correct 129

133 IUT Rodez université Toulouse capitole I Test d intégration Après génération du.exe à partir du.jar : Lancement du.exe (scores et sauves vides) : Saisie incorrecte : 130

134 Lancement d une partie un joueur (pseudo Choix de la méthode de l IA suite à l entrée du vide) : pseudo : Saisie incorrecte pour l IA : Retour au menu : 131

135 Début de partie (joueur vs IA méthode 1), Mauvaise saisie de case : le joueur commence : x On passe notre tour : Un pion est joué (minuscules et majuscules acceptées) : 132

136 On joue un coup non jouable : Appel du menu : Saisie incorrecte : (pour le quitter et le sauve) Retour au jeu : 133

137 Sauvegarde de la partie : Vérification que la sauvegarde ait bien été enregistrée : On charge la partie (Le tour de jeu et le jeu On ne donne pas de nom à la partie : ont bien été sauvegardés) : 134

138 Chaque nom de partie est unique grâce à l assemblage : jour/mois/année heure : minutes : secondes (qui est unique) : Les deux parties n ont pas de nom mais sont unique par la date Cas où il y a plus de 10 sauvegardes : que On vérifie que la partie supprimée est bien la bonne et la nôtre à bien été sauvée : (test1 a bien été supprimée) 135

139 Retour au menu sans sauvegarde : On perd la partie contre l IA (Score non sauvé) : On gagne la partie contre l IA (Score sauvé) : On vérifie que le score soit bien sauvé : 136

140 On reprend une partie sauvegardée et on On la sauve : continue : L ancienne partie n a pas été modifiée et la nouvelle est bien sauvegardée (2 impressions) : 137

141 On retourne au menu et on lance une partie un joueur vs IA méthode 2 puis IA méthode 3 (mêmes fonctions que l IA méthode 1 seul les coups joués sont différents) : On retourne au menu et on lance une partie Pseudo vide : deux joueurs : 138

142 Joueur 2 prend le même nom que le joueur 1 : Les noirs commencent : Tirage aléatoire de la couleur (cas 1 : joueur1 noir et joueur2 blanc, cas 2 : joueur1 blanc et joueur2 noir) : 139

143 Mauvaise saisie de case : On joue un coup non jouable (c est encore à nous) : On passe notre tour (joueur suivant, plateau Un pion est joué (appel du joueur suivant) : inchangé) : 140

144 On ne peut rien jouer (passage à l autre joueur automatiquement) : Appel du menu : Saisie incorrecte : (pour le quitter et le sauve) 141

145 Retour au jeu : Sauvegarde de la partie : Vérification que la sauvegarde ait bien été enregistrée : On charge la partie (Le tour de jeu et le jeu ont bien été sauvegardés) 142

146 On charge la partie (Saisie incorrecte) : Cas où il y a plus de 10 sauvegardes : Saisie incorrecte : 143

147 On vérifie que la partie supprimée est bien la bonne et que la nôtre à bien été sauvée : (2impr) Sauve9 a bien été supprimée et sauve 11 a bien été sauvegardée Retour au menu sans sauvegarde : La partie se termine normalement : 144

148 On vérifie que le score soit bien sauvé : On reprend une partie sauvegardée et on On la sauve : continue : 145

149 L ancienne partie n a pas été modifiée et la nouvelle est bien sauvegardée : On quitte puis on consulte les parties On consulte les scores : sauvegardées : 146

150 On consulte l aide (mauvaise saisie dans l aide) : On consulte les règles : On consulte le «A propos du jeu» : 147

151 On retourne au menu : On quitte le jeu : Saisie incorrecte dans le «quitter» : On n a pas quitté (retour au menu, 0 étant toujours «retour») : 148

152 On a quitté normalement, création des deux fichiers de sauvegarde (sauvegardes.dat et score.dat) : On relance le.exe et on regarde les scores : On charge les sauvegardes : 149

153 On quitte le jeu et on supprime les fichiers de sauvegarde : On relance le jeu et on regarde les scores (bien vides) : On regarde les sauvegardes (bien vides) : 150

154 On recrée des scores et des sauves : On a quitté normalement, création des deux fichiers de sauvegarde (sauvegardes.dat et score.dat) : 151

155 On relance le jeu avec des sauvegardes et on rajoute des nouvelles sauvegardes : On quitte normalement et on relance le jeu (toutes les sauvegardes (anciennes et nouvelles sont chargées)) : 152

156 Tableau des scores complet : Nouveau score égal au dernier du tableau (score non sauvegardé) : Le tableau des scores se trie bien automatiquement : Cas 1 : Même score 153

157 Cas 2 : Score supérieur Cas 3 : Score intermédiaire 154

158 IUT Rodez université Toulouse capitole I VI. Conclusion Ce projet a mobilisé beaucoup de temps et d énergie au sein de notre équipe, et les efforts fournis par chacun de nos membres sont récompensés aujourd hui par la remise de l intégralité des livrables. D une manière générale nous sommes satisfaits de notre travail non pas car il est exempts de défauts mais car il a su mettre l accent sur certains aspects fondamentaux, aspects que nous vous décrirons ci-après. Résultats obtenus Le résultat de ce projet pourrait se résumer en partie aux livrables joints avec ce dossier, ainsi qu avec l apport d expérience qu a engendré le suivi d une telle démarche. Apports du projet En effet, la réalisation de ce logiciel nous a non seulement permis de renforcer nos compétences techniques dans le domaine de la programmation orientée objet, mais également d aborder de nouveaux concepts, comme celui de la récursivité même si son implémentation n a pas été effective dans les livrables. Notre maitrise du logiciel Eclipse que ce soit par l utilisation de plugin de modélisation ou par la prise en mains des différentes configurations possibles a été également augmentée. Au regard de notre future implication en entreprise, ce projet nous a ouvert à de nouvelles considérations telles que le concept de qualité, la rigueur mathématique en ce qui concerne le respect des délais et du planning ainsi que la communication avec la MOA inhérente à un tel projet. L appréhension de concepts tels que le cycle de vie itératif, le rôle et la place de chacun au sein d une équipe, ou la rédaction et le suivi des différents documents produits, nous a permis de mieux définir ce que pouvait être la conduite d un projet sous contraintes. La communication a été au centre de notre démarche, que ce soit entre les membres de l équipe par le biais de différents logiciels (vidéo-conférence, mail), ou avec l équipe MOA par le biais de réunions régulières. La bonne entente a joué un rôle primordial au sein de notre équipe afin de maintenir un climat de coopération pleine et entière même dans les moments difficiles. Si le résultat obtenu n est pas parfait, il nous a tout de même permis de travailler ensemble et de réviser bon nombre d idées que nous nous faisions à propos du développement d un logiciel. Pour finir nous tenons à remercier l ensemble de l équipe pédagogique qui nous a apporté son soutien tout au long du processus. othelloothello 155

159 IUT Rodez université Toulouse capitole I Manuel utilisateur Tables des matières I. Installation et lancement du jeu ) Support fourni et prérequis ) Installation ) Lancement du jeu II. Lancement d une partie ) Menu principal ) Lancement d une partie 2 joueurs ) Lancement d une partie contre l ordinateur ) Déroulement d une partie III. Sauvegarder et charger une partie ) Sauvegarder une partie ) Chargement d une partie sauvegardée ) Suppression des sauvegardes IV. Autres Fonctions ) Tableau des scores ) Suppression des meilleurs scores ) Aide othelloothello 156

160 I. Installation et lancement du jeu 1. Support fourni et prérequis Le jeu d Othello vous est fourni sous forme d un CD-ROM, vous trouverez dessus tout ce dont vous aurez besoin pour en profiter. Votre machine doit posséder une plateforme java. Si ce n est pas le cas, téléchargez et installez là à partir du lien suivant : 2. Installation Pour pouvoir profiter du jeu d Othello voici quelques étapes primordiales afin d éviter tout problème par la suite : a) Insérer le CD-ROM dans le lecteur de votre PC b) Explorer le CD, puis copier-coller le dossier jeux sur un espace de votre machine dont vous possédez les droits d écritures (ex : Mes documents) 3. Lancement du jeu Pour pouvoir lancer une partie, deux options s offrent à vous : a) Lancer le fichier othello.exe, cliquer sur exécuter si une fenêtre vous le demande. b) Si la méthode précédente ne marche pas, lancer un invite de commandes puis taper la commande suivante : java jar chemin_de_votre_fichier.jar Ici le fichier othello.jar ce trouve dans bureau\jeux 157

161 II. Lancement d une partie 1. Menu principal Une fois le jeu lancé, vous obtiendrez le menu suivant : Plusieurs choix s offrent alors à vous, vous pouvez saisir des chiffres de 1 à 6 : 1) Lancer une nouvelle partie contre l ordinateur, vous permet de démarrer une partie 1 joueur 2) Lancer une nouvelle partie contre une personne, vous permet de démarrer une partie 2 joueurs 3) Charger une sauvegarde, vous permet de reprendre une partie préalablement enregistrée (cf. III.2) 4) Tableau des scores, vous permet de consulter le tableau des scores si vous avez déjà effectué une ou plusieurs parties. Seuls les meilleurs scores seront enregistrés 5) Aide, vous permet de consulter les règles du jeu ainsi que des renseignements sur l équipe de conception 6) Quitter, vous permet de quitter le jeu 2. Lancement d une partie 2 joueurs Si vous désirez jouer une partie 2 joueurs, vous devrez saisir 2 dans le menu principal. Après cela, vous devrez saisir, un par un, vos pseudos puis la partie commencera. Les couleurs de pions sont réparties aléatoirement, les pions noirs jouent en premier. 158

162 3. Lancement d une partie contre l ordinateur Si vous désirez jouer une partie contre l ordinateur, vous devrez saisir 1 dans le menu principal. Après avoir saisi votre pseudo, vous devrez choisir la stratégie avec laquelle évoluera l ordinateur, 3 choix s offrent à vous : 1) L ordinateur jouera un coup au hasard 2) L ordinateur jouera le coup qui lui rapportera le plus de pions 3) l ordinateur calculera 2 coups d avance afin de trouver les meilleurs coups Ce choix effectué, vous commencerez la partie. 4. Déroulement d une partie Peu importe le mode de jeu choisi, le déroulement d une partie est toujours le même. Le joueur devra poser un pion suivant les règles officielles du jeu (cf. IV.2). Lors de votre tour, plusieurs options vous sont proposées : a) Saisir les coordonnées d une case sous la forme lettre suivie d un chiffre (ex : A1) b) Saisir M ou m, vous permettra d afficher le menu et ainsi de quitter et de sauvegarder votre partie c) Saisir P ou p, afin de passer votre tour Plateau de départ du jeu 159