LearningEnemy.cpp

   1 #include "LearningEnemy.h"
   2 #include "Board.h"
   3
   4 #define SQU(x) ((x) * (x))
   5 #define MOD(x) (x) > 0 ? (x) : -(x)
   6 #define MAX_ALPHABETA 1000000
   7
   8
   9 int LearningEnemy::heuristica(Board board, bool player)
  10 {
  11     return (int)(d[0]*distCentro(board,player) + d[1]*distEntreSiMan(board,player) +
  12            d[2]*distEntreSiEuc(board,player) + d[3]*cubicPolynome(board,player) -
  13            d[4]*(d[0]*distCentro(board,!player) + d[1]*distEntreSiMan(board,!player) +
  14            d[2]*distEntreSiEuc(board,!player) + d[3]*cubicPolynome(board,!player)));
  15 }
  16
  17 // heurística: minimizar a soma das distâncias das nossas peças para o centro do tabuleiro
  18 double LearningEnemy::distCentro(Board board, bool player)
  19 {
  20         double res = 0;
  21         rep(i, 8)
  22                 rep(j, 8)
  23                         if(board.get(player, i, j))
  24                                 res += SQU(i - 3.5) + SQU(j - 3.5); // distância para o centro
  25         return res;
  26 }
  27
  28 // heurística: minimizar a soma das distâncias de manhattan entre nossas peças
  29 double LearningEnemy::distEntreSiMan(Board board, bool player)
  30 {
  31         double res = 0;
  32         rep(i, 8)
  33                 rep(j, 8)
  34                         if(board.get(player, i, j))
  35                 rep(k, 8)
  36                     rep(l, 8)
  37                         if(board.get(player, k, l))
  38                                             res += MOD(i - k) + MOD(j - l); // distancia entre pontos
  39         return res;
  40 }
  41
  42 // heurística: minimizar a soma das distâncias de euclides entre nossas peças
  43 double LearningEnemy::distEntreSiEuc(Board board, bool player)
  44 {
  45         double res = 0;
  46         rep(i, 8)
  47                 rep(j, 8)
  48                         if(board.get(player, i, j))
  49                 rep(k, 8)
  50                     rep(l, 8)
  51                         if(board.get(player, k, l))
  52                                             res += SQU(i - k) + SQU(j - l); // distancia entre pontos
  53         return res;
  54 }
  55
  56 // heurística: minimizar polinomio cubico sobre as posicoes das nossas pecas
  57 double LearningEnemy::cubicPolynome(Board board, bool player)
  58 {
  59     /* Precisa ser otimizado */
  60     double res = 0;
  61         rep(i, 8)
  62                 rep(j, 8)
  63                         if(board.get(player, i, j))
  64                             res += d[5+INDEX(i,j)]*i*i*i + d[5+63+INDEX(i,j)]*i*i +
  65                 d[5+2*63+INDEX(i,j)]*i + d[5+3*63+INDEX(i,j)]*j*j*j +
  66                 d[5+4*63+INDEX(i,j)]*j*j + d[5+5*63+INDEX(i,j)]*j;
  67     return 0;
  68 }
  69
  70 LearningEnemy * LearningEnemy::createSon()
  71 {
  72     double bump;
  73     double diff;
  74     LearningEnemy * novo = new LearningEnemy(_player,_minimax_depth);
  75     /* Para cada variavel, criar uma variavel semelhante a do pai com um bump aleatorio
  76     que eh inversamente proporcional ao numero de jogos e com uma variacao aleatoria que
  77     depende das ultimas variacoes e do numero de vitorias e derrotas da ultima rodada e
  78     do numero de vitorias e derrotas geral. */
  79     rep(i, VAR_DOU) {
  80         bump = /* valor entre -1 e 1, dividido pelo número de jogos totais */ 0;
  81         diff = 3*d_int[0][i] + 2*d_int[1][i] + d_int[2][i];
  82         diff = /* valor entre -diff e diff, mais positivo quanto mais vitorias na ultima rodada */
  83         novo->d[i] = d[i] + bump + diff;
  84         /* atribuir nova derivada */
  85     }
  86     return novo;
  87 }
  88
  89 LearningEnemy * LearningEnemy::createSon(LearningEnemy enemy)
  90 {
  91     double bump;
  92     double diff;
  93     LearningEnemy * novo = new LearningEnemy(_player,_minimax_depth);
  94     /* Mesmo que o outro, porém escolhendo como base a variável de um dos pais, proporcionalmente
  95     ao percentual de vitorias de cada um */
  96     return novo;
  97 }