Début TP7

ITIAdventure/src/exemplesimulation1.txt

+Monde LeMondeimpitoyabledASI
+Piece BureauDesNicolas
+Piece BureauDuDirecteur
+Piece BureauDeRakoto
+Piece BureauDeGasso
+Piece Couloir
+PorteSerrure Porte1 Couloir BureauDesNicolas
+PorteSerrure Porte2 Couloir BureauDuDirecteur
+Porte Porte3 Couloir BureauDeRakoto
+Porte Porte4 Couloir BureauDeGasso
+Porte Trappe BureauDeRakoto BureauDuDirecteur
+Porte PassageSecret BureauDesNicolas BureauDeGasso
+Clef Porte1 BureauDeRakoto
+Clef Porte2 BureauDeGasso
+JoueurHumain Etudiant1 10 10 Couloir
\ No newline at end of file

ITIAdventure/src/fr/insarouen/asi/prog/asiaventure/Main.java

+package fr.insarouen.asi.prog.asiaventure;
+
+import fr.insarouen.asi.prog.asiaventure.NomDEntiteDejaUtiliseDansLeMondeException;
+
+import java.util.Scanner;
+import java.io.FileReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.FileNotFoundException;
+import java.lang.ClassNotFoundException;
+
+public class Main {
+    private Simulateur simu;
+
+    /**
+	* Constructeur du Main
+	*/
+    public Main() {
+        
+    }
+
+    /**
+	* afficherMenu affiche le menu du jeu
+	*/
+    private void afficherMenu() {
+        System.out.println("\n --- Menu --- ");
+        System.out.println("1/ jouer ");
+        System.out.println("2/ charger un fichier de description ");
+        System.out.println("3/ sauver la partie actuelle ");
+        System.out.println("4/ charger une partie ");
+        System.out.println("5/ quitter \n");
+    }
+}

ITIAdventure/src/fr/insarouen/asi/prog/asiaventure/Simulateur.java

