/*
*  BOOK.C
*  Tom Kerrigan's Simple Chess Program (TSCP)
*
*  Copyright 1997 Tom Kerrigan
*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "defs.h"
#include "data.h"
#include "protos.h"

/* the opening book file, declared here so we don't have to include stdio.h in
   a header file */
FILE *book_file;

/* open_book() opens the opening book file and initializes the random number
   generator so we play random book moves. */

void open_book()
{
  srand(time(NULL));
  book_file = fopen("book.txt", "r");
  if (!book_file)
    printf("Opening book missing.\n");
}

/* close_book() closes the book file. This is called when the program exits. */

void close_book()
{
  if (book_file)
    fclose(book_file);
  book_file = NULL;
}

/* book_move() returns a book move (in integer format) or -1 if there is no
   book move. */

int book_move()
{
  char line[256];
  char book_line[256];
  int i, j, m;
  int move[50];  /* the possible book moves */
  int count[50];  /* the number of occurrences of each move */
  int moves = 0;
  int total_count = 0;

  if (!book_file || hply > 25)
    return -1;

  /* line is a string with the current line, e.g., "e2e4 e7e5 g1f3 " */
  line[0] = '\0';
  j = 0;
  for (i = 0; i < hply; ++i)
    j += sprintf(line + j, "%s ", move_str(hist_dat.m.b));

  /* compare line to each line in the opening book */
  fseek(book_file, 0, SEEK_SET);
  while (fgets(book_line, 256, book_file)) {
    if (book_match(line, book_line)) {

      /* parse the book move that continues the line */
      m = parse_move(&book_line[strlen(line)]);
      if (m == -1)
        continue;
      m = gen_dat[m].m.u;

      /* add the book move to the move list, or update the move's
         count */
      for (j = 0; j < moves; ++j)
        if (move[j] == m) {
          ++count[j];
          break;
        }
      if (j == moves) {
        move[moves] = m;
        count[moves] = 1;
        ++moves;
      }
      ++total_count;
    }
  }

  /* no book moves? */
  if (moves == 0)
    return -1;

  /* Think of total_count as the set of matching book lines.
     Randomly pick one of those lines (j) and figure out which
     move j "corresponds" to. */
  j = rand() % total_count;
  for (i = 0; i < moves; ++i) {
    j -= count;
    if (j < 0)
      return move;
  }
  return -1;  /* shouldn't get here */
}

/* book_match() returns TRUE if the first part of s2 matches s1. */

BOOL book_match(char *s1, char *s2)
{
  int i;

  for (i = 0; i < (signed int)strlen(s1); ++i)
    if (s2 == '\0' || s2 != s1)
      return FALSE;
  return TRUE;
}

Eröffnungsbücher zur Entwicklung von Stockfish:

https://github.com/official-stockfish/books

Eröffnungs-Bücher für Engines verfolgen verschiedene Zwecke:

1. Ganz ohne Buch, um auch die Fähigkeiten der Engines in der Eröffnungsphase, nicht außen vorzulassen.
BTW Lc0 spielt ohne Buch auch sehr gut. Das Netz wird von dem Beginn an ohne Buchhilfe trainiert.

2. Mit einem kurzen Buch, z.B. bis zum 3. bis 5. Doppelzug. Damit wird die Breite der Eröffnungsvarianten beeinflusst.

3. Kurze oder längere Bücher, die ausgeglichen oder nicht (ganz) ausgeglichen sind.
Damit wird geprüft, ob eine Engine mit schwierigen Eröffnungspositionen gut oder weniger gut zurecht kommt.

4. Anti-Remis-Bücher, wie z.B. HERT, um die Remishäufigkeit einzugrenzen.

5. Vorgenerierte Bücher für Stockfish und/oder Lc0, wie z.B. Cerebellum.
Sie decken das optimierte Zugverhalten einer Engine bis ins späte Mittelspiel ab.

6. Spezielle Bücher für eine bestimmte Engine mit einem bestimmten Netz/NNUE. Dazu wird eine große Menge an Testpartien benötigt.

7. Positionelle Bücher, die halb- und/oder geschlossene Varianten bevorzugen.

8. GUI-Bücher, die mit der GUI erworben werden, z.B. Fritz, Sdredder oder Hiarcs.

