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;
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
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;
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){
try{
p.activer();
}
catch(ActivationImpossibleException e ){
System.out.println(e);
public void executer() {
if (!estMort()){
Porte p = this.trouverPorteOuverte();
if (p != null ) {
try{
this.franchir(p);
}
catch(PorteFermeException e){
System.out.println("la porte" + p.getNom() + "est fermé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
*/
private void echangerObjets(){
List<Objet> objetsPiece = getPiece().getObjets().stream().filter(Objet::estDeplacable).collect(Collectors.toList());
List<Objet> objetsMonstre = getObjets().stream().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);
}
for(int i = objetsMonstre.size()-1; i>=0 ; i--){
try{
deposer(objetsMonstre.get(i));
}
catch(ObjetNonPossedeParLeVivantException e ){
System.out.println(objetsMonstre.get(i).getNom() + " Pas dans " + getNom());
}
objetsMonstre.remove(objetsMonstre.get(i));
* 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
*/
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());
List<Objet> tmp = new ArrayList<>();
for (Objet o : objPiece) {
tmp.add(o);
this.getPiece().retirer(o);
}
for (Objet o2 : objMonstre) {
this.getPiece().deposer(o2);
this.deposer(o2);
}
for(Objet o3 : tmp) {
this.prendre(o3);
}
}
/**
* executer execute l'action voulu
*/
public void executer(){
if(getPointVie() > 0){
changerPiece();
echangerObjets();
}
* trouverPorteOuverte methode qui permet de trouver une porte ouverte parmi les portes entourant la piece
* @return la porte ouverte trouvée aléatoirement
*/
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);
}
}
......
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{
monde = new Monde("monde");
piece = new Piece(monde, "piece");
monstre = new Monstre("monstre", monde, 10, 10, piece, new PiedDeBiche("a1", monde), new PiedDeBiche("a2",monde));
piece1 = new Piece(monde, "piece1");
piece1.deposer(new PiedDeBiche("b1", monde));
piece1.deposer(new PiedDeBiche("b2", monde));
porte1 = new Porte("porte1", monde, piece, piece1);
piece2 = new Piece(monde, "piece2");