Yes, all pieces (except those in the base) move one step in the same direction. For left player e.g. the movement starts with the pieces from right-to-left, so one cann't land at own piece.
Thankls for the link i will look at.

Meanwhile, here my minimax-code:


[source lang="cpp"]//--------------------------------------------------------------------------------int cBoard::MiniMaxAB(tBoard& board, int depth, int alpha, int beta, int sumscore, bool left){ if (depth == _maxdepth) return sumscore; std::vector<tMove> movelist; GenerateMoves(&board, left, movelist); if (movelist.size() == 0) return sumscore; int this_alpha = -1000000; int this_beta = +1000000; // Max node if (left == _cpuleft) { for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &board, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int score = movelist[i].rating; int val = MiniMaxAB(board2, depth+1, Max(alpha, this_alpha), beta, sumscore+score, !left); this_alpha = Max(this_alpha, val); if (this_alpha >= beta) { break; } } return this_alpha; } else { for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &board, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int score = -movelist[i].rating; int val = MiniMaxAB(board2, depth+1, alpha, Min(beta, this_beta), sumscore+score, !left); this_beta = Min(this_beta, val); if (alpha >= this_beta) { break; } } return this_beta; } return 0;}//--------------------------------------------------------------------------------tMove cBoard::MiniMaxAB(bool left, int maxdepth){ _cpuleft = left; _maxdepth = maxdepth; tMove bestmove; bestmove.rating = -1000000; int currentscore; _bestmoves.clear(); std::vector<tMove> movelist; GenerateMoves(&m_fields, left, movelist); for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &m_fields, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int rating = movelist[i].rating; currentscore = MiniMaxAB(board2, 0, -1000000, +1000000, rating, !left); if (currentscore > bestmove.rating) { bestmove.rating = currentscore; bestmove.move = movelist[i].move; } tMove move; move.move = movelist[i].move; move.rating = currentscore; _bestmoves.push_back(move); } return bestmove;}[/source]

The starting function is MiniMaxAB(bool left, int maxdepth), where for "left"=true the cpu player is on the left side else right side.
The evaluation of a  move is done in the function ExecuteMove(...)

P.S: My Code in the code snippet doesn't seem to be shon correctly, parts are missing, is that a known bug?
E.g. i can only see
"GenerateMoves(&m_fields, left, movelist);
for (unsigned int i=0; i bestmove.rating)
{
bestmove.rating = currentscore;
bestmove.move = movelist[i].move;
}
..."

but it should be

"GenerateMoves(&m_fields, left, movelist);
for (unsigned int i=0; i<movelist.size(); ++i)
{
  tBoard board2;
  memcpy(&board2, &m_fields, sizeof(tBoard));
  ExecuteMove(&board2, left, movelist[i]);
  int rating = movelist[i].rating;
  currentscore = MiniMaxAB(board2, 0, -1000000, +1000000, rating, !left);
  if (currentscore > bestmove.rating)
  {
   bestmove.rating = currentscore;
   bestmove.move = movelist[i].move;  
  }
  tMove move;
  move.move = movelist[i].move;
  move.rating = currentscore;
  _bestmoves.push_back(move);
}
"

Yes, all pieces (except those in the base) move one step in the same direction. For left player e.g. the movement starts with the pieces from right-to-left, so one cann't land at own piece.
Thankls for the link i will look at.

Meanwhile, here my minimax-code:


[source lang="cpp"]//--------------------------------------------------------------------------------int cBoard::MiniMaxAB(tBoard& board, int depth, int alpha, int beta, int sumscore, bool left){ if (depth == _maxdepth) return sumscore; std::vector<tMove> movelist; GenerateMoves(&board, left, movelist); if (movelist.size() == 0) return sumscore; int this_alpha = -1000000; int this_beta = +1000000; // Max node if (left == _cpuleft) { for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &board, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int score = movelist[i].rating; int val = MiniMaxAB(board2, depth+1, Max(alpha, this_alpha), beta, sumscore+score, !left); this_alpha = Max(this_alpha, val); if (this_alpha >= beta) { break; } } return this_alpha; } else { for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &board, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int score = -movelist[i].rating; int val = MiniMaxAB(board2, depth+1, alpha, Min(beta, this_beta), sumscore+score, !left); this_beta = Min(this_beta, val); if (alpha >= this_beta) { break; } } return this_beta; } return 0;}//--------------------------------------------------------------------------------tMove cBoard::MiniMaxAB(bool left, int maxdepth){ _cpuleft = left; _maxdepth = maxdepth; tMove bestmove; bestmove.rating = -1000000; int currentscore; _bestmoves.clear(); std::vector<tMove> movelist; GenerateMoves(&m_fields, left, movelist); for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &m_fields, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int rating = movelist[i].rating; currentscore = MiniMaxAB(board2, 0, -1000000, +1000000, rating, !left); if (currentscore > bestmove.rating) { bestmove.rating = currentscore; bestmove.move = movelist[i].move; } tMove move; move.move = movelist[i].move; move.rating = currentscore; _bestmoves.push_back(move); } return bestmove;}[/source]

