/*
 *  plateau.cpp
 *  TicTaeToe
 *
 *  Created by Lionel BUCHELE on 29/04/11.
 *  Copyright 2011 EFREI. All rights reserved.
 *
 */

#include "Thebault-Buchele-plateau.h"
#include "math.h"
#include "Thebault-Buchele-Min.h"
#include "Thebault-Buchele-Max.h"
#include "Thebault-Buchele-Masque.h"
#include <iostream>
#include "stdio.h"

plateau* plateau::jeu = NULL;
int  plateau::n = 0;
int plateau::m = 0;
int plateau::p = 0;
int plateau::libre = 0;

plateau::plateau(int Longueur, int Hauteur, int p)
{
	
	this->n = Longueur;
	this->m = Hauteur;
	this->libre = Hauteur*Longueur;
	this->p = p;
	this->cellule.resize(this->n,vector<Case*>(this->m));
	for(int x  = 0;x<this->n;x++)for(int y = 0;y<this->m;y++)this->cellule[x][y] = new Case(x,y);
	this->graph = NULL;
}

plateau::~plateau()
{
    unsigned int x = 0, y = 0;
    for(x = 0;x<this->n;x++)
    {
        for(y = 0;y<this->m;y++)
            delete cellule[x][y];
    }

}
// _________________________
// Date : 4 mai 2011
// Function : Envoi le singloton jeu qui est le plateau
// _________________________
plateau *plateau::getInstance(const int &Longueur,const int &Largeur,const int &P)
{
	if(jeu == NULL)
	{
		jeu = new plateau(Longueur,Largeur,P);
	}
	return jeu;
}

plateau* plateau::getInstance()
{
	return jeu;
}


// _________________________
// Date : 4 mai 2011
// Function : Retourne largeur du plateau
// _________________________
int plateau::getM()
{
	return m;
}

// _________________________
// Date : 4 mai 2011
// Function : Retourne longueur du plateau
// _________________________
int plateau::getN()
{
	return n;
}


// _________________________
// Date : 4 mai 2011
// Function : Retourne le nombre de case libre
// _________________________
int plateau::getLibre()
{
	return libre;
}

// _________________________
// Date : 5 mai 2011
// Function : Change le nombre de case vide
// _________________________
void plateau::setLibre(int a)
{
	libre = a;
}

// _________________________
// Date : 4 mai 2011
// Function : Fais la différences entre le nombre de masque possible de l'ordi - masque possible de l'homme
//
// _________________________

float plateau::heuristique()
{
	plateau *game = plateau::getInstance();
	return (game->Masque(1)-game->Masque(2));
}

// _________________________
// Date : 4 mai 2011
// Function : Fais la différences entre le nombre de masque possible de l'ordi - masque possible de l'homme
// i = 1 possibilité de l'ordinateur
// i = 2 possibilité du joueur
// _________________________

