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);
}
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);
}
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("***************************************************************************************");
}
}
}
