Cours CNAM par J. Laforgue

Exercice06_Othello

Retour

Télécharger

Conception et codage de la programmation d'un programme qui permet à 2 joueurs de jouer au jeu d'Othello, et de remplacer un des joueurs par un robot.

Exercice06_Othello.pdf

            compil.bat
      fr
         cnam
            ia
               AlphaBeta.java

package fr.cnam.ia;

import java.util.*;

public class AlphaBeta
{
  private AlphaBetaInt    _ia;              // Objet qui implémente AlphaBetaInt
  private int          _profondeur;      // Profondeur maximal 
  private int          _joueur;          // Numero du joueur qui joue automatiquement
  private int          _joueurAdverse;   // Numero du joueur adverse

public AlphaBeta(AlphaBetaInt ia,    // L'objet qui implémente les méthodes de l'interface
                   int profondeur,  // profondeur maximal de recherche
                   int joueur,      // numéro du joueur automatique
                   int joueurAdverse) // numéro du joueur adverse
  {
    _ia            = ia;
    _profondeur    = profondeur;
    _joueur        = joueur;
    _joueurAdverse = joueurAdverse;
  }

// méthode appelé par le joueur automatique qui retourne le meilleur coup à jouer.
  //  EtatJeu est l'état initial du jeu sur lequel il faut jouer un coup
  //
  public Object estimer(EtatJeu etatJeu)
  {
    ResultatAlphaBeta resultat = alphabeta(_joueur,etatJeu,0,-10000,+10000);
    return(resultat.coup);
  }

// méthode récurssive de recherche du meilleur coup
  // joueur est le joueur courant dans l'arbre de recherche
  // etatJeu est l'état courant du jeu sur lequel le joueur doit jouer
  // profondeur est la profondeur courante
  // alpha est le seuil maximal d'allégage de l'arbre
  // beta  est le seuil minimal d'allégage de l'arbre
  //
  public ResultatAlphaBeta alphabeta(int joueur,EtatJeu etatJeu,int profondeur,int alpha,int beta)
  {
    ResultatAlphaBeta resultat ;

// Determination des coups valides du joueur
    Vector v = _ia.coupsValides(joueur,etatJeu);
    if (v.size() == 0) // Si le joueur ne peut pas jouer
      {
        Vector v2 = _ia.coupsValides(getAdverse(joueur),etatJeu);
        if (v2.size() == 0) // Les 2 joueurs ne peuvent pas jouer
          resultat = _ia.evaluer(_joueur,joueur,getAdverse(joueur),null,etatJeu);
        else // Le joueur adverse joue
          resultat = alphabeta(getAdverse(joueur),etatJeu,profondeur+1,alpha,beta);
      }
    else
      {
        int minimum = +10000;
        int maximum = -10000;
        Object coup=null;
        for(int i=0;i<v.size();i++)
          {
            // On calcule la nouvelle position en fonction du coup joué
            EtatJeu etatJeuNew = _ia.majEtatJeu(joueur,
                                                etatJeu,
                                                v.elementAt(i));

ResultatAlphaBeta result=_ia.evaluer(_joueur,joueur,getAdverse(joueur),v.elementAt(i),etatJeuNew);

if ( (profondeur < _profondeur) && (result.prioritaire==0) )
              result=alphabeta(getAdverse(joueur),etatJeuNew,profondeur+1,alpha,beta);

if (joueur == _joueur)
              {
                if (result.res > maximum) 
                  {
                    maximum = result.res;
                    coup = v.elementAt(i);
                  }
                if (maximum > alpha)  
                  {
                    alpha=maximum;
                    if (maximum>beta) 
                      {
                        resultat = new ResultatAlphaBeta(maximum,coup,0); // coupure beta
                        break;
                      }
                  }
              }
            else
              {
                if (result.res < minimum) 
                  {
                    minimum = result.res;
                    coup = v.elementAt(i);
                  }
                if (minimum < beta) 
                  {
                    beta=minimum;
                    if (minimum < alpha) 
                      {
                        resultat = new ResultatAlphaBeta(minimum,coup,0); // coupure alpha
                        break;
                      }
                  }
              }
          }

// on retourne la valeur maximal ou minimal suivant le joueur courant
        if (joueur == _joueur) 
          resultat = new ResultatAlphaBeta(maximum,coup,0);
        else
          resultat = new ResultatAlphaBeta(minimum,coup,0);
      }
    
    return resultat;
  }

// Valeur minimal entre deux entiers
  private int min(int a,int b)
  {
    if (a<b)return a; else return b;
  }

// Retourne le numéro du joueur adverse
  private int getAdverse(int joueur)
  {
    if (joueur == _joueur) return(_joueurAdverse);
    else return(_joueur);
  }

}

               AlphaBetaInt.java
               EtatJeu.java
               ResultatAlphaBeta.java
            ihm
            othello
               controleur
                  ControleurOthello.java
                  ControleurOthelloDistant.java

