public static void AlmacenarModelo(Partida partida)
        {
            //Se comprueba que la partida no se ha jugado anteriormente, para no falsear porcentaje de acierto



            foreach (var movimientos in ModeloAprendizaje.partidas)
            {
                if (movimientos.Count == partida.Movimientos.Count)
                {
                    int indice = 0;
                    for (int i = 0; i < movimientos.Count; i++)
                    {
                        if (movimientos[i] != partida.Movimientos[i])
                        {
                            break;
                        }
                        indice++;
                    }
                    if (indice == (movimientos.Count - 1))
                    {
                        return;
                    }
                }
            }

            List <string> listaMovimientos = new List <string>();

            foreach (string cadena in partida.Movimientos)
            {
                listaMovimientos.Add(cadena);
                PosicionTablero valor = new PosicionTablero();
                if (posiciones.ContainsKey(cadena))
                {
                    valor          = posiciones[cadena];
                    valor.Ganadas  = (partida.Estado == Progreso.JUGADOR1GANA) ? posiciones[cadena].Ganadas + 1 : posiciones[cadena].Ganadas;
                    valor.Perdidas = (partida.Estado == Progreso.JUGADOR2GANA) ? posiciones[cadena].Perdidas + 1 : posiciones[cadena].Perdidas;
                    valor.Tablas   = (partida.Estado == Progreso.TABLAS) ? posiciones[cadena].Tablas + 1 : posiciones[cadena].Tablas;
                    valor.Totales++;
                    valor.Porcentaje   = ((float)valor.Ganadas + (float)valor.Tablas / 2.0f) / (float)valor.Totales;
                    valor.Tablero      = partida.Tablero;
                    posiciones[cadena] = valor;
                }
                else
                {
                    valor.Ganadas    = (partida.Estado == Progreso.JUGADOR1GANA) ? 1 : 0;
                    valor.Perdidas   = (partida.Estado == Progreso.JUGADOR2GANA) ? 1 : 0;
                    valor.Tablas     = (partida.Estado == Progreso.TABLAS) ? 1 : 0;
                    valor.Totales    = 1;
                    valor.Tablero    = partida.Tablero;
                    valor.Porcentaje = (float)valor.Ganadas / (float)valor.Totales;
                    posiciones.Add(cadena, valor);
                }
            }
            ModeloAprendizaje.partidas.Add(listaMovimientos);
        }
        // public static MLContext mlContext = new MLContext(seed: 0);

        public static string Tablero2String(Partida partida)
        {
            string keyDictionary = "";

            for (int fila = 0; fila < partida.Tablero.GetLength(0); fila++)
            {
                for (int columna = 0; columna < partida.Tablero.GetLength(1); columna++)
                {
                    keyDictionary += ((int)partida.Tablero[fila, columna]);
                }
            }
            return(keyDictionary);
        }
示例#3
0
        public Partida SiguienteMovimiento(Partida partida)
        {
            var posicionesEvaluar = partida.PosicionesSiguientes(partida.Turno);
            List <Ficha[, ]> posicionesEvaluarNormalizada = new List <Ficha[, ]>();

            List <Ficha[, ]> newList = new List <Ficha[, ]>(posicionesEvaluar.Count);

            posicionesEvaluar.ForEach((item) =>
            {
                Ficha[,] nuevo = (Ficha[, ])item.Clone();
                posicionesEvaluarNormalizada.Add(nuevo);
            });

            //Si el turno es del jugador2 se intercambian las fichas
            if (partida.Turno == Turno.JUGADOR2)
            {
                for (int i1 = 0; i1 < posicionesEvaluarNormalizada.Count; i1++)
                {
                    posicionesEvaluarNormalizada[i1] = partida.FlipTablero(posicionesEvaluarNormalizada[i1]);
                }
            }

            List <InputData> inputData = new List <InputData>();

            foreach (var a in posicionesEvaluarNormalizada)
            {
                InputData input = new InputData();
                input.Features = new float[9];

                input.Features[0] = ((int)a[0, 0]) / (float)2.0;
                input.Features[1] = ((int)a[0, 1]) / (float)2.0;
                input.Features[2] = ((int)a[0, 2]) / (float)2.0;
                input.Features[3] = ((int)a[1, 0]) / (float)2.0;
                input.Features[4] = ((int)a[1, 1]) / (float)2.0;
                input.Features[5] = ((int)a[1, 2]) / (float)2.0;
                input.Features[6] = ((int)a[2, 0]) / (float)2.0;
                input.Features[7] = ((int)a[2, 1]) / (float)2.0;
                input.Features[8] = ((int)a[2, 2]) / (float)2.0;


                inputData.Add(input);
            }
            string fichero = "Level" + (int)(_level * 100) + ".zip";

            var model = mlContext.Model.Load(fichero, out var predictionPipelineSchema);



            var                    predictionEngine = mlContext.Model.CreatePredictionEngine <InputData, OutputData>(model);
            OutputData             prediction;
            InputData              maximo;
            float                  valor                    = -1;
            int                    indiceMaximo             = 0;
            int                    prediccionScoreAcumulado = 0;
            int                    i = 0;
            List <scoreMovimiento> listaResultado = new List <scoreMovimiento>();

            foreach (var movimiento in inputData)
            {
                prediction = predictionEngine.Predict(movimiento);
                if (prediction.Porcentaje > valor)
                {
                    valor        = prediction.Porcentaje;
                    maximo       = movimiento;
                    indiceMaximo = i;
                }
                scoreMovimiento score = new scoreMovimiento();
                score.posicion            = i;
                score.score               = Math.Abs((int)(prediction.Porcentaje * 100));
                prediccionScoreAcumulado += Math.Abs(score.score);
                listaResultado.Add(score);
                i++;
            }

            if (_random)
            {
                int contador = 100;
                //Rellenamos
                listaResultado = listaResultado.OrderByDescending(x => x.score).ToList();
                for (int j = 0; j < listaResultado.Count(); j++)
                {
                    var aux = new scoreMovimiento();
                    aux.posicion           = listaResultado[j].posicion;
                    aux.score              = listaResultado[j].score;
                    aux.probabilidadMinima = contador - ((int)(aux.score * 100 / ((prediccionScoreAcumulado == 0) ? 1 : prediccionScoreAcumulado)));
                    aux.probabilidadMaxima = contador;
                    if (aux.probabilidadMinima < 0)
                    {
                        aux.probabilidadMinima = 0;
                    }
                    contador          = aux.probabilidadMinima - 1;
                    listaResultado[j] = aux;
                }
                //Ficha[,] posicion = new Ficha[partida.Rango, partida.Rango];
                //
                //partida.Turno = partida.Turno == Turno.JUGADOR1 ? Turno.JUGADOR2 : Turno.JUGADOR1;


                int probabilidad = new Random().Next(0, 100);

                int indice = 0;
                try
                {
                    indice = listaResultado.Where(x => x.probabilidadMinima <= probabilidad && x.probabilidadMaxima >= probabilidad).First().posicion;
                }
                catch
                {
                }

                partida.Tablero = posicionesEvaluar[indice];
            }
            else
            {
                partida.Tablero = posicionesEvaluar[indiceMaximo];
            }
            partida.Turno = partida.Turno == Turno.JUGADOR1 ? Turno.JUGADOR2 : Turno.JUGADOR1;



            return(partida);
        }
