   /* Pepito v1.59  -- file: datos.c --
   Copyright (c) 2000-1 Carlos del Cacho

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.

   Contact the author: guggenjaimito@yahoo.com
*/

#ifndef UNIQUE_SOURCE_FILE
#  include "datos.h"
#endif

#include "zobrist.h"

// declaración de variables globales:

char entrada[4096];
FILE *log_file = NULL;
FILE *gamelog_file = NULL;
FILE *batch_file = NULL;

char opp_name[256] = { "" };
char my_name[256] = { "" };
char site_name[256] = {""};

entero64 MASK[65];       // enmascara cada bit de un entero de 8 bytes. MASK[64] es cero.
entero64 FILA[8];        // enmascara cada fila del tablero (está al revés que en la notación
                         // ajedrecística. la fila octava es FILA[0] y la primera es FILA[7]

entero64 COLUMNA[8];     // igual q antes pero con las columnas. COLUMNA[0] is la columna A.

entero64 IZQUIERDA[8], DERECHA[8];

entero64 PASADO[2][64];  // máscaras usadas en la detección de peones pasados

entero64 AISLADO[8];     //   "     "   "   "   "     "      "   "    aislados
entero64 PAS_ALEJA_D[8];
entero64 PAS_ALEJA_I[8];

// tablas usadas para calcular rápidamente la información de ataques
// se inicializan al comienzo del programa. ver initataq.c

entero64 ATAQUES_TORRE_FIL[64][256];
entero64 ATAQUES_TORRE_COL[64][256];

entero64 ATAQUES_ALFIL_45[64][256];
entero64 ATAQUES_ALFIL_315[64][256];

entero64 ATAQUES_CABALLO[64];
entero64 ATAQUES_REY[64];
entero64 ATAQUES_PEON_B[64];
entero64 ATAQUES_PEON_N[64];

entero64 VACIO_ALFIL[64];                // ataques del alfil en un tablero vacío
entero64 VACIO_TORRE[64];                // ataques de la torre en un...

entero64 ENTRE[64][64];                  // casillas situadas entre otras 2 ídem

// todas las direcciones q se muestran a continuación asumen un tablero desde
// el punto de vista de las blancas. p ej. Norte => dirección fila 1  -> fila 8

entero64 RAYO_N[64];
entero64 RAYO_S[64];
entero64 RAYO_O[64];
entero64 RAYO_E[64];
entero64 RAYO_NE[64];
entero64 RAYO_NO[64];
entero64 RAYO_SE[64];
entero64 RAYO_SO[64];
entero64 RAYO_N_AMPLIO[8];
entero64 RAYO_S_AMPLIO[8];
entero64 CASILLA_PEON_B[64];
entero64 CASILLA_PEON_N[64];


char DIRECCION[64][64];   // devuelve un código q indica si dos casillas están relacionadas
                          // por una determinada dirección: norte, sur, este... o ninguna.

char TAXI_CAB[64][64];    // distancia en filas + distancia en columnas
char DISTANCIA[64][64];   // min (distancia en filas, distancia en columnas)

unsigned long HASH_SIZE;           // número total de entradas de la tabla de transposición
unsigned long PAWN_HASH_SIZE;
unsigned long CACHE_SIZE;

int Nalimov;              // booleano. Estamos usando las tablas de E.Nalimov?
xboard_type xb_info;      // estructura con información relativa a la comunicación con Xboard

jugada_ext pv[MAX_PROF+1][MAX_PROF+1];   // array q guarda la variante principal en cada nivel
                                         // de la búsqueda junto con la pieza q mueve en cada
                                         // caso

jugada_ext pvdebug[MAX_PROF+1];
entero64 debughash[MAX_PROF+1];

int pv_long[MAX_PROF+1];                 // longitud de la variable principal en cada nivel

partida tab;                             // registro con info sobre el tablero y la búsqueda

int MAXPROF;

// tablas usadas para calcular rápidamente la posición del bit más/menos significativo
// en un número de 8 bytes.

char MSB[65536];  // guarda la posición del MSB del índice (2 bytes)
char LSB[65536];  // guarda la posición del LSB del índice (2 bytes)

// array con el valor de las piezas

