Cours CNAM par J. Laforgue

Exercice01_Agents

Retour

Télécharger

Le code de l'exercice 01.
Une partie de ce code est commentée dans la correction des diagrammes.
L'exécution de ce programme est présenté en cours.
Une lecture globale de ce code est réalisée en cours.

      README.txt
      Joueur1
         Agent_Agressif.java
         Agent_Collant.java
         Agent_Couard.java
         compil.bat
      Joueur2
         Agent_Agressif2.java
         Agent_Ensemble.java
         Agent_Prudent.java

package fr.cnam.joueur;

import java.rmi.*;
import fr.cnam.espacetore.*;

import fr.cnam.espacetore.EspaceToreODInt;
import fr.cnam.joueur.FactoryAgentInt;

public class Agent_Prudent extends Agent 
{
    int nbFuire;
    public Agent_Prudent(int couleur,
              FactoryAgentInt factory,
              int portRMI) throws RemoteException
    {
        super(couleur,
              factory,
              portRMI);
        nbFuire = 0;
    }

public void deplacer()
    {
        try{
            if (! espace.getModeCombat())
                {
                    fuireEnnemie();
                    if (! deplacerEnsemble(10))
                        super.deplacer();
                }
            else
                {
                  if ( (getNbVie()<5) && (nbFuire<50) )
                        {
                            if (! fuireEnnemie())
                                super.deplacer();
                            nbFuire++;
                        }
                    else
                        {
                          deplacerEnnemie();
                          super.deplacer();
                        }
                }

}catch(Exception ex){System.out.println(ex);ex.printStackTrace();};
    }
}

         compil.bat
      compil.bat
      fr
         cnam
            clientihm
               IHMVisuJeuPull.java

package fr.cnam.clientihm;

import java.rmi.*;
import java.rmi.registry.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

import fr.cnam.espacetore.*;
import fr.cnam.grille.*;
import fr.cnam.clientihm.*;
import fr.cnam.util.*;
import fr.cnam.ihm.*;

// Classe de visualisation de la grille de jeu
// Mode de communication avec l'espace de Tore : Pull
// Cette ihm tire l'etat de la grille de l'espace de Tore
//
public class IHMVisuJeuPull implements FormulaireInt
{
    private CanvasIHM  grilleihm;
    private EspaceToreODInt espace;

public static void main(String... args) throws Exception
    {
        new IHMVisuJeuPull(args);
    }

public IHMVisuJeuPull(String... args) throws Exception
    {
        // Port du serveur de socket RMI car pour etre notifie on cree un objet distribue
        // Si on cree plusieurs client sur la meme machine, il faut que ce port soit
        //  different
        // 
        Parametres params = new Parametres(args);

// Host de l'espace de tore
        String hostEspaceTore = params.getString("host_espace_tore","localhost");

// Port de l'espace de tore
        int portEspaceTore = params.getInt("port_annuaire",9100);

// Port RMI des agents
        int portRMI = params.getInt("port_od",9103);

String name = "rmi://"+hostEspaceTore+":"+
            portEspaceTore+"/"+
            EspaceToreOD.NOM_ESPACE_TORE;
        System.out.println(name);
        espace = (EspaceToreODInt)(Naming.lookup(name));
        
        // récrupération des tailles de la grille
        int nbX=espace.getNbX();
        int nbY=espace.getNbY();
        int tailleCellule=espace.getTailleCellule();
        int tailleCase = 15;

// On crée le formulaire
        Formulaire form = new Formulaire("GRILLE",this,nbX*tailleCase+20,nbY*tailleCase+20);

// On y ajoute la grille
        grilleihm = form.addGrilleIHM(nbX,nbY,tailleCase,null);
        form.afficher(50,50);

// Thread qui tire l'etat de la grille de l'espace de Tore
        ThreadPullPopulation t = new ThreadPullPopulation();
        t.start();
    }

public void     submit(Formulaire form,String nom)
    {
    }

// Classe de defintion du Thread de Pull
    // ----------------------------------------
    class ThreadPullPopulation extends Thread
    {
        public void run()
        {
            if (grilleihm==null)System.out.println("NULL");
            try{
                while (true)
                    {
                        // Pull de l'etat de la grille
                        CelluleGrille[][] grille = espace.getGrille();
                        //
                        for(int i=0;i<espace.getNbX();i++)
                            for(int j=0;j<espace.getNbY();j++)
                                if (grille[i][j]!=null)
                                    {
                                        if (grille[i][j].couleur!=grilleihm.getMarque(i,j))
                                            grilleihm.setMarque(grille[i][j].couleur,i,j);
                                    }
                                else
                                    if (grilleihm.getMarque(i,j)!=0)
                                        grilleihm.setMarque(0,i,j);
                        try{Thread.sleep(100);}catch(Exception ex){};
                    }
            }
            catch(Exception ex){System.out.println("erreur:"+ex);ex.printStackTrace();};
        }
    }
}

IHMVisuJeuPush.java

package fr.cnam.clientihm;

import java.rmi.*;
import java.rmi.registry.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

import fr.cnam.espacetore.*;
import fr.cnam.grille.*;
import fr.cnam.clientihm.*;
import fr.cnam.util.*;
import fr.cnam.ihm.*;

// Classe de visualisation de la grille de jeu
// Mode de communication entre l'espace de tore et cette IHM : Push
// Cette IHM utilise un DP Observer/Observable pour etre notifier
//  des mouvements des Agents
//
public class IHMVisuJeuPush implements FormulaireInt
{
    public static void main(String... args) throws Exception
    {
        new IHMVisuJeuPush(args);
    }

public IHMVisuJeuPush(String... args) throws Exception
    {
        // Port du serveur de socket RMI car pour etre notifie on cree un objet distribue
        // Si on cree plusieurs client sur la meme machine, il faut que ce port soit
        //  different
        // 
        Parametres params = new Parametres(args);

// Host de l'espace de tore
        String hostEspaceTore = params.getString("host_espace_tore","localhost");

// Port de l'espace de tore
        int portEspaceTore = params.getInt("port_annuaire",9100);

// Port RMI des agents
        int portRMI = params.getInt("port_od",9103);

String name = "rmi://"+hostEspaceTore+":"+
            portEspaceTore+"/"+
            EspaceToreOD.NOM_ESPACE_TORE;
        System.out.println(name);
        EspaceToreODInt espace = (EspaceToreODInt)(Naming.lookup(name));
        
        // récrupération des tailles de la grille
        int nbX=espace.getNbX();
        int nbY=espace.getNbY();
        int tailleCellule=espace.getTailleCellule();
        int tailleCase = 15;

// On crée le formulaire
        Formulaire form = new Formulaire("GRILLE",this,nbX*tailleCase+20,nbY*tailleCase+20);

// On y ajoute la grille
        CanvasIHM  grilleihm = form.addGrilleIHM(nbX,nbY,tailleCase,null);
        form.afficher(50,50);

// ==================================
        // Observer qui est notifie en RMI
        new ObserverEspaceToreRMI(portRMI,new ObserverGrille(grilleihm),espace);

}

public void     submit(Formulaire form,String nom)
    {
    }
}

ObserverEspaceToreRMI.java

package fr.cnam.clientihm;

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;

import fr.cnam.espacetore.*;