float plateau::Masque(int i)
{
	plateau *game = plateau::getInstance();
	pmasque diagonale = NULL;
	int val = 0;
	int masqueH = 0;
	int masqueV = 0;
	float total = 0;
	// Masque Horizontale
	for(int x = 0; x < n; x ++)
	{
		masqueH = 0;
		for(int y = 0; y < m; y ++)
		{
			val = 0;
			if(*this->cellule[x][y] == i || *this->cellule[x][y] == 0)
			{
				if(masqueH >0)
				{
					if(x - masqueH > 0)
					{	
						val= MasqueHorizontal(cellule[x][y],i,0);
						masqueH = val;
					}
				}
				else
				{
					val= MasqueHorizontal(cellule[x][y],i,0);
					masqueH = val;
				}
				if(val / p >= 1)total = total + (val*1.00 / p);
				
				
				// Masque Diagonale
				val = MasqueDiagonaleBD(cellule[x][y],i,0);
				if(val >= p)
				{	
					// On vérifie que le point n'appartient pas à une diagonale pré enregistré
					if(verifMasque(diagonale,x,y) == false)
					{
						if(diagonale == NULL)
							diagonale = CreateNodeMasque(x,y,x+val-1,y+val-1);
						else Add(diagonale,x,y,x+val-1,y+val-1);		
						if(val / p >= 1)total = total + (val*1.00 / p);
					}
				}
				val = MasqueDiagonaleHD(cellule[x][y],i,0);
				if(val >= p)
				{	
					// On vérifie que le point n'appartient pas à une diagonale pré enregistré
					if(verifMasque(diagonale,x,y) == false)
					{
						if(diagonale == NULL)diagonale = CreateNodeMasque(x,y,x+val-1,y-val+1);
						else Add(diagonale,x,y,x+val-1,y-val+1);
						/*pmasque temp = diagonale;
						while(temp != NULL)
						{
							cout<<"la diagonale "<<temp->x1<<" , "<<temp->y1<<" // "<<temp->x2<<" , "<<temp->y2<<endl;
							temp = temp->suivant;
						}*/
						if(val / p >= 1)total = total + (val*1.00 / p);
					}
				}
			}
		}
	}
	
	//Masque Vertical
	for(int y = 0; y < m; y ++)
	{
		masqueV = 0;
		for(int x = 0; x < n; x ++)
		{
			val = 0;
			if(*this->cellule[x][y] == i || *this->cellule[x][y] == 0)
			{
				if(masqueV >0)
				{
					if(y - masqueV > 0)
					{
						val= MasqueVertical(cellule[x][y],i,0);
						masqueV = val;
					}
				}
				else{
					val= MasqueVertical(cellule[x][y],i,0);
					masqueV = val;}
				if(val / p >= 1)total = total + (1.00*val / p);
			}
		}
	}
	deleteNode(diagonale);
	return total;
	
}




// _________________________
// Date : 4 mai 2011
// Function (private): Fais les masques horizontales
// index : correspond à la recherche 
// 0 haut
// 1 bas
// _________________________

int plateau::MasqueHorizontal(Case *coup,int val, int sens)
{
	int M = m - 1;
	plateau *game = plateau::getInstance();
	int i = 1;
	if(sens == 0)
	{
		if(coup->getY() < M)
		{
			if( *game->cellule[coup->getX()][coup->getY()+1] == val || *game->cellule[coup->getX()][coup->getY()+1] == 0)i = i + MasqueHorizontal(game->cellule[coup->getX()][coup->getY()+1],val,1);
			
		}
		if(coup->getY()>0) 
		{
			if(*game->cellule[coup->getX()][coup->getY()-1] == val|| *game->cellule[coup->getX()][coup->getY()-1] == 0)
			{
				i = i + MasqueHorizontal(game->cellule[coup->getX()][coup->getY()-1],val,2);
			}
		}
	}
	else if(sens == 2)
	{
		if(coup->getY()>0) 
		{
			if(*game->cellule[coup->getX()][coup->getY()-1] == val|| *game->cellule[coup->getX()][coup->getY()-1] == 0) i = i + MasqueHorizontal(game->cellule[coup->getX()][coup->getY()-1],val,2);
		}
	}
	else if(sens == 1)
	{
		if(coup->getY()<M) 
		{
			if(*game->cellule[coup->getX()][coup->getY()+1] == val|| *game->cellule[coup->getX()][coup->getY()+1] == 0) i = i + MasqueHorizontal(game->cellule[coup->getX()][coup->getY()+1],val,1);
		}
	}
	return i;
}

// _________________________
// Date : 4 mai 2011
// Function (private): Fais les masques verticales
// index : correspond à la recherche 
// 1 droite
// 0 gauche
// _________________________

