public Move(int x, int y, ReversiGame reversiGame)
{
this.moveCode = xSequence[x] + (y + 1).ToString();
this.coordinates = new Point(x, y);
this.reversiGame = reversiGame;
//CalculateProfitPoints();
}
public Move(string moveCode, ReversiGame reversiGame)
{
this.moveCode = moveCode;
this.coordinates = new Point(xSequence.IndexOf(this.moveCode[0]), Convert.ToInt32(this.moveCode.Substring(1)) - 1);
this.reversiGame = reversiGame;
//CalculateProfitPoints();
}
public Move(Point coordinates, ReversiGame reversiGame)
{
this.moveCode = xSequence[coordinates.X] + (coordinates.Y + 1).ToString();
this.coordinates = coordinates;
this.reversiGame = reversiGame;
//CalculateProfitPoints();
}
public override Move GetBestMove(ReversiGame reversiGame)
///<summary>
///
/// This is the lvl 0 so the mashine is stupid and returns random, but correct move answers
///
///</summary>
{
List <Move> available_moves = new List <Move>();
for (int x = 0; x < gameVsMachine.board.Width; x++)
{
for (int y = 0; y < gameVsMachine.board.Height; y++)
{
Move move_candidate = new Move(x, y, reversiGame);
if (move_candidate.IsValid)
{
available_moves.Add(move_candidate);
}
}
}
return(available_moves[new Random().Next(0, available_moves.Count)]);
}
public override Move GetBestMove(ReversiGame reversiGame)
{
List <Move> best_moves = new List <Move>();
for (int x = 0; x < reversiGame.Matrix.GetLength(0); x++)
{
for (int y = 0; y < reversiGame.Matrix.GetLength(1); y++)
{
Move candidate = new Move(x, y, reversiGame);
if (!candidate.IsValid)
{
continue;
}
bool candidate_accepted = true;
List <Move> same_good_moves = new List <Move>();
for (int i = 0; i < best_moves.Count; i++)
{
if (candidate.ProfitPoints.Count < best_moves[i].ProfitPoints.Count)
{
candidate_accepted = false;
break;
}
else if (candidate.ProfitPoints.Count == best_moves[i].ProfitPoints.Count)
{
same_good_moves.Add(best_moves[i]);
}
}
if (candidate_accepted)
{
best_moves.Clear();
best_moves.AddRange(same_good_moves);
best_moves.Add(candidate);
}
}
}
return(best_moves[new Random().Next(0, best_moves.Count)]);
}
public abstract Move GetBestMove(ReversiGame reversiGame);
public override Move GetBestMove(ReversiGame reversiGame)
{
#region rubish
////declare variables not war:
//var winning = new List<Move>();
//var next_winning = new List<Pair<Move>>();
//var lossing = new List<Move>();
//var next_lossing = new List<Pair<Move>>();
//var drawing = new List<Move>();
//var next_drawing = new List<Pair<Move>>();
//var comboing = new List<Move>();
//var next_comboing = new List<Pair<Move>>();
//var normal = new List<Pair<Move>>();
//for(int x=0; x<this.gameVsMachine.board.Width; x++)
//{
// for(int y=0; y<this.gameVsMachine.board.Height; y++)
// {
// ReversiGame experiment = this.Clone() as ReversiGame;
// Move move = new Move(x, y, experiment);
// if (move.IsValid)
// {
// switch (move.Execute())
// {
// case GameStatus.Normal:
// ReversiGame second_experimental = experiment.Clone() as ReversiGame;
// Move opponents_move = Machine_LVL_2_Algorithm.GetBestMove(second_experimental);
// switch (opponents_move.Execute())
// {
// case GameStatus.Normal:
// Move next_machine_best_move = Machine_LVL_2_Algorithm.GetBestMove(second_experimental);
// normal.Add(new Pair<Move>(move, next_machine_best_move));
// break;
// case GameStatus.BlackWon:
// if (this.PlayerColor == PlayerColor.White)
// {
// next_lossing.Add(new Pair<Move>(move, opponents_move));
// }
// else if (this.PlayerColor == PlayerColor.Black)
// {
// next_winning.Add(new Pair<Move>(move, opponents_move));
// }
// break;
// case GameStatus.WhiteWon:
// if (this.PlayerColor == PlayerColor.Black)
// {
// next_lossing.Add(new Pair<Move>(move, opponents_move));
// }
// else if (this.PlayerColor == PlayerColor.White)
// {
// next_winning.Add(new Pair<Move>(move, opponents_move));
// }
// break;
// case GameStatus.Draw:
// next_drawing.Add(new Pair<Move>(move, opponents_move));
// break;
// case GameStatus.BlackCombo:
// case GameStatus.WhiteCombo:
// next_comboing.Add(new Pair<Move>(move, opponents_move));
// break;
// default:
// break;
// }
// break;
// case GameStatus.BlackWon:
// if (this.PlayerColor == PlayerColor.White)
// {
// winning.Add(move);
// }
// else if (this.PlayerColor == PlayerColor.Black)
// {
// lossing.Add(move);
// }
// break;
// case GameStatus.WhiteWon:
// if (this.PlayerColor == PlayerColor.Black)
// {
// winning.Add(move);
// }
// else if (this.PlayerColor == PlayerColor.White)
// {
// lossing.Add(move);
// }
// break;
// case GameStatus.Draw:
// drawing.Add(move);
// break;
// case GameStatus.BlackCombo:
// case GameStatus.WhiteCombo:
// comboing.Add(move);
// break;
// default:
// break;
// }
// }
// }
//}
//Move get_executable_move(Move move)
//{
// return new Move(move.Coordinates, this);
//}
//if (winning.Count > 0)
//{
// List<Move> best_moves = winning.GetMaxProperties("ProfitPoints", "Count") as List<Move>;
// return get_executable_move(best_moves[new Random().Next(0, best_moves.Count)]);
//}
//else if (next_winning.Count > 0)
//{
// List<Pair<Move>> best_solutions = next_winning.GetMaxProperties("A", "ProfitPoints", "Count") as List<Pair<Move>>;
// return get_executable_move(best_solutions[new Random().Next(0, best_solutions.Count)].A);
//}
//else if (comboing.Count > 0)
//{
// List<Move> best_moves = comboing.GetMaxProperties("ProfitPoints", "Count") as List<Move>;
// return get_executable_move(best_moves[new Random().Next(0, best_moves.Count)]);
//}
//else if (normal.Count > 0)
//{
// Dictionary<Move, int> moves_with_total_profits_count = new Dictionary<Move, int>();
// for(int i=0; i<normal.Count; i++)
// {
// moves_with_total_profits_count.Add(normal[i].A, normal[i].A.ProfitPoints.Count + normal[i].B.ProfitPoints.Count);
// }
// var best = moves_with_total_profits_count.ToList().GetMaxProperties("Value") as List<KeyValuePair<Move, int>>;
// return get_executable_move(best[new Random().Next(0, best.Count)].Key);
//}
//else if (next_drawing.Count > 0)
//{
// List<Pair<Move>> best_solutions = next_drawing.GetMaxProperties("A", "ProfitPoints", "Count") as List<Pair<Move>>;
// return get_executable_move(best_solutions[new Random().Next(0, best_solutions.Count)].A);
//}
//else if (drawing.Count > 0)
//{
// // List<Move> best_moves = drawing.GetMaxProperties("ProfitPoints", "Count") as List<Move>;
// // return get_executable_move(best_moves[new Random().Next(0, best_moves.Count)]);
// return get_executable_move(drawing[new Random().Next(0, drawing.Count)]);
//}
//else if (next_comboing.Count > 0)
//{
// List<Pair<Move>> best_solutions = next_comboing.GetMaxProperties("A", "ProfitPoints", "Count") as List<Pair<Move>>;
// return get_executable_move(best_solutions[new Random().Next(0, best_solutions.Count)].A);
//}
//else if (next_lossing.Count > 0)
//{
// List<Pair<Move>> best_solutions = next_lossing.GetMaxProperties("A", "ProfitPoints", "Count") as List<Pair<Move>>;
// return get_executable_move(best_solutions[new Random().Next(0, best_solutions.Count)].A);
//}
//else if (lossing.Count > 0)
//{
// List<Move> best_moves = lossing.GetMaxProperties("ProfitPoints", "Count") as List<Move>;
// return get_executable_move(best_moves[new Random().Next(0, best_moves.Count)]);
//}
//else
//{
// return null;
//}
#endregion
List <Move> winning, lossing, drawing, comboing;
winning = lossing = drawing = comboing = new List <Move>();
Dictionary <Move, int> moves_with_balances = new Dictionary <Move, int>();
for (int x = 0; x < this.gameVsMachine.board.Width; x++)
{
for (int y = 0; y < this.gameVsMachine.board.Height; y++)
{
ReversiGame experimental = reversiGame.Clone() as ReversiGame;
Move move = new Move(x, y, experimental);
int profit_count = move.ProfitPoints.Count;
if (move.IsValid)
{
switch (move.Execute())
{
case GameStatus.Normal:
moves_with_balances.Add(move, profit_count - new Machine_LVL_1_Algorithm(gameVsMachine).GetBestMove(experimental).ProfitPoints.Count);
break;
case GameStatus.BlackWon:
if (this.PlayerColor == PlayerColor.White)
{
winning.Add(move);
}
else if (this.PlayerColor == PlayerColor.Black)
{
lossing.Add(move);
}
break;
case GameStatus.WhiteWon:
if (this.PlayerColor == PlayerColor.White)
{
lossing.Add(move);
}
else if (this.PlayerColor == PlayerColor.Black)
{
winning.Add(move);
}
break;
case GameStatus.Draw:
drawing.Add(move);
break;
case GameStatus.BlackCombo:
case GameStatus.WhiteCombo:
comboing.Add(move);
break;
default:
break;
}
}
}
}
if (winning.Count > 0)
{
var best = winning.GetMaxProperties("ProfitPoints", "Count") as List <Move>;
return(GetExecutableMove(best[new Random().Next(0, best.Count)]));
}
else if (comboing.Count > 0)
{
var best = comboing.GetMaxProperties("ProfitPoints", "Count") as List <Move>;
return(GetExecutableMove(best[new Random().Next(0, best.Count)]));
}
else if (moves_with_balances.Count > 0)
{
var best_solutions = moves_with_balances.ToList().GetMaxProperties("Value") as List <KeyValuePair <Move, int> >;
return(GetExecutableMove(best_solutions[new Random().Next(0, best_solutions.Count)].Key));
}
else if (drawing.Count > 0)
{
return(GetExecutableMove(drawing[new Random().Next(0, drawing.Count)]));
}
else if (lossing.Count > 0)
{
var best = lossing.GetMaxProperties("ProfitPoints", "Count") as List <Move>;
return(GetExecutableMove(best[new Random().Next(0, best.Count)]));
}
else
{
return(null);
}
}
public override Move GetBestMove(ReversiGame reversiGame)
{
//MessageBox.Show("Ctrl1: "+this.PlayerColor.ToString());
//return base.GetBestMove();
#region rubbish
/*List<Move> less_most_profitable_for_opponent_moves = new List<Move>();
* for(int x=0; x<gameVsMachine.board.Width; x++)
* {
* for(int y=0; y<gameVsMachine.board.Height; y++)
* {
* Chessboard.Square[,] test_matrix = gameVsMachine.board.Squares;
* ReversiGame tester_game = new ReversiGame(ref test_matrix);
* Move move = new Move(x, y, tester_game);
* if (!move.IsValid) continue;
* GameStatus testerGameStatus = tester_game.ExecuteMove(move);
*
* switch (testerGameStatus)
* {
* case GameStatus.Normal://checking the opponent's situation:
* Move opponents_best_move = Machine_LVL_1_Algorithm.GetBestMove(tester_game);
* for(int i=0; i<less_most_profitable_for_opponent_moves.Count; i++)
* {
* if (opponents_best_move.ProfitPoints.Count > less_most_profitable_for_opponent_moves[i].ProfitPoints.Count) break;
*
* else
* {
*
* less_most_profitable_for_opponent_moves.Add(opponents_best_move);
* }
* }
* break;
* case GameStatus.BlackWon:
* case GameStatus.WhiteWon:
* case GameStatus.Draw:
* return base.GetBestMove();
* default://combo:
* break;
* }
*
*
* }
* }*/
#endregion
//return GetBestMove(this);
var move_with_user_best_answer_pairs = new List <Pair <Move> >();
var winning_moves = new List <Move>();
var losing_moves = new List <Move>();
var drawing_moves = new List <Move>();
var comboing_moves = new List <Move>();
for (int x = 0; x < reversiGame.Matrix.GetLength(0); x++)
{
for (int y = 0; y < reversiGame.Matrix.GetLength(1); y++)
{
//PlayerColor[,] experimental_matrix = gameVsMachine.board.FetchMatrix();
//ReversiGame experimental_game = new ReversiGame(ref experimental_matrix, this.PlayerColor);
ReversiGame experimental_game = reversiGame.Clone() as ReversiGame;
//MessageBox.Show(experimental_game.PlayerColor.ToString());
Move move = new Move(x, y, experimental_game);
if (move.IsValid)
{
switch (move.Execute())
{
case GameStatus.Normal:
move_with_user_best_answer_pairs.Add(new Pair <Move>(new Move(x, y, experimental_game), new Machine_LVL_1_Algorithm(gameVsMachine).GetBestMove(experimental_game)));
break;
case GameStatus.WhiteWon:
if (experimental_game.PlayerColor == PlayerColor.Black)
{ //winning
winning_moves.Add(move);
}
else if (experimental_game.PlayerColor == PlayerColor.White)
{ //lossing
losing_moves.Add(move);
}
break;
case GameStatus.BlackWon:
if (experimental_game.PlayerColor == PlayerColor.White)
{ //winning
winning_moves.Add(move);
}
else if (experimental_game.PlayerColor == PlayerColor.Black)
{ //lossing
losing_moves.Add(move);
}
break;
case GameStatus.Draw:
drawing_moves.Add(move);
break;
case GameStatus.BlackCombo:
case GameStatus.WhiteCombo:
comboing_moves.Add(move);
break;
}
}
}
}
//MessageBox.Show("Ctrl2: " + this.PlayerColor.ToString());
Random random = new Random();
if (winning_moves.Count > 0)
{
return(GetExecutableMove(winning_moves[random.Next(0, winning_moves.Count)]));
}
else if (comboing_moves.Count > 0)
{
/*List<Move> best_moves = new List<Move>();
*
* for (int i = 0; i < comboing_moves.Count; i++)
* {
* bool best = true;
* List<Move> same_best_moves = new List<Move>();
* for (int j = 0; j < best_moves.Count; j++)
* {
* if (comboing_moves[i].ProfitPoints.Count < best_moves[j].ProfitPoints.Count)
* {
* best = false;
* break;
* }
* else if (comboing_moves[i].ProfitPoints.Count == best_moves[j].ProfitPoints.Count)
* {
* same_best_moves.Add(best_moves[j]);
* }
* }
* if (best)
* {
* best_moves.Clear();
* best_moves.AddRange(same_best_moves);
* best_moves.Add(comboing_moves[i]);
* }
* }*/
List <Move> best_moves = comboing_moves.GetMaxProperties("ProfitPoints", "Count") as List <Move>;
return(GetExecutableMove(best_moves[random.Next(0, best_moves.Count)]));
}
else if (move_with_user_best_answer_pairs.Count > 0)
{
//MessageBox.Show("Ctrl3: " + this.PlayerColor.ToString());
/*var best_solutions = new List<Pair<Move>>();
* for (int i = 0; i < move_with_user_best_answer_pairs.Count; i++)
* {
* bool best = true;
* var same_best_solutions = new List<Pair<Move>>();
* for (int j = 0; j < best_solutions.Count; j++)
* {
* if (move_with_user_best_answer_pairs[i].B.ProfitPoints.Count > best_solutions[j].B.ProfitPoints.Count)
* {
* best = false;
* break;
* }
* else if (move_with_user_best_answer_pairs[i].B.ProfitPoints.Count == best_solutions[j].B.ProfitPoints.Count)
* {
* same_best_solutions.Add(best_solutions[j]);
* }
* }
* if (best)
* {
* best_solutions.Clear();
* best_solutions.AddRange(same_best_solutions);
* best_solutions.Add(move_with_user_best_answer_pairs[i]);
* }
* }*/
List <Pair <Move> > best_solutions = move_with_user_best_answer_pairs.GetMinProperties("B", "ProfitPoints", "Count") as List <Pair <Move> >;
//Move choosen_move = best_solutions[random.Next(0, best_solutions.Count)].A;
//Move output = new Move(choosen_move.Coordinates, this);
return(GetExecutableMove(best_solutions[random.Next(0, best_solutions.Count)].A));
}
else if (drawing_moves.Count > 0)
{
return(GetExecutableMove(drawing_moves[random.Next(0, drawing_moves.Count)]));
}
else if (losing_moves.Count > 0)
{
return(new Machine_LVL_1_Algorithm(gameVsMachine).GetBestMove(reversiGame));
}
else
{
return(null);
}
}