+package fr.insarouen.asi.prog.asiaventure;
+
+import fr.insarouen.asi.prog.asiaventure.elements.objets.Objet;
+import fr.insarouen.asi.prog.asiaventure.Monde;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.Piece;
+import fr.insarouen.asi.prog.asiaventure.elements.objets.serrurerie.Clef;
+import fr.insarouen.asi.prog.asiaventure.elements.vivants.JoueurHumain;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.Porte;
+
+import java.util.Scanner;
+import java.io.Reader;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/** 
+* Classe définissant un Simulateur de notre jeu possèdant 3 attributs :
+* monde : le Monde du Simulateur ; 
+* conditionsDeFin : les conditions de fin de notre simulation ;
+* etatDuJeu : l'EtatDuJeu actuel ;
+*/
+public class Simulateur {
+
+    // public Simulateur(Monde monde, ConditionDeFin... conditionsDeFin){
+
+    // }
+
+    // public Simulateur(ObjectInputStream ois) throws IOException {
+
+    // }
+
+    /**
+    * Simulateur constructeur de Simulateur
+    * @param ois le stream à lire
+    * @throws IOException
+    * @throws NomDEntiteDejaUtiliseDansLeMondeException
+    */
+    public Simulateur(Reader reader) throws IOException, NomDEntiteDejaUtiliseDansLeMondeException {
+        Scanner sc = new Scanner(reader);
+        String mot;
+        String temp;
+        Monde monde = null;
+        String porte;
+        String piece;
+        JoueurHumain joueurHumain;
+        Map < String,Piece > pieces = new HashMap< String,Piece>();
+        Map < String,Porte > portes = new HashMap< String,Porte>();
+        Map < String,Clef > clefs = new HashMap< String,Clef>();
+        while (sc.hasNext()){
+
+            switch(sc.next()){
+
+                case "Monde":
+                    monde = new Monde(sc.next());
+                    break;
+                case "Piece":
+                    temp = sc.next();
+                    try{
+                        pieces.put(temp, new Piece(monde, temp));
+                    }
+                    catch(NomDEntiteDejaUtiliseDansLeMondeException e){
+                        System.out.println(e);
+                    }
+                    break;
+                case "PorteSerrure":
+                    temp = sc.next();
+                    try{
+                        portes.put(temp, new Porte(temp, monde, pieces.get(sc.next()), pieces.get(sc.next())));
+                    }
+                    catch(NomDEntiteDejaUtiliseDansLeMondeException e){
+                        System.out.println(e);
+                    }
+                    break;
+                case "Porte":
+                    temp = sc.next();
+                    try{
+                        portes.put(temp, new Porte(temp, monde, pieces.get(sc.next()), pieces.get(sc.next())));
+                    }
+                    catch(NomDEntiteDejaUtiliseDansLeMondeException e){
+                        System.out.println(e);
+                    }
+                    break;
+                case "Clef":
+                    porte = sc.next();
+                    piece = sc.next();
+                    //clefs.put(porte, portes.get(porte).getSerrure().creerClef());
+                    try{
+                        clefs.put(porte, pieces.get(piece).getPorte(porte).getSerrure().creerClef());
+                    }
+                    catch(NomDEntiteDejaUtiliseDansLeMondeException e){
+                        System.out.println(e);
+                    }
+                    break;
+                case "JoueurHumain":
+                    try{
+                        joueurHumain = new JoueurHumain(sc.next(), monde, Integer.parseInt(sc.next()) , Integer.parseInt(sc.next()) , pieces.get(sc.next()));
+                    }
+                    catch(NomDEntiteDejaUtiliseDansLeMondeException e){
+                        System.out.println(e);
+                    }
+                    break;
+            }
+        }
+        
+    }
+    
+    /**
+    * enregistrer permet d'enregistrer le jeu
+    * @param oos La partie a enregistrer
+    */
+    public void enregistrer(ObjectOutputStream oos) {
+
+    }
+
+    /**
+    * ajouterConditionsDeFin permet d'ajouter des conditions de fin
+    * @param conditions Conditions de fin a ajouter
+    */
+    public void ajouterConditionsDeFin(Collection<ConditionDeFin> conditions) {
+
+    }
+
+    /**
+    * ajouterConditionDeFin permet d'ajouter une condition de fin
+    * @param condition Condition de fin a ajouter
+    */
+    public void ajouterConditionDeFin(ConditionDeFin condition) {
+
+    }
+
+    /**
+    * executerUnTour permet d'executer un tour
+    * @return Etat du jeu apres execution du tour
+    * @throws Throwable Eventuelles erreurs
+    */
+    public EtatDuJeu executerUnTour() throws Throwable {
+        return null;
+    }
+
+    /**
+    * executerNbTours permet d'executer plusieurs tours
+    * @param nb Nombre de tours
+    * @return Etat du jeu apres executions des tours
+    * @throws Throwable Eventuelles erreurs
+    */
+    public EtatDuJeu executerNbTours(int nb) throws Throwable {
+        return null;
+    }
+
+    /**
+    * executerJusquALaFin permet d'executer le jeu jusqu'a la fin
+    * @return Etat du jeu apres execution a la fin
+    * @throws Throwable Eventuelles erreurs
+    */
+    public EtatDuJeu executerJusquALaFin() throws Throwable {
+        return null;
+    }
+
+    /**
+    * stopperJeu permet de stopper le jeu
+    */
+    public void stopperJeu() {
+    }
+}
\ No newline at end of file

ITIAdventure/src/fr/insarouen/asi/prog/asiaventure/elements/Executable.java

 package fr.insarouen.asi.prog.asiaventure.elements;
 
+import fr.insarouen.asi.prog.asiaventure.elements.vivants.CommandeImpossiblePourLeVivantException;
+
 /**
  * Executable est l'interface qui permet d'executer un objet.
  */
@@ -8,5 +10,5 @@ public interface Executable {
     /**
     * executer execute l'action programmée.
     */
-    void executer();
+    void executer() throws CommandeImpossiblePourLeVivantException;
 }
\ No newline at end of file

ITIAdventure/src/fr/insarouen/asi/prog/asiaventure/elements/vivants/CommandeImpossiblePourLeVivantException.java

+package fr.insarouen.asi.prog.asiaventure.elements.vivants;
+
+
+public class CommandeImpossiblePourLeVivantException extends VivantException{
+
+    public CommandeImpossiblePourLeVivantException(){
+
+    }
+
+    public CommandeImpossiblePourLeVivantException(String msg){
+        super(msg);
+    }
+}
\ No newline at end of file

ITIAdventure/src/fr/insarouen/asi/prog/asiaventure/elements/vivants/JoueurHumain.java