// Cet observer s'abonne a l'espace de tore distant. Il sera notifie quand
//  les agents se deplacent.
//  Il est un objet distribue qui envoie son stub a l'espace de tore afin d'etre notifie.
//
public class ObserverEspaceToreRMI extends UnicastRemoteObject implements ObserverRMIInt
{
    Observer observer; // L'objet cible de notification

// Constructeur
    public ObserverEspaceToreRMI(int portRMI,Observer observer,EspaceToreODInt espace ) throws RemoteException
    {
        super(portRMI);
        try{
            this.observer = observer;

// Recuperation du stub de l'objet distribue
            Remote stub = UnicastRemoteObject.toStub(this);

// On s'abonne aux changement des données 
            // Ici en RMI donc donner son stub en parametre
            //
            espace.addObserver(stub);

}catch(Exception ex){ex.printStackTrace();System.out.println("ObserverEspaceToreRMI: erreur dans le constructeur \n"+ex);};
    }

// Methode qui est appelée si une donnée change dans l'espace de tore
    //
    public void update(Observable observable, Object arg) throws RemoteException
    {
        // On relait la notification à l'objet cible
        observer.update(observable,arg);
    }
}

ObserverGrille.java

package fr.cnam.clientihm;

import java.util.*;

import fr.cnam.espacetore.*;
import fr.cnam.grille.*;
import fr.cnam.ihm.*;

// Classe d'observation qui est prévenu par update si une donnee change
//  dans l'espace de tore
//
public class ObserverGrille implements Observer
{
    private CanvasIHM grilleIHM;

public ObserverGrille(CanvasIHM grilleIHM)
    {
        this.grilleIHM = grilleIHM;
    }

// On recoit un changement de couleur d'une case de la grille de 
    //  l'espace de tore
    //
    public void update(Observable observable, Object arg)
    {
        String str="";
        try{
            str  = (String)(arg);
            String[] infos = str.split(" ");
            int x       = Integer.parseInt(infos[0]);
            int y       = Integer.parseInt(infos[1]);
            int couleur = Integer.parseInt(infos[2]);
            System.out.println(String.format("%3d %3d %3d",x,y,couleur));
            
            grilleIHM.setMarque(couleur,x,y);
        }catch(Exception ex) {System.out.println("update> [["+str+"]] "+ex);}
    }
        
}

               ObserverRMIInt.java
            espacetore
               CelluleGrille.java
               ControleurJeu.java
               EspaceTore.java

package fr.cnam.espacetore;

import java.awt.Point;
import java.util.*;
import java.rmi.*;

import fr.cnam.tore.*;
import fr.cnam.joueur.*;
import fr.cnam.ihm.*;

// Classe qui créer un espace de tore qui contient une grille
//  dans laquelle les agents se deplacent
//
public class EspaceTore implements EspaceToreInt
{
  private ControleurJeu           controleurJeu;
  private ObservableEspace        observable;
  private CelluleGrille[][]       grille;
  private Tore                    tore;
  private Random                  rdm;
  private int                     numero;   // Pour numeroter de maniere unique les agents

// Constructeur
  public EspaceTore(ControleurJeu controleurJeu)
  {
    this.controleurJeu = controleurJeu;
    this.observable = new ObservableEspace();
    this.rdm = new Random();
    this.numero = 0;
  }

public void init()
  {
    this.grille     = new CelluleGrille[controleurJeu.getNbX()][controleurJeu.getNbY()];
    this.tore       = new Tore(controleurJeu.getNbX(),controleurJeu.getNbY());
  }

// Determine une case libre pour positionner l'agent quand il arrive
  //  dans la grille
  synchronized public Point arriver(AgentInt agent,int couleur)
  {
    try{
      if (agent==null)
        System.out.println("arriver> STUB NULL STUB NULL STUB NULL ");

CelluleGrille c=null;
      while (c==null)
        {
          int i = Math.abs(rdm.nextInt())%controleurJeu.getNbX();
          int j = Math.abs(rdm.nextInt())%controleurJeu.getNbY();
        
          c = grille[i][j];
          if (c==null)
            {
              grille[i][j] = new CelluleGrille(couleur,agent);
              try{agent.setNbVie(10);}
              catch(Exception ex){System.out.println("Impossible acceder agent");}
              if (observable.countObservers()!=0)
                {
                  try{
                    observable.setChanged();
                    observable.notifyObservers(""+i+" "+j+" "+couleur);
                  }catch(Exception ex){System.out.println("** EspaceTore.arriver> Pb de notification "+ex);}
                }
              return( new Point(i,j));
            }
        }
    }catch(Exception ex){ex.printStackTrace();}
    return(null);
  }

// Supprime tous les agents
  synchronized public void supprimerTousAgents()
  {
    for(int i=0;i<controleurJeu.getNbX();i++)
      for(int j=0;j<controleurJeu.getNbY();j++)
        {
          CelluleGrille c = grille[i][j];
          if (c!=null)
            {
              grille[i][j]=null;
              try{c.agent.setNbVie(0);}
              catch(Exception ex){System.out.println("Impossible acceder agent");}
              if (observable.countObservers()!=0)
                {
                  try{
                    observable.setChanged();
                    observable.notifyObservers(""+i+" "+j+" "+"0");
                  }catch(Exception ex){System.out.println("** EspaceTore.arriver> Pb de notification "+ex);}
                }
            }
        }
  }

// Methode utilisee par un agent pour se deplacer
  //  x,y : position de l'agent
  //  sensX,sensY : sens vers où l'agent veut se deplacer
  //  couleur : couleur de l'agent
  //  retourne la nouvelle position de l'agent 
  //  retourne null si l'agent n'a pas pu se deplacer(la case destinatrice est occupée)
  //  
  public Point deplacer(int numero,int x,int y,int sensX,int sensY,int couleur)
  {
    try{
      Point p = deplacerSynchro(numero,x,y,sensX,sensY,couleur);
      Thread.sleep(getTempo());  // Temps d'attente pour chaque deplacement
      return p;
    }catch(Exception ex)
      {
        System.out.println("Erreur>deplacer: "+ex);
        ex.printStackTrace();
        return null;
      }
  }
  // Methode pour realiser un deplacement synchronise
  // Cette methode est synhcrone afin que deux agents ne puissent pas se deplacer
  //  sur la même case
  //
  synchronized public Point deplacerSynchro(int numero,int x,int y,int sensX,int sensY,int couleur)throws Exception
  {
    // Cellule de la grille de l'agent
    CelluleGrille cell = grille[x][y];

// Si un agent essaye de se deplacer alors qu'il a été tué entre temps
    //  alors la cellule contient null
    if (cell==null) return null;

// Si la cellule ne contient pas d'agent
    if (cell.agent == null) 
      {
        System.out.println("deplacer> agent null dans la case. Pas normal");
        return null;
      }

// Si l'agent de la cellule n'est pas celle de l'agent
    if (cell.agent.getNumero() !=numero) return null;

// Calcul de la case de destination en fonction du sens de deplacement
    Point p = tore.deplacer(x,y,sensX,sensY);

// Si la case de destination est libre
    if (grille[(int)p.x][(int)p.y]==null)
      {
        // La case est libre : l'agent s'y déplace
        CelluleGrille c = grille[x][y];
        grille[x][y] = null;
        grille[(int)p.x][(int)p.y] = c;

// Notification du deplacement
        if (observable.countObservers()!=0)
          {
            try{
              System.out.println(String.format("Notification : %3d %3d %3d",x,y,0));
              observable.setChanged();
              observable.notifyObservers(""+x+" "+y+" "+"0");
              observable.setChanged();
              observable.notifyObservers(""+p.x+" "+p.y+" "+couleur);
            }catch(Exception ex){System.out.println("** EspaceTore.deplacer> Pb de notification "+ex);}
          }
      }
    else
      {
        if (controleurJeu.getModeCombat()) // Mode combat
          {
            // La case de deplacement est occupee
            try{
              CelluleGrille c = grille[(int)p.x][(int)p.y];
              if (c.couleur!=couleur)
                {
                  // La case de deplacement est occupee par un ennemi
                                    
                  // On decremente le nbre de vie de l'ennemi
                  //  La methode setNbVie arrete le thread si 0
                  //
                  c.agent.setNbVie(c.agent.getNbVie()-1);
                                    
                  // Si son nbre de vie est 0 alors on notifie
                  //   que le case est vide car l'agent est mort
                  if (c.agent.getNbVie()==0)
                    {
                      grille[(int)p.x][(int)p.y]=null;
                      if (observable.countObservers()!=0)
                        {
                          observable.setChanged();
                          observable.notifyObservers(""+p.x+" "+p.y+" "+"0");
                        }
                      
                    }
                  // L'agent a attaqué un agent ennemie, il reste à sa place
                  //  et cela compte pour un deplacement
                  p = new Point(x,y);
                }
              else
                p=null;  // Pas de deplacement sur une case occupée par un ami en mode combat
            }catch(Exception ex){System.out.println("Impossible acceder agent"+ex);
              ex.printStackTrace();p=null;}
          }
        else // La case n'est pas libre et on n'est pas en mode combat
          p=null; 
      }

return p;
  }

public boolean getModeCombat(){return controleurJeu.getModeCombat();}

public int getTempo(){return controleurJeu.getTempo();}

public ObservableEspace getObservable()
  {
    return observable;
  }

public int getNbX()
  {
    return controleurJeu.getNbX();
  }
  public int getNbY()
  {
    return controleurJeu.getNbY();
  }
  public int getTailleCellule()
  {
    return controleurJeu.getTailleCase();
  }

public int getNumero()
  {
    numero++;
    return numero;
  }

synchronized public Vector getPopulation(int couleur)
  {
    Vector elements = new Vector();
        
    for(int i=0;i<controleurJeu.getNbX();i++)
      {
        for(int j=0;j<controleurJeu.getNbY();j++)
          {
            CelluleGrille c = grille[i][j];
            if (c!=null)
              {
                if( c.couleur == couleur)
                  {
                    elements.addElement((Object)(new Point(i,j)));
                  }
              }
          }
      }
    return (elements);
  }

synchronized public CelluleGrille[][] getGrille()
  {
    return grille;
  }

public Vector getAutrePopulation(int couleur)
  {
    Vector elements = new Vector();
        
    for(int i=0;i<controleurJeu.getNbX();i++)
      {
        for(int j=0;j<controleurJeu.getNbY();j++)
          {
            CelluleGrille c = grille[i][j];
            if (c!=null)
              {
                if( c.couleur != couleur)
                  {
                    elements.addElement((Object)(new Point(i,j)));
                  }
              }
          }
      }
    return (elements);
  }

public void submit(Formulaire form, String nomSubmit)
  {
    try{
      if (nomSubmit.equals("VALIDER"))
        {
          //inutile car fenetre synchrone.
        }
    }catch(Exception ex){}
  }

}

