Propuesta para desafíos javascript 2014

[NSD]

al problema de la inteligencia dejo mi propuesta.
funca bien y ademas, propone diferentes caminos para lograr el objetivo cambiando un unico parametro.

Código Javascript:

TRON.prototype.ia=function()
{
    // Aumentar este valor hace mas inteligente a la ia pero recarga la pila de recursion pudiendo explotar y/o ser leeeeeeento.
    // Una gran mejora seria que en lugar de ser fijo, aumentara a medida que disminuyen los espacios libres, esto la haria mas versatil.
    // Notese que cambiando este numero se obtienen diferentes soluciones de dominacion total.
    // Ej: 3, 4. 
    // Con un valor menor a 2 no es lo sufientemente inteligente como para encontrar un camino correcto.
    var maximunCall = 3;
    
    // Este valor es un parchesito para no complicar el algoritmo. con que sea mayor o igual a la longitud del mapa es suficiente.
    // Otra gran mejora, seria que en lugar de ser fijo se calculara segun las dimenciones de la matriz.    
    var incrementoAgresivo = 25;
 
    function mejorPosicion(arr, min, pred)
    {
        var max = min;
        var dir = pred;
        for(var i=0; i< arr.length; i++)
        {
            if(arr[i] > max)
            {
                max = arr[i];
                dir = i;
            }
        }
 
        return dir;
    }
 
    function recursiveMejorCamino(pos, mapa, movTmp, nroCall)
    {
        nroCall++;
        if((mapa[pos[0]][pos[1]] == 0) && (nroCall < maximunCall))
        {
            movTmp++;
            var movT = new Array();
            movT[0] = recursiveMejorCamino([(pos[0]-1), pos[1]], mapa, movTmp , nroCall) + (((nroCall > 1) && (mapa[(pos[0]-((pos[0]-2) >= 0 ? (pos[0]-2) : 0))][pos[1]] == 2)) ? incrementoAgresivo : 0);                                  // Arriba
            movT[1] = recursiveMejorCamino([(pos[0]+1), pos[1]], mapa, movTmp , nroCall) + (((nroCall > 1) && (mapa[((pos[0]+2) < mapa.length ? (pos[0]+2) : (mapa.length-1))][pos[1]] == 2)) ? incrementoAgresivo : 0);                    // Abajo
            movT[2] = recursiveMejorCamino([pos[0], (pos[1]-1)], mapa, movTmp , nroCall) + (((nroCall > 1) && (mapa[pos[0]][(pos[1]-((pos[1]-2) >= 0 ? (pos[1]-2) : 0))] == 2)) ? incrementoAgresivo : 0);                                  // Izquierda
            movT[3] = recursiveMejorCamino([pos[0], (pos[1]+1)], mapa, movTmp , nroCall) + (((nroCall > 1) && (mapa[pos[0]][((pos[1]+2) < mapa[pos[0]].length ? (pos[1]+2) : (mapa[pos[0]].length-1))] == 2)) ? incrementoAgresivo : 0);    // Derecha
            var dir = mejorPosicion(movT, 0 , 3);
            
            return ((movTmp*1) + (movT[dir]*1));
        } else
            return 0;
    }
 
    var movP = new Array();
    movP[0] = recursiveMejorCamino([(this.jugador[0]-1), this.jugador[1]], this.mapa,   0,  0); // Arriba
    movP[1] = recursiveMejorCamino([(this.jugador[0]+1), this.jugador[1]], this.mapa,   0,  0); // Abajo
    movP[2] = recursiveMejorCamino([this.jugador[0], (this .jugador[1]-1)], this.mapa,  0,  0); // Izquierda
    movP[3] = recursiveMejorCamino([this.jugador[0], (this.jugador[1]+1)], this.mapa,   0,  0); // Derecha
 
    var dir = mejorPosicion(movP,0 , 0);
 
    switch (dir)
    {
        case 0 :
            return DIRECCION.arriba;
        break;
        case 1 :
            return DIRECCION.abajo;
        break;
        case 2 :
            return DIRECCION.izquierda;
        break;
        case 3 :
            return DIRECCION.derecha;
        break;
    }
};
 

con esto califico para entrar al concurso?