package fr.cnam.othello.controleur;

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

import fr.cnam.othello.model.*;
import fr.cnam.othello.vue.*;
import fr.cnam.prog.*;

// Proxy de communication vers le controleur du maitre.
// Ce proxy est utilise par l'esclave.
//
public class ControleurOthelloDistant implements ControleurOthello
{
  private ControleurOthelloODInt controleur; // interface distante du conroleur

// Constructeur qui fait un lookup sur le controleur distant
  //
  public ControleurOthelloDistant()
  {
    String urmi=null;
    try
      {
        String host = Exercice06_Joueur.addresseHostJoueur1;
        urmi = "rmi://"+host+":9100/CONTROLEUR_OTHELLO";
        controleur = (ControleurOthelloODInt)Naming.lookup(urmi);
        System.out.println("Lookup sur controleur "+urmi);
      }
    catch(Exception ex){System.out.println("Erreur lookup sur "+urmi);}
  }

// methodes du proxy
  // ------------------------------

public boolean actionJouerOthello(int joueur,int x,int y)
  {
    try{
      return controleur.actionJouerOthello(joueur,x,y);
    }catch(Exception ex){return false;}
  }
  public void actionNotificationOthello()
  {
    try{
      controleur.actionNotificationOthello();
    }catch(Exception ex){};
  }
  // Ajouter un observer par l'esclave consiste a creer 
  //  un adaptateur de l'observeur distant et 
  //  faire le add observeur sur le contoleur distant qui va a son tour
  //  cree un proxy d'observer
  //
  public void addObserveur(Observer observeur)
  {
    try{
      AdaptObserverOthello adaptateur = new AdaptObserverOthello(9200,observeur);
      ObserverDistant obsdis = adaptateur.toStub();
      controleur.addObserveur(obsdis);
    }catch(Exception ex){
      try{
        AdaptObserverOthello adaptateur = new AdaptObserverOthello(9201,observeur);
        ObserverDistant obsdis = adaptateur.toStub();
        controleur.addObserveur(obsdis);
      }catch(Exception ex2){};
    };
  }

public int getNumJoueurCourant()
  {
    try{
      return controleur.getNumJoueurCourant();
    }catch(Exception ex){return 0;}
  }

}

ControleurOthelloImpl.java

package fr.cnam.othello.controleur;

import java.util.*;

import fr.cnam.othello.model.*;

// Class de definition du controleur du jeu d'othello
//  qui est un singleton
//
public class ControleurOthelloImpl implements ControleurOthello
{
  // L'attribut du singleton
  private static ControleurOthello controleurOthelloSingleton = null;

// Attribut qui designe que ce singleton doit utiliser
  //  un controleur distant
  //
  private static boolean remote = false;
  
  // Le modele
  private ModelOthello modelOthello;
  
