R3.04 - concept. et prog. objet

1°/ Objectif

• Le moteur de jeu des TPs précédent est modifié pour intégrer un réseau de villes, chaque ville abritant une population.
  
• A chaque tour, une partie des personnes (par famille notamment) de chaque population va migrer d'une ville à une autre.
• Pour cela, on va lire le maillage constitué par les villes dans un fichier texte et constituer ainsi un graphe orienté pondéré.
• Du côté des humains, on va ajouter la notion de famille en permettant à chaque humain de référencer ses ascendants et descendants.
  

• Créez le fichier Vertex.java, à partir du code suivant :

import java.util.*;
 
class Vertex {
 
    Set<Edge> edgesFrom; // set of edges that come from other vertices
    Set<Edge> edgesTo; // set of edges that go to other vertices
    Population pop;
    String name;
 
    public Vertex(Population pop, String name) {
	edgesFrom = new HashSet<Edge>();
	edgesTo = new HashSet<Edge>();
	this.pop = pop;
	this.name = name;
    }
 
    public void setPopulation(Population pop) {
	this.pop = pop;
    }
 
    public String toString() {
	return name+" : "+pop;
    }
}

• Créez le fichier Edge.java à partir du code suivant :
  

class Edge {
 
    Vertex from;
    Vertex to;
    double weight;
 
    public Edge(double weight) {
	from = null;
	to = null;
	this.weight = weight;
    }
 
    public Edge(Vertex from, Vertex to, double weight) {
	this.from = from;
	this.to = to;
	this.weight = weight;
    }
 
    public String toString() {
	return "edge from "+from.name+" to "+to.name;
    }
}

import java.util.*;
 
class GraphOP {
 
    public List<Vertex> vertices;
    public int nbVertices;
    public int nbEdges;
 
    public GraphOP() {
	vertices = new ArrayList<Vertex>();
	nbVertices = 0;
	nbEdges = 0;
    }
 
    public Vertex createVertex(Population pop, String name) {
	Vertex v = new Vertex(pop, name);
	vertices.add(v);
	nbVertices += 1;
	return v;
    }
 
    public void connectVertices(Vertex src, Vertex dest, double weight) {
	Edge e = new Edge(src,dest,weight);
	src.edgesTo.add(e);
	dest.edgesFrom.add(e);
	nbEdges += 1;
    }
 
    public boolean disconnectVertices(Vertex src, Vertex dest) {
	boolean connOk = false;
	for( Edge e : src.edgesTo) {
	    if (e.to == dest) {
		connOk = true;
		src.edgesTo.remove(e);
		dest.edgesFrom.remove(e);
		break;
	    }
	}
	return connOk;
    }
 
    public void createFromFile(String fileName) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(fileName));
        int nb = Integer.parseInt(br.readLine());
        String line = "";
        for(int i=0;i<nb;i++) {
            line = br.readLine();
            String[] parts = line.split(",");
            createVertex(null, parts[1]);            
        }
        line = "a";
        while ((line !=null) && (!line.isEmpty())) {
            line = br.readLine();
            String[] parts = line.split(",");
            int from = Integer.parseInt(parts[0]) -1;
            int to = Integer.parseInt(parts[1]) -1;
            double dist = Double.parseDouble(parts[2]);
            connectVertices(vertices.get(from), vertices.get(to), dist);
        }
    }

    public void createFromArray(String[] towns, double[] connections) {
        // à compléter
    }
}

7
Bordeaux
Lyon
Marseille
Paris
Rennes
Strasbourg
Toulouse
1,2,700
1,3,500
1,4,750
1,7,200
2,1,700
2,3,300
...

abstract class Humain {
  ...
  boolean dead;
 
  // ajouts attributs d'ascendance/descendance
  protected Humain pere;
  protected Humain mere;
  protected Set<humain> enfants;
  ...
  // modif méthodes
  public void vieillir() {
    age++;
    if (age > esperanceVie) dead = true;
  }
  public boolean isDead() {
    if ((dead)||(age > esperanceVie)) return true;
    return false;
  }
 
  // ajout méthodes
  public void mourrir() {
    dead = true;
    // à compléter
  }
  public void setParents(Humain pere, Humain mere) {
    // à compléter
  }
 
  public void addChild(Humain enfant) {
    // à compléter
  }
 
  public Set<Humain> getAscendants(int nbLevel) {
    // à compléter
  }
 
  public Set<Humain> getDescendants(int nbLevel) {
    // à compléter
  }
}

Copiez/collez les sources du TP4 et modifiez les pour que :

• le programme principal ait un nouveau paramètre qui représente le nom du fichier texte contenant la description du graphe des ville (cf. section 2.1)
• le moteur de jeu contienne une nouvelle variable GraphOP towns. Si un nom de fichier a été donné en paramètre, towns est initialisé grâce à ce fichier. Sinon, on utilise des tableaux écrits directement dans le code (cf. createFromArray() )
• pour chaque ville de towns, on crée une population initiale comme dans les TPs précédents.
• à chaque tour de jeu :
  • pour chaque ville, on organise les rencontres comme dans les TPs précédents.
  • pour chaque ville :
    • on tire aléatoirement un nbMove compris entre 0 et 3.
    • pour i de 0 à nbMove :
      
      • on choisit aléatoirement un humain h dans la population,
      • on tire aléatoirement un entier nbLevel entre 1 et 3,
      • on récupère les sets des ascendants/descendants de niveau nbLevel de h, puis on met les 2 sets ET h dans un même Set<Humain> famille.
      • on tire aléatoirement une ville de destination parmi les villes directement connectées à la ville courante.
      • on déplace famille dans la population de cette ville. Mais comme les routes sont dangereuses, tirez aléatoirement un entier nbMorts entre 0 et min (3,taille famille), et ensuite tirez nbMorts humains dans famille et faîtes les mourrir (sans oublier de les enlever de famille)
    • on fait vieillir la population.

• Pour implémenter ce moteur de jeu, il est conseillé de définir de nouvelles méthodes. A vous de trouver lesquelles et où les définir.