EspaceToreInt.java
EspaceToreOD.java

package fr.cnam.espacetore;

import java.lang.*;
import java.util.*;
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.awt.Point;
import fr.cnam.joueur.*;
import fr.cnam.util.*;
import fr.cnam.espacetore.*;

// OD qui encapsule l'espace de tore afin qu'il puisse etre utilise 
//  de maniere distante
//  
public class EspaceToreOD extends UnicastRemoteObject implements EspaceToreODInt
{
    final public static String NOM_ESPACE_TORE = "ESPACE_TORE";
    
    EspaceToreInt espaceTore;

public EspaceToreOD(EspaceToreInt espaceTore,int portRMI,int portAdaptateur) throws RemoteException
    {
        super(portRMI);
        System.out.println("Constructor UnicasRemoteObject : port "+
                           portRMI);

try{
          LocateRegistry.createRegistry(portAdaptateur);
          System.out.println("Creation du service de nommage : port "+portAdaptateur);
        } catch(Exception ex){}

try{
            this.espaceTore = espaceTore;

String name = "rmi://localhost:" +
                portAdaptateur +
                "/" +
                NOM_ESPACE_TORE;
            Naming.bind(name,this);
            System.out.println("Bind : "+name+" port "+portAdaptateur);
        }catch(Exception ex){};
    }

public void addObserver(Remote observer) throws RemoteException
    {
        espaceTore.getObservable().addObserver( new ProxyObserverEspace(observer,(Observable)(espaceTore.getObservable()))  ); // Ajout de l'observable pour delete
    }

public Point arriver(AgentInt agent,int couleur) throws RemoteException
    {
        try{
            return espaceTore.arriver(agent,couleur);
        }catch(Exception ex){};
        return(null);
    }

public Point deplacer(int numero,int x,int y,int sensX,int sensY,int couleur) throws RemoteException
    {
        try{
          return espaceTore.deplacer(numero,x,y,sensX,sensY,couleur);
        }catch(Exception ex){};
        return(null);
    }

public int getTempo() throws RemoteException
    {
        try{
            return espaceTore.getTempo();
            }catch(Exception ex){};
        return(200);
    }

public int getNbX() throws RemoteException
    {
        return espaceTore.getNbX();
    }

public int getNbY() throws RemoteException
    {
        return espaceTore.getNbY();
    }

public int getTailleCellule() throws RemoteException
    {
        return espaceTore.getTailleCellule();
    }

public Vector getPopulation(int couleur) throws RemoteException
    {
        return espaceTore.getPopulation(couleur);
    }

public CelluleGrille[][] getGrille() throws RemoteException
    {
        return espaceTore.getGrille();
    }

public Vector getAutrePopulation(int couleur) throws RemoteException
    {
        return espaceTore.getAutrePopulation(couleur);
    }

public boolean getModeCombat() throws RemoteException
    {
        return espaceTore.getModeCombat();
    }

public int getNumero() throws RemoteException
  {
    return espaceTore.getNumero();
  }

// =====================================================================
    public static void main(String... args) throws Exception
    {
        Parametres params = new Parametres(args);

int portRMI        = params.getInt("port_od",9101);
        int portEspaceTore = params.getInt("port_annuaire",9100);

System.out.println("Demarrage de l'espace de Tore");

// Création du service de nommage utilisé par RMI
        try{
            LocateRegistry.createRegistry(portEspaceTore);
            System.out.println("Creation du service de nommage : port "+portEspaceTore);
        } catch(Exception ex){}
        
        ControleurJeu controleurJeu = new ControleurJeu();
        EspaceTore espace = new EspaceTore(controleurJeu);
        IhmControleurJeu ihm = new IhmControleurJeu(controleurJeu,
                                                    espace);

EspaceToreOD espaceOD = new EspaceToreOD( espace ,portRMI,portEspaceTore);

}

EspaceToreODInt.java

package fr.cnam.espacetore;

import java.lang.*;
import java.rmi.*;
import java.util.*;
import java.awt.Point;
import fr.cnam.joueur.*;

/** Interface d'utilisation de l'espace de Tore de manière distante
 */
public interface EspaceToreODInt extends Remote
{
  // Methode qui permet a l'IHM de s'abonner afin qu'elle soit notifiee des changements des cases de la grille
  //    observer est le Stub de l'objet RMI qui est utilise par l'IHM pour etre  prevenu des notifications 
  //
  public void addObserver(Remote observer) throws RemoteException;

// Methode qui permet a un agent de se deplacer dans l'espace de Tore
  //   Cette methode est synhronisee sur l'espace de Tore afin que deux agents ne puissent pas 
  //      se deplacer en meme temps sur une meme case.
  // La methode retourn un Point qui est les coordonnees en x et y de destination calculees par l'espace de Tore.
  //    La valeur est null si le deplacement ne peut pas se faire.
  //
  public Point deplacer(int numero,int x,int y,int sensX,int sensY,int couleur) throws RemoteException;

// Methode qui retourne le temps en millisecondes utilisee par chaque agent pour attendre entre chaque deplacement.
  //
  public int getTempo() throws RemoteException;

// Retourne la taille en X de la grille de l'espace de Tore.
  //
  public int getNbX() throws RemoteException;

// Retourne la taille en Y de la grille de l'espace de Tore.
  //
  public int getNbY() throws RemoteException;

// Methode qui retourne la taille de la cellule de la grille.
  //
  public int getTailleCellule() throws RemoteException;

// Methode qui retourne un tableau contenant les coordonnees de tous les agents qui ont la couleur 
  //   passe en parametre.
  //
  public Vector getPopulation(int couleur) throws RemoteException;

// Methode qui retourne la grille geree par l'espace de tore
  //
  public CelluleGrille[][] getGrille() throws RemoteException;

// Methode utilise par un agent pour se declarer au pres de l'espace de Tore.
  // L'espace de Tore reçoit le stub de l'agent ce qui va lui permettre d'utiliser les methodes de l'agent
  // De plus cette methode calcule une coordonnee libre de la grille qui est retournee
  // Cette methode est synchronisee afin que deux agents ne puissent arriver sur une meme case.
  //
  public Point arriver(AgentInt agent,int couleur) throws RemoteException;

// Methode qui retourne un tableau contenant les coordonnees de tous les agents qui n'ont pas la couleur passe en parametre.
  //
  public Vector getAutrePopulation(int couleur) throws RemoteException;

// Retourne le mode combat ou non de l'espace de tore
  //
  public boolean getModeCombat() throws RemoteException;

// Retourne un numero unique afin de numeroter chacun des agents de maniere unique
  //
  public int getNumero() throws RemoteException;

}

IhmControleurJeu.java

package fr.cnam.espacetore;

import fr.cnam.tore.*;
import fr.cnam.ihm.*;
import fr.cnam.espacetore.*;

public class IhmControleurJeu implements FormulaireInt
{
  private ControleurJeu controleurJeu;
  private EspaceTore    espaceTore;
  private boolean       modeCombat;

public IhmControleurJeu(ControleurJeu controleurJeu,
                          EspaceTore    espaceTore)
  {
    this.controleurJeu = controleurJeu;
    this.espaceTore    = espaceTore;
    this.modeCombat = false;

Formulaire form = new Formulaire("Parametres",this,false,300,300,true);
    form.addText("NBX","Taille en X",true,"30");
    form.addText("NBY","Taille en Y",true,"30");
    form.addText("TAILLE_CELLULE","Taille de la cellulle",true,"15");
    form.addButton("LANCER","Lancer");
    form.addText("TEMPO","Tempo",true,"250");
    form.addButton("VALIDER","Valider");
    form.addButton("MODENORMAL","Mode normal");
    form.addButton("MODECOMBAT","Mode combat");
    form.desactiver("MODENORMAL");
    form.addButton("RAZ","Raz");
    form.afficher();
  }

public void submit(Formulaire form, String nomSubmit)
  {
    try{
      if (nomSubmit.equals("LANCER"))
        {
          controleurJeu.setParam(
                                 Integer.parseInt(form.getValeurChamp("NBX")),
                                 Integer.parseInt(form.getValeurChamp("NBY")),
                                 Integer.parseInt(form.getValeurChamp("TAILLE_CELLULE")));

controleurJeu.setTempo(Integer.parseInt(form.getValeurChamp("TEMPO")));
          controleurJeu.setModeCombat(modeCombat);

espaceTore.init();

form.desactiver("NBX");
          form.desactiver("NBY");
          form.desactiver("TAILLE_CELLULE");
          form.desactiver("LANCER");
          System.out.println("LANCEMENT DE L'ESPACE DE TORE");
        }

if (nomSubmit.equals("VALIDER"))
        {
          controleurJeu.setTempo(Integer.parseInt(form.getValeurChamp("TEMPO")));
        }
      if (nomSubmit.equals("MODENORMAL"))
        {
          modeCombat=false;
          controleurJeu.setModeCombat(modeCombat);
          form.desactiver("MODENORMAL");
          form.activer("MODECOMBAT");
        }
      if (nomSubmit.equals("MODECOMBAT"))
        {
          modeCombat=true;
          controleurJeu.setModeCombat(modeCombat);
          form.desactiver("MODECOMBAT");
          form.activer("MODENORMAL");
        }

if (nomSubmit.equals("RAZ"))
        {
          espaceTore.supprimerTousAgents();
        }

if (nomSubmit.equals("STOP"))
        {
                  
        }

}catch(Exception ex){}
  }
}