  // Constructeur
  //
  private ControleurOthelloImpl(ModelOthello model)
  {
    modelOthello = model;
  }

// Pour positionner le mode remote
  //
  static public void remote()
  {
    remote=true;
  }

// Creation du singleton
  //
  static public ControleurOthello getInstance()
  {
    if (controleurOthelloSingleton==null)
      {
        // Le controleur est local
        //
        if (!remote)
          {
            // Creation du controleur
            controleurOthelloSingleton = new ControleurOthelloImpl(new ModelOthello());

// Creation de l'adaptateur pour utiliser le controleur de manière distant
            //  Celui du 2eme joueur ne se cree pas car meme port (9200)
            try
              {
                new ControleurOthelloODImpl(controleurOthelloSingleton);
              }
            catch(Exception ex){System.out.println("Erreur de creation du controleur OD");}
          }
        // Le controleur est distant
        //
        else
          controleurOthelloSingleton = new ControleurOthelloDistant();

}

return controleurOthelloSingleton;
  }

// Action de jeu d'un joueur qui consiste a modifier le modele
  //
  synchronized public boolean actionJouerOthello(int joueur,int x,int y)
  {
    System.out.println("Controleur : actionJouerOthello");
    return modelOthello.jouerOthello(joueur,x,y);
  }

// Action de demande au modele de notifier son etat
  //
  synchronized public void actionNotificationOthello()
  {
    System.out.println("actionNotificationOthello");
    if (modelOthello!=null)
      {
        modelOthello.notifierOthello();
      }
  }

// Ajouter un observer a l'observable
  //
  synchronized public void addObserveur(Observer observeur)
  {
    modelOthello.getObservableOthello().addObserver(new ProxyObserverAsynchrone(observeur));
  }

synchronized public int getNumJoueurCourant()
  {
    return modelOthello.getNumJoueurCourant();
  }

}

ControleurOthelloODImpl.java

package fr.cnam.othello.controleur;

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

import fr.cnam.othello.model.*;
import fr.cnam.othello.controleur.*;
import fr.cnam.othello.vue.*;

// Adapteur RMI qui permet d'utiliser le controleur de maniere distant
//
public class ControleurOthelloODImpl extends UnicastRemoteObject implements ControleurOthelloODInt
{
  private ControleurOthello controleur; // Le controleur

// Constructeur
  //
  public ControleurOthelloODImpl(ControleurOthello controleur) throws Exception
  {
    super(9200);
    this.controleur = controleur;

// Creation de l'annuaire s'il n'existe pas déjà
    try{LocateRegistry.createRegistry(9100);} catch(Exception ex){};

String urmi = "rmi://localhost:9100/CONTROLEUR_OTHELLO";
    System.out.println("Service : "+urmi);
    Naming.rebind(urmi,this);
    System.out.println("Service connecteur enregistre : "+urmi);
  }

// Les methodes adaptees :
  //-------------------------------

public boolean actionJouerOthello(int joueur,int x,int y) throws RemoteException
  {
    try{
      return controleur.actionJouerOthello(joueur,x,y);
    }catch(Exception ex){return false;}
  }
  public void actionNotificationOthello() throws RemoteException
  {
    try{
      controleur.actionNotificationOthello();
    }catch(Exception ex){};
  }
  // On surcharge le traitement de la méthode addobserveur afin de creer
  //  un proxy d'Observer qui utilise l'oberveur distant passe en parametre
  //  qui est un stub 
  //
  public void addObserveur(ObserverDistant observeurDistant) throws RemoteException
  {
    try{
      System.out.println("Création du proxy d'un observer distant");
      controleur.addObserveur(new ProxyObserverAsynchrone(new ProxyObserverOthello(observeurDistant)));
      System.out.println("Ajout du proxy comme observer de l'observable");
    }catch(Exception ex){System.out.println("Erreur addObserveur distant");};
  }

public int getNumJoueurCourant() throws RemoteException
  {
    try{
      return controleur.getNumJoueurCourant();
    }catch(Exception ex){return 0;}
  }

}

                  ControleurOthelloODInt.java
               model
                  ModelOthello.java