int plateau::MasqueVertical(Case *coup,int val, int sens)
{
	int N = n - 1;
	plateau *game = plateau::getInstance();
	int i = 1;
	if(sens == 0)
	{
		if(coup->getX() < N)
		{
			if(*game->cellule[coup->getX()+1][coup->getY()] == val || *game->cellule[coup->getX()+1][coup->getY()] == 0)i = i + MasqueVertical(game->cellule[coup->getX()+1][coup->getY()],val,2);
			
		}
		if(coup->getX()>0) 
		{
			if(*game->cellule[coup->getX()-1][coup->getY()] == val|| *game->cellule[coup->getX()-1][coup->getY()] == 0) i = i + MasqueVertical(game->cellule[coup->getX()-1][coup->getY()],val,1);
		}
	}
	else if(sens == 1)
	{
		if(coup->getX()>0) 
		{
			if(*game->cellule[coup->getX()-1][coup->getY()] == val|| *game->cellule[coup->getX()-1][coup->getY()] == 0) i = i + MasqueVertical(game->cellule[coup->getX()-1][coup->getY()],val,1);
		}
	}
	else if(sens == 2)
	{
		if(coup->getX()<N) 
		{
			if(*game->cellule[coup->getX()+1][coup->getY()] == val|| *game->cellule[coup->getX()+1][coup->getY()] == 0) i = i + MasqueVertical(game->cellule[coup->getX()+1][coup->getY()],val,2);
		}
	}
	return i;
	
}

// _________________________
// Date : 4 mai 2011
// Function (private): Fais les masques  diagonale Sud-Est / Nord-Ouest
// index : correspond à la recherche 
// 0 haut droite
// 1 bas gauche
// 
// _________________________
int plateau::MasqueDiagonaleHD(Case *coup,int val, int sens)
{
	int N = n - 1;
	int M = m - 1;
	plateau *game = plateau::getInstance();
	int i = 1;
	if(sens == 0)
	{
		if(coup->getX() < N && coup->getY()< M && coup->getX() >0 && coup->getY()>0)
		{
			
			if(*game->cellule[coup->getX()-1][coup->getY()+1] == val || *game->cellule[coup->getX()-1][coup->getY()+1] == 0)i = i + MasqueDiagonaleHD(game->cellule[coup->getX()-1][coup->getY()+1],val,1);
			if(*game->cellule[coup->getX()+1][coup->getY()-1] == val || *game->cellule[coup->getX()+1][coup->getY()-1] == 0)i = i + MasqueDiagonaleHD(game->cellule[coup->getX()+1][coup->getY()-1],val,2);
		}
		else if(coup->getX()== N && coup->getY()<M)
		{
			if(*game->cellule[coup->getX()-1][coup->getY()+1] == val || *game->cellule[coup->getX()-1][coup->getY()+1] == 0)i = i + MasqueDiagonaleHD(game->cellule[coup->getX()-1][coup->getY()+1],val,1);
		}
		else if(coup->getY() == M && coup->getX()<N)
		{
			if(*game->cellule[coup->getX()+1][coup->getY()-1] == val || *game->cellule[coup->getX()+1][coup->getY()-1] == 0)i = i + MasqueDiagonaleHD(game->cellule[coup->getX()+1][coup->getY()-1],val,2);
		}
		else if(coup->getX() == 0 && coup->getY() > 0)
		{
			if(*game->cellule[coup->getX()+1][coup->getY()-1] == val || *game->cellule[coup->getX()+1][coup->getY()-1] == 0)i = i + MasqueDiagonaleHD(game->cellule[coup->getX()+1][coup->getY()-1],val,2);
		}
		else if(coup->getY() == 0 && coup->getX()>0)
		{
			if(*game->cellule[coup->getX()-1][coup->getY()+1] == val || *game->cellule[coup->getX()-1][coup->getY()+1] == 0)i = i + MasqueDiagonaleHD(game->cellule[coup->getX()-1][coup->getY()+1],val,1);
		}
	}
	else if(sens == 1)
	{
		if(coup->getY()<M && coup->getX()>0)if(*game->cellule[coup->getX()-1][coup->getY()+1] == val || *game->cellule[coup->getX()-1][coup->getY()+1] == 0)i = i + MasqueDiagonaleHD(game->cellule[coup->getX()-1][coup->getY()+1],val,1);
	}
	else if(sens == 2)
	{
		if(coup->getX()<N && coup->getY()>0 )if(*game->cellule[coup->getX()+1][coup->getY()-1] == val || *game->cellule[coup->getX()+1][coup->getY()-1] == 0)i = i + MasqueDiagonaleHD(game->cellule[coup->getX()+1][coup->getY()-1],val,2);
	}
	return i;
}