+package fr.insarouen.asi.prog.asiaventure.elements.vivants;
+
+import fr.insarouen.asi.prog.asiaventure.elements.objets.Objet;
+import fr.insarouen.asi.prog.asiaventure.Monde;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.Piece;
+import fr.insarouen.asi.prog.asiaventure.NomDEntiteDejaUtiliseDansLeMondeException;
+import fr.insarouen.asi.prog.asiaventure.elements.objets.ObjetNonDeplacableException;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.ObjetAbsentDeLaPieceException;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.PorteInexistanteDansLaPieceException;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.PorteFermeException; 
+import fr.insarouen.asi.prog.asiaventure.elements.ActivationException; 
+import fr.insarouen.asi.prog.asiaventure.elements.vivants.CommandeImpossiblePourLeVivantException;
+
+
+public class JoueurHumain extends Vivant{
+    private String ordre;
+
+    public JoueurHumain(String nom, Monde monde, int pointVie, int pointForce, Piece piece, Objet... objets) throws NomDEntiteDejaUtiliseDansLeMondeException{
+        super(nom, monde, pointVie, pointForce, piece, objets);
+    }
+
+    public void setOrdre(String ordre){
+        this.ordre = ordre;
+    }
+
+    private void commandePrendre(String obj) throws ObjetAbsentDeLaPieceException, ObjetNonDeplacableException{
+        prendre(obj);
+    }
+
+    private void commandePoser(String obj) throws ObjetNonPossedeParLeVivantException{
+        deposer(obj);
+    }
+
+    private void commandeFranchir(String nomPorte) throws PorteFermeException, PorteInexistanteDansLaPieceException{
+        franchir(nomPorte);
+    }
+
+    private void commandeOuvrirPorte(String nomPorte) throws ActivationException, PorteInexistanteDansLaPieceException{
+        getPiece().getPorte(nomPorte).activer();
+    }
+
+    private void commandeOuvrirPorte(String nomPorte, String nomObjet) throws ActivationException, PorteInexistanteDansLaPieceException, ObjetNonPossedeParLeVivantException{
+        getPiece().getPorte(nomPorte).activerAvec(getObjet(nomObjet));
+    }
+
+    public void executer() throws CommandeImpossiblePourLeVivantException{
+
+    }
+}
\ No newline at end of file

ITIAdventure/src/fr/insarouen/asi/prog/asiaventure/elements/vivants/Monstre.java

 package fr.insarouen.asi.prog.asiaventure.elements.vivants;
 
+import fr.insarouen.asi.prog.asiaventure.elements.objets.Objet;
 import fr.insarouen.asi.prog.asiaventure.Monde;
+import fr.insarouen.asi.prog.asiaventure.elements.Entite;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.Piece;
 import fr.insarouen.asi.prog.asiaventure.NomDEntiteDejaUtiliseDansLeMondeException;
-import fr.insarouen.asi.prog.asiaventure.elements.objets.Objet;
-import fr.insarouen.asi.prog.asiaventure.elements.structure.ObjetAbsentDeLaPieceException;
 import fr.insarouen.asi.prog.asiaventure.elements.objets.ObjetNonDeplacableException;
-import fr.insarouen.asi.prog.asiaventure.elements.structure.Piece;
-import fr.insarouen.asi.prog.asiaventure.elements.structure.Porte;
-import fr.insarouen.asi.prog.asiaventure.elements.structure.PorteFermeException;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.ObjetAbsentDeLaPieceException;
 import fr.insarouen.asi.prog.asiaventure.elements.structure.PorteInexistanteDansLaPieceException;
-import fr.insarouen.asi.prog.asiaventure.elements.ActivationImpossibleException;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.PorteFermeException;
 import fr.insarouen.asi.prog.asiaventure.elements.Etat;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.Porte;
+import fr.insarouen.asi.prog.asiaventure.elements.Activable;
+import fr.insarouen.asi.prog.asiaventure.elements.ActivationImpossibleException;
+import fr.insarouen.asi.prog.asiaventure.elements.ActivationException;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.Porte;
+import fr.insarouen.asi.prog.asiaventure.elements.Executable;
 
-import java.util.*;
-import java.util.stream.Collectors;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.stream.Collectors;;
 
 /** 
  * Classe héritant de Vivant définissant un Monstre possèdant 6 attributs :
@@ -24,7 +35,7 @@ import java.util.stream.Collectors;
  * piece : la Piece où le Monstre se trouve
  * objets : le dictionnaire des Objets que le Monstre possède, en clé leur nom et en valeur l'Objet
  */