package fr.cnam.othello.model;

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

import fr.cnam.othello.vue.DataVueOthello;

// Classe de definition du modele du jeu d'othello
//
public class ModelOthello 
{
  public final static int NB_COLONNES = 8;
  public final static int NB_LIGNES   = 8;
  private ObservableOthello  observableOthello;
  private int[][] grilleModele;
  private int numJoueurCourant;

// Constructeur
  //
  public ModelOthello()
  {
    this.observableOthello = new ObservableOthello();
    this.grilleModele = new int[NB_COLONNES][NB_LIGNES];
    this.numJoueurCourant = 1;

//Init
    this.grilleModele[3][3]=1;
    this.grilleModele[3][4]=2;
    this.grilleModele[4][3]=1;
    this.grilleModele[4][4]=2;
  }

// Traitement d'un coup d'un joueur
  //
  public boolean jouerOthello(int numJoueur,int x, int y)
  {
    if (numJoueurCourant!=numJoueur) 
      {
        return false;
      }

// maj du jeu
    Vector pionsARetourner = calculerPrises(grilleModele,numJoueur,x,y);
    if (pionsARetourner.size()!=0)
      {
        for(int i=0;i<pionsARetourner.size();i++)
          {
            Point p = (Point)(pionsARetourner.elementAt(i));
            grilleModele[(int)p.x][(int)p.y] = numJoueur;
          }
        if (numJoueur==1) 
          {
            if (peutJouer(grilleModele,2))
              numJoueurCourant=2;
          }
        else 
          {
            if (peutJouer(grilleModele,1))
              numJoueurCourant=1;
          }
        // On notifie le nouvel etat de la grille du jeu
        //
        observableOthello.setChanged();
        observableOthello.notifyObservers(getData());
      }
    else
      {
        System.out.println("COUP INVALIDE");
        return false;
      }

return true;
  }

// getteurs
  //
  public ObservableOthello getObservableOthello()
  {
    return observableOthello;
  }
  public int getNumJoueurCourant()
  {
    return numJoueurCourant;
  }
  public DataVueOthello getData()
  {
    int[][] grille = new int[NB_COLONNES][NB_LIGNES];

for(int i=0;i<NB_COLONNES;i++)
      for(int j=0;j<NB_LIGNES;j++)
        {
          grille[i][j]=grilleModele[i][j];
        }
    return  new DataVueOthello(grille);
  }
    
