Commit e850d8d5 authored by Aroubate Hamza's avatar Aroubate Hamza
Browse files

Début TP7

parent e5c3248e
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
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");
}
}
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
package fr.insarouen.asi.prog.asiaventure.elements; 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. * Executable est l'interface qui permet d'executer un objet.
*/ */
...@@ -8,5 +10,5 @@ public interface Executable { ...@@ -8,5 +10,5 @@ public interface Executable {
/** /**
* executer execute l'action programmée. * executer execute l'action programmée.
*/ */
void executer(); void executer() throws CommandeImpossiblePourLeVivantException;
} }
\ No newline at end of file
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
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
package fr.insarouen.asi.prog.asiaventure.elements.vivants; 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.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.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.objets.ObjetNonDeplacableException;
import fr.insarouen.asi.prog.asiaventure.elements.structure.Piece; import fr.insarouen.asi.prog.asiaventure.elements.structure.ObjetAbsentDeLaPieceException;
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.PorteInexistanteDansLaPieceException; 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.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.ArrayList;
import java.util.stream.Collectors; 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 : * Classe héritant de Vivant définissant un Monstre possèdant 6 attributs :
...@@ -24,7 +35,7 @@ import java.util.stream.Collectors; ...@@ -24,7 +35,7 @@ import java.util.stream.Collectors;
* piece : la Piece où le Monstre se trouve * 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 * 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 * Constructeur de Montre
* @param nom nom du monstre * @param nom nom du monstre
...@@ -40,81 +51,90 @@ public class Monstre extends Vivant { ...@@ -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(){ public void executer() {
List<Porte> portesOuvrables = getPiece().getPortes().stream().filter(p -> ( (p.getEtat() == Etat.OUVERT) || (p.getEtat() == Etat.FERME) ) ).collect(Collectors.toList()); if (!estMort()){
Collections.shuffle(portesOuvrables); Porte p = this.trouverPorteOuverte();
Porte p = portesOuvrables.iterator().next(); if (p != null ) {
Boolean aOuvert = false; try{
if (p.getEtat()==Etat.FERME){ this.franchir(p);
try{ }
p.activer(); catch(PorteFermeException e){
} System.out.println("la porte" + p.getNom() + "est fermée" );
catch(ActivationImpossibleException e ){ }
System.out.println(e); catch(PorteInexistanteDansLaPieceException e){
System.out.println("la porte" + p.getNom() + "n'existe pas dans la pièce" );
}
this.setPointDeVie(this.getPointVie() -1);
try{
echangerObjets();
}
catch(ObjetNonPossedeParLeVivantException e){
System.out.println(e);
}
catch(ObjetAbsentDeLaPieceException e){
System.out.println(e);
}
catch(ObjetNonDeplacableException e){
System.out.println(e);
}
} }
aOuvert = true;
}
try{
franchir(p);
}
catch(PorteFermeException e ){
System.out.println(e);
}
catch(PorteInexistanteDansLaPieceException e ){
System.out.println(e);
} }
else
System.out.println(this.getNom()+" est mort !");
}
if(aOuvert)
try{
p.activer();
}
catch(ActivationImpossibleException e ){
System.out.println(e);
}
setPointDeVie(getPointVie()-1);
/**
* 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
private void echangerObjets(){ * @throws ObjetAbsentDeLaPieceException Declenchee lorsque l'objet est absent de la piece
List<Objet> objetsPiece = getPiece().getObjets().stream().filter(Objet::estDeplacable).collect(Collectors.toList()); * @throws ObjetNonDeplacableException Declenchee lorsque l'objet n'est pas deplacable
List<Objet> objetsMonstre = getObjets().stream().collect(Collectors.toList()); */
public void echangerObjets() throws ObjetNonPossedeParLeVivantException,ObjetAbsentDeLaPieceException,ObjetNonDeplacableException{
for(Objet o: objetsPiece) List<Objet> objPiece = this.getPiece().getObjets().stream().filter(Objet::estDeplacable).collect(Collectors.toList());
try{ List<Objet> objMonstre = this.getObjets().stream().filter(Objet::estDeplacable).collect(Collectors.toList());
prendre(o);///On est sencé les retirer pour les remmettre dans la piece ici c'est pas fait
} List<Objet> tmp = new ArrayList<>();
catch(ObjetAbsentDeLaPieceException e ){
System.out.println(o.getNom() + " Pas dans " + getPiece().getNom()); for (Objet o : objPiece) {
} tmp.add(o);
catch(ObjetNonDeplacableException e ){ this.getPiece().retirer(o);
System.out.println(e); }
}
for (Objet o2 : objMonstre) {
for(int i = objetsMonstre.size()-1; i>=0 ; i--){ this.getPiece().deposer(o2);
try{ this.deposer(o2);
deposer(objetsMonstre.get(i)); }
}
catch(ObjetNonPossedeParLeVivantException e ){ for(Objet o3 : tmp) {
System.out.println(objetsMonstre.get(i).getNom() + " Pas dans " + getNom()); this.prendre(o3);
}
objetsMonstre.remove(objetsMonstre.get(i));
} }
} }
/** /**
* 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){ public Porte trouverPorteOuverte() {
changerPiece(); List<Porte> listePortesOuvertes = this.getPiece().getPortes().stream().filter(p->p.getEtat()==Etat.OUVERT || p.getEtat()==Etat.CASSE).collect(Collectors.toList());
echangerObjets(); Collections.shuffle(listePortesOuvertes);
}
if (listePortesOuvertes.size()==0)return null;
return listePortesOuvertes.get(0);
} }
} }
......
package fr.insarouen.asi.prog.asiaventure.elements.vivants; 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 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.ObjetNonDeplacableException;
import fr.insarouen.asi.prog.asiaventure.elements.objets.*; import fr.insarouen.asi.prog.asiaventure.elements.structure.Piece;
import fr.insarouen.asi.prog.asiaventure.elements.structure.*; import fr.insarouen.asi.prog.asiaventure.Monde;
import fr.insarouen.asi.prog.asiaventure.elements.*; import fr.insarouen.asi.prog.asiaventure.NomDEntiteDejaUtiliseDansLeMondeException;
import fr.insarouen.asi.prog.asiaventure.elements.vivants.*; 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 class TestMonstre {