// _________________________
// Date : 4 mai 2011
// Function (private): Cherche les masques possibles ds la diagonale diagonale Sud-Ouest / Nord-Est
// index : correspond à la recherche 
// 1 haut gauche
// 2 bas droite
// 
// _________________________

int plateau::MasqueDiagonaleBD(Case *coup, int val, int sens)
{
	int M = m - 1;
	int N = n - 1;
	plateau *game = plateau::getInstance();
	int i = 1;
	if(sens == 0)
	{
		if(coup->getX() < N  && coup->getY()<M && coup->getX() > 0 && coup->getY() > 0)
		{
			if( *game->cellule[coup->getX()+1][coup->getY()+1] == val|| *game->cellule[coup->getX()+1][coup->getY()+1] == 0)i = i + MasqueDiagonaleBD(game->cellule[coup->getX()+1][coup->getY()+1],val,2);
			if( *game->cellule[coup->getX()-1][coup->getY()-1] == val || *game->cellule[coup->getX()-1][coup->getY()-1] == 0)i = i + MasqueDiagonaleBD(game->cellule[coup->getX()-1][coup->getY()-1],val,1);
		}
		else if(coup->getX()== N && coup->getY() >0)
		{
			if( *game->cellule[coup->getX()-1][coup->getY()-1] == val || *game->cellule[coup->getX()-1][coup->getY()-1] == 0)i = i + MasqueDiagonaleBD(game->cellule[coup->getX()-1][coup->getY()-1],val,1);
		}
		else if(coup->getY()== M && coup->getX() >0)
		{
			if( *game->cellule[coup->getX()-1][coup->getY()-1] == val || *game->cellule[coup->getX()-1][coup->getY()-1] == 0)i = i + MasqueDiagonaleBD(game->cellule[coup->getX()-1][coup->getY()-1],val,1);
		}
		else if(coup->getX()== 0 && coup->getY() < M)
		{
			if( *game->cellule[coup->getX()+1][coup->getY()+1] == val|| *game->cellule[coup->getX()+1][coup->getY()+1] == 0)i = i + MasqueDiagonaleBD(game->cellule[coup->getX()+1][coup->getY()+1],val,2);
		}
		else if(coup->getY() == 0 && coup->getX()< N)
		{
			if( *game->cellule[coup->getX()+1][coup->getY()+1] == val|| *game->cellule[coup->getX()+1][coup->getY()+1] == 0)i = i + MasqueDiagonaleBD(game->cellule[coup->getX()+1][coup->getY()+1],val,2);
		}
	}
	else if(sens == 1)
	{
		
		if(coup->getX() > 0 && coup->getY()>0)
		{
			if( *game->cellule[coup->getX()-1][coup->getY()-1] == val || *game->cellule[coup->getX()-1][coup->getY()-1] == 0)
			{
				i = i + MasqueDiagonaleBD(game->cellule[coup->getX()-1][coup->getY()-1],val,1);
			}
		}
	}
	else if(sens == 2)
	{
		if(coup->getY()<M && coup->getX()<N)if( *game->cellule[coup->getX()+1][coup->getY()+1] == val|| *game->cellule[coup->getX()+1][coup->getY()+1] == 0)i = i + MasqueDiagonaleBD(game->cellule[coup->getX()+1][coup->getY()+1],val,2);
	}
	return i;
}


// _________________________
// Date : 4 mai 2011
// Function : Regarde si le  plateau est  victorieux
// retour 
// 0 : pas de victoire
// 1 : computer
// 2 : joueur
// autre : erreur
// _________________________

int plateau::victory(Case *coup)
{
	plateau *game = plateau::getInstance();
	int val = 0;
	val = game->SolutionVertical(coup, 0);
	if(val >= p )return coup->getAvailable_case();
	val = game->SolutionHorizontal(coup, 0);
	if(val >= p )return coup->getAvailable_case();
	val = game->SolutionDiagonaleBD(coup, 0);
	if(val >= p )return coup->getAvailable_case();
	val = game->SolutionDiagonaleHD(coup, 0);
	if(val >= p )return coup->getAvailable_case();
	return 0;
}
// _________________________
// Date : 4 mai 2011
// Function (private): Regarde si le  plateau est  victorieux en horizontal
// index : correspond à la recherche 
// 0 haut
// 1 bas
// _________________________