  // Notifier l'etat du modele (appele depuis le controleur)
  //
  public void notifierOthello()
  {
    System.out.println("notifierOthello");
    observableOthello.setChanged();
    observableOthello.notifyObservers(getData());
  }

// Calcul les prises d'un coup d'un joueur en explorant les 8 directions du coup joue.
  // Retourne un Vector contenant les prises (Point)
  // Si le vecteur est vide alors cela veut dire que le coup n'est pas jouable
  //
  public static Vector calculerPrises(int[][] grilleModele,int joueur,int x,int y)
  {
    int tailleGrille = grilleModele[0].length;
    Point sens[]={new Point(-1,-1),
                  new Point(0,-1),
                  new Point(1,-1),
                  new Point(-1,0),
                  new Point(1,0),
                  new Point(-1,1),
                  new Point(0,1),
                  new Point(1,1)};
    Vector v = new Vector();

// Si la case jouee n'est pas libre alors coup invalide
    if (grilleModele[x][y]!=0) return v;

// On parcours les 8 sens possible a partir de la case joue
    //
    Point depart = new Point(x,y);
    for(int s=0;s<8;s++)
      {
        Point p = depart;
        boolean fini = false;
        Vector tmp = new Vector(); // Les cases dans un sens
        p = caseSuiv(p,sens[s]);
        while(!fini)
          {
            if( (pointDehors(p,tailleGrille)) || 
                (grilleModele[(int)p.x][(int)p.y]==0) )
              {
                fini=true;
                tmp= new Vector();
              }
            else
              {
                if(grilleModele[(int)p.x][(int)p.y]!=joueur)
                  {
                    tmp.addElement(p);
                    p=caseSuiv(p,sens[s]);
                  }
                else {fini=true;}
              }
          }
        // On ajoute les cases d'un sens
        for(int i=0;i<tmp.size();i++)
          {
            v.addElement(tmp.elementAt(i));
          }
      }

// Si il existe des cases valides alors on ajoute 
    //  la case jouee
    if (v.size()!=0)
      v.addElement(depart);

// On retourne les cases a retourner
    return(v);
  }

// Teste si le point est en dehors de la grille
  //
  static public boolean pointDehors(Point p,int tailleGrille)
  {
    int px=(int)p.x;
    int py=(int)p.y;
    if ( (px<0)||
         (px>=tailleGrille)||
         (py<0)||
         (py>=tailleGrille))
      return(true);
    else
      return(false);
  }

// Determine la case suivante en fonction d'un sens
  //
  static public Point caseSuiv(Point p,Point sens)
  {
    return( new Point(p.x+sens.x,
                      p.y+sens.y));
  }

//Determine si un joueur peut jouer
  //
  static public boolean peutJouer(int[][] grilleModele,int joueur)
  {
    int nb=0;
    for(int i=0;i<NB_COLONNES;i++)
      for(int j=0;j<NB_LIGNES;j++)
        if (grilleModele[i][j]==0)
          {
            Vector v = calculerPrises(grilleModele,joueur,i,j);
            if (v.size()!=0) nb++;
          }
    if (nb==0)return false;
    else return true;
  }
}

                  ObservableOthello.java
                  ProxyObserverAsynchrone.java
               vue
                  AdaptObserverOthello.java

package fr.cnam.othello.vue;

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

// Classe qui adapte l'observeur local afin qu'il puisse
//  etre utilisé a travers une interface distante 
//
public class AdaptObserverOthello extends UnicastRemoteObject implements ObserverDistant
{
  Observer observeurLocal;
    
  // Constructeur
  public AdaptObserverOthello(int port,Observer observeurLocal) throws RemoteException
  {
    super(port);
    System.out.println("Creation de l'adaptateur observer sur port "+port);
    this.observeurLocal=observeurLocal;
  }

// Methode de notification 
  //
  public void update(Observable o,Object arg)  throws RemoteException
  {
    System.out.println(">>AdaptObserverOthello>update");
    DataVueOthello data = (DataVueOthello)arg;
    observeurLocal.update(o,data);
  }

// Le stub
  //
  public ObserverDistant toStub() 
  {
    try{
      ObserverDistant stub = (ObserverDistant)(UnicastRemoteObject.toStub(this));
      System.out.println("Recuperation du stub");
      if (stub==null)
        System.out.println("Le stub est null");
      return stub;
    }catch(Exception ex){System.out.println("Erreur sur toStub ");return null;}
  }
}

                  DataVueOthello.java
                  ObserverDistant.java
                  ObserverOthello.java
                  ObserverOthelloRobot.java

package fr.cnam.othello.vue;

import java.util.*;

import fr.cnam.othello.model.ModelOthello;
import fr.cnam.othello.controleur.*;

// Classe de definition de l'observer de l'ihm d'Othello
//
public class ObserverOthelloRobot implements Observer
{
  VueAfficherOthello vue;
    
  // Constructeur
  //
  public ObserverOthelloRobot(VueAfficherOthello vue)
  {
    this.vue=vue;
  }

// Methode de notification : arg est toutes les donnees du modele
  //
  public void update(Observable o,Object arg)
  {
    System.out.println(">>ObserverOthelloRobot: update");
    Robot.getInstance();
  }
}

