include("v4.Globals");
//debug(getAIName());

global _GPGridHeigth    = 36;
global _GPGridWidth     = 36;
global _GPGridDecalage  = 18;   // decalage pour que le _getPath soit en coords positives

global _GPValueEmptyCell    = 0;
global _GPValueObstacle     = -1;
global _GPValueOutOfBounds  = -1;
global _GPValueTakenCells   = -1;

global _GPGrid_default;
/**
* _GPGrid_update renvoie une représentation de la carte en array par défaut
* On le lance comme routine au premier tour
*/
function _GPGrid_create(){
    _GPGrid_default = [];
    for(var y = _GPGridHeigth/2*-1;y<=_GPGridHeigth/2;y++){
        _GPGrid_default[y+_GPGridDecalage] = [];
        for(var x = _GPGridWidth/2*-1;x<=_GPGridWidth/2;x++){
            if(_COORDSYXCELLS_[y][x]){
                var cell = _COORDSYXCELLS_[y][x];
                if(inArray(_CELLS_OBSTACLES_, cell)){
                    _GPGrid_default[y+_GPGridDecalage][x+_GPGridDecalage] = _GPValueObstacle;
                }
                else{
                    _GPGrid_default[y+_GPGridDecalage][x+_GPGridDecalage] = _GPValueEmptyCell;
                }
            }else{
                _GPGrid_default[y+_GPGridDecalage][x+_GPGridDecalage] = _GPValueOutOfBounds;
            }
        }
    }
}
if(getTurn() == 1){ _GPGrid_create();}

/**
* getGridAdjacent
* renvoie la grille des cellules disponibles
* @cell             : la cell d'origine
* @radius           : la portée ( MP )
* @takenCells       : un array de cells interdites ( LeeksCells )
* @returnByMoves    : bool renvoie un tableau avec les cases reachable/radius
* @returnByArea     : bool renvoie un tableau avec toutes les cases reachable
*/
global _GPGrid;
function getGridAdjacent(cell, radius, takenCells, returnByMoves, returnByArea, returnByCells){
    // on initialise les returns
        var retour;
        var returnMoves = [];
        var returnArea = [];
        var returnCells = [];
    // la cellule d'origine
        var initialCell_x = _CELLSCOORDS_[cell][0]+_GPGridDecalage;
        var initialCell_y = _CELLSCOORDS_[cell][1]+_GPGridDecalage;
    // on réinitialise la carte par défaut pour l'utiliser dans cet appel
        _GPGrid = _GPGrid_default;
    // on ajoute les cells à ignorer
        if(count(takenCells) > 0){
            var c;
            var cx;
            var cy;
            for(c in takenCells){
                cx = _CELLSCOORDS_[c][0]+_GPGridDecalage;
                cy = _CELLSCOORDS_[c][1]+_GPGridDecalage;
                _GPGrid[cy][cx] = _GPValueTakenCells;
            }
        }
    // la cell sur laquelle on se trouve
        if(!inArray(takenCells, cell)){
            if(returnByMoves){  returnMoves[0] = [cell];    }
            if(returnByArea) {  push(returnArea, cell);     }
            if(returnByCells){  returnCells[cell] = 0;      }
        }

    if(radius > 0){
        var k; var x; var y; var i; var j; var realCell;
        var counting = _GPValueEmptyCell + 1;
        var cellArray = findFreeCell(initialCell_x, initialCell_y, counting);
        // premier mouvement, initialisation de la boucle
            for(k in cellArray){
                y = k[1];
                x = k[0];
                realCell = _GPGetRealCellFromXY(x,y);
                if(realCell){
                    if(returnByMoves)   {   if(!returnMoves[1]){returnMoves[1] = [];    }
                                            push(returnMoves[1], realCell);             }
                    if(returnByArea)    {   push(returnArea, realCell);                 }
                    if(returnByCells)   {   returnCells[cell] = 1;                      }
                }
            }
        // mouvements suivants
            for(i=1;i<radius;i++){
                cellArray = findTheEnd(cellArray, counting+i);
                    for(j in cellArray){
                        y = j[1];
                        x = j[0];
                        realCell = _GPGetRealCellFromXY(x,y);
                        if(realCell){
                            if(returnByMoves)   {   if(!returnMoves[i+1]){returnMoves[i+1] = [];    }
                                                    push(returnMoves[i+1], realCell);               }
                            if(returnByArea)    {   push(returnArea, realCell);                     }
                            if(returnByCells)   {   returnCells[realCell] = i+1;                    }
                        }
                    }
            }
    }

         if (returnByMoves && !returnByArea && !returnByCells)  {   retour = returnMoves;   }
    else if (!returnByMoves && returnByArea && !returnByCells)  {   retour = returnArea;    }
    else if (!returnByMoves && !returnByArea && returnByCells)  {   retour = returnCells;   }
    else    {   retour = [["moves":returnMoves],["area":returnArea],["cells":returnCells]]; }

    if(false && returnByMoves){
        var nbMoves;
        var arrayMove;
        var c;
        for(nbMoves:arrayMove in returnMoves){
            for(c in arrayMove){
                mark(c, COLOR_GREEN*((nbMoves/(arrayMax(returnCells)+1))*256));
        }   }   pause();
    }
    if(false && returnCells){
        var nbMoves;
        var arrayMove;
        var c;
        for(c:nbMoves in returnCells){
            mark(c, COLOR_GREEN*nbMoves/(arrayMax(returnCells)+1));
        }   pause();
    }

return retour;
}