int plateau::SolutionHorizontal(Case *coup, int sens)
{
	int M = m - 1;
	plateau *game = plateau::getInstance();
	int i = 1;

	if(sens == 0)
	{
		if(coup->getY() < M)
		{
			if(*coup == *game->cellule[coup->getX()][coup->getY()+1])i = i + SolutionHorizontal(game->cellule[coup->getX()][coup->getY()+1],1);
			
		}
		if(coup->getY()>0) 
		{
			if(*coup == *game->cellule[coup->getX()][coup->getY()-1])
			{
				i = i + SolutionHorizontal(game->cellule[coup->getX()][coup->getY()-1],2);
			}
		}
	}
	else if(sens == 2)
	{
		if(coup->getY()>0) 
		{
			if(*coup == *game->cellule[coup->getX()][coup->getY()-1]) i = i + SolutionHorizontal(game->cellule[coup->getX()][coup->getY()-1],2);
		}
	}
	else if(sens == 1)
	{
		if(coup->getY()<M) 
		{
			if(*coup == *game->cellule[coup->getX()][coup->getY()+1]) i = i + SolutionHorizontal(game->cellule[coup->getX()][coup->getY()+1],1);
		}
	}
	return i;
}

// _________________________
// Date : 4 mai 2011
// Function (private): Regarde si le  plateau est  victorieux en vetical
// index : correspond à la recherche 
// 1 droite
// 0 gauche
// _________________________

int plateau::SolutionVertical(Case *coup, int sens)
{
	int N = n - 1;
	plateau *game = plateau::getInstance();
	int i = 1;
	if(sens == 0)
	{
		if(coup->getX() < N)
		{
			if(*coup == *game->cellule[coup->getX()+1][coup->getY()])i = i + SolutionVertical(game->cellule[coup->getX()+1][coup->getY()],2);
			
		}
		if(coup->getX()>0) 
		{
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()]) i = i + SolutionVertical(game->cellule[coup->getX()-1][coup->getY()],1);
		}
	}
	else if(sens == 1)
	{
		if(coup->getX()>0) 
		{
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()]) i = i + SolutionVertical(game->cellule[coup->getX()-1][coup->getY()],1);
		}
	}
	else if(sens == 2)
	{
		if(coup->getX()<N) 
		{
			if(*coup == *game->cellule[coup->getX()+1][coup->getY()]) i = i + SolutionVertical(game->cellule[coup->getX()+1][coup->getY()],2);
		}
	}
	return i;
	
}

// _________________________
// Date : 4 mai 2011
// Function (private): Regarde si le  plateau est  victorieux en diagonale Sud-Est / Nord-Ouest
// index : correspond à la recherche 
// 0 haut droite
// 1 bas gauche
// 
// _________________________
int plateau::SolutionDiagonaleHD(Case *coup, int sens)
{
	int N = n - 1;
	int M = m - 1;
	plateau *game = plateau::getInstance();
	int i = 1;
	if(sens == 0)
	{
		if(coup->getX() < N && coup->getY()< M && coup->getX() >0 && coup->getY()>0)
		{
			
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()+1])i = i + SolutionDiagonaleHD(game->cellule[coup->getX()-1][coup->getY()+1],1);
			if(*coup == *game->cellule[coup->getX()+1][coup->getY()-1])i = i + SolutionDiagonaleHD(game->cellule[coup->getX()+1][coup->getY()-1],2);
		}
		else if(coup->getX()== N && coup->getY()<M)
		{
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()+1])i = i + SolutionDiagonaleHD(game->cellule[coup->getX()-1][coup->getY()+1],1);
		}
		else if(coup->getY() == M && coup->getX()<N)
		{
			if(*coup == *game->cellule[coup->getX()+1][coup->getY()-1])i = i + SolutionDiagonaleHD(game->cellule[coup->getX()+1][coup->getY()-1],2);
		}
		else if(coup->getX() == 0 && coup->getY() > 0)
		{
			if(*coup == *game->cellule[coup->getX()+1][coup->getY()-1])i = i + SolutionDiagonaleHD(game->cellule[coup->getX()+1][coup->getY()-1],2);
		}
		else if(coup->getY() == 0 && coup->getX()>0)
		{
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()+1])i = i + SolutionDiagonaleHD(game->cellule[coup->getX()-1][coup->getY()+1],1);
		}
	}
	else if(sens == 1)
	{
		if(coup->getY()<M && coup->getX()>0)if(*coup == *game->cellule[coup->getX()-1][coup->getY()+1])i = i + SolutionDiagonaleHD(game->cellule[coup->getX()-1][coup->getY()+1],1);
	}
	else if(sens == 2)
	{
		if(coup->getX()<N && coup->getY()>0 )if(*coup == *game->cellule[coup->getX()+1][coup->getY()-1])i = i + SolutionDiagonaleHD(game->cellule[coup->getX()+1][coup->getY()-1],2);
	}
	return i;
}