-public class Monstre extends Vivant {
+public class Monstre extends Vivant implements Executable{
     /**
      * Constructeur de Montre
      * @param nom nom du monstre
@@ -40,81 +51,90 @@ public class Monstre extends Vivant {
     }
 
     /**
-	* changerPiece permet de changer la piece en passant par une porte ouverte parmi les portes entourant la piece
+	* executer comportement du monstre
 	*/
-    private void changerPiece(){
-        List<Porte> portesOuvrables = getPiece().getPortes().stream().filter(p -> ( (p.getEtat() == Etat.OUVERT) || (p.getEtat() == Etat.FERME) )  ).collect(Collectors.toList());
-        Collections.shuffle(portesOuvrables);
-        Porte p = portesOuvrables.iterator().next();
-        Boolean aOuvert = false;
-        if (p.getEtat()==Etat.FERME){
+    public void executer()  {
+        if (!estMort()){
+            Porte p = this.trouverPorteOuverte();
+            if (p != null ) {
                 try{
-                p.activer();
+                    this.franchir(p);
                 }
-            catch(ActivationImpossibleException e ){
-                System.out.println(e);
+                catch(PorteFermeException e){
+                    System.out.println("la porte" + p.getNom() + "est fermée" );
                 }
-           
-            aOuvert = true;
+                catch(PorteInexistanteDansLaPieceException e){
+                    System.out.println("la porte" + p.getNom() + "n'existe pas dans la pièce" );
                 }
-            
+                this.setPointDeVie(this.getPointVie() -1);
                 try{
-            franchir(p);
+                    echangerObjets();
                 }
-        catch(PorteFermeException e ){
+                catch(ObjetNonPossedeParLeVivantException e){
                     System.out.println(e);
                 }
-        catch(PorteInexistanteDansLaPieceException e ){
+                catch(ObjetAbsentDeLaPieceException e){
+                    System.out.println(e);
+                }
+                catch(ObjetNonDeplacableException e){
                     System.out.println(e);
                 }
                 
-        if(aOuvert)
-            try{
-                p.activer();
             }
-            catch(ActivationImpossibleException e ){
-                System.out.println(e);
         }
-        setPointDeVie(getPointVie()-1);
+        else
+            System.out.println(this.getNom()+" est mort !");
+    }
+
 
+    /**
+	* estMort methode qui permet de savoir si un monstre est mort
+	* @return boolean qui indique si le monstre est mort
+	*/
+    public boolean estMort() {
+        return this.getPointVie() == 0;
     }
 
+
     /**
-	 * echangerObjets echange les objets entre la piece et le monstre où il se trouve
+	* echangerObjets echange les objets entre la piece et le monstre
+	* @throws ObjetNonPossedeParLeVivantException Declenchee lorsque l'objet n'est pas possede par le monstre
+    * @throws ObjetAbsentDeLaPieceException Declenchee lorsque l'objet est absent de la piece
+    * @throws ObjetNonDeplacableException Declenchee lorsque l'objet n'est pas deplacable
 	*/
-    private void echangerObjets(){
-        List<Objet> objetsPiece = getPiece().getObjets().stream().filter(Objet::estDeplacable).collect(Collectors.toList());
-        List<Objet> objetsMonstre = getObjets().stream().collect(Collectors.toList());
+    public void echangerObjets() throws ObjetNonPossedeParLeVivantException,ObjetAbsentDeLaPieceException,ObjetNonDeplacableException{
+        List<Objet> objPiece   = this.getPiece().getObjets().stream().filter(Objet::estDeplacable).collect(Collectors.toList());
+        List<Objet> objMonstre = this.getObjets().stream().filter(Objet::estDeplacable).collect(Collectors.toList());
 
-        for(Objet o: objetsPiece)
-            try{
-                prendre(o);///On est sencé les retirer pour les remmettre dans la piece ici c'est pas fait
-            } 
-            catch(ObjetAbsentDeLaPieceException e ){
-                System.out.println(o.getNom() + " Pas dans " + getPiece().getNom());
-            }
-            catch(ObjetNonDeplacableException e ){
-                System.out.println(e);
-            }
+        List<Objet> tmp = new ArrayList<>();
 
-        for(int i = objetsMonstre.size()-1; i>=0 ; i--){
-            try{
-                deposer(objetsMonstre.get(i));
+        for (Objet o : objPiece) {
+            tmp.add(o);
+            this.getPiece().retirer(o);
         }
-            catch(ObjetNonPossedeParLeVivantException e ){
-                System.out.println(objetsMonstre.get(i).getNom() + " Pas dans " + getNom());
+
+        for (Objet o2 : objMonstre) {
+            this.getPiece().deposer(o2);
+            this.deposer(o2);
         }
-            objetsMonstre.remove(objetsMonstre.get(i));
+
+        for(Objet o3 : tmp) {
+            this.prendre(o3);
         }
+        
     }
+
+
     /**
-	 * executer execute l'action voulu
+	* trouverPorteOuverte methode qui permet de trouver une porte ouverte parmi les portes entourant la piece
+	* @return la porte ouverte trouvée aléatoirement
 	*/
-    public void executer(){
-        if(getPointVie() > 0){
-            changerPiece();
-            echangerObjets();
-        }
+    public Porte trouverPorteOuverte() {
+        List<Porte> listePortesOuvertes = this.getPiece().getPortes().stream().filter(p->p.getEtat()==Etat.OUVERT || p.getEtat()==Etat.CASSE).collect(Collectors.toList());
+        Collections.shuffle(listePortesOuvertes);
+
+        if (listePortesOuvertes.size()==0)return null;
+        return listePortesOuvertes.get(0);
     }
 
 }

ITIAdventure/srctest/fr/insarouen/asi/prog/asiaventure/elements/vivants/TestMonstre.java

 package fr.insarouen.asi.prog.asiaventure.elements.vivants;
 
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.hamcrest.core.IsEqual;
 import org.junit.Test;
-import java.util.*;
+import static org.junit.Assert.assertThat;
+import static org.hamcrest.core.IsEqual.equalTo;
+import org.hamcrest.core.IsEqual;
+import org.junit.Before;
+import static org.hamcrest.core.Is.is;
 
-import fr.insarouen.asi.prog.asiaventure.*;
-import fr.insarouen.asi.prog.asiaventure.elements.objets.*;
-import fr.insarouen.asi.prog.asiaventure.elements.structure.*;
-import fr.insarouen.asi.prog.asiaventure.elements.*;
-import fr.insarouen.asi.prog.asiaventure.elements.vivants.*;
+import fr.insarouen.asi.prog.asiaventure.elements.objets.ObjetNonDeplacableException;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.Piece;
+import fr.insarouen.asi.prog.asiaventure.Monde;
+import fr.insarouen.asi.prog.asiaventure.NomDEntiteDejaUtiliseDansLeMondeException;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.ObjetAbsentDeLaPieceException;
+import fr.insarouen.asi.prog.asiaventure.elements.objets.Objet;
+import fr.insarouen.asi.prog.asiaventure.elements.objets.PiedDeBiche;
+import fr.insarouen.asi.prog.asiaventure.elements.structure.Porte;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
 
 public class TestMonstre {
-    public Monde monde;
-    public Piece piece;
-    public Piece piece1;
-    public Piece piece2;
-    public Porte porte1;
-    public Porte porte2;
+    public Monde m;
+    public Piece p;
     public Monstre monstre;
-    private PiedDeBiche pdb;
-    private PiedDeBiche pdb1;
 
     @Before
-    public void init()throws NomDEntiteDejaUtiliseDansLeMondeException{
+    public void init() throws Exception{
+        m = new Monde("monde1");
+    }
+
+    @Test
+    public void test_executer(){
+        try {
+            Piece piece1 = new Piece(m, "piece1");
+            Piece piece2 = new Piece(m, "piece2");
+            Piece piece3 = new Piece(m, "piece3");
+            Piece piece4 = new Piece(m, "piece4");
+
+            Porte p1 = new Porte("porte1",m,piece1,piece4);
+            Porte p2 = new Porte("porte2",m,piece2,piece3);
+            Porte p3 = new Porte("porte3",m,piece4,piece3);
+
+            Objet objet1 = new Objet("objet1",m){
+                public boolean estDeplacable(){return false;}
+            };
+            PiedDeBiche pdb = new PiedDeBiche("pdb1",m);
+
+            p1.activer();