class Robot implements Runnable
{
  private static Robot singleton=null;
  private Robot()
  {
    new Thread(this).start();
  }
  public static Robot getInstance(){
    if(singleton==null)return new Robot();
    else return singleton;
  }
  public void run(){
    while(true){
      try{
        for(int i=0;i<ModelOthello.NB_COLONNES;i++)
          for(int j=0;j<ModelOthello.NB_LIGNES;j++)
            ControleurOthelloImpl.getInstance().actionJouerOthello(2,i,j);
        Thread.sleep(200);
      }catch(Exception ex){};
    }
  }
}

                  ObserverRobot.java
                  ProxyObserverOthello.java
                  RobotOthello.java

package fr.cnam.othello.vue;

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import fr.cnam.othello.model.*;
import fr.cnam.othello.controleur.*;
import fr.cnam.ihm.*;
import fr.cnam.ia.*;

// Classe de definition du robot
//
public class RobotOthello implements AlphaBetaInt
{
  private   ControleurOthello controleur; // Le controleur
  private   int               numJoueurRobot;  // 1 ou 2

// Constructeur
  //
  public RobotOthello(int numJoueurArg)
  {
    // Initialisation par defaut des attributs de la vue
    numJoueurRobot  = numJoueurArg;
    controleur = ControleurOthelloImpl.getInstance();
    controleur.addObserveur(new ObserverRobot(this));
  }

// Le robot joue 
  //
  public void jouerCoup(DataVueOthello data)
  {
    int numJoueurCourant = controleur.getNumJoueurCourant();
    if (numJoueurRobot!=numJoueurCourant) 
      {
        System.out.println("Pas au robot");
        return;
      }

int joueurAdverse;
    if (numJoueurRobot==1) joueurAdverse=2;
    else joueurAdverse=1;
    AlphaBeta algo = new AlphaBeta(this,
                                   5,  // On peut augmenter la profondeur
                                   numJoueurRobot,
                                   joueurAdverse);
    Point p = (Point)algo.estimer(new EtatJeuGrille(data.getGrille()));
    if (p==null) 
      {
        System.out.println("LA PARTIE EST TERMINEE");
        int diff = differencePions(data.getGrille(),numJoueurRobot,joueurAdverse);
        if (diff>0) System.out.println("LE ROBOT "+numJoueurRobot+" A GAGNE AVEC UNE DIFFERENCE DE "+diff);
        else if (diff<0) System.out.println("LE ROBOT "+numJoueurRobot+" A PERDU AVEC UNE DIFFERENCE DE "+diff);
        else System.out.println("MATCH NUL");
      }
    else 
      {
        System.out.println("Coup joue par le robot: "+p.x+" "+p.y);
        controleur.actionJouerOthello(numJoueurRobot,p.x,p.y);
      }
  }

// Difference du nombre de pions entre ceux
  //  de numJoueur et l'autre
  //
  static public int differencePions(int[][] grille,int numJoueur,int numJoueurAdverse)
  {
    int s1=0;
    int s2=0;
    for(int i=0;i<ModelOthello.NB_COLONNES;i++)
      for(int j=0;j<ModelOthello.NB_LIGNES;j++)
        {
          if(grille[i][j]==numJoueur) s1++;
          if(grille[i][j]==numJoueurAdverse) s2++;
        }
    return s1-s2;
  }

// retourne les coups valides d'un joueur en fonction d'une grille
  //
  public Vector coupsValides(int joueur,EtatJeu etatJeu)
  {
    EtatJeuGrille etatJeuGrille=(EtatJeuGrille)etatJeu;
    int[][] grille = etatJeuGrille.grille;
    Vector vlist =new Vector();
    
    int nb=0;
    for(int i=0;i<ModelOthello.NB_COLONNES;i++)
      for(int j=0;j<ModelOthello.NB_LIGNES;j++)
        if (grille[i][j]==0)
          {
            Vector v = ModelOthello.calculerPrises(grille,joueur,i,j);
            if (v.size()!=0) 
              vlist.add((Object)new Point(i,j));
          }
    return vlist;
  }

// retourne une copie de la grille avec la mise a jour de la grille en
  // entree en fonction d'un coup joué
  public EtatJeu majEtatJeu(int joueur,EtatJeu etatJeu,Object coup)
  {
    EtatJeuGrille etatJeuGrille=(EtatJeuGrille)etatJeu;
    int[][] grille = etatJeuGrille.grille;
    int[][] grilleNouvelle = new int[ModelOthello.NB_COLONNES][ModelOthello.NB_LIGNES];
    for(int i=0;i<ModelOthello.NB_COLONNES;i++)
      for(int j=0;j<ModelOthello.NB_LIGNES;j++)
        grilleNouvelle[i][j]=grille[i][j];

Point p = (Point)coup;
    Vector pionsARetourner = ModelOthello.calculerPrises(grilleNouvelle,joueur,p.x,p.y);
    if (pionsARetourner.size()!=0)
      {
        for(int i=0;i<pionsARetourner.size();i++)
          {
            Point pp = (Point)(pionsARetourner.elementAt(i));
            grilleNouvelle[(int)pp.x][(int)pp.y] = numJoueurRobot;
          }
      }
    return (EtatJeu)(new EtatJeuGrille(grilleNouvelle));
  }
  