function _GPGetRealCellFromXY(x,y){
    return _COORDSYXCELLS_[y-_GPGridDecalage][x-_GPGridDecalage];
}

/**
* trouve les cases voisines qui sont libres
* @posX    position en x sur la grille
* @posY    position en y sur la grille
* @pNumber valeur que von prendre les cases libres
* @return  tableau des cases libre trouvé
*/
    function findFreeCell(posX, posY, pNumber) {
        var arrayWay = [];
        var number = pNumber || _GPValueEmptyCell;
        _GPGrid[posY][posX] = pNumber;

            for (var i = count(GPAdjacentCells) - 1; i >= 0; i--) {
                if (GPAdjacentCells[i](posY, posX, false) === _GPValueEmptyCell) {
                    var adjC = GPAdjacentCells[i](posY, posX, true);
                    _GPGrid[adjC[1]][adjC[0]] = pNumber + 1;
                    push(arrayWay, adjC);
                }
            };

        if (count(arrayWay) === 0) return false;
        else return arrayWay;
    }


/**
* Appelle la fonction findFreeCell, pour chaque case que trouve cette fonction
* @pArray tableau de cells libres
* @pCount valeur que vont prendre les cases qui seront trouvées
* @return tableau des cases libres trouvées
*/
    function findTheEnd(pArray, pCount) {
        var lcount = pCount + 1;
        var nextCellArray = [];
        for (var i = count(pArray) - 1; i >= 0; i--) {

            var lArray = findFreeCell(pArray[i][0], pArray[i][1], pCount);
            if (lArray != false) {
                for (var j = count(lArray) - 1; j >= 0; j--) {
                    push(nextCellArray, [lArray[j][0], lArray[j][1]]);
                }
            } else continue;
        }
        return nextCellArray;
    };

/**
* recupère la valeur de la case de gauche de la case cible
* @pY     position en Y de la case ciblé]
* @pX     position en X de la case ciblé]
* @pArray si true renvoie la valeur un array de la position de la case
* @return valeur de la case
*/
    var leftCell = function(pY, pX, pArray) {

        pArray = pArray || false;
        if (pArray) return [pX - 1, pY];
        if (pX - 1 >= 0 && pX - 1 <= _GPGridWidth && pX > 0) {
            return _GPGrid[pY][pX - 1];
        } else return false;

    };

/**
* recupère la valeur de la case de droite de la case cible
* @pY     position en Y de la case ciblé]
* @pX     position en X de la case ciblé]
* @pArray si true renvoie la valeur un array de la position de la case
* @return valeur de la case
*/
    var rightCell = function(pY, pX, pArray) {
        pArray = pArray || false;
        if (pArray) return [pX + 1, pY];
        if (pX + 1 >= 0 && pX + 1 <= _GPGridWidth && pX < _GPGridWidth - 1) {
            return _GPGrid[pY][pX + 1];
        } else return false;
    };

/**
 * recupère la valeur de la case en bas de la case cible
* @pY     position en Y de la case ciblé]
* @pX     position en X de la case ciblé]
* @pArray si true renvoie la valeur un array de la position de la case
* @return valeur de la case
*/
    var downCell = function(pY, pX, pArray) {
        pArray = pArray || false;
        if (pArray) return [pX, pY + 1];
        if (pY + 1 >= 0 && pY + 1 <= _GPGridHeigth && pY < _GPGridHeigth - 1) {
            return _GPGrid[pY + 1][pX];
        } else return false;
    };

/**
 * recupère la valeur de la case du haut de la case cible
* @pY     position en Y de la case ciblé]
* @pX     position en X de la case ciblé]
* @pArray si true renvoie la valeur un array de la position de la case
* @return valeur de la case
*/
    var upCell = function(pY, pX, pArray) {
        pArray = pArray || false;
        if (pArray) return [pX, pY - 1];
        if (pY - 1 >= 0 && pY - 1 <= _GPGridHeigth && pY > 0) {
            return _GPGrid[pY - 1][pX];
        } else return false;
    };
global GPAdjacentCells = [leftCell, rightCell, downCell, upCell];