               ObservableEspace.java
               ProxyObserverEspace.java
            grille
               GrilleControlesInt.java
               GrilleIHM.java

package fr.cnam.grille;

import java.awt.*;
import java.awt.event.*;
import java.util.*;

import fr.cnam.tore.*;

/**
   Classe de définition d'une grille IHM avec laquelle il est possible : 
   - de colorer ou effacer une case de la grille 
   - de realiser une action sur chacun des 10 boutons qui se trouvent à cote de la grille 
   - de nommer les boutons 
   
*/
public class GrilleIHM
{
    private final static int    MAX_CONTROLES = 10;
    private final static int    NB_MAX_MARQUE = 10;

private Panel              _panel;
    private Canvas             _canvas;
    private Button             _controles[];
    private GrilleControlesInt _anyActions;
    private int                _nbX;
    private int                _nbY;
    private int                _tailleCase;
    private int                _grille[][];
    private int                _width;
    private int                _height;
    private Color[]            _couleurs;

// ======================================================================
    /** Constructeur de la grille. 
        L'objet créé doit ensuite être insérer dans une objet swing comme par exemple un Frame d'une fenêtre principale. 
        La méthode getPanel() retourne le Panel de la GrilleIHM. 
        @param nbX nombre colonne de la grille
        @param nbY nombre de ligne de la grille
        @param tailleCase la taille en pixel des cases de la grille
    */
    public GrilleIHM(int nbX,
                     int nbY,
                     int tailleCase) 
    {
        // Creation du panel principal
        _panel = new Panel();

// Caractéristiques de la grille
        _tailleCase  = tailleCase;
        _nbX         = nbX;
        _nbY         = nbY;
        _width       = _nbX * _tailleCase;
        _height      = _nbY * _tailleCase;
        _couleurs    = new Color[NB_MAX_MARQUE];
        _couleurs[0] = Color.black;
        _couleurs[1] = Color.red;
        _couleurs[2] = Color.green;
        _couleurs[3] = Color.blue;
        _couleurs[4] = Color.gray;
        _couleurs[5] = Color.magenta;
        _couleurs[6] = Color.orange;
        _couleurs[7] = Color.yellow;
        _couleurs[8] = Color.cyan;
        _couleurs[9] = Color.pink;

// Creation du canvas
        _canvas = new GrilleCanvas(this);
        _canvas.resize(_width+5,_height+5);

// Initialisation du tableau de la grille
        _grille = new int[_nbX][_nbY];
        razGrille();

// Initialisation des boutons d'actions
        _anyActions = null;
        _controles = new Button[MAX_CONTROLES];

// Creation du panel des zones de saisie et des boutons
        Panel controle = new Panel(new GridLayout(MAX_CONTROLES,1));
        for(int i=0;i<MAX_CONTROLES;i++)
            {
                int num = i+1;
                _controles[i] = new Button("Action "+num);
                _controles[i].setSize(100,20);
                _controles[i].addActionListener( new ControleAction(num,this));
                controle.add(_controles[i]);
                _controles[i].setLabel("Bouton " + i);
            }

// On ajoute les 2 éléments dans l'IHM
        // 
        _panel.add(controle);
        _panel.add(_canvas);
    }

// ======================================================================
    /**
       Initialise l'acteur qui est un objet qui implémente l'interface  GrilleControlesInt
     */
    public void setActeur(GrilleControlesInt acteur)
    {
        _anyActions = acteur;
    }
  