示例#4
0
        static void Main(string[] args)
        {
            ILevel  jugador1 = new PlayerRandom();
            ILevel  jugador2 = new PlayerRandom();
            Partida partida;
            int     numeroPartidasModelo = 50;

            Console.WriteLine("Generando  {0} Partidas como modelo", numeroPartidasModelo);

            do
            {
                partida = new Partida(rango: 3, jugador1, jugador2);
                partida.Jugar(false);
                ModeloAprendizaje.AlmacenarModelo(partida);
            } while (ModeloAprendizaje.partidas.Count < numeroPartidasModelo);



            Console.WriteLine("Empezando partidas");



            int auxResultadoJugador1 = 0;
            int auxResultadoJugador2 = 0;
            int auxtablas            = 0;

            //Partida

            jugador2 = new PlayerIA(0.90);
            //  jugador1 =
            //    jugador2 = new PlayerIA(0.90);
            jugador1 = new PlayerIA(0.25, true);
            for (int j = 0; j < 2000; j++)
            {
                partida = new Partida(rango: 3, jugador1, jugador2);

                partida.Jugar(false);
                switch (partida.Estado)
                {
                case Progreso.JUGADOR1GANA: auxResultadoJugador2++; break;

                case Progreso.JUGADOR2GANA: auxResultadoJugador1++; break;

                default: auxtablas++; break;
                }
            }
            System.Console.WriteLine("********************************************************************");
            System.Console.WriteLine("jugador1-{0}:{1}", partida.Jugador1.Descripcion(), auxResultadoJugador1);
            System.Console.WriteLine("jugador2-{0}:{1}", partida.Jugador2.Descripcion(), auxResultadoJugador2);
            System.Console.WriteLine("Empate:{0}", auxtablas);
            System.Console.WriteLine("********************************************************************");


            ILevel[] jugadores = new ILevel[1];
            jugadores[0] = (ILevel) new PlayerIA(0.90);
            //   jugadores[1] = (ILevel)new PlayerIA(0.25);
            //    jugadores[2] = (ILevel)new PlayerIA(0.50);
            //    jugadores[3] = (ILevel)new PlayerIA(0.75);
            //    jugadores[4] = (ILevel)new PlayerIA(0.90);
            ILevel[] jugadores2 = new ILevel[1];
            //   jugadores2[0] = (ILevel)new PlayerRandom();
            //    jugadores2[1] = (ILevel)new PlayerIA(0.25);
            //    jugadores2[2] = (ILevel)new PlayerIA(0.50);
            //    jugadores2[3] = (ILevel)new PlayerIA(0.75);
            //     jugadores2[4] = (ILevel)new PlayerIA(0.90);
            jugadores2[0] = (ILevel) new PlayerIA(0.25);


            int numeroPartidas = 2000;

            foreach (var j1 in jugadores)
            {
                foreach (var j2 in jugadores2)
                {
                    int resultadoJugador1 = 0;
                    int resultadoJugador2 = 0;
                    int tablas            = 0;
                    for (int j = 0; j < numeroPartidas; j++)
                    {
                        var partida1 = new Partida(rango: 3, j1, j2);

                        partida1.Jugar(false);
                        switch (partida1.Estado)
                        {
                        case Progreso.JUGADOR1GANA: resultadoJugador2++; break;

                        case Progreso.JUGADOR2GANA: resultadoJugador1++; break;

                        default: tablas++; break;
                        }
                    }
                    System.Console.WriteLine("**************************-Partidas Jugadas:{0}-****************************************", numeroPartidas);
                    System.Console.WriteLine("jugador1-{0}:{1}", j1.Descripcion(), resultadoJugador1);
                    System.Console.WriteLine("jugador2-{0}:{1}", j2.Descripcion(), resultadoJugador2);
                    System.Console.WriteLine("Empate:{0}", tablas);
                    System.Console.WriteLine("***************************************************************************************");
                }
            }
        }