The starting function is MiniMaxAB(bool left, int maxdepth), where for "left"=true the cpu player is on the left side else right side.
The evaluation of a  move is done in the function ExecuteMove(...)

P.S: My Code in the code snippet doesn't seem to be shon correctly, parts are missing, is that a known bug?
E.g. i can only see
"GenerateMoves(&m_fields, left, movelist);
    for (unsigned int i=0; i bestmove.rating)
    {
    bestmove.rating = currentscore;
    bestmove.move = movelist[i].move;
    }
..."

but it should be

"GenerateMoves(&m_fields, left, movelist);
for (unsigned int i=0; i<movelist.size(); ++i)
{
  tBoard board2;
  memcpy(&board2, &m_fields, sizeof(tBoard));
  memset(&eval, 0, sizeof(tEvaluation));
  ExecuteMove(&board2, left, movelist[i], eval);
  int rating = movelist[i].rating;
  currentscore = MiniMaxAB(board2, 0, -1000000, +1000000, rating, !left);
  if (currentscore > bestmove.rating)
  {
   bestmove.rating = currentscore;
   bestmove.move = movelist[i].move;  
  }
  tMove move;
  move.move = movelist[i].move;
  move.rating = currentscore;
  _bestmoves.push_back(move);
}
"

Yes, all pieces (except those in the base) move one step in the same direction. For left player e.g. the movement starts with the pieces from right-to-left, so one cann't land at own piece.
Thankls for the link i will look at.

Meanwhile, here my minimax-code:


[source lang="cpp"]//--------------------------------------------------------------------------------int cBoard::MiniMaxAB(tBoard& board, int depth, int alpha, int beta, int sumscore, bool left){ if (depth == _maxdepth) return sumscore; std::vector<tMove> movelist; GenerateMoves(&board, left, movelist); if (movelist.size() == 0) return sumscore; int this_alpha = -1000000; int this_beta = +1000000; // Max node if (left == _cpuleft) { for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &board, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int score = movelist[i].rating; int val = MiniMaxAB(board2, depth+1, Max(alpha, this_alpha), beta, sumscore+score, !left); this_alpha = Max(this_alpha, val); if (this_alpha >= beta) { break; } } return this_alpha; } else { for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &board, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int score = -movelist[i].rating; int val = MiniMaxAB(board2, depth+1, alpha, Min(beta, this_beta), sumscore+score, !left); this_beta = Min(this_beta, val); if (alpha >= this_beta) { break; } } return this_beta; } return 0;}//--------------------------------------------------------------------------------tMove cBoard::MiniMaxAB(bool left, int maxdepth){ _cpuleft = left; _maxdepth = maxdepth; tMove bestmove; bestmove.rating = -1000000; int currentscore; _bestmoves.clear(); std::vector<tMove> movelist; GenerateMoves(&m_fields, left, movelist); for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &m_fields, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int rating = movelist[i].rating; currentscore = MiniMaxAB(board2, 0, -1000000, +1000000, rating, !left); if (currentscore > bestmove.rating) { bestmove.rating = currentscore; bestmove.move = movelist[i].move; } tMove move; move.move = movelist[i].move; move.rating = currentscore; _bestmoves.push_back(move); } return bestmove;}[/source]

The starting function is MiniMaxAB(bool left, int maxdepth), where for "left"=true the cpu player is on the left side else right side.
The evaluation of a  move is done in the function ExecuteMove(...)

Yes, all pieces (except those in the base) move one step in the same direction. For left player e.g. the movement starts with the pieces from right-to-left, so one cann't land at own piece.
Thankls for the link i will look at.

Meanwhile, here my minimax-code:


[source lang="cpp"]//--------------------------------------------------------------------------------int cBoard::MiniMaxAB(tBoard& board, int depth, int alpha, int beta, int sumscore, bool left){ if (depth == _maxdepth) return sumscore; std::vector<tMove> movelist; GenerateMoves(&board, left, movelist); if (movelist.size() == 0) return sumscore; int this_alpha = -1000000; int this_beta = +1000000; // Max node if (left == _cpuleft) { for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &board, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int score = movelist[i].rating; int val = MiniMaxAB(board2, depth+1, Max(alpha, this_alpha), beta, sumscore+score, !left); this_alpha = Max(this_alpha, val); if (this_alpha >= beta) { break; } } return this_alpha; } else { for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &board, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int score = -movelist[i].rating; int val = MiniMaxAB(board2, depth+1, alpha, Min(beta, this_beta), sumscore+score, !left); this_beta = Min(this_beta, val); if (alpha >= this_beta) { break; } } return this_beta; } return 0;}//--------------------------------------------------------------------------------tMove cBoard::MiniMaxAB(bool left, int maxdepth){ _cpuleft = left; _maxdepth = maxdepth; tMove bestmove; bestmove.rating = -1000000; int currentscore; _bestmoves.clear(); std::vector<tMove> movelist; GenerateMoves(&m_fields, left, movelist); for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &m_fields, sizeof(tBoard)); ExecuteMove(&board2, left, movelist[i]); int rating = movelist[i].rating; currentscore = MiniMaxAB(board2, 0, -1000000, +1000000, rating, !left); if (currentscore > bestmove.rating) { bestmove.rating = currentscore; bestmove.move = movelist[i].move; } tMove move; move.move = movelist[i].move; move.rating = currentscore; _bestmoves.push_back(move); } return bestmove;}[/source]

The starting function is MiniMaxAB(bool left, int maxdepth), where fpr "left"=true the cpu player is on the left side else right side.

Yes, all pieces (except those in the base) move one step in the same direction. For left player e.g. the movement starts with the pieces from right-to-left, so one cann't land at own piece.
Thankls for the link i will look at.

Meanwhile, here my minimax-code:

[source lang="cpp"]//--------------------------------------------------------------------------------tMove cBoard::MiniMaxAB(bool left, int maxdepth){ tEvaluation eval; _cpuleft = left; _maxdepth = maxdepth; tMove bestmove; bestmove.rating = -1000000; int currentscore; _bestmoves.clear(); std::vector<tMove> movelist; GenerateMoves(&m_fields, left, movelist); for (unsigned int i=0; i<movelist.size(); ++i) { tBoard board2; memcpy(&board2, &m_fields, sizeof(tBoard)); memset(&eval, 0, sizeof(tEvaluation)); ExecuteMove(&board2, left, movelist[i], eval); int rating = movelist[i].rating; currentscore = MiniMaxAB(board2, 0, -1000000, +1000000, rating, !left); if (currentscore > bestmove.rating) { bestmove.rating = currentscore; bestmove.move = movelist[i].move; } tMove move; move.move = movelist[i].move; move.rating = currentscore; _bestmoves.push_back(move); } return bestmove;}//--------------------------------------------------------------------------------int cBoard::MiniMaxAB(tBoard& board, int depth, int alpha, int beta, int sumscore, bool left){tEvaluation eval;if (depth == _maxdepth) return sumscore;std::vector<tMove> movelist;GenerateMoves(&board, left, movelist);if (movelist.size() == 0) return sumscore;int this_alpha = -1000000;int this_beta = +1000000;// Max nodeif (left == _cpuleft){  for (unsigned int i=0; i<movelist.size(); ++i)  {   tBoard board2;   memcpy(&board2, &board, sizeof(tBoard));     memset(&eval, 0, sizeof(tEvaluation));   ExecuteMove(&board2, left, movelist[i], eval);   int score = movelist[i].rating;   int val = MiniMaxAB(board2, depth+1, Max(alpha, this_alpha), beta, sumscore+score, !left);   this_alpha = Max(this_alpha, val);   if (this_alpha >= beta)   {    break;   }  }  return this_alpha;} else{  for (unsigned int i=0; i<movelist.size(); ++i)  {   tBoard board2;   memcpy(&board2, &board, sizeof(tBoard));   memset(&eval, 0, sizeof(tEvaluation));   ExecuteMove(&board2, left, movelist[i], eval);   int score = -movelist[i].rating;   int val = MiniMaxAB(board2, depth+1, alpha, Min(beta, this_beta), sumscore+score, !left);   this_beta = Min(this_beta, val);   if (alpha >= this_beta)   {    break;   }  }  return this_beta;}return 0;}[/source]