    // ======================================================================
    /**
       Retourne le panel contenant la GrilleIHM
       @return le panel
     */
    public Panel getPanel()
    {
        return(_panel);
    }

// ======================================================================
    /** Efface le contenu de la grille 
        (La valeur 0 est mise dans chaque case)
     */
    public void razGrille()
    {
        for(int i=0;i<_nbX;i++)
            {
                for(int j=0;j<_nbY;j++)
                    {
                        _grille[i][j]=0;
                    }
            }
    }

// ======================================================================
    /** Affecte à une case de la grille la marque (couleur)
        @param marque une valeur de 1 à 10 (couleur) ou 0 (case vide)
        @param x coordonnée en x de la case
        @param y coordonnée en y de la case
     */
    public void setMarque(int marque,int x,int y)
    {
        _grille[x][y] = marque;
        marquer(marque,x,y);
    }
  
    // ======================================================================
    /** Retourne la marque de la case
       @param x coordonnée en x de la case
       @param y coordonnée en y de la case
       @return la valeur de la case (de 0 à 10)
     */
    public int getMarque(int x,int y)
    {
        return(_grille[x][y]);
    }
  
    // ======================================================================
    /** Teste si la case est libre (différente de 0)
        @param x coordonnée en x de la case
        @param y coordonnée en y de la case
        @return true si la case est libre sinon false
    */
    public boolean siCaseLibre(int x,int y)
    {
        return( getMarque(x,y)==0 );
    }
  
    // ======================================================================
    /** Retourne le nombre de colonne de la grille
        @return le nombre de colonne
    */
    public int getNbX()
    {
        return(_nbX);
    }
  
    // ======================================================================
    /** Retourne le nombre de ligne de la grille
        @return le nombre de ligne
    */
    public int getNbY()
    {
        return(_nbY);
    }

// ======================================================================
    /** Retourne le nombre max de couleur géré par GrilleIHM
        @return nombre max
    */
    public int getNbMaxMarqueur()
    {
        return(NB_MAX_MARQUE);
    }  
    // ======================================================================
    /** Permet de changer le nom d'un bouton de l'IHM.
        @param num numéro du bouton (de 1 à 10)
        @param nom du bouton
    */
    public void setNomBouton(int num,String nom)
    {
        _controles[num-1].setLabel(nom);
    }

// ======================================================================
    // Affichage de la grille
    //
    private void afficherGrille()
    {
        Graphics g = _canvas.getGraphics();

// On efface toute la grille
        g.clearRect(0,0,_width,_height);

// Tracer des lignes verticales
        for(int i=0;i<_nbX+1;i++)
            {
                Point p1= new Point( (_width/_nbX)*i,0);
                Point p2= new Point( (_width/_nbX)*i,_height);
                g.drawLine(p1.x,p1.y,p2.x,p2.y);
            }

// Tracer des lignes horizontales
        for(int i=0;i<_nbY+1;i++)
            {
                Point p1= new Point( 0,      (_height/_nbY)*i);
                Point p2= new Point( _width, (_height/_nbY)*i);
                g.drawLine(p1.x,p1.y,p2.x,p2.y);
            }

// Tracer des éléments
        for(int i=0;i<_nbX;i++)
            {
                for(int j=0;j<_nbY;j++)
                    {
                        marquer(_grille[i][j],i,j);
                    }
            }
    }

// ======================================================================
    // Tracer d'un élément dans la grille
    //
    private void marquer(int marque,int x,int y)
    {
        Graphics g = _canvas.getGraphics();
        int niX1 = x*(_width/_nbX);
        int niX2 = (x+1)*(_width/_nbX);
        int niY1 = y*(_height/_nbY);
        int niY2 = (y+1)*(_height/_nbY);

g.clearRect(niX1+1,niY1+1,niX2-niX1-2,niY2-niY1-2);
        if (marque >0)
            {
                g.setColor(_couleurs[marque-1]);
                g.fillRect(niX1+2,niY1+2,niX2-niX1-4,niY2-niY1-4);
            }
    }

// ======================================================================
    /** Méthode de test de la classe.
        Ce programme crée une grille et crée un thread qui déplace une case.
        Les boutons permettent de tester le comportement du déplacement
    */
    public static void main(String... args)
    {
        int nbX=20;
        int nbY=30;

// On crée la fenêtre
        Frame fen = new Frame();

// On y ajoute la grille
        GrilleIHM grilleihm = new GrilleIHM(nbX,nbY,15);

// Exemple qui teste la grille
        Test t = new Test(grilleihm);
        grilleihm.setActeur(t);
        
        // Panel in Frame
        fen.add(grilleihm.getPanel());

// Pour fermer la fenetre
        GrilleWindowAdapter a = new GrilleWindowAdapter();
        fen.addWindowListener((WindowListener)a);
        
        // On affiche la fenetre
        fen.setLocation(100,100);
        fen.setSize(300+nbX*15,250+nbY*15);
        fen.show();
        
        // Démarrage du test
        t.start();
    }

// ===============================================================
    // Inner classe interne de definition du callback sur les boutons
    // ===============================================================
    // Pour récupérer les actions de click sur les boutons
    class ControleAction implements ActionListener
    {
        int _type; // numero bouton
        GrilleIHM _grille; // La grille IHM

// Constructeur afin de designer le type d'action
        public ControleAction(int type, GrilleIHM grille)
        {
            _type=type;
            _grille=grille;
        }

// Traitement des actions
        public void actionPerformed(ActionEvent e)
        {
            if (_anyActions!=null)
                {
                    _anyActions.action(_type,_grille);
                }
        }
    }

// ===============================================================
    // Classe interne de definition de la surcharge de paint du canvas
    // ===============================================================
    class GrilleCanvas extends Canvas
    {
        GrilleIHM _g;
        
        public GrilleCanvas(GrilleIHM g)
        {
            _g = g;
        }

public void paint(Graphics g)
        {
            _g.afficherGrille();
        }
    }

} // Fin de GrilleIHM

// ===============================================================
// Classe interne de fermeture de la fenetre
// ===============================================================
// L'adaptateur d'une window
//
class GrilleWindowAdapter extends WindowAdapter
{
    // On ne s'interesse que a l'action de fermeture de
    // la fenetre
    public void windowClosing(WindowEvent e) 
    {
        System.exit(0);
    }
}

// ===============================================================
/** Classe utilisée pour tester la classe Tore et la grille
 */
class Test extends Thread implements GrilleControlesInt
{
    private GrilleIHM grille;
    private int mode;

public Test(GrilleIHM g)
    {
        grille = g;
        mode=1;
    }

public void run()
    {
        Random  rdm = new Random();
        Tore espace = new Tore(grille.getNbX(),grille.getNbY());

// 
        grille.setNomBouton(1,"Dep aleat");
        grille.setNomBouton(2,"Pos aleat");
        grille.setNomBouton(3,"Vers le coin\n (0,0)");
        
        //
        int x=grille.getNbX()/2;
        int y=grille.getNbY()/2;
        grille.setMarque(1,x,y);
        while(true)
            {
                if (mode==1)
                    {
                        int sensX = rdm.nextInt(3)-1;
                        int sensY = rdm.nextInt(3)-1;
                        Point p = espace.deplacer(x,y,sensX,sensY);
                        grille.setMarque(0,x,y);
                        x = (int)p.x;
                        y = (int)p.y;
                        grille.setMarque(1,x,y);
                    }

if (mode==2)
                    {
                        grille.setMarque(0,x,y);
                        x = rdm.nextInt(grille.getNbX());
                        y = rdm.nextInt(grille.getNbY());
                        grille.setMarque(1,x,y);
                        try{Thread.sleep(1000);}catch(Exception ex){};
                    }

if (mode==3)
                    {
                        Point sens = espace.sensTore(new Point(x,y),new Point(0,0));
                        Point p = espace.deplacer(x,y,sens.x,sens.y);
                        grille.setMarque(0,x,y);
                        x = (int)p.x;
                        y = (int)p.y;
                        grille.setMarque(1,x,y);
                    }
                
                try{Thread.sleep(200);}catch(Exception ex){};
            }
    }

public void action(int num,GrilleIHM grille)
    {
        mode = num;
    }

}