9. Umfangreiche Eröffnungsbibliotheken oder -Datenbanken für das Training oder zum Recherchieren.

10. FRC-Eröffnungen, deren Partien nicht auf das theoretische Eröffnungswissen basieren.

Immer geht es um die Frage, will man Testen, eine Rangliste erstellen oder mit der Engine an einem Turnier teilnehmen.

Hier ein umfangreiches englischsprachiges Buch zur Eröffnungstheorie: “Fundamental Chess Openings”:

https://ia601001.us.archive.org/21/items/fundamentalchessopenings/FCO%20Fundamental%20Chess%20Openings.pdf

Hier eine Beschreibung zur Erstellung eigener Eröffnungsbücher unter der Fritz-GUI:

http://help.chessbase.com/Fritz/15/Deu/index.html?own_book.htm

Hier eine Beschreibung für Scid als Eröffnungstraining:

https://sourceforge.net/p/scid/wiki/TheOpeningTrainer/

Hier einige Threads auf Chess.com zu Scid zur Erstellung eines Eröffnungsrepertoire:

https://www.chess.com/clubs/forum/view/using-scid-to-develop-an-opening-repertoire

Hier drei YouTube Videos zu Scid zum Eröffnungstraining und zur Eröffnungserstellung:

https://www.google.de/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwjMmaC3y_f2AhURi_0HHdDfAu8QwqsBegQIAhAB&url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D7_ZPltcSyjo&usg=AOvVaw3znPFH6mwZprqqgsostqhu

https://www.google.de/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwjMmaC3y_f2AhURi_0HHdDfAu8QwqsBegQIGBAB&url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DNNfw27knJrI&usg=AOvVaw14TveIWGe2Pr6_wV2d8guk

https://www.youtube.com/watch?v=7_ZPltcSyjo&index=6&list=PLC53505mbsT6zSPQcUAZpCa2_JOV2XBNg

Für die Erstellung von Eröffnungsbücher sind Schachdatenbanken unerlässlich.

Hier der Wikipedia Beitrag zu „Schachdatenbanken“:

https://de.wikipedia.org/wiki/Schachdatenbank?wprov=sfti1

Die Webseite von Stefan Pohl bietet eine vielfältige Auswahl von Eröffnungen, Tools und Tests zum Download an:

https://www.sp-cc.de/downloads--links.htm

Die Webseite von Frank Quisinsky weist auch eine große Auswahl von Eröffnungsbücher auf:

https://www.amateurschach.de/

Hier die Dokumentation zum FEOBOS Projekt:
https://www.amateurschach.de/download/book/documentation-feobos.pdf

Auch Thomas Zipproth verfolgt mit Cerebellum und Brainfish zwei interessante Projekte:

https://zipproth.de/Brainfish/

Beim Einsatz von SpitzenCPUHardware oder dem Einsatz von neuronalen Netzen (z.B. LC0) ist zu bedenken, dass die Engine durch Berechnung und/oder Netzzugriff die gleichen oder in manchen Positionen bessere Züge finden als ein Eröffnungsbuch.

Hervorzuheben ist besonders die Eröffnungs-Enzyklopädie von Chessbase:

https://en.chessbase.com/post/new-opening-encyclopaedia-2021

Nicht zuletzt ist 365chess.com mit seinem „Opening Explorer“ zu erwähnen:

https://www.365chess.com/eco.php

„Chess Trap Scorer“ ein schönes Tool zur Eröffnungsanalyse.

Hier die Links:

https://medium.com/applied-data-science/how-to-calculate-the-trappiest-openings-in-chess-2bc24a6345f7

https://github.com/davidADSP/chess-trap-scorer

Hier eine sehr interessante Veröffentlichung über „Quantifying the complexity and similarity of chess openings using online chess community data“.

https://www.nature.com/articles/s41598-023-31658-w

Hier Tools für die Generierung von FRC 960 Stellungen:

https://wlabe.com/chess960

https://play.google.com/store/apps/details?id=com.chambol.chess960generator&hl=en_US

Webseite von UHO Eröffnungen:

https://web.archive.org/web/20201205120539/https://www.sp-cc.de/unbalanced-human-openings.htm

Schach-Eröffnungsbücher werden in der Regel von Schachexperten, Meistern oder Großmeistern erstellt. Es gibt verschiedene Ansätze und Methoden zur Erstellung solcher Bücher, aber im Allgemeinen folgen sie einem ähnlichen Prozess:

1. Datensammlung: Die Autoren sammeln eine große Menge an Schachpartien, entweder aus Schachdatenbanken oder von Turnieren und Meisterschaften. Diese Partien werden als Ausgangspunkt für die Analyse und Erstellung des Eröffnungsbuchs verwendet.

2. Analyse: Die gesammelten Partien werden gründlich analysiert, um die Hauptvarianten und Zugfolgen in den verschiedenen Eröffnungen zu identifizieren. Die Autoren bewerten die Züge anhand ihrer Spielstärke, Popularität und ihrer theoretischen Bedeutung.

3. Baumstruktur: Die Baumstruktur eines Eröffnungsbuchs stellt die verschiedenen Zugmöglichkeiten und Varianten dar. Normalerweise wird ein Baumdiagramm verwendet, wobei jeder Zug eine Verzweigung im Baum darstellt. Der Hauptzweig repräsentiert die Hauptvariante, während die Nebenzweige alternative Zugmöglichkeiten darstellen.

4. Varianten: Varianten werden in das Eröffnungsbuch eingepflegt, um verschiedene Alternativen und Nebenvarianten zu berücksichtigen. Dies geschieht durch das Hinzufügen von Unterzweigen im Baum, die von den Hauptzweigen abzweigen. Die Autoren entscheiden basierend auf ihrer Analyse und Bewertung, welche Varianten in das Buch aufgenommen werden.

5. Lernen durch Partien: Um das Eröffnungsbuch zu verbessern, werden neue Schachpartien analysiert und in das Buch integriert. Wenn eine neue Partie gespielt wird, vergleichen die Autoren den Verlauf der Partie mit den vorhandenen Varianten im Buch. Wenn die Partie von der bekannten Theorie abweicht oder eine neue vielversprechende Idee enthält, kann sie als Ergänzung in das Buch aufgenommen werden.

Es ist wichtig anzumerken, dass die Erstellung von Eröffnungsbüchern ein fortlaufender Prozess ist. Mit der Entwicklung der Schachtheorie und dem Auftreten neuer Ideen und Spielweisen werden Bücher regelmäßig aktualisiert, um auf dem neuesten Stand zu bleiben und die besten Züge und Varianten zu repräsentieren.

Bestimmte Schritte bei der Erstellung von Schach-Eröffnungsbüchern können automatisiert werden. Es stehen verschiedene Tools zur Verfügung, die Schachdatenbanken, Engines und andere Technologien nutzen, um den Prozess effizienter zu gestalten. Hier sind einige Beispiele für solche Tools:

1. Schachdatenbanken: Es gibt mehrere Schachdatenbanken wie ChessBase, SCID (Shane's Chess Information Database) oder lichess.org, die eine umfangreiche Sammlung von Schachpartien bieten. Diese Datenbanken ermöglichen die Recherche und den Zugriff auf eine große Menge an Partien, die als Grundlage für die Analyse und Erstellung des Eröffnungsbuchs dienen können.

2. Schach-Engines: Schach-Engines wie Stockfish, Komodo oder Houdini sind leistungsstarke Schachprogramme, die Zugbewertungen und Variantenanalyse bieten. Diese Engines können verwendet werden, um die Partien zu analysieren, um Zugstärken zu bewerten und neue Ideen zu entdecken. Sie können auch beim Erstellen und Verwalten der Baumstruktur des Eröffnungsbuchs helfen.

3. Eröffnungsbuch-Generatoren: Es gibt spezialisierte Software wie Fritz Opening Tree oder Chess Position Trainer, die bei der Erstellung und Verwaltung von Eröffnungsbüchern unterstützen. Diese Tools ermöglichen das Organisieren der Zugfolgen, Hinzufügen von Varianten, Anzeigen von Statistiken und helfen beim Generieren von Baumstrukturen.

4. Online-Plattformen: Online-Schachplattformen wie lichess.org oder chess.com bieten nicht nur Zugriff auf große Schachdatenbanken, sondern auch Funktionen zur Analyse von Partien. Spieler können ihre eigenen Partien hochladen und Schach-Engines verwenden, um Varianten und Zugbewertungen zu erhalten. Diese Informationen können verwendet werden, um Eröffnungsbücher zu verbessern und neue Varianten einzupflegen.

Es ist wichtig zu beachten, dass trotz der Verfügbarkeit solcher Tools und Technologien immer noch menschliches Fachwissen und Urteilsvermögen erforderlich sind, um ein qualitativ hochwertiges Eröffnungsbuch zu erstellen. Automatisierte Tools dienen als Unterstützung und erleichtern den Prozess, aber sie können nicht alle Aspekte der Erstellung eines Eröffnungsbuchs abdecken.

Die genaue Implementierung des Buchlern-Algorithmus in einer Software wie ChessBase wäre proprietär und daher nicht öffentlich bekannt. Allerdings gibt es allgemeine Ansätze, wie ein Buchlern-Algorithmus in Schachsoftware arbeiten könnte. Hier ist eine detaillierte Erklärung der Punkte 1 bis 4:

### 1. Partien sammeln

- **Datenquellen**: Der Algorithmus könnte Partien aus verschiedenen Quellen sammeln, einschließlich Online-Spiele, importierte Partien oder Engine-gegen-Engine-Spiele.

- **Filterung**: Bevor Partien für das Buchlernen verwendet werden, könnten sie gefiltert werden, um nur Spiele von bestimmter Qualität einzubeziehen. Zum Beispiel könnte die Software nur Partien von Spielern über einer bestimmten Elo-Stärke oder Partien bis zu einer bestimmten Zugtiefe berücksichtigen.

### 2. Bewertung der Züge

- **Endergebnis-Bewertung**: Einfache Algorithmen könnten das Endergebnis der Partie verwenden, um den Wert eines Zugs zu bestimmen (Gewinn = positiv, Remis = neutral, Verlust = negativ).

- **Zug-Positionswertung**: Fortgeschrittene Algorithmen könnten den Wert einer Position nach einem Zug mit Hilfe einer Schachengine bewerten. Beispielsweise könnte eine Engine die Position bewerten und diese Bewertung dem jeweiligen Zug zuweisen.

- **Statistische Analyse**: Der Algorithmus könnte auch die Häufigkeit und den Erfolg eines Zuges in allen gesammelten Partien analysieren. Ein Zug, der häufig gespielt wird und oft zu einem Gewinn führt, würde höher bewertet.

### 3. Aktualisierung des Eröffnungsbuches

- **Gewichtsanpassung**: Jeder Zug in einem Eröffnungsbuch hat oft ein Gewicht, das seine Wahrscheinlichkeit bestimmt, in einer gegebenen Position gespielt zu werden. Der Algorithmus könnte dieses Gewicht basierend auf der Bewertung des Zuges anpassen.

- **Hinzufügen/Entfernen von Zügen**: Basierend auf der Zugbewertung könnte der Algorithmus entscheiden, bestimmte Züge zum Eröffnungsbuch hinzuzufügen oder daraus zu entfernen. Zum Beispiel könnte ein Zug, der in mehreren hohen Qualitäts-Partien zu einem Verlust führte, entfernt werden.

- **Rückverfolgung**: Der Algorithmus könnte auch die Züge rückverfolgen, die zu einer bestimmten Position geführt haben, und ihre Gewichtung entsprechend anpassen. Das bedeutet, dass nicht nur der unmittelbare Zug, sondern auch die vorherigen Züge, die zur aktuellen Position geführt haben, aktualisiert werden könnten.

### 4. Manuelle Anpassung und Überprüfung: Abhängig von der Software können Sie wahrscheinlich auch manuelle Anpassungen vornehmen, wenn Sie denken, dass das automatische Lernen zu unerwünschten Ergebnissen führt.

Dies sind allgemeine Ansätze und die tatsächliche Implementierung in ChessBase könnte variieren. Für die genauesten Informationen wäre es am besten, die offizielle Dokumentation oder Support-Ressourcen zu konsultieren, hier: https://help.chessbase.com/Fritz/18/Deu/index.html?000001.htm

Hier ein Link auf ein Github Projekt zum „Chess Book Learning“ in Python Quellcode:

https://github.com/Aloril/chess_book_learning

Als Analyse Engine wurde Stockfish verwandt.
Andere Engines sind möglich.

Hier die Erklärungen zum Erstellung eines Eröffnungsbuchs unter Fritz/Chessbase:

http://help.chessbase.com/Fritz/15/Deu/index.html?own_book.htm