  // evalue la "force" d'un état de la grille sachant que le coup joué est "coup"
  // retourne une valeur numérique qui traduit l'avantage du joueur
  // Cette valeur est maximal si le joueur courant est le joueur automatique
  // Cette valeur est minimal sinon
  //
  //  joueurOrdinateur : Numero du joueur automatique
  //  joueur           : numero du joueur courant dans l'alpha beta
  //  joueurAdverse    : numero du joueur adverse de joueur
  //  coup             : coup joué (si nécessaire dans le calcul d'évaluation)
  //  etatJeu          : état de la grille du jeu suite au coup joué
  //
  public ResultatAlphaBeta evaluer(int joueurOrdinateur,int joueur,int joueurAdverse,Object coup,EtatJeu etatJeu)
  {
    EtatJeuGrille etatJeuGrille=(EtatJeuGrille)etatJeu;
    int[][] grille = etatJeuGrille.grille;
    int sens;
    if (joueur==joueurOrdinateur)sens=1;
    else sens=-1;

if (coup!=null)
      {
        // Un coup dans les coins est prioritaire.
        // Cela signifie que l'algo AlphaBeta ne descend pas plus bas dans
        // la recherche d'un meilleur coup.
        //
        Point p = (Point)coup;
        if ( ((p.x==0) && (p.y==0))||
             ((p.x==0) && (p.y==ModelOthello.NB_LIGNES-1))||
             ((p.x==ModelOthello.NB_COLONNES-1) && (p.y==0))||
             ((p.x==ModelOthello.NB_COLONNES-1) && (p.y==ModelOthello.NB_LIGNES-1)) )
          return new ResultatAlphaBeta(100*sens,coup,1);  // 1 => prioritaire
        
        // Si le coup est sur un bord alors meilleur que la différence
        //  Poids important.
        //
        if ( (p.x==0) || (p.y==0)||
             (p.y==ModelOthello.NB_LIGNES-1)||
             (p.x==ModelOthello.NB_COLONNES-1) )
          return  new ResultatAlphaBeta(50*sens,coup,0);
      }

// Différence des pions retournés par le joueur automatique avec l'adverse
    //
    if (joueur==joueurOrdinateur) return new ResultatAlphaBeta(differencePions(grille,joueur,joueurAdverse),coup,0);
    else return new ResultatAlphaBeta(differencePions(grille,joueurAdverse,joueur),coup,0);

}
}

class EtatJeuGrille implements EtatJeu
{
  public int[][] grille;
  public EtatJeuGrille(int[][] grille)
  {
    this.grille=grille;
  }
}

VueAfficherOthello.java