            ihm
            joueur
               Agent.java

package fr.cnam.joueur;

import java.util.*;
import java.awt.Point;
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;

import fr.cnam.espacetore.*;
import fr.cnam.tore.*;

public abstract class Agent extends UnicastRemoteObject implements AgentInt, Runnable
{
  protected FactoryAgentInt factory;
  protected int x;
  protected int y;
  protected int couleur;
  protected boolean stopThread;
  protected int tempo;
  protected Thread thread;
  protected Random rdm;
  protected EspaceToreODInt espace;
  protected int nbX;
  protected int nbY;
  protected Tore tore;
  protected int nbVie;
  protected int numero;

public Agent(int couleur,
               FactoryAgentInt factory,
               int portRMI
               ) throws RemoteException
  {
    super(portRMI);
    try{
      this.factory = factory;
      this.espace = factory.getEspaceTore();
      this.stopThread = false;
      this.tempo = espace.getTempo();
      this.nbX = espace.getNbX();
      this.nbY = espace.getNbY();
      this.nbVie = 10;
      AgentInt stub = (AgentInt)(UnicastRemoteObject.toStub(this));
      Point p = espace.arriver(stub,couleur);
      this.x=(int)p.x;
      this.y=(int)p.y;

this.couleur = couleur;
      this.numero=espace.getNumero();  // Numero unique d'un agent
      this.rdm = new Random();
      this.tore = new Tore(this.nbX,this.nbY);
            
      this.thread = new Thread(this);
      this.thread.start(); 
    }catch(Exception ex){System.out.println("Erreur init agent");}
  }

public void run()
  {
    while(! stopThread)
      deplacer();  // Cette methode peut etre surchargéee par les classes qui héritent de la classe Agent
    System.out.println("Arret du thred");
  }

// Deplacement aleatoire
  //
  public void deplacer()
  {
    try{
      int sensX = Math.abs(rdm.nextInt())%3 - 1;
      int sensY = Math.abs(rdm.nextInt())%3 - 1;
      //System.out.println("x,y = "+x+","+y+" sens: "+sensX+" "+sensY);
      // Deplacement dans la grille
      Point p = espace.deplacer(numero,x,y,sensX,sensY,couleur);
      if (p != null)
        {
          // Le deplacement est possible
          x = (int)p.x;
          y = (int)p.y;
          //System.out.println("Agent "+numero+"> deplacer en "+x+" "+y);
        }
    }
    catch(Exception ex){System.out.println("Erreur deplacer");}
  }

// Methode permettant de deplacer l'agent de telle maniere qu'il se
  // dirige vers un agent de meme marque que lui.
  // Cette methode retourne false si le deplacement n'est pas possible
  // Le principe : 
  //    on determine le plus proche superieur à un certain seuil
  //    
  public boolean deplacerEnsemble(int seuil)
  {
    try{
      int sensX;
      int sensY;
      Point p;
      Vector points;
        
      // Determination des positions de tous les agents de meme marque
      //  qui evoluent dans la grille
      //
      points = null;

points = this.espace.getPopulation(this.couleur);
        
      // Si il n'y en a pas alors retourne false
      if (points != null)
        {
          // On determine le plus proche superieur a un seuil 
          Point pointProche = this.tore.lePlusProche(new Point(x,y),points,seuil);
                
          // Si il n'y en a pas alors retourne false
          if (pointProche != null)
            {
              // Determination du sens de deplacement
              //
              Point sens = this.tore.sens(new Point(x,y),pointProche);
              sensX = (int)(sens.x);
              sensY = (int)(sens.y);
              //System.out.println("sens "+numero+": "+sensX+" "+sensY);
              // Realisation du deplacement
              //
              p = espace.deplacer(numero,x,y,sensX,sensY,couleur);
              if (p!=null) 
                {
                  x = (int)p.getX();
                  y = (int)p.getY();
                  //System.out.println("Agent "+numero+"> deplacer ensemble en "+x+" "+y);
                  return(true);
                }
            }
        }
      return(false);
    }
    catch(Exception ex){return false;}
  }
    
  // Methode permettant de deplacer l'agent de telle maniere qu'il se
  // dirige vers un agent de meme marque que lui.
  // Cette methode retourne true si le deplacement a ete possible
  // Le principe : 
  //    on determine le plus proche inferieur à un certain seuil et 
  //    si le nombre d'agent trouve est inferieur a un certain seuil
  //    
  public boolean deplacerEnsembleInferieur(int seuil,int nbAgentSeuil)
  {
    try{
      int sensX;
      int sensY;
      Point p;
      Vector points;
        
      // Determination des positions de tous les agents de meme marque
      //  qui evoluent dans la grille
      //
      points = null;

points = this.espace.getPopulation(this.couleur);
        
      // Si il n'y en a pas alors retourne false
      if (points != null)
        {
          // On determine le plus proche superieur a un seuil 
          Point pointProche = this.tore.lePlusProcheInferieur(new Point(x,y),points,seuil,nbAgentSeuil);
                
          // Si il n'y en a pas alors retourne false
          if (pointProche != null)
            {
              // Determination du sens de deplacement
              //
              Point sens = this.tore.sens(new Point(x,y),pointProche);
              sensX = (int)(sens.x);
              sensY = (int)(sens.y);
              //System.out.println("sens "+numero+": "+sensX+" "+sensY);
              // Realisation du deplacement
              //
              p = espace.deplacer(numero,x,y,sensX,sensY,couleur);
              if (p!=null) 
                {
                  x = (int)p.getX();
                  y = (int)p.getY();
                  //System.out.println("Agent "+numero+"> deplacer ensemble en "+x+" "+y);
                  return(true);
                }
            }
        }
      return(false);
    }
    catch(Exception ex){return false;}
  }
    
  // Methode permettant de deplacer l'agent de telle maniere qu'il se
  // dirige vers un agent de marque differente de lui.
  // Cette methode retourne false si le deplacement n'est pas possible
  // Le principe : 
  //    on determine le plus proche
  //    
  // Ce deplacement est agressif car l'agent attaque tout le temps
  //  tout ennemi proche
  //
  public boolean deplacerEnnemie()
  {
    try{
      int sensX;
      int sensY;
      Point p;
      Vector points;
        
      // Determination des positions de tous les agents pas de meme marque
      //  qui evoluent dans la grille
      //
      points = null;

points = this.espace.getAutrePopulation(this.couleur);
        
      // Si il n'y en a pas alors retourne false
      if (points != null)
        {
          // On determine le plus proche (seuil = 0)
          Point pointProche = this.tore.lePlusProche(new Point(x,y),points,0);
                
          // Si il n'y en a pas alors retourne false
          if (pointProche != null)
            {
              // Determination du sens de deplacement
              //
              Point sens = this.tore.sens(new Point(x,y),pointProche);
              sensX = (int)(sens.x);
              sensY = (int)(sens.y);
                        
              // Realisation du deplacement
              //
              p = espace.deplacer(numero,x,y,sensX,sensY,couleur);
              if (p!=null) 
                {
                  x = (int)p.getX();
                  y = (int)p.getY();
                  //System.out.println("Agent> deplacer en "+x+" "+y);
                  return(true);
                }
            }
        }
      return(false);
    }catch(Exception ex){return false;}
  }
    
  // Les agents partent a l'oppose des agents ennemies
  //
  public boolean fuireEnnemie()
  {
    try{
      int sensX;
      int sensY;
      Point p;
      Vector points;
        
      // Determination des positions de tous les agents pas de meme marque
      //  qui evoluent dans la grille
      //
      points = null;

points = this.espace.getAutrePopulation(this.couleur);
        
      // Si il n'y en a pas alors retourne false
      if (points != null)
        {
          // On determine le plus proche (seuil = 0)
          Point pointProche = this.tore.lePlusProche(new Point(x,y),points,0);
                
          // Si il n'y en a pas alors retourne false
          if (pointProche != null)
            {
              // Determination du sens de deplacement
              //
              Point sens = this.tore.sens(new Point(x,y),pointProche);
              sensX = -(int)(sens.x);
              sensY = -(int)(sens.y);
                        
              // Realisation du deplacement
              //
              p = espace.deplacer(numero,x,y,sensX,sensY,couleur);
              if (p!=null) 
                {
                  x = (int)p.getX();
                  y = (int)p.getY();
                  //System.out.println("Agent> deplacer en "+x+" "+y);
                  return(true);
                }
            }
        }
      return(false);
    }catch(Exception ex){return false;}
  }

// Les agents partent a l'oppose de ses propres agents
  //
  public boolean fuireAmis()
  {
    try{
      int sensX;
      int sensY;
      Point p;
      Vector points;
        
      // Determination des positions de tous les agents de meme marque
      //  qui evoluent dans la grille
      //
      points = null;

points = this.espace.getPopulation(this.couleur);
        
      // Si il n'y en a pas alors retourne false
      if (points != null)
        {
          // On determine le plus proche (seuil = 0)
          Point pointProche = this.tore.lePlusProche(new Point(x,y),points,0);
                
          // Si il n'y en a pas alors retourne false
          if (pointProche != null)
            {
              // Determination du sens de deplacement
              //
              Point sens = this.tore.sens(new Point(x,y),pointProche);
              sensX = -(int)(sens.x);
              sensY = -(int)(sens.y);
                        
              // Realisation du deplacement
              //
              p = espace.deplacer(numero,x,y,sensX,sensY,couleur);
              if (p!=null) 
                {
                  x = (int)p.getX();
                  y = (int)p.getY();
                  //System.out.println("Agent> deplacer en "+x+" "+y);
                  return(true);
                }
            }
        }
      return(false);
    }catch(Exception ex){return false;}
  }

public int getNumero(){return numero;}
   
  public int getNbVie() throws RemoteException
  {
    return nbVie;
  }
    
  public void setNbVie(int nbVie) throws RemoteException
  {
    this.nbVie = nbVie;
    if (nbVie<=0)
      {
        stopThread=true;
      }
  }
    
}

               AgentDefaut.java
               AgentInt.java
               ChargeurDefaut.java

package fr.cnam.joueur;

import java.io.*;

// Chargeur de classe qui est utilisé par défaut.
// Il est désigné dans le lancement de l'exemple
//
public class ChargeurDefaut extends ClassLoader
{
    static public String pathClasses = "";

public ChargeurDefaut(ClassLoader parent)
    {
        super(parent); 
    }

public Class findClass(String nom) throws ClassNotFoundException
    {
        File fic;
        FileInputStream fis;
        Class c=null;
        byte[] donnees;
     
        try{
            // Lecture du fichier de classe
            String path = nom.replace('.','/');
            fic = new File(pathClasses+"/"+path+
                           ".class");
            fis = new FileInputStream(fic);
            
            donnees = new byte[(int) fic.length()];
            int octetslus=fis.read(donnees);
            fis.close();
            
            // Résolution de la classe 
            c = (Class)(defineClass(nom,
                                    donnees,
                                    0,donnees.length));

}catch(Exception ex){System.out.println("ChargeurDefaut findClass> "+ex);}
        return c;
    }
}

               CreationAgent.java
               CreationAgentInt.java
               DynamicCreationAgent.java

package fr.cnam.joueur;

import java.util.*;
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.util.*;
import java.lang.reflect.*;

public class DynamicCreationAgent implements InvocationHandler
{
  private CreationAgent creationAgent;

public DynamicCreationAgent() throws RemoteException
  {
    this.creationAgent = new CreationAgent();
  }

public Object invoke(Object proxy,
                       Method m,
                       Object[] args) throws Throwable
    {
      if (m.getName().equals("creerAgent"))
        {
          String nomClasseAgent = (String)args[0];
          int    couleur        = (Integer)args[1];

AgentInt agent = null;
          try{
            Class<?> classe = 
              Class.forName(nomClasseAgent,true, 
                            ClassLoader.getSystemClassLoader());
            Class[] parameter = new Class[3];
            parameter[0] = int.class;
            parameter[1] = FactoryAgentInt.class;
            parameter[2] = int.class;
            Constructor constr = classe.getConstructor(parameter);
            agent = (Agent)(constr.newInstance(couleur,
                                               FactoryAgent.getInstance(),
                                               FactoryAgent.getInstance().getPortRMI()));

// Injection de dependance entre CreationAgent et la classe d'agent
            //
            creationAgent.setAgent(agent);
          }catch(Exception ex){
            System.out.println("Impossible de creer un agent dynamique de :"+nomClasseAgent);
            System.out.println("Creation d'un agent par defaut");
            try{
              m.invoke(creationAgent, args);
            }catch(Exception ex2){ex2.printStackTrace();}
          }
          return null; //void
        }
      else
        {
          return m.invoke(this.creationAgent, args);
        }
    }
}

FactoryAgent.java

package fr.cnam.joueur;

import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.util.*;
import java.awt.Point;
import java.lang.reflect.*;

import fr.cnam.espacetore.*;
import fr.cnam.joueur.*;
import fr.cnam.util.*;

public class FactoryAgent implements FactoryAgentInt
{
  static private FactoryAgent singleton=null;
  static private int portRMI=9200;
  static private String hostEspaceTore="localhost";
  static private int portEspaceTore=9100;

private ArrayList<AgentInt> agents;
  private EspaceToreODInt espaceTore;

private CreationAgentInt builder;

static FactoryAgentInt getInstance()
  {
    if (singleton!=null) return singleton;
    else 
      {
        singleton = new FactoryAgent();
        return singleton;
      }
  }

static void initialisation(int portRMI,
                             String hostEspaceTore,
                             int    portEspaceTore)
  {
    FactoryAgent.portRMI=portRMI;
    FactoryAgent.hostEspaceTore=hostEspaceTore;
    FactoryAgent.portEspaceTore=portEspaceTore;
  }

private FactoryAgent()
  {
    int casex=0;
    try{
      casex=1;
      this.agents = new ArrayList<AgentInt>();
            
      espaceTore = (EspaceToreODInt)(Naming.lookup("rmi://"+hostEspaceTore+":"+
                                                   portEspaceTore+"/"+
                                                   EspaceToreOD.NOM_ESPACE_TORE));
      System.out.println("Connexion à l'espace de Tore réussi");

casex=2;
      builder = (CreationAgentInt)Proxy.newProxyInstance( 
                                                         ClassLoader.getSystemClassLoader(),
                                                         new Class<?>[] { CreationAgentInt.class },
                                                         new DynamicCreationAgent());
    }catch(Exception ex)
      {
        switch(casex)
          {
          case 1:
            System.out.println("Pb connexion : "+hostEspaceTore+" "+
                               portEspaceTore+" "+EspaceToreOD.NOM_ESPACE_TORE);
            espaceTore=null;
            break;
          case 2:
            System.out.println("Pb de creation du builder");
            builder=null;
            break;
          default:
            break;
          }
      }
  }

public AgentInt creerAgent(String nomClasseAgent,int couleur) throws RemoteException
  {
    if(builder==null) {System.out.println("Builder null"); return null; }

// Creation d'un agent dynamiquement
    builder.creerAgent(nomClasseAgent,couleur);
    
    // Recuperation de l'agent cree
    AgentInt agent = builder.getAgent();
    if (agent!=null)
      {
        // Ajout de l'agent cree dans la collection
        agents.add(agent);
      }
    else {System.out.println("L'agent demande n'a pas ete cree");}

return agent;
  }

public int getTauxMortalite()
  {
    try{
      int nbMort=0;
      for(AgentInt a : agents)
        if (a.getNbVie()<=0) nbMort++;
      if (nbMort==0) return 0;
      else return((nbMort*100)/agents.size());
    }catch(Exception ex){return 0;}
  }

public EspaceToreODInt getEspaceTore()
  {return espaceTore;}

public String getPathClassesAgent()
  {
    return ChargeurDefaut.pathClasses;
  }
    
