I programmi per giocare a scacchi hanno fatto progressi incredibili nell'ultimo decennio, e questo è dovuto solo in parte all'aumento delle prestazioni fornite dall'hardware. Sono state sviluppate anche nuove euristiche e raffinati algoritmi vecchi, grazie alla collaborazione stretta tra programmatori e Maestri. Il fatto è che i più forti giocatori al mondo oggigiorno sono macchine, e questo vale non solo per l'hardware specializzato (si ricordi la sfida Kasparov-Deep Blue che segnò la prima sconfitta di un campione mondiale da parte di un computer, New York, 1997, http://scacchi.qnet.it/manuale/comp02.htm, http://www.research.ibm.com/deepblue/home/html/b.html); attualmente i programmi per PC raggiungono il livello di un Maestro Internazionale (2400 Elo), forza che si eleva notevolmente se viene usato hardware dedicato o macchine a 64 bit.

Una conseguenza dell'aumento di forza dei programmi è stato un cambiamento necessario nelle condizioni di torneo. Una volta le partite venivano sospese e il giocatore che effettuata l'ultima mossa prima della sospensione metteva in busta la "mossa segreta", mentre l'altro passava tutta la notte ad analizzare la posizione, a cercare di scoprire la mossa segreta dell'avversario e la migliore continuazione. Oggigiorno, invece, le partite di torneo devono finire obbligatoriamente in giornata per evitare l'ausilio del computer.

Questo articolo propone una panoramica dei diversi tipi di software libero a disposizione in ambito scacchistico, di cui i motori di scacchi sono solo una parte (la più nota per il gran pubblico). Cominceremo con il formato libero usato per scambiare partite, per passare successivamente in rassegna le più importanti funzionalità di Crafty, forse il più forte programma libero in circolazione. Faremo anche una revisione di Scid (un database) e di Xboard, una sofisticata interfaccia grafica, per finire con gli scacchi giocati via Internet e con le possibilità documentative che il software libero consente.

Formato PGN (Portable Game Notation)

I programmi vengono realizzati per lavorare con dati: nel nostro caso con partite di scacchi. Software libero senza una versione libera del formato con il quale vengono immagazzinate e trasmesse le partite impedirebbe un effettivo uso dei programmi. La definizione del formato PGN obbedisce a questo scopo. I criteri utilizzati nella specificazione del formato sono i seguenti (http://www.tim-mann.org/Standard):

• dettagli pubblicamente disponibili e liberi da qualsiasi complessità innecessaria;
• formato non proprietario;
• possibilità di lavorare sulla più ampia gamma di piattaforme;
• facilità di espansione futura;
• internazionale;
• capacità di poter accogliere le informazioni normalmente usate nei software scacchistici e nelle riviste specializzate.

Un file PGN è un file ASCII che contiene una o più partite con la seguente struttura:

[Event "F/S Return Match"] 
[Site "Belgrade, Serbia JUG"] 
[Date "1992.11.04"] 
[Round "29"] 
[White "Fischer, Robert J."]
[Black "Spassky, Boris V."] 
[Result "1/2-1/2"] 

1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O Be7 6. Re1 b5 7. Bb3 d6 8. c3
O-O 9. h3 Nb8 10. d4 Nbd7 11. c4 c6 12. cxb5 axb5 13. Nc3 Bb7 14. Bg5 b4 15.
Nb1 h6 16. Bh4 c5 17. dxe5 Nxe4 18. Bxe7 Qxe7 19. exd6 Qf6 20. Nbd2 Nxd6 21.
Nc4 Nxc4 22. Bxc4 Nb6 23. Ne5 Rae8 24. Bxf7+ Rxf7 25. Nxf7 Rxe1+ 26. Qxe1 Kxf7
27. Qe3 Qg5 28. Qxg5 hxg5 29. b3 Ke6 30. a3 Kd6 31. axb4 cxb4 32. Ra5 Nd5 33.
f3 Bc8 34. Kf2 Bf5 35. Ra7 g6 36. Ra6+ Kc5 37. Ke1 Nf4 38. g3 Nxh3 39. Kd2 Kb5
40. Rd6 Kc5 41. Ra6 Nf2 42. g4 Bd3 43. Re6 1/2-1/2

Si deve pensare al formato PGN come a un sistema per scambiare dati e per far si che questi possano essere letti facilmente da un umano (una partita in formato PGN ha per le mosse una struttura quasi identica alla normale notazione algebrica usata per trascrivere le partite, per cui è possibile facilmente riprodurre e studiare una partita sulla scacchiera a partire da essa), e non per trattare i dati. Essendo un formato ASCII, non è pensabile poter immagazzinare e fare ricerche su file che contengono centinaia di migliaia di partite; per fare questo ci serve un database. Lo scopo di quest'ultimo è poter esportare/importare grandi quantità di partite tra le basi di dati appositamente progettate per questo scopo. Possiamo dire che il formato PGN è l'equivalente per gli scacchi di quello che il DXF è per i programmi CAD o la notazione SMILES in ambito chemioinformatico/bioinformatico.

La partita Fischer-Spassky usata come esempio contiene la struttura tipica di una partita in formato PGN. Essa è composta da una serie di tag racchiusi tra parentesi quadre seguita da una linea vuota e dalla sezione delle mosse; ogni linea di tale sezione deve contenere al massimo 80 colonne. Ci sono sette tag obbligatori (noti come i Seven Tag Roster):

• Event: il nome del torneo o del match.
• Site: in genere la città dove si è giocata la partita.
• Date: la data di inizio della partita.
• Round: il numero del turno della partita nel torneo.
• White: il giocatore che conduce il Bianco.
• Black: il giocatore che conduce il Nero.
• Result: il risultato della partita.

Il risultato viene ripetuto alla fine della sezione delle mosse. Ci sono altri tag aggiuntivi per specificare informazioni come Elo dei giocatori, controllo di tempo, variazioni, ecc., ma sono opzionali. Tra questi forse un tag importante è ECO, che specifica il codice ECO (Encyclopaedia of Chess Openings) dell'apertura, e FEN, che specifica la notazione Forsyth-Edwards (Forsyth-Edwards Notation) se la posizione di partenza è diversa dalla posizione iniziale (usato per studi o problemi).

Un problema del formato PGN, derivato dalla sua natura ASCII è il fatto che in seguito a errori di battitura o abbreviazioni ci possono essere partite con diciture diverse per giocatori, città, date, ecc. Le basi di dati moderne hanno la possibilità, una volta importata la raccolta PGN, di correggere questi difetti in diversi modi.

Crafty

Crafty è un motore di scacchi, cioè un programma per giocare partite, scritto da Robert Hyatt. È un discendente di Cray Blitz, sempre opera di Hyatt, un programma molto famoso che ha segnato un'epoca e nel quale sono state introdotte alcune importanti novità teoriche, come ad esempio le bitboard. È possibile trovare diverse versioni di Crafty, insieme ad alcune partite, informazioni e basi di finali (endgame tablebases) all'indirizzo ftp://ftp.cis.uab.edu/pub/hyatt.

Crafty è probabilmente il più forte programma libero disponibile attualmente. All'undicesima edizione del torneo tra computer organizzato da Leo Dijksman (http://wbec-ridderkerk.nl), Crafty 19.20 su processore Opteron a 64 bit si è classificato in ventiquattresima posizione (l'ultima tra i programmi della "Prima Divisione", quelli più forti), totalizzando 9 punti su 28, raggiungendo l'Elo (incredibile!) di 2663 (tredicesimo programma in graduatoria per Elo), cioè il livello di un Gran Maestro tra i più forti. Per avere un'idea della forza relativa del programma, si tenga conto che la FIDE (la Federazione Scacchistica Internazionale), nel luglio di 2003, dava la seguente statistica (http://it.wikipedia.org/wiki/ELO):

• un giocatore ha Elo superiore a 2800 (Gary Kasparov);
• 16 giocatori hanno Elo superiore a 2700;
• 113 giocatori hanno Elo superiore a 2600.

Crafty non possiede interfaccia grafica ma è compatibile con Xboard, di cui parleremo più avanti. Le caratteristiche più importanti del programma sono:

• Ovviamente codice sorgente libero. L'obiettivo dell'autore è fornire un codice che rappresenti lo stato dell'arte per quanto riguarda la programmazione di motori scacchistici. Hyatt non fa esplicitamente riferimento a una licenza, ma si limita a vietare l'utilizzo di Crafty in ogni tipo di torneo per programmi e il suo utilizzo commerciale. Questo ha obbligato alcune distribuzioni che includono il programma a chiedere chiarimenti all'autore (ad esempio, se la vendita dei CD contenenti la distribuzione potesse determinare una violazione di questi vincoli). Nella mia distribuzione Debian, nel file /usr/share/doc/crafty/copyright si può trovare parte della corrispondenza che chiarisce questi punti in modo positivo, per fortuna, per quanto riguarda l'inclusione di Crafty nella distribuzione ufficiale.
• Riga di comando flessibile, la quale fornisce molte informazioni riguardanti il processo di "riflessione" del programma. La riga di comando è attiva anche durante il tempo di analisi del programma. Un esempio:
  
  

  White(6): display +---+---+---+---+---+---+---+---+ 8 | R | . | | Q | K | B | | R | +---+---+---+---+---+---+---+---+ 7 | P | P | P | B | N | P | P | P | +---+---+---+---+---+---+---+---+ 6 | | . | N | P | | . | | . | +---+---+---+---+---+---+---+---+ 5 | . |-B-| . | | P | | . | | +---+---+---+---+---+---+---+---+ 4 | | . | | . |-P-| . | | . | +---+---+---+---+---+---+---+---+ 3 | . | |-N-| | . |-N-| . | | +---+---+---+---+---+---+---+---+ 2 |-P-|-P-|-P-|-P-| |-P-|-P-|-P-| +---+---+---+---+---+---+---+---+ 1 |-R-| |-B-|-Q-| . |-R-|-K-| | +---+---+---+---+---+---+---+---+ a b c d e f g h White(6): d3 time used: 13.85 time surplus 2:29 time limit 32.72 (3:49) depth time score variation (1) 8 0.27 0.37 6. ... a6 7. Bxc6 Nxc6 8. Nd5 Ne7 9. Qe2 c6 10. Nxe7 Bxe7 11. Be3 8-> 0.33 0.37 6. ... a6 7. Bxc6 Nxc6 8. Nd5 Ne7 9. Qe2 c6 10. Nxe7 Bxe7 11. Be3 9 0.99 0.41 6. ... a6 7. Bc4 b5 8. Bb3 Na5 9. Bg5 Nxb3 10. axb3 f6 11. Be3 9-> 1.07 0.41 6. ... a6 7. Bc4 b5 8. Bb3 Na5 9. Bg5 Nxb3 10. axb3 f6 11. Be3 10 1.65 0.28 6. ... a6 7. Bc4 b5 8. Bb3 Na5 9. Be3 Nxb3 10. axb3 b4 11. Ne2 c5 10-> 2.39 0.28 6. ... a6 7. Bc4 b5 8. Bb3 Na5 9. Be3 Nxb3 10. axb3 b4 11. Ne2 c5 11 3.61 0.34 6. ... a6 7. Bc4 b5 8. Bb3 Na5 9. Be3 Nxb3 10. axb3 c5 11. Qe2 Be6 12. Bg5 11-> 11.27 0.34 6. ... a6 7. Bc4 b5 8. Bb3 Na5 9. Be3 Nxb3 10. axb3 c5 11. Qe2 Be6 12. Bg5 12 11.27 1/29* 6. ... a6

  
  
• Utilizza il tempo di riflessione dell'opponente.
• Interfaccia grafica compatibile con Xboard.
• File di log che registrano le mosse effettuate in formato PGN e il processo di riflessione del programma (varianti analizzate, score, ecc.).
• Manuale in linea dei comandi abbastanza esauriente.
• Vasta libreria di aperture. È possibile, a partire da una collezione di partite in formato PGN, costruire un libro di aperture. Questo consente, ad esempio, di variare a piacere il repertorio di aperture che il programma gioca normalmente. Le spiegazioni su come costruire il proprio libro di aperture si ottengono digitando help book al prompt del programma.
• Utilizzo di basi di finali (endgame tablebases). Le basi di finali sono tabelle precompilate in formato adeguato che contengono le informazioni su come giocare un finale con un certo numero di pezzi (ad esempio R + T + P contro R + T) a partire da qualsiasi configurazione iniziale dei pezzi. Le basi di finali includono ovviamente tutte le posizioni di "matto semplice", cioè quelle posizioni nelle quali è possibile dare scacco matto (ad esempio R + A + A contro R oppure R + T contro R). Tabelle di finali già compilate si possono scaricare da ftp://ftp.cis.uab.edu/pub/hyatt/TB/.
• Facilitazioni per le annotazioni, cioè per inserire commenti, variazioni o simboli (indicanti concetti come buona mossa, cattiva mossa, ecc.), con la possibilità di essere esportati in formato PGN, HTML, LaTeX.

Gnuchess è un altro valido programma, ma la sua potenza di gioco è lontana da quella di Crafty.

I motori di scacchi, anche su normali PC, sono troppo forti per confronti diretti, soprattutto con giocatori amatoriali, ma sono utili per l'analisi delle partite.

Scid

Le basi di dati sono, a mio avviso, il software più importante per un giocatore di scacchi, sia esso amatore o professionista. Io le uso per preparare linee di apertura su grandi database, cercando partite in base a determinate posizioni: negli anni ho raccolto circa 5 milioni di partite che ho distribuito in 4 database e che mi consentono di preparare linee di apertura molto specializzate per i pochi tornei che ormai gioco, visto che non ho il tempo di studiare tutto il materiale a disposizione. Può sembrare esagerata una raccolta di partite di queste dimensioni per un giocatore amatoriale come me, ma si tenga conto che cercando una qualche posizione, dopo 8-10 mosse si può arrivare a tirar fuori non più di una ventina di partite, anche su un database di un milione. Il professionista usa il database per preparare incontri con altri giocatori di livello internazionale, vedendo le linee di apertura che i suoi avversari hanno giocato più recentemente, con quale esito, ecc.

Scid (Shane's Chess Information Database, http://scid.sourceforge.net) è un'applicazione di database per Windows e Linux scritta in C++ che consente di cercare partite in base a diversi criteri, di visualizzarne l'andamento graficamente e di produrre report di aperture e giocatori. Dispone di un motore di scacchi, Scidlet, che consente l'analisi delle posizioni, ma la funzionalità di analisi è compatibile con qualsiasi programma compatibile con Winboard/Xboard.

Il programma è altamente configurabile tramite interfaccia grafica. Le opzioni di funzionamento sono salvate, nella mia distribuzione Debian, all'interno della cartella ~/.scid/. L'applicazione principale viene lanciata con il comando Scid, ed è un frontend grafico scritto in Tcl/Tk che usa Tkscid, un interprete Tcl/Tk esteso per supportare le funzionalità di database di Scid.

Oltre a Scid, Tkscid e Scidlet, Scid contiene le seguenti utilità:

• pgnscid, un programma a riga di comando per trasformare un file di partite in formato PGN nel formato di Scid;
• scmerge, unisce più database di Scid in uno unico maggiore;
• scidpgn, stampa sullo standard output in formato PGN tutte le partite contenute in un database Scid;
• sc_import, importa partite in formato PGN all'interno di un database di Scid esistente;
• sc_spell, applica correzioni sui nomi in un database Scid (usato per avere uniformità sui nomi dei giocatori, luoghi e tornei, ad esempio).

Alcune funzionalità:

• finestra principale
  
  
  
  
• finestra di analisi, usando Crafty come motore
  
  
  
  
• crosstable, tabella finale di risultati per un torneo, contenenti tutti i giocatori e la variazione finale dell'Elo di ciascuno
  
  
  
  
• navigatore di aperture ECO (Encyclopaedia of Chess Openings)
  
  
  
  
• elenco di partite nel database
  
  
  
  
• finestra PGN della partita corrente
  
  
  
  
• informazione sul giocatore, contenente le statistiche per tutte le partite di quel giocatore nel database
  
  
  
  
• grafico dell'Elo di un giocatore, contenente l'andamento cronologico dell'Elo in base a tutte le partite contenute nel database
  
  

Inoltre, Scid consente di inviare e gestire direttamente le partite giocate per corrispondenza.

Il formato di database di Scid consente la ricerca e il trattamento di grandi quantità di partite. Ad esempio, il mio computer di casa, con processore AMD Sempron a 1672 MHz, ha impiegato 5 secondi per aprire un file con oltre 1.420.000 partite e circa 7 secondi per trovare nel database tutte le partite che raggiungono la posizione della Difesa Siciliana dopo 1.e4 c5 2.Cf3 e6 3.d4 cxd4 4.Cxd4 a6 5.c4.

Xboard

Standard per interfacce grafiche

Molti programmi, sia liberi che commerciali, dispongono della propria interfaccia grafica. Tuttavia nel tempo sono stati standardizzati alcuni protocolli di comunicazione tra i motori di scacchi e i software utilizzati per visualizzare e gestire le partite. Questo permette a un programmatore che, ad esempio, non sia interessato allo sviluppo dell'interfaccia grafica e che voglia concentrarsi sugli algoritmi di calcolo di utilizzare programmi già disponibili per consentire non solo di visualizzare, ma anche di comunicare con altri motori di scacchi, a patto che includa nel proprio programma il protocollo di comunicazione con l'interfaccia grafica. Questo si sposa perfettamente con lo spirito di Unix e del software libero, dove è sempre possibile, appoggiandosi al lavoro di chi ci ha preceduto, dare qualcosa di nuovo rispetto a quello che è stato già fatto, senza dover ripetere il lavoro portato avanti da altri.

Ci sono due standard principali di interfacce per i programmi che giocano a scacchi: UCI e Winboard/Xboard. Il primo è usato soprattutto dai programmi commerciali, mentre il secondo da quelli liberi. Noi ci concentreremo su Xboard, un'interfaccia sviluppata da diverse persone (inclusa la FSF, che l'ha potenziata notevolmente), tra le quali Tim Mann (il programmatore originale) è la più importante (ulteriori informazioni si possono trovare all'URL http://www.tim-mann.org/xboard.html). Winboard è un porting di Xboard su piattaforme Win32 curato dallo stesso Mann.

Un elenco di programmi compatibili con Xboard si può trovare, oltre che nel succitato sito di Tim Mann, all'indirizzo http://wbec-ridderkerk.nl, dove si può vedere l'ottimo sito curato da Leo Dijksman il quale organizza competizioni tra programmi con relativo calcolo di Elo e graduatoria in base ai risultati. Chiunque può iscrivere il proprio programma e farlo giocare contro i più forti software del mondo. Attualmente si è conclusa l'undicesima edizione ed è aperta l'iscrizione per la dodicesima.

Caratteristiche di Xboard

Xboard è una scacchiera grafica che fa da interfaccia ai motori Gnuchess o Crafty (principalmente, ma anche a qualunque programma compatibile con lo standard Xboard/Winboard), a Internet Chess Server (ICS), a partite giocate per corrispondenza o a una qualunque raccolta personale di partite. Come interfaccia di Gnuchess e Crafty, consente di analizzare partite o posizioni arbitrarie, guardare partite giocate tra i due programmi, ecc. Come interfaccia di un server ICS (xboard -ics), è possibile giocare contro altri utenti ICS, osservare partite in corso o visualizzare partite appena finite, come vedremo nella sezione dedicata a Internet. Per ultimo, Xboard è un client di scacchi per corrispondenza, utilizzando il programma cmail.

Personalmente utilizzo Xboard per fare giocare tra loro programmi diversi. Se non viene specificato alcun argomento, Xboard si inizializza nella modalità MachineBlack, nel quale l'opponente, con il Nero, è il programma Gnuchess. Per utilizzarlo invece in modalità standalone, per riprodurre una qualche partita salvata in precedenza, si può lanciare con l'opzione -ncp/-noChessProgram, anche se per questi compiti io preferisco utilizzare una base di dati come Scid, che offre funzionalità più avanzate di editing e di gestione delle partite/annotazioni/export. Nella modalità TwoMachines è possibile specificare due programmi che giocano tra loro riproducendo la partite attraverso Xboard. Inoltre, è possibile usare Xboard nella modalità standalone su una collezione di partite (salvate per esempio in formato PGN) con l'utilità pxboard, ad esempio digitando dalla riga di comando:

cat games.pgn | pxboard

Xboard ci apre una finestra che ci consente di selezionare e riprodurre sulla scacchiera una qualunque partita contenuta nel file.

Xboard dispone di una miriade di opzioni che possono essere specificate dalla riga di comando. Il seguente script permette di fare giocare un match di 10 partite tra Gnuchess e Crafty, e lo utilizzo per modificare in maniera agevole tempo di riflessione e opponenti su una configurazione di base che mi è comoda:

#!/usr/bin/perl

# xboard.pl
# Copyright (C) 2005  Francisco Yepes Barrera 
#
# 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 of the License, 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. 

# Configurazione globale
$timeControl = "-timeControl 10:00"; 
$movesPerSession = "-movesPerSession 40"; 
$movesPerSession .= "-timeIncrement 0"; 
$clockMode = "-clockMode True"; 
$showThinking = "-showThinking True"; 
$ponderNextMove = "-ponderNextMove True"; 
$matchGames = "-matchGames 10"; 
$firstChessProgram = "";
$firstDirectory = "";
$secondChessProgram = "-secondChessProgram 'crafty xboard logpath=/tmp'"; 
$secondDirectory = "";

$size = "-size Large"; 
$showCoords = "-showCoords True"; 
$highlightLastMove = "-highlightLastMove True"; 
$darkSquareColor = "-darkSquareColor brown"; 
$saveGameFile = "-saveGameFile /tmp/xboard.pgn"; 
$initialmode = "-initialMode TwoMachines";

# Esecuzione
system("xboard $initialmode $timeControl $movesPerSession 
    $clockMode $showThinking $ponderNextMove $matchGames $firstChessProgram 
    $firstDirectory $secondChessProgram $secondDirectory $size $highlightLastMove 
    $darkSquareColor $saveGameFile");

Lo script realizza un match tra Gnuchess (che comincia la prima partita giocando con il Bianco) e Crafty sulla base di 40 mosse in 10 minuti (nella modalità non incrementale, cioè non vengono aggiunti bonus di tempo per mossa effettuata). Ogni programma giocherà 5 partite con il Bianco e 5 con il Nero. Il risultato finale viene salvato in formato PGN nel file /tmp/xboard.pgn per essere poi analizzato o importato in una base di dati.

Internet

Come abbiamo detto, la forza dei programmi attuali non consente a un giocatore di club di giocare alla pari con il computer. È importante, per poter realizzare progressi, giocare con giocatori di livello simile al nostro, ma è parimenti essenziale poter diversificare i nostri opponenti, in modo da poter confrontarsi con stili diversi, forze di gioco relative differenti, ecc. Internet ci apre una finestra immensa dalla quale possiamo scegliere, in qualsiasi momento, un opponente adeguato alla nostra abilità oppure visualizzare partite tra maestri che stanno avendo luogo in questo momento, siano esse partite di allenamento o di un qualche torneo.

Queste funzionalità sono disponibili tramite un Internet Chess Server (ICS). Non abbiamo spazio per entrare nei dettagli della tecnologia alla base degli ICS, ma possiamo dire che si tratta di una tecnologia client/server basata inizialmente su una variante di telnet. I server tengono traccia dei giocatori e di alcune loro caratteristiche e accettano comandi che ci consentono di osservare partite già iniziate, ad esempio, oppure di richiedere un opponente tra quelli che in quel momento sono collegati al server. Il protocollo ICS è poco documentato e non è standardizzato, ma è possibile trovare alcune riferimenti, ad esempio, alla pagina che Tim Mann dedica all'interfaccia grafica Xboard (http://www.tim-mann.org/xboard/engine-intf.html).

La data ufficiale di inizio di ICS è il 15 gennaio 1992, ad opera di Michael Moore dell'Università dello Utah e Richard Nash (http://en.wikipedia.org/wiki/Internet_Chess_Server). Nel luglio del 1992, il server fu spostato su una macchina all' Università di Carnegie Mellon da John Chanak, William Kish e Aaron Putnam. Ulteriormente, alla fine dello stesso anno, il servizio fu rilevato da Daniel Sleator, professore all'Università di Carnegie Mellon, che aggiunse molti miglioramenti alla versione iniziale. Nel 1994 Sleator mise il copyright sul codice e dal 1995 cominciò a commercializzarlo, cambiandone il nome con quello di Internet Chess Club (ICC). Questo fatto provocò una polemica all'interno della comunità ICS, finché un gruppo di programmatori creò il Free Internet Chess Server (FICS), una versione libera di ICC (il loro moto dice "We do it for the game, not the money") che ancora oggi è attiva all'URL http://www.freechess.org. ICC e FICS possono essere considerarti i due ICS più importanti attivi attualmente.

Facciamo ora un esempio di una sessione ICS a FICS con Xboard come client. Il collegamento viene effettuato tramite il seguente comando:

xboard -ics -icshost freechess.org

Il server freechess.org ci chiederà un nome utente e una password. Naturalmente, prima di iniziare dovremo aver provveduto a creare un account su http://www.freechess.org. Dopo il login, possiamo cominciare a inserire i comandi per ricevere informazioni sui giocatori correntemente attivi, le partite in corso, ecc.

Va detto innanzitutto che possiamo chiedere informazione sui comandi impartibili attraverso il comando help:

fics% help match

match

Usage: match user [rated|unrated] [Time] [Inc] [Black_Start Black_Inc]
[White|Black] [{board_category board}|w#|bughouse|crazyhouse|wild fr|sui]

SUMMARY
-------
  This command allows you to challenge a given user to a game of chess.
To challenge player USER to a match, type "match USER".  The type of match
being offered depends on: 
(1) your variable settings (preferences). 
(2) information you give in the match request.

The player USER will need to accept or decline the challenge.  You can
cancel a challenge you have made using the "withdraw" command.

MATCH VARIABLES
---------------
  You can specify the parameters for the match.  If no parameters are
Type [next] to see next page.

Al login, il server FICS ci propone un elenco di news che possiamo visualizzare in qualsiasi momento con il comando news:

fics% news 
Index of the last few news items: 
1127 (Sat, Dec 10) TM Positions Available 
1128 (Sun, Dec 11) Sandbagging is NOT Allowed - Reminder 
1130 (Mon, Dec 19) BabasChess v3.6 
1132 (Sat, Dec 31) NYE Marathon Winner 
1134 (Wed, Jan  4) Babaschess minor bug update 
1135 (Fri, Jan 20) New admin 
1137 (Sat, Feb 11) ChessLecture.com prize tourney going monthly 
1138 (Tue, Feb 21) FICS needs relayers! 
1139 (Fri, Mar  3) FICS 11th Anniversary Celebration 
1140 (Fri, Mar  3) March ChessLecture.com tourney 

fics% news 1132 
1132 (Sat, Dec 31) NYE Marathon Winner

Winner of the marathon is AntyDisch with 15 points. 
\   http://www.freechess.org/Events/2006/NYEMarathon/index.html for the full 
\   standings/results.

Posted by SuperIntellect.

Per vedere l'elenco dei giocatori attivi al momento, si usa il comando who:

fics% who

2737^GMIvanchuk(D)(GM)
2713.TaoGizmo(C)
2712^GMBacrot(D)(GM)
2700 EJD(C)
2663^GMVallejoPons(D)(GM)
2624^GMRadjabov(D)(GM)
2542^GMMacieja(D)(GM)
2518^GMAronian(D)(GM) 
      ...

Al momento in cui mi sono collegato io c'erano parecchi giocatori interessanti, inclusi, come potete vedere, alcuni Grandi Maestri con Elo superiore a 2700 e due programmi (contraddistinti dalla (C)).Vediamo le partite in corso:

fics% games

           ...
  1 2491 IMDziuba    2497 IMCzarnota [ su120   0] 1:03:00 - 52:37 (35-35) B: 19 
100 2531 GMBobras    2486 IMGajewski [ su120   0]  52:00 - 59:36 (35-35) B: 14 
229 2585 GMMacieja   2479 GMGrabarcz [ su120   0] 1:07:00 - 44:37 (32-32) B: 15 
185 2700 EJD         2368 Mainflame  [ br  5   5]   5:02 -  3:30 (34-34) B: 19 
167 2524 GMBartel    2619 GMKempinsk [ su120   0]  56:00 - 56:46 (38-38) B: 16  
 43 2605 GMWojtaszek 2610 GMSocko    [ su120   0] 1:00:37 - 58:00 (35-35) W: 21 
187 2765 GMSvidler   2650 GMVallejoP [ su120   0] 1:38:57 -1:58:50 (38-38) W: 10  
 74 2700 GMRadjabov  2740 GMLeko     [ su120   0] 1:56:32 -1:41:15 (34-33) B: 16  
 81 2752 GMAronian   2729 GMIvanchuk [ su120   0] 1:41:42 -1:56:05 (38-38) W: 12 
190 2717 GMBacrot    2801 GMTopalov  [ su120   0] 1:46:07 -1:52:09 (39-39) W:  9

  230 games displayed. 

Come vedete c'è una riga per partita dove sono indicati, oltre ai giocatori e ai relativi Elo, le condizioni di tempo accordate per la partita (tra parentesi quadre), il tempo ancora a disposizione per i due giocatori e il numero di mosse effettuate, con indicazione del colore che muove (Bianco, W, o Nero, B). In questa occasione ho deciso di vedere con Xboard la partita che stava giocando Bacrot contro il Campione del Mondo Topalov; quindi, ho inserito:

fics% observe 190
Movelist for game 190:

GMBacrot (2717) vs. GMTopalov (2801) --- Sat Mar  4, 06:28 PST 2006 
Unrated standard match, initial time: 120 minutes, increment: 0 seconds.

Finalmente, il comando seek ci consente di cercare un avversario per una partita impostando le condizioni che desideriamo (tempo, colore, ecc.), inviando una richiesta a tutti i giocatori collegati, mentre il comando match consente di sfidare un dato utente a una partita e il comando play permette di rispondere a un utente che ha fatto una richiesta in precedenza (in questo caso il sistema verifica se il punteggio Elo o la categoria è nel range richiesto dal nostro opponente). Tutte le partite giocate e/o visualizzate sono salvabili in formato PGN passando a Xboard anche l'argomento -saveGameFile [nomefile].

Documentazione

Secondo me il software libero, sia per quanto riguarda i motori di scacchi che i database, ha un livello tecnico paragonabile ai programmi proprietari. C'è però un ambito in cui non ha rivali, ed è nella capacità di documentazione, avendo la possibilità di generare documenti di qualità e di esportare partite in formati come HTML, Postscript, DVI in notazione FAN (Figurine Algebraic Notation). La notazione FAN è una variante della notazione SAN (Standard Algebraic Notation) che utilizza icone dei pezzi in miniatura invece dell'abbreviazione ASCII del pezzo.

Prendiamo come esempio la partita Kasparov-Kramnik, che abbiamo già usato nella sezione dedicata a Scid, con lo scopo di ottenere un documento in notazione FAN. Esportiamo questa partita con Scid in formato LaTeX con il nome game.tex (Scid consente anche di esportare in formato HTML, ma genera una pagina che contiene la partita in notazione SAN), dopodiché lanciamo i seguenti comandi dalla linea di comando:

$ latex game.tex
$ xdvi game.dvi
$ dvips game.dvi

Il primo comando ci consente di generare un documento DVI che contiene la partita in notazione FAN. È necessario che sia installato il pacchetto tex-chess, che contiene i font per il supporto della notazione scacchistica da parte di TeX/LaTeX. Il secondo comando consente la visualizzazione del file DVI appena creato, mentre il terzo crea il file Postscript a partire dal file DVI. Lo stesso risultato si può ottenere attraverso LyX, importando il file TeX contente la partita e generando direttamente il PS, ma su file con grandi quantità di partite, contenenti annotazioni e varianti, a volte questa procedura fallisce. L'utilizzo della riga di comando è più robusto.

Se vogliamo mettere sul nostro sito le partite in notazione FAN, possiamo usare latex2html:

$ latex2html game.tex

che da questo risultato:

Kasparov, Gary (2838)
Kramnik, Vladimir (2809)
Botvinnik Memorial m (2)
Moscow RUS
2001.12.02 1/2-1/2 B41l

1/2-1/2

Conclusione

Nel mondo degli scacchi le novità sono all'ordine del giorno. Nuovi software e nuovi approcci vengono realizzati e provati in continuazione. La possibilità di poter giocare con persone che vivono all'altro capo del mondo o di collaborare con esse per costruire un programma che un giorno "sfiderà il campione mondiale" sono sufficientemente attraenti da coinvolgere un enorme numero di individui, appassionati e programmatori. Altri si limitano a provare i software creati da terzi per il semplice piacere di capire quale approccio è il più forte: scegliere cosa fare in base alle proprie attuali conoscenze e ai propri desideri diventa una scelta personale, soggettiva. Spero che il lettore sia invogliato ad approfondire alcuni degli argomenti trattati per conto proprio.