Partage
  • Partager sur Facebook
  • Partager sur Twitter

Mon MinMax joue vraiment mal

Sujet résolu
victorm951
    28 juin 2015 à 15:01:15

    Salut à tous,
    Comme dit dans le titre j'ai codé un joueur MinMax (à partir du cours http://openclassrooms.com/courses/l-algorithme-min-max), mais mon problème, c'est qu'il joue très mal.
    Par exemple, si j'aligne 2 croix, il ne va pas forcement essayer de me bloquer...
    Voici mon code :
    Graphic_Interface.java
    package com.vm.games;


import javax.swing.*;
import java.awt.*;

public class Graphic_Interface {

    public static int[][] grid = new int[3][3];
    private static BT bt1;
    private static BT bt2;
    private static BT bt3;
    private static  BT bt4;
    private static  BT bt5;
    private static  BT bt6;
    private static  BT bt7;
    private static BT bt8;
    private static   BT bt9;

    //------------------------------------------------------------------------------------------------------------------------------------------------------

    public static void main(String[] args) {

        int[] t = new int[2];

        t[0]=0;
        t[1]=0;
        bt1 = new BT("", t);
        t[0]=1;
        t[1]=0;
        bt2 = new BT("", t);
        t[0]=2;
        t[1]=0;
        bt3 = new BT("", t);
        //##################
        t[0]=0;
        t[1]=1;
        bt4 = new BT("", t);
        t[0]=1;
        t[1]=1;
        bt5 = new BT("", t);
        t[0]=2;
        t[1]=1;
        bt6 = new BT("", t);
        //##################
        t[0]=0;
        t[1]=2;
        bt7 = new BT("", t);
        t[0]=1;
        t[1]=2;
        bt8 = new BT("", t);
        t[0]=2;
        t[1]=2;
        bt9 = new BT("", t);

        JFrame window = new JFrame();
        window.setTitle("Tic Tac Toe");
        window.setSize(600, 600);
        window.setLocationRelativeTo(null);
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel pan = new JPanel();
        pan.setBackground(Color.WHITE);
        window.setContentPane(pan);

        GridLayout gl = new GridLayout();
        gl.setColumns(3);
        gl.setRows(3);
        gl.setRows(3);
        gl.setHgap(5);
        gl.setVgap(5);
        window.setLayout(gl);

        window.getContentPane().add(bt1);
        window.getContentPane().add(bt2);
        window.getContentPane().add(bt3);
        window.getContentPane().add(bt4);
        window.getContentPane().add(bt5);
        window.getContentPane().add(bt6);
        window.getContentPane().add(bt7);
        window.getContentPane().add(bt8);
        window.getContentPane().add(bt9);

        window.setVisible(true);
        System.out.println("Window is now visible");


    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------

    public static void play(int x, int y, int p){
        grid[x][y]=p;
        showGrid();
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------

    private static void showGrid(){

        if(grid[0][0]!=0){
            bt1.setText(symbol(grid[0][0]));
            bt1.setEnabled(false);
        }

        if(grid[1][0]!=0){
            bt2.setText(symbol(grid[1][0]));
            bt2.setEnabled(false);
        }

        if(grid[2][0]!=0){
            bt3.setText(symbol(grid[2][0]));
            bt3.setEnabled(false);
        }

        //####################################

        if(grid[0][1]!=0){
            bt4.setText(symbol(grid[0][1]));
            bt4.setEnabled(false);
        }

        if(grid[1][1]!=0){
            bt5.setText(symbol(grid[1][1]));
            bt5.setEnabled(false);
        }

        if(grid[2][1]!=0){
            bt6.setText(symbol(grid[2][1]));
            bt6.setEnabled(false);
        }

        //####################################

        if(grid[0][2]!=0){
            bt7.setText(symbol(grid[0][2]));
            bt7.setEnabled(false);
        }

        if(grid[1][2]!=0){
            bt8.setText(symbol(grid[1][2]));
            bt8.setEnabled(false);
        }

        if(grid[2][2]!=0){
            bt9.setText(symbol(grid[2][2]));
            bt9.setEnabled(false);
        }


    }

    private static String symbol(int p){
        if(p==1){
            return "O";
        }else{
            return "X";
        }
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------

    public static boolean win(int p){

        if (grid[0][0]==p && grid[1][1]==p && grid[2][2]==p){
            gameEnd();
            return true;
        }else if(grid[0][2]==p && grid[1][1]==p && grid[2][0]==p){
            gameEnd();
            return true;
        }else if(grid[0][0]==p && grid[0][1]==p && grid[0][2]==p){
            gameEnd();
            return true;
        }else if(grid[1][0]==p && grid[1][1]==p && grid[1][2]==p){
            gameEnd();
            return true;
        }else if(grid[2][0]==p && grid[2][1]==p && grid[2][2]==p){
            gameEnd();
            return true;
        }else if(grid[0][0]==p && grid[1][0]==p && grid[2][0]==p){
            gameEnd();
            return true;
        }
        else if(grid[0][1]==p && grid[1][1]==p && grid[2][1]==p){
            gameEnd();
            return true;
        }else if(grid[0][2]==p && grid[1][2]==p && grid[2][2]==p){
            gameEnd();
            return true;
        }else{
            return false;
        }

    }


    public static boolean gameFull(){
        for(int i=0 ; i<2 ; i++){
            for(int j=0 ; j<2 ; j++){
                if(grid[i][j]!=0){
                    return false;
                }
            }
        }
        return true;
    }

    public static void gameEnd(){
        bt1.setEnabled(false);
        bt2.setEnabled(false);
        bt3.setEnabled(false);
        bt4.setEnabled(false);
        bt5.setEnabled(false);
        bt6.setEnabled(false);
        bt7.setEnabled(false);
        bt8.setEnabled(false);
        bt9.setEnabled(false);
    }

}
    Min_Max.java
    package com.vm.games;


public class Min_Max {

    public static int[][] grid;
    private static int p1_series = 0;
    private static int p2_series = 0;

    public static void ia_play(int depth){

        int max = -10000;
        int tmp = 0;
        int maxI = 0;
        int maxJ = 0;


        for(int i=0 ; i<3 ; i++){
            for(int j=0 ; j<3 ; j++){

                if(grid[i][j]==0){

                    grid[i][j]=1;
                    tmp=min(depth-1);

                    if(tmp>max){
                        max = tmp;
                        maxI = i;
                        maxJ = j;
                    }

                    grid[i][j]=0;
                }
            }
        }

        Graphic_Interface.play(maxI, maxJ, 1);
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------------------------------------------------------------------------

    private static int max(int depth){

        if(depth==0 || winner()!=0){
            return score();
        }

        int max=-10000;
        int tmp;

        for(int i=0 ; i<3 ; i++){
            for(int j=0 ; j<3 ; j++){

                if(grid[i][j]==0){

                    grid[i][j]=2;
                    tmp=min(depth-1);

                    if(tmp > max){
                        max=tmp;
                    }

                    grid[i][j]=0;

                }
            }
        }
        return max;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------------------------------------------------------------------------

    private static int min(int depth){

        if(depth==0 || winner()!=0){
            return score();
        }

        int min = 10000;
        int tmp;

        for(int i=0 ; i<3 ; i++){
            for(int j=0 ; j<3 ; j++){

                if(grid[i][j]==0){

                    grid[i][j]=1;
                    tmp=max(depth - 1);

                    if(tmp<min){
                        min=tmp;
                    }

                    grid[i][j]=0;
                }
            }
        }

        return min;

    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------------------------------------------------------------------------

    private static int score(){

        int winner=0;
        int pieces_nb=0;

        for(int i=0 ; i<3 ; i++){
            for(int j=0; j<3 ; j++){

                if(grid[i][j]!=0){
                    pieces_nb++;
                }

            }
        }

        winner = winner();

        if(winner==1){
            return 1000 - pieces_nb;
        }else if(winner==2){
            return pieces_nb - 1000;
        }else if(winner!=0){
            return 0;
        }

        p1_series = 0;
        p2_series = 0;
        series_nb(2);

        return p1_series - p2_series;

    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------

    private static void series_nb(int n){

        int c1=0;
        int c2=0;
        p1_series=0;
        p2_series=0;


        /*
        +--
        -+-
        --+
         */

        for(int a=0 ; a<3 ; a++){

            if(grid[a][a]==1){

                c1++;
                c2=0;

                if(c1==n){
                    p1_series++;
                }

            }else if(grid[a][a]==2){

                c2++;
                c1=0;

                if(c2==n){
                    p2_series++;
                }

            }

        }

        c1=0;
        c2=0;


        /*
        --+
        -+-
        +--
         */

        for(int b=0 ; b<3 ; b++){

            if(grid[b][2-b]==1){

                c1++;
                c2=0;

                if(c1==n){
                    p1_series++;
                }

            }else if(grid[b][2-b]==2){

                c2++;
                c1=0;

                if(c2==n){
                    p2_series++;
                }

            }

        }


        /*
        -+-
        +++
        -+-
         */

        for(int i=0 ; i<3 ; i++){

            c1=0;
            c2=0;


            /*
            ---
            +++
            ---
             */

            for(int j=0 ; j<3 ; j++){

                if(grid[i][j]==1){

                    c1++;
                    c2=0;

                    if(c1==n){
                        p1_series++;
                    }

                }else if(grid[i][j]==2){

                    c2++;
                    c1=0;

                    if(c2==n){
                        p2_series++;
                    }

                }

            }

            c1=0;
            c2=0;


            /*
            -+-
            -+-
            -+-
             */

            for(int k=0 ; k<3 ; k++){

                if(grid[k][i]==1){

                    c1++;
                    c2=0;

                    if(c1==n){
                        p1_series++;
                    }

                }else if(grid[k][i]==2){

                    c2++;
                    c1=0;

                    if(c2==n){
                        p2_series++;
                    }

                }

            }

        }

    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------------------------------------------------------------------------

    public static int winner(){

        series_nb(3);

        if(p1_series>0){
            return 1;
        }else if(p2_series>0){
            return 2;
        }else{

            for(int i=0 ; i<3 ; i++){
                for(int j=0 ; j<3 ; j++){

                    if(grid[i][j]==0){
                        return 0;
                    }

                }
            }

        }

        return 3;

    }

}
    BT.java
    package com.vm.games;

import javax.swing.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;


public class BT extends JButton implements MouseListener {

    int[] coords = new int[2];

    public BT(String text, int[] nb){

        super(text);
        this.coords[0] = nb[0];
        this.coords[1] = nb[1];
        this.addMouseListener(this);

    }


    //------------------------------------------------------------------------------------------------------------------------------------------------------


    public void mouseClicked(MouseEvent event){

        if(this.isEnabled()){

            Graphic_Interface.play(coords[0], coords[1], 2);

            if(Graphic_Interface.win(2)){
                JOptionPane.showMessageDialog(null, "You have won");
            }else if(Graphic_Interface.gameFull()) {
                JOptionPane.showMessageDialog(null, "You haven't lost, but you haven't won");
            }else{
                Min_Max.grid = Graphic_Interface.grid;
                Min_Max.ia_play(10);

                if(Graphic_Interface.win(1)){
                    JOptionPane.showMessageDialog(null,"You have lost");
                }else if(Graphic_Interface.gameFull()) {
                    JOptionPane.showMessageDialog(null, "You haven't lost, but you haven't won");
                }

            }


        }

    }


    //------------------------------------------------------------------------------------------------------------------------------------------------------


    public void mouseEntered(MouseEvent event){}
    public void mouseExited(MouseEvent event){}
    public void mousePressed(MouseEvent event){}
    public void mouseReleased(MouseEvent event){}

}
    Est-ce que quelqu’un pourrait me dire ce qui ne va pas SVP ?
    Merci par avance
    • Partager sur Facebook
    • Partager sur Twitter
    victorm951
    victorm951
      2 juillet 2015 à 0:07:45

      Up. Si vous aviez ne serait-ce qu'une piste,se serait vraiment sympa.
      • Partager sur Facebook
      • Partager sur Twitter

      Mon MinMax joue vraiment mal

      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
      × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
      • Editeur ●
      • Markdown