  public int getPortRMI() { return portRMI;}
    
}

FactoryAgentInt.java
FactoryAgentOD.java

package fr.cnam.joueur;

import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;

import fr.cnam.espacetore.*;
import fr.cnam.joueur.*;
import fr.cnam.util.*;

public class FactoryAgentOD extends UnicastRemoteObject implements FactoryAgentInt
{
    private FactoryAgentInt factory;

public FactoryAgentOD(String nomFactory,
                          int portRMIFactory,
                          int portAdaptateur,
                          FactoryAgentInt factory) throws Exception
        {
            super(portRMIFactory);
            System.out.println("Constructor UnicastRemoteObject : port "+
                               portRMIFactory);
            this.factory=factory;
            
            try{
                LocateRegistry.createRegistry(portAdaptateur);
                System.out.println("Creation du service de nommage : port "+portAdaptateur);
            } catch(Exception ex){}

String name = "rmi://localhost:" +
                portAdaptateur +
                "/" +
                nomFactory;
            
            Naming.rebind(name,this);
            System.out.println("Bind : "+name+" port "+portAdaptateur);
        }
    
    public AgentInt creerAgent(String nomClasseAgent,int couleur) throws RemoteException
    {
      // Creation de l'agent par le factory
      AgentInt agent = factory.creerAgent(nomClasseAgent,couleur);

// On retourne le stub de l'agent pour les utilisateurs
      //  distant du factory
      return (AgentInt)(UnicastRemoteObject.toStub(agent));
    }

public int getTauxMortalite() throws RemoteException
    {
        return factory.getTauxMortalite();
    }

public EspaceToreODInt getEspaceTore() throws RemoteException
    {
        return factory.getEspaceTore();
    }

public String getPathClassesAgent()
    {
        return ChargeurDefaut.pathClasses;
    }

public int getPortRMI() throws RemoteException
  {
    return factory.getPortRMI();
  }

static public void main(String... args) throws Exception
    {
        Parametres params = new Parametres(args);

// Nom du factory
        String nomFactory = params.getString("nom_od","FACTORY");
        
        // Port RMI des OD (factory, agents)
        int portRMI = params.getInt("port_od",9102);
        
        // Port Adaptateur du factory
        int portAdaptateur = params.getInt("port_adaptateur",9100);
        
        // Couleur du joueur
        int couleur=params.getInt("couleur",1);

// Host de l'espace de tore
        String hostEspaceTore = params.getString("host_espace_tore","localhost");
        // Port de l'espace de tore
        int portEspaceTore = params.getInt("port_espace_tore",9100);

// Path des classes d'agent
        ChargeurDefaut.pathClasses = params.getString("pathClasses");

// Initialisation du factory
        FactoryAgent.initialisation(portRMI,hostEspaceTore,portEspaceTore);

FactoryAgentOD factory = new FactoryAgentOD(nomFactory,
                                                    portRMI,
                                                    portAdaptateur,
                                                    FactoryAgent.getInstance());
    }
}

FormCreerAgents.java

package fr.cnam.joueur;
import java.util.*;
import java.io.*;
import java.awt.Point;
import fr.cnam.ihm.*;
import fr.cnam.joueur.*;

// 
public class FormCreerAgents implements FormulaireInt
{
  private FactoryAgentInt factory;
  private Formulaire        form;
  private ArrayList<String> classesAgent;
    
  // Constructeur
  public FormCreerAgents(FactoryAgentInt factory,int couleur)
  {
    this.factory = factory;

form = new Formulaire("Creer agents",this,300,500);
    form.addText("TYPE_AGENT","Type d'agent",true,"");
    form.addButton("CREER_AGENT","Creer un agent");
    try{
      System.out.println("====>"+factory.getPathClassesAgent());
      classesAgent = getClassesAgent(factory.getPathClassesAgent());
    }catch(Exception ex){};
    int num=1;
    for(String classeAgent : classesAgent)
      {
        form.addLabel(classeAgent);
        form.addText("NB_AGENT_"+num,"Nombre d agent",true,"10");
        form.addButton("CR_AGENT_"+num,"Creer");
        num++;
      }
    form.addText("COULEUR","Couleur",true,""+couleur);
    form.addText("MORTALITE","Mortalite",false,"0");

form.addButton("Quit","Quit");
    form.setButtonFermer("Quit");
    try{
      form.afficher();
    }catch(FormulaireException ex)
      {
        System.out.println("Erreur de saisi dans le formulaire :"+ex);
      }

new PullFactoryAgent().start();
  }

//
  public void submit(Formulaire form, String nomSubmit)
  {
    try{
      if (nomSubmit.equals("CREER_AGENT"))
        {
          String nomClasse=form.getValeurChamp("TYPE_AGENT");
          int couleur=Integer.parseInt(form.getValeurChamp("COULEUR"));
          AgentInt s = factory.creerAgent(nomClasse,couleur);
        }

if (nomSubmit.startsWith("CR_AGENT_"))
        {
          int num = Integer.parseInt(nomSubmit.replace("CR_AGENT_",""));
          int couleur=Integer.parseInt(form.getValeurChamp("COULEUR"));
          int nb = Integer.parseInt(form.getValeurChamp("NB_AGENT_"+num));
          for(int i=0;i<nb;i++)
            {
              System.out.println("====> "+classesAgent.get(num-1));
              AgentInt s = factory.creerAgent(classesAgent.get(num-1),couleur);
            }
        }

}
    catch(Exception ex){ex.printStackTrace();};
  }

private static ArrayList<String> getClassesAgent(String pathClassesAgent)
  {
    ArrayList<String> list = new ArrayList<String>();
    File dir = new File(pathClassesAgent+"/fr/cnam/joueur");
    String[] files = dir.list();
    for(String f : files)
      {
        if (f.startsWith("Agent_"))
          {
            System.out.println("----> "+"fr.cnam.joueur."+f.replace(".class",""));
            list.add("fr.cnam.joueur."+f.replace(".class",""));
          }
      }
    return list;
  }

class PullFactoryAgent extends Thread
  {
    public void run()
    {
      while (true)
        {
          try {
            int taux = factory.getTauxMortalite();
            form.setValeurChamp("MORTALITE",""+taux);
            Thread.sleep(100);
          }catch(Exception ex){ex.printStackTrace();};
        }
    }
  }
}

               IHMJoueur.java
            tore
            util
      runEspaceTore.bat
      runFactoryODAgent_Joueur1.bat
      runFactoryODAgent_Joueur2.bat
      runIHMJoueur_1.bat
      runIHMJoueur_2.bat
      runIHMVisuJeuPull.bat
      runIHMVisuJeuPush.bat
      runIHMVisuJeuPush2.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE