package Model.Othello;
import java.util.Vector;
import View.GridViewObserver;
import Model.Couleur;
// <editor-fold defaultstate="collapsed" desc=" UML Marker ">
// #[regen=yes,id=DCE.0913F360-B291-FFF7-28FB-D8991F12DEF9]
// </editor-fold>
public class GridOthello {
// <editor-fold defaultstate="collapsed" desc=" UML Marker ">
// #[regen=yes,id=DCE.B71ED8DE-87CD-34CE-186D-C01BAE5A0047]
// </editor-fold>
private Vector _lignes;
private GridViewObserver _observer;
private int _cursorRow;
private int _cursorCol;
// <editor-fold defaultstate="collapsed" desc=" UML Marker ">
// #[regen=yes,regenBody=yes,id=DCE.A02F09BF-5DD9-CE9C-2FB2-3B95808A209C]
// </editor-fold>
public Vector get_lignes () {
return _lignes;
}
// <editor-fold defaultstate="collapsed" desc=" UML Marker ">
// #[regen=yes,regenBody=yes,id=DCE.447E8A53-2364-B975-E4B1-B94C5FBCD979]
// </editor-fold>
public void set_lignes (Vector val) {
this._lignes = val;
}
public GridOthello(int largeurGrille){
this.set_lignes(new Vector());
for(int i = 0; i<largeurGrille; i++){
this.add_ligne(new Ligne(largeurGrille));
}
//initialiser les coordonnées des cases
for(int i = 0; i<largeurGrille; i++){
for(int j = 0; j<largeurGrille; j++){
Ligne uneLigne = (Ligne)this._lignes.elementAt(i);
Case uneCase = (Case)uneLigne.get_cases().elementAt(j);
uneCase.set_x(i);
uneCase.set_y(j);
}
}
this.initGrid();
}
// <editor-fold defaultstate="collapsed" desc=" UML Marker ">
// #[regen=yes,id=DCE.8BDCB3FD-5CB2-9422-6057-B83A753F4814]
// </editor-fold>
public void add_ligne (Ligne ligne) {
this.get_lignes().addElement(ligne);
}
public void initGrid(){
this.setCellInit(3, 3, new Pion(new Couleur(Couleur.RED)));
this.setCellInit(3, 4, new Pion(new Couleur(Couleur.BLACK)));
this.setCellInit(4, 3, new Pion(new Couleur(Couleur.BLACK)));
this.setCellInit(4, 4, new Pion(new Couleur(Couleur.RED)));
}
/**
* Permet d'affecter un observeur
* @param obs
* Objet à notifier lorsque la grille change
*/
public void setObserver(GridViewObserver obs)
{
_observer = obs;
}
/**
* Positionne le cuseur du joueur
* @param la ligne par rapport à la grille
* @param la colonne par rapport à la grille
*/
public void setCursorPos(int row, int col)
{
_cursorRow = row;
_cursorCol = col;
fireUpdateCursorMove();
}
/**
* Retourne la ligne du cuseur
* @return The row on the board
*/
public int getCursorRow()
{
return _cursorRow;
}
/**
* Retourne la colonne du cuseur
* @return The Column on the board
*/
public int getCursorCol()
{
return _cursorCol;
}
/**
* Dit à l'observer que la grille à changer
*
*/
private void fireUpdateCursorMove()
{
if(_observer != null)
_observer.othelloCursorMoveEvent();
}
private void fireUpdateSetPion()
{
if(_observer != null)
_observer.othelloSetPionEvent();
}
/**
* Place un valeur dans une cellule
*
* @param row
* La linge dans la grille
* @param col
* La colonne dans la grille
* @param value
* La valeur à mettre dans ligne et la colonne
*/
public void setCell(int row, int col, Pion p)
{
Ligne uneLigne = (Ligne)this._lignes.elementAt(row);
Case uneCase = (Case)uneLigne.get_cases().elementAt(col);
//s'il n'y a pas de pion, alors on peut peut-etre mettre un pion
if(uneCase.get_pion() == null){
Vector v = this.verifyValidatedCase(row,col,p);
if(v.size() != 0){
uneCase.set_pion(p);
this.majGrid(p,v);
fireUpdateSetPion();
}
}
}
private void setCellInit(int row, int col, Pion p)
{
Ligne uneLigne = (Ligne)this._lignes.elementAt(row);
Case uneCase = (Case)uneLigne.get_cases().elementAt(col);
//s'il n'y a pas de pion, alors on peut peut-etre mettre un pion
if(uneCase.get_pion() == null){
uneCase.set_pion(p);
uneCase.set_x(col);
uneCase.set_y(row);
fireUpdateSetPion();
}
}
// ==========================================================
/**
* Calcul les prises d'un coup d'un joueur en explorant les 8 directions du coup jou�.<BR>
* Retourne un Vector contenant les prises (Cases)
**/
public Vector verifyValidatedCase(int row, int col, Pion pion){
int tailleGrille = this.get_lignes().size();
Case sens[]={new Case(-1,-1),
new Case(0,-1),
new Case(1,-1),
new Case(-1,0),
new Case(1,0),
new Case(-1,1),
new Case(0,1),
new Case(1,1)};
Vector v = new Vector();
//teste si la case jouee est libre
Ligne ligneDeLaCaseJouee = (Ligne)this.get_lignes().elementAt(row);
Case caseJouee = (Case)ligneDeLaCaseJouee.get_cases().elementAt(col);
if(caseJouee.get_pion() != null){return v;}
// On parcours les 8 sens possible � partir de la case jou�e
Case depart = new Case(col, row);
depart.set_pion(pion);
for(int s=0;s<8;s++)
{
Case c = depart;
boolean fini = false;
Vector tmp = new Vector(); // Les cases dans un sens
c = caseSuiv(c,sens[s]);
if(!caseDehors(c,tailleGrille)){
while(!fini)
{
if( caseDehors(c,tailleGrille))
{
fini=true;
tmp= new Vector();
}else{
Ligne l = (Ligne)this.get_lignes().elementAt(c.get_y());
Case cs = (Case)l.get_cases().elementAt(c.get_x());
c.set_pion(cs.get_pion());
if( (caseDehors(c,tailleGrille)) ||(c.get_pion() == null) )
{
fini=true;
tmp= new Vector();
}
else
{
if(c.get_pion().get_couleur().get_valeur()!=pion.get_couleur().get_valeur())
{
tmp.addElement(c);
c=caseSuiv(c,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 jou�e
if (v.size()!=0)
v.addElement(depart);
// On retourne les cases � retourner
return(v);
}
// ==========================================================
// Determine la case suivante en fonction d'un sens
//
private Case caseSuiv(Case c,Case sens)
{
return( new Case(c.get_x()+sens.get_x(), c.get_y()+sens.get_y()));
}
// ==========================================================
// Teste si le point est en dehors de la grille
//
private boolean caseDehors(Case c,int tailleGrille)
{
int px=(int)c.get_x();
int py=(int)c.get_y();
if ( (px<0)||
(px>=tailleGrille)||
(py<0)||
(py>=tailleGrille)
)
return(true);
else
return(false);
}
public void majGrid(Pion p, Vector v){
for(int i =0; i<v.size();i++){
Case uneCase = (Case)v.elementAt(i);
Ligne ligneAChanger = (Ligne)this.get_lignes().elementAt(uneCase.get_y());
Case caseAChanger = (Case)ligneAChanger.get_cases().elementAt(uneCase.get_x());
caseAChanger.set_pion(p);
ligneAChanger.get_cases().setElementAt(caseAChanger, uneCase.get_x());
this.get_lignes().setElementAt(ligneAChanger, uneCase.get_y());
}
}
public boolean IsCoupPossible(Pion p){
boolean possible = false;
int largeurGrille = this.get_lignes().size();
//tester si le pion peut etre joué
for(int i = 0; i<largeurGrille; i++){
for(int j = 0; j<largeurGrille; j++){
Vector v = verifyValidatedCase(i,j,p);
if(v.size()>0){
possible = true;
}
}
}
return possible;
}
}