package fr.cnam.othello.vue;

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import fr.cnam.othello.model.*;
import fr.cnam.othello.controleur.*;
import fr.cnam.ihm.*;

// Classe de definition d'une vue qui affiche un jeu d'othello
//
public class VueAfficherOthello implements FormulaireInt, ControlesCanvasIHM
{
  private   ControleurOthello controleur; // Le controleur
  private   CanvasIHM         ihm;        // L'IHM de la grille
  private   int               numJoueur;  // 1 ou 2
  private   Formulaire        form;       // Le formulaire
  private   boolean           modeRobot;  // En mode robot

// Constructeur de la vue
  //
  public VueAfficherOthello(int numJoueurArg)
  {
    // Initialisation par defaut des attributs de la vue
    //
    numJoueur  = numJoueurArg;
    controleur = ControleurOthelloImpl.getInstance();
    modeRobot = false;

// Creation du formulaire
    //
    CanvasIHM.TYPE_MARQUE=2; // Afficher des ronds plutoit que des carres
    form = new Formulaire("OTHELLO",this,300,300);
    form.addButton("ROB","MODE ROBOT");
    ihm = form.addGrilleIHM(ModelOthello.NB_COLONNES,ModelOthello.NB_LIGNES,20,this);

// Abonnement au modele
    //
    controleur.addObserveur(new ObserverOthello(this));

}

// getteur
  //
  public CanvasIHM getIHM(){return ihm;}

// Affichage de l'ihm
  // 
  public void afficher()
  {
    // Affichage de l'IHM
    form.afficher(10+500*(numJoueur-1),10);

// Demande au controleur de recuperer toutes les informations du modele via
    //  la notification. 
    //
    controleur.actionNotificationOthello();
  }

// Methode appele quand on clique sur un bouton
  //
  public void     submit(Formulaire form,String nom)
  {
    if (nom.equals("ROB"))
      {
        if (! modeRobot)
          {
            modeRobot=true;
            new RobotOthello(numJoueur);
            controleur.actionNotificationOthello();
          }
        else
          {
            System.out.println("MODE ROBOt DEJA ACTIF");
          }
      }
  }

// Methode appele quand on clique dans une case
  //
  public void pointerCaseGrille(int xCase,int yCase,CanvasIHM ihm)
  {
    System.out.println("pointerCaseGrille: "+xCase+" "+yCase);
    boolean aujoueurdejouer = controleur.actionJouerOthello(numJoueur,xCase,yCase);
    if (!aujoueurdejouer)
      System.out.println("COUP INVALIDE OU CE N'EST PAS A VOUS DE JOUER");
  }
  
  // Non utilise
  public void pointerCanvas(Object target,int x,int y,CanvasIHM ihm)
  {
  }

}

            prog
               Exercice06.java
               Exercice06_Joueur.java

package fr.cnam.prog;

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

import fr.cnam.ihm.*;

import fr.cnam.othello.vue.*;
import fr.cnam.othello.controleur.*;

// Programme principal d'execution du jeu d'othello
//
// Ce programme est utilise par chacun des joueur en passant en parametre
//  le numero du joueur
//
// Le joueur 1 doit lancer en premier son programme (il est le maitre)
//  et ensuite le joueur 2
//
//   args[0] = numero du joueur : 1 ou 2
//
public class Exercice06_Joueur
{
  static public String addresseHostJoueur1 = "localhost";

public static void main(String... args) throws Exception
  {
    int numJoueur = Integer.parseInt(args[0]);  // 1 ou 2

// Si c'est le joueur 2 alors il est l'esclave. Le controleur qu'il utilise
    //  est donc remote (il se trouve dans la JVM du joueur 1)
    //
    if (numJoueur == 2) ControleurOthelloImpl.remote();

// Creation de l'IHM du joueur
    VueAfficherOthello vueJeu = new VueAfficherOthello(numJoueur);
    vueJeu.afficher();

}
}

            tore
      run.bat
      runJoueur1.bat
      runJoueur2.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE