//randomly picks a piece (used for random opponent)
public Piece RandomPickPiece(Board b, AvailablePieces av)
{
Piece[] pieces = av.RemainingPieces;
int count = av.GetRemainingCount();
int rng = rnd.Next(count - 1);
int it = 0;
foreach (Piece p in pieces)
{
if (rng == it)
{
if (p == null)
{
continue;
}
else
{
return(p);
}
}
if (p != null)
{
it++;
}
}
return(null);
}
//original attempt at MinMax pick, not used anymore
public Piece RecursivePickPiece(Board b, AvailablePieces av)
{
List <int[]> playableLocations = b.GetOpenSpots();
Dictionary <Piece, double> evaluationDict = new Dictionary <Piece, double>();
int piecesLeft = av.GetRemainingCount();
/*foreach (Piece temp in av.RemainingPieces)
* {
* if (temp != null) { piecesLeft++; }
* }*/
//int searchDepth = Convert.ToInt32(Math.Floor(Convert.ToDecimal(av.RemainingPieces.Length / piecesLeft)));
int searchDepth = 2;
foreach (Piece p in av.RemainingPieces)
{
if (p != null)
{
double value = 0;
Dictionary <Piece, double> abc = RecursivePickEvaluation(b, av, searchDepth);
foreach (KeyValuePair <Piece, double> i in abc)
{
value += i.Value;
}
evaluationDict.Add(p, value);
}
}
List <Piece> sorted = evaluationDict.OrderBy(x => x.Value).ToDictionary(pair => pair.Key).Keys.ToList();
return(sorted[0]);
}
//original attempt at MinMax play, no longer used
public int[] RecursivePlayPiece(Board b, Piece p, AvailablePieces a)
{
List <int[]> playableLocations = b.GetOpenSpots();
Dictionary <int[], double> staticEval = new Dictionary <int[], double>();
List <int[]> playableSubset;
foreach (int[] i in playableLocations)
{
staticEval.Add(i, StaticPlayEvaluate(b, p, i, a));
}
int piecesLeft = a.GetRemainingCount();
int searchDepth;
if (piecesLeft > 0)
{
searchDepth = Convert.ToInt32(Math.Floor(Convert.ToDecimal(a.RemainingPieces.Length / (piecesLeft))));
if (searchDepth > 4)
{
searchDepth = 4;
}
}
else
{
searchDepth = 0;
}
playableSubset = staticEval.OrderByDescending(x => x.Value).ToDictionary(x => x.Key).Keys.ToList().Take(Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(a.GetRemainingCount() * 1 / (4 - searchDepth + 1))))).ToList();
Dictionary <int[], double> evaluationDict = new Dictionary <int[], double>();
/*foreach(Piece temp in a.RemainingPieces)
* {
* if (temp != null) { piecesLeft++; }
* }*/
foreach (int[] coordinates in playableSubset)
{
double value = 0;
Dictionary <int[], double> abc = RecursivePlayEvaluation(b, p, a, searchDepth);
foreach (KeyValuePair <int[], double> i in abc)
{
value += i.Value;
}
evaluationDict.Add(coordinates, value);
}
List <int[]> sorted = evaluationDict.OrderByDescending(x => x.Value).ToDictionary(pair => pair.Key).Keys.ToList();
if (sorted.Count == 0)
{
return(PlayPiece(b, p, a));
}
return(sorted[0]);
}
//Evaluation Function for placing a piece
public double StaticPlayEvaluate(Board b, Piece p, int[] coordinates, AvailablePieces a)
{
double v1 = Coefficients[0] * EvaluationFunctions.BinarySum(EvaluationFunctions.CommonProperties(EvaluationFunctions.EvaluationDirection.Row, b, coordinates[0], coordinates[1]));
double v2 = Coefficients[1] * EvaluationFunctions.BinarySum(EvaluationFunctions.CommonProperties(EvaluationFunctions.EvaluationDirection.Column, b, coordinates[0], coordinates[1]));
double v3 = Coefficients[2] * EvaluationFunctions.BinarySum(EvaluationFunctions.CommonProperties(EvaluationFunctions.EvaluationDirection.Diagonal, b, coordinates[0], coordinates[1]));
double v4 = Coefficients[3] * EvaluationFunctions.SpotsRemaining(EvaluationFunctions.EvaluationDirection.Row, b, coordinates[0], coordinates[1]);
double v5 = Coefficients[4] * EvaluationFunctions.SpotsRemaining(EvaluationFunctions.EvaluationDirection.Column, b, coordinates[0], coordinates[1]);
double v6 = Coefficients[5] * EvaluationFunctions.SpotsRemaining(EvaluationFunctions.EvaluationDirection.Diagonal, b, coordinates[0], coordinates[1]);
double v7 = Coefficients[6] * a.GetRemainingCount();
double v8 = Coefficients[7] * EvaluationFunctions.CommonPiecesRemaining(EvaluationFunctions.EvaluationDirection.Row, b, a.RemainingPieces, coordinates[0], coordinates[1]);
double v9 = Coefficients[8] * EvaluationFunctions.CommonPiecesRemaining(EvaluationFunctions.EvaluationDirection.Column, b, a.RemainingPieces, coordinates[0], coordinates[1]);
double v10 = Coefficients[9] * EvaluationFunctions.CommonPiecesRemaining(EvaluationFunctions.EvaluationDirection.Diagonal, b, a.RemainingPieces, coordinates[0], coordinates[1]);
int v11 = EvaluationFunctions.Winnable(EvaluationFunctions.EvaluationDirection.Diagonal, b, coordinates[0], coordinates[1]);
int v12 = EvaluationFunctions.WinningMoveAvailable(p, b, coordinates);
//return v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10;
return((v1 * v4 * v8) + (v2 * v5 * v9) + (v3 * v6 * v10 * v11) + v12);
//return (v1 * v8 - v4) + (v2 * v9 - v5) + (v3 * v10 * v11 - v6);
}