// _________________________
// Date : 4 mai 2011
// Function (private): Regarde si le  plateau est  victorieux en diagonale Sud-Ouest / Nord-Est
// index : correspond à la recherche 
// 1 haut gauche
// 2 bas droite
// 
// _________________________

int plateau::SolutionDiagonaleBD(Case *coup, int sens)
{
	int M = m - 1;
	int N = n - 1;
	plateau *game = plateau::getInstance();
	int i = 1;
	if(sens == 0)
	{
		if(coup->getX() < N  && coup->getY()<M && coup->getX() > 0 && coup->getY() > 0)
		{
			if(*coup == *game->cellule[coup->getX()+1][coup->getY()+1])i = i + SolutionDiagonaleBD(game->cellule[coup->getX()+1][coup->getY()+1],2);
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()-1])i = i + SolutionDiagonaleBD(game->cellule[coup->getX()-1][coup->getY()-1],1);
		}
		else if(coup->getX()== N && coup->getY() >0)
		{
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()-1])i = i + SolutionDiagonaleBD(game->cellule[coup->getX()-1][coup->getY()-1],1);
		}
		else if(coup->getY()== M && coup->getX() >0)
		{
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()-1])i = i + SolutionDiagonaleBD(game->cellule[coup->getX()-1][coup->getY()-1],1);
		}
		else if(coup->getX()== 0 && coup->getY() < M)
		{
			if(*coup == *game->cellule[coup->getX()+1][coup->getY()+1])i = i + SolutionDiagonaleBD(game->cellule[coup->getX()+1][coup->getY()+1],2);
		}
		else if(coup->getY() == 0 && coup->getX()< N)
		{
			if(*coup == *game->cellule[coup->getX()+1][coup->getY()+1])i = i + SolutionDiagonaleBD(game->cellule[coup->getX()+1][coup->getY()+1],2);
		}
	}
	else if(sens == 1)
	{
		
		if(coup->getX() > 0 && coup->getY()>0)
		{
			if(*coup == *game->cellule[coup->getX()-1][coup->getY()-1])
			{
				i = i + SolutionDiagonaleBD(game->cellule[coup->getX()-1][coup->getY()-1],1);
			}
		}
	}
	else if(sens == 2)
	{
		if(coup->getY()<M && coup->getX()<N)if(*coup == *game->cellule[coup->getX()+1][coup->getY()+1])i = i + SolutionDiagonaleBD(game->cellule[coup->getX()+1][coup->getY()+1],2);
	}
	return i;
}

// _________________________
// Date : 4 mai 2011
// Function :affichage des bons pions
// _________________________
char plateau::affichageJoueur(int i)
{
	if(i == 0)return char(32);
	if(i == 1)return char(120);
	if(i == 2)return char(111);	
}
// _________________________
// Date : 4 mai 2011
// Function :affichae du plateau de jeu
// _________________________
void plateau::affichage()
{
	cout<<"     ";
	for(int x = 0; x<this->m;x++)cout<<x<<"   ";
	cout<<endl<<"    ";
	for(int x = 0; x<this->m;x++)cout<<"____";
	for(int x = 0;x<this->n;x++)
	{
		for(int y = 0;y<this->m;y++)
		{
			if(y == 0)cout<<endl<<" "<<x<<" |";
			cout<<" "<<affichageJoueur(this->cellule[x][y]->getAvailable_case())<<" |";
		}
	}
	cout<<endl;cout<<"    ";
	for(int x = 0; x<this->m;x++)cout<<"____";
	cout<<endl<<endl;;
}

// _________________________
// Date : 4 mai 2011
// Function :Tour de letre humain
// _________________________
int plateau::jouerHomme( )
{
	int x = -1, y = -1;
//int x = 0, y = 0;	
	bool verif = false;
	while(verif == false)
	{
		cout<<"Veuillez selectionner des coordonnees valide de votre prochain coup :"<<endl<<"x : ";
		cin>>x;
		cout<<endl<<"y : ";
		cin>>y;
		if(x >=0 && x <n && y>=0 && y < m)if(this->cellule[x][y]->getAvailable_case()==0)verif = true;
	}
	libre--;
	this->cellule[x][y]->setAvailable_case(2);
	if(graph == NULL)
	{  
		cout<<"Nouveau tour"<<endl;
		graph = new Max(this->cellule[x][y], NULL, 0);
	}
	/*else
	{
		for(int i = 0; i < libre+1; i++)
		{
			if(this->cellule[x][y]->getX() == graph->successeur[i]->coup->getX() && this->cellule[x][y]->getY() == graph->successeur[i]->coup->getY())
				graph = graph->successeur[i];
		}
	}*/
	affichage();
	if(this->victory(this->cellule[x][y]) > 0)return 2;
	else return 0;
}
// _________________________
// Date : 5 mai 2011
// Function :Tour de la machine
// _________________________
int plateau::jouerMachine()
{
	if(graph == NULL)
	{
		graph = new Max(NULL, NULL, 0);
	}
	
	int retour;
	graph->play();
	graph->AffectationHeuristique();
	int i = 0;
	while(graph->heuristique != graph->successeur[i]->heuristique)i++;
	graph->successeur[i]->coup->setAvailable_case(1);
	if(this->victory(graph->successeur[i]->coup)>0)retour = 1;
	else retour = 0;
	graph->suppression();
	graph = NULL;
	affichage();
	libre--;
	return retour;
	//if(graph->predecesseur == NULL)cout<<"XEIOHKHFXD"<<endl;
}

int plateau::jouerElagage()
{
	
	if(graph == NULL)
	{
		graph = new Max(NULL, NULL, 0);
	}
	
	int retour;
	graph->play();
	for(int ind = 0;ind < graph->successeur.size();ind++)graph->successeur[ind]->Elagage();
	//cout<<"FFFFFIIIIINNNNNN"<<endl;
	int i = 0;
	Case *coup;
	for(int i = 0;i < graph->successeur.size();i++)
		if(graph->beta < graph->successeur[i]->alpha)
		{
			graph->beta = graph->successeur[i]->alpha;
			coup = graph->successeur[i]->coup;
			
		}
	
	//while(graph->beta == graph->successeur[i]->alpha)i++;
	//graph->successeur[i]->
	coup->setAvailable_case(1);
	if(this->victory(coup) > 0)retour = 1;//graph->successeur[i]->coup)>0)retour = 1;
	else retour = 0;
	graph->suppression();
	graph = NULL;
	affichage();
	libre--;
	return retour;	
}
// _________________________
// Date : 5 mai 2011
// Function :Choix du prochain coup après finition du processus MinMax
// _________________________
void plateau::selectionCoup()
{
	int i = 0;
	while(graph->heuristique != graph->successeur[i]->heuristique)i++;
	graph->successeur[i]->coup->setAvailable_case(1);
	MinMax *temp;
	temp = graph;
	graph = graph->successeur[i];
	for(int x = 0; x < temp->successeur.size(); x++)
	{
		if(x != i)
		{
			temp->successeur[i]->suppressionBranche(temp->successeur[i]);
			delete temp->successeur[i];
		}
	}
	delete temp;
}