int VALOR[13] = { 0, PEON_VAL, CABALLO_VAL, ALFIL_VAL, TORRE_VAL, DAMA_VAL, REY_VAL,
                     PEON_VAL, CABALLO_VAL, ALFIL_VAL, TORRE_VAL, DAMA_VAL, REY_VAL };

int MaxPos[2];  // máximo valor posicional

int CONTROL_INC;
int LastProf;


// variables requeridas por el código de Eugene


int TB_CRC_CHECK;
int cbEGTBCompBytes;
char EGTB_PATH[255];
unsigned long EGTB_CSIZE;
// diversas cosas del archivo de configuración

int RESIGN_MARGIN;  // valor en "centipeones" antes del cual Pepito arroja la toalla
int BOOK_RANDOM;    // booleano. elección aleaotoria en el libro ?
int USE_BOOK;       // booleano. estamos usando el libro de aperturas ?
int BOOK_WIDTH;
int BOOK_LEARN;
int DISPLAY_MARGIN;
int UCI_MODE;
int COORD_MODE;
int GAME_STYLE;
int ICS_MODE=0;

char BOOK_FILE[256] = { "libro" };

const int *TABLA_PEON; // puntero a tabla con valores posicionales del peón. hay q inicializarlo
                       // para cada búsqueda según la fase de la partida.

entero32 tiempo;
char *prompt;


// tablas necesarias en la generación de jugadas:

int ROTADO_90[64]=
  {
     0,  8, 16, 24, 32, 40, 48, 56,
     1,  9, 17, 25, 33, 41, 49, 57,
     2, 10, 18, 26, 34, 42, 50, 58,
     3, 11, 19, 27, 35, 43, 51, 59,
     4, 12, 20, 28, 36, 44, 52, 60,
     5, 13, 21, 29, 37, 45, 53, 61,
     6, 14, 22, 30, 38, 46, 54, 62,
     7, 15, 23, 31, 39, 47, 55, 63
  };


int ROTADO_45[64]=
  {
     0,  1,  3,  6, 10, 15, 21, 28,
     2,  4,  7, 11, 16, 22, 29, 36,
     5,  8, 12, 17, 23, 30, 37, 43,
     9, 13, 18, 24, 31, 38, 44, 49,
    14, 19, 25, 32, 39, 45, 50, 54,
    20, 26, 33, 40, 46, 51, 55, 58,
    27, 34, 41, 47, 52, 56, 59, 61,
    35, 42, 48, 53, 57, 60, 62, 63
  };

int SHIFT_45[64]=
  {
     0,  1,  3,  6, 10, 15, 21, 28,
     1,  3,  6, 10, 15, 21, 28, 36,
     3,  6, 10, 15, 21, 28, 36, 43,
     6, 10, 15, 21, 28, 36, 43, 49,
    10, 15, 21, 28, 36, 43, 49, 54,
    15, 21, 28, 36, 43, 49, 54, 58,
    21, 28, 36, 43, 49, 54, 58, 61,
    28, 36, 43, 49, 54, 58, 61, 63
  };

int ROTADO_315[64]=
  {
     28, 21, 15, 10,  6,  3,  1,  0,
     36, 29, 22, 16, 11,  7,  4,  2,
     43, 37, 30, 23, 17, 12,  8,  5,
     49, 44, 38, 31, 24, 18, 13,  9,
     54, 50, 45, 39, 32, 25, 19, 14,
     58, 55, 51, 46, 40, 33, 26, 20,
     61, 59, 56, 52, 47, 41, 34, 27,
     63, 62, 60, 57, 53, 48, 42, 35
  };

int SHIFT_315[64]=
  {
     28, 21, 15, 10,  6,  3,  1,  0,
     36, 28, 21, 15, 10,  6,  3,  1,
     43, 36, 28, 21, 15, 10,  6,  3,
     49, 43, 36, 28, 21, 15, 10,  6,
     54, 49, 43, 36, 28, 21, 15, 10,
     58, 54, 49, 43, 36, 28, 21, 15,
     61, 58, 54, 49, 43, 36, 28, 21,
     63, 61, 58, 54, 49, 43, 36, 28
  };

