MultiSource/Applications/obsequi/toggle_move.c

#include "globals.h"
#include "macros.h"

//########################################################
// This function counts the number of safe moves in a row.
//
// Never call this function for rows 0 or 31.
//########################################################
static inline s32bit
count_safe(s32bit player, s32bit row)
{
  u32bit guard = g_board[player][row-1] & g_board[player][row+1];

  // mask contains a bit for each safe move.
  u32bit mask= ( (~(g_board[player][row] | (g_board[player][row] << 1)))
                 & (guard & (guard << 1)) );

  return COUNTMOVES(mask);
}

//########################################################
// This function counts the number of real moves in a row.
//
// Never call this function for rows 0 or 31.
//########################################################
static inline s32bit
count_real(s32bit player, s32bit row)
{
  // mask contains a bit for each real move.
  u32bit mask= ~(g_board[player][row] | (g_board[player][row] << 1));

  return COUNTMOVES(mask);
}


static inline void
_update_safe(s32bit player, s32bit row)
{
  s32bit count = count_safe(player, row);

  g_info_totals[player].safe += count - g_info[player][row].safe;
  g_info[player][row].safe    = count;
}

static inline void
_update_real(s32bit player, s32bit row)
{
  s32bit count = count_real(player, row);
  
  g_info_totals[player].real += count - g_info[player][row].real;
  g_info[player][row].real = count;
}



extern void
update_safe(s32bit player, s32bit row)
{ _update_safe(player, row); }

extern void
update_real(s32bit player, s32bit row)
{ _update_real(player, row); }

extern void
toggle_move(Move move, s32bit player)
{
  s32bit row, col, horz_play, vert_play;
  
  row = (move).array_index, col = (move).mask_index;
  horz_play = player & PLAYER_MASK;
  vert_play = player ^ PLAYER_MASK;
  
  g_board[horz_play][row]   ^= (3<<col);
  g_board[vert_play][col]   ^= (1<<row);
  g_board[vert_play][col+1] ^= (1<<row);
  
  // update safe moves
  if(row - 1 != 0)
    _update_safe(horz_play, row - 1);
  _update_safe(horz_play, row);
  if(row != g_board_size[horz_play])
    _update_safe(horz_play, row + 1);
  
  if(col - 1 != 0)
    _update_safe(vert_play, col - 1);
  if(col + 1 != g_board_size[vert_play])
    _update_safe(vert_play, col + 2);
  
  // update real moves
  _update_real(horz_play, row);

  _update_real(vert_play, col);
  _update_real(vert_play, col + 1);
}


//#define DEBUG_SCORE_MOVE

static inline s32bit
score_move(Move move, s32bit player)
{
  s32bit row, col, horz_play, vert_play;
  s32bit score;
    
  row = move.array_index, col = move.mask_index;
  horz_play = player & PLAYER_MASK;
  vert_play = player ^ PLAYER_MASK;
  
  g_board[horz_play][row]   ^= (3<<col);
  g_board[vert_play][col]   ^= (1<<row);
  g_board[vert_play][col+1] ^= (1<<row);
  
  // update real moves
  score = count_real(horz_play, row) - g_info[horz_play][row].real;

  score -= count_real(vert_play, col) - g_info[vert_play][col].real;
  score -= count_real(vert_play, col + 1) - g_info[vert_play][col+1].real;

  // update safe moves
  if(row - 1 != 0)
    score +=  count_safe(horz_play, row - 1) - g_info[horz_play][row-1].safe;
  score += count_safe(horz_play, row) - g_info[horz_play][row].safe;
  if(row != g_board_size[horz_play])
    score += count_safe(horz_play, row+1) - g_info[horz_play][row+1].safe;
  
  if(col - 1 != 0)
    score -= count_safe(vert_play, col - 1) - g_info[vert_play][col-1].safe;
  if(col + 1 != g_board_size[vert_play])
    score -= count_safe(vert_play, col + 2) - g_info[vert_play][col+2].safe;
  
  g_board[horz_play][row]   ^= (3<<col);
  g_board[vert_play][col]   ^= (1<<row);
  g_board[vert_play][col+1] ^= (1<<row);
  
  score *= 128;
  score += g_first_move[player][row][col];

  return score;
}

extern void
score_and_get_first(Move movelist[MAXMOVES], s32bit num_moves,
                    s32bit player, Move first)
{
  s32bit i, max = -50000, max_index = -1;

  //========================================================
  // Give the move from the hashtable a large sorting value.
  //========================================================
  /*
  {
    int z = 0;
    for (z = 0; z < num_moves; z++)
      printf("> %d %d\n", movelist[z].array_index, movelist[z].mask_index);
  }
  */
  if(first.array_index != -1){
    for(i = 0; i < num_moves; i++){
      if(first.array_index == movelist[i].array_index
         && first.mask_index == movelist[i].mask_index){
        movelist[i].info = 450000;
        max_index = i;
      } else {
        movelist[i].info = score_move(movelist[i], player);
      }
    }
  }

  else {
    for(i = 0; i < num_moves; i++){
      movelist[i].info = score_move(movelist[i], player);
      if(movelist[i].info > max){
        max = movelist[i].info;
        max_index = i;
      }
    }
  }
  
  if(max_index == -1) fatal_error(1, "No maximum\n");
  
  // put biggest at front
  if(num_moves > 1) {
    Move tmp_move = movelist[max_index];
    for(i = max_index; i > 0; i--)
      movelist[i] = movelist[i - 1];
    movelist[0] = tmp_move;
  }
}