diff options
Diffstat (limited to 'macros/latex/contrib/xskak/xskak.tex')
| -rw-r--r-- | macros/latex/contrib/xskak/xskak.tex | 3490 |
1 files changed, 3490 insertions, 0 deletions
diff --git a/macros/latex/contrib/xskak/xskak.tex b/macros/latex/contrib/xskak/xskak.tex new file mode 100644 index 0000000000..f8655af210 --- /dev/null +++ b/macros/latex/contrib/xskak/xskak.tex @@ -0,0 +1,3490 @@ +% !Mode:: "TeX:DE:UTF-8:Main" +% -*- mode: TeX -*- -*- coding: UTF-8 -*- +\def\UFcurrentpackage{xskak} +\newcommand\UFcurrentversion{1.5} + +\RequirePackage{fix-cm} + +\documentclass[pagesize,parskip=half-,fontsize=12pt]{scrartcl} +\usepackage[utf8]{inputenc} + +%% xskak specific commands +\usepackage[LSB1,LSB2, LSB3,LSBC2,LSBC3,LSBC4,LSBC5, T1]{fontenc} +\usepackage{xskak} +%\usepackage{eqparbox} +\usepackage{tabularx} + +\usepackage{framed} +\colorlet{shadecolor}{lightgray!25} + + +\makeatletter +\newcommand\Describefillkey[4][]{\par\index{#2 (\textbackslash chessboard key)}% +\makebox[0pt][r]{\tiny #1\hspace{1em}}% + \colorbox{green!25}{\makebox[\dimexpr\textwidth-2\fboxsep\relax]{\ttfamily% + \eqparbox{fillkey}{#2=\meta{#3}}\hfill + \eqparbox{fillexample}{% + \ifthenelse{\equal{#4}{}}% + {#2} + {#2={#4}}}}}% + \par\nobreak\@afterheading} +\makeatother + +\usepackage{filecontents} +\usepackage{UF-xskak-documentation} + +\setchessboard{smallboard, showmover=false} +\xskakset{style=UF} + +\usepackage{showexpl} +\makeatletter +\renewcommand\board@pgf@extractangle[2]{%#1 command, #2 pgfpoint + \pgfextracty{\len@board@tempy}{#2}% + \pgfextractx{\len@board@tempx}{#2}% + \ifdim\len@board@tempx=0pt\relax + %\len@board@tempy= 1 or unchanged? + \else + %\divide \len@board@tempy by \strip@pt\len@board@tempx\relax + \pgfmathsetlength{\len@board@tempy}{\len@board@tempy/\len@board@tempx}% + \fi + \ifdim\len@board@tempx=0pt\relax + \ifdim\len@board@tempy=0pt\relax + \def#1{0}% + \else + \ifdim\len@board@tempy>0pt\relax + \def#1{90}% + \else + \def#1{-90}% + \fi + \fi + \fi + \ifdim\len@board@tempy=0pt\relax + \ifdim\len@board@tempx=0pt\relax + \def#1{0}% + \else + \ifdim\len@board@tempx>0pt\relax + \def#1{0}% + \else + \def#1{180}% + \fi + \fi + \fi + \ifdim\len@board@tempx>0pt\relax + \ifdim\len@board@tempy>0pt\relax + \pgfmathatan{\len@board@tempy}% + \edef#1{\pgfmathresult}% + \fi + \ifdim\len@board@tempy<0pt\relax + \pgfmathatan{\len@board@tempy}% + \edef#1{\pgfmathresult}% + \fi + \fi + \ifdim\len@board@tempx<0pt\relax + \ifdim\len@board@tempy>0pt\relax + \pgfmathatan{-\len@board@tempy}% + \pgfmathadd{-\pgfmathresult}{180}% + \edef#1{\pgfmathresult}% + \fi + \ifdim\len@board@tempy<0pt\relax + \pgfmathatan{\len@board@tempy}% + \pgfmathadd{\pgfmathresult}{180}% + \edef#1{\pgfmathresult}% + \fi + \fi + } + +\makeatother + +\begin{document} + +\title{\packagename{xskak}: An extension to \skaksty} +\author{Ulrike Fischer} +\maketitle + +\tableofcontents + +\section{Changes} +\begin{description} +\item[2019-06-23] (Version 1.5)] Corrected a bug: \cs{xskak@beforecomment}{} was not defined. styleA was missing a space. Improved the documentation and added the source to the ctan upload. + +\item[2015-01-02] (Version 1.4)] Corrected a bug: After a promotion the promotionpiece and the fen position were wrong. +\item[2014-04-19] (Version 1.3)] Corrected a bug: enpassant test didn't check the piece and so other figures than a pawn could make an enpassant move. +\item[2012-08-24 (Version 1.2b)] +Corrected a small bug -- \cs{printchessgame} doesn't wrap around a wrapfigure. + + +\item[2012-08-24 (Version 1.2a)] +Corrected a small bug -- \cs{hidemoves} printed comment signs. + +\item[2008-10-10 (Version 1.2)] +Made some changes to make \xskak compatible to the version 1.5 of +\skaksty. See below for details. + +Changed Code: As \cs{longmoves} doesn't work with \cs{variation} +anyway \cs{variation} now use always \cs{shortmoves}. + +Bug correction: \skaksty forgets to store comments after castling +moves. Code to correct this has been added to \xskak. + +Bug correction: \xskak didn't print check and mate symbol after +castling moves due to wrong position of braces. + +\item[2008-07-28 (Version 1.1)] +Bug correction: Added the code for the promotion piece to the SAN and +LAN notation. + +Bug correction: Remove some spurious spaces. + +\end{description} + + +\section{Introduction} + +\Xskak\footnote{License: \LaTeX\ Project Public License} is an extension for \skaksty -- and as \xskak is an extension +(and not a replacement) the main work is still done by \skaksty so +please read first the documentation of \skaksty as I'm not explaining +the \packagename{skak} commands in this documentation. + + +\Skaksty is a package from Torben Hoffmann which can parse and print +chess games given in (a subset of) the PGN notation. + +The main features of \packagename{xskak} are: + +\begin{itemize} +\item \packagename{xskak} can handle an extended set of PGN. + +\item \packagename{xskak} +can parse and store an arbitrary number of chess games in PGN. The +games can be exported and imported and all positions and moves can be +retrieved at anytime. + +\item \packagename{xskak} can +handle an arbitrary number of printing styles to distinguish +the different variations levels. + +\end{itemize} + +\minisec{Extended PGN handling} + +When handling a PGN chess parsers at first have to split the notation +in different chunks. I will call this step the \emph{PGN parser}. +As an example\\[1ex]\mbox{}\quad {\ttfamily 15.Ne5!+ +\$3 \{This breaks the black defense\} (15.Re1? Kg8!)}\\[1ex] contains as +chunks a \emph{move number} (\texttt{15.}), a \emph{move} +(\texttt{Ne5}), \emph{short move comments} (\texttt{!+}), a +\emph{NAG} (\texttt{\$3}), a \emph{comment} (\texttt{\{This breaks +the black defense\}}) and a \emph{variation} (\texttt{(15.Re1? +Kg8!)}). + +Neither \packagename{skak} nor \packagename{xskak} can handle all +legal PGN's. \Skaksty can only handle PGN's which contains move +numbers, moves and short comments. \packagename{xskak} can +additionally handle NAG's and a special form of comments. None of the +packages can currently parse PGN's with variations. + + +\minisec{Storing moves} + +After the splitting of the PGN the chunks are processed further. +Depending on the type of the chunk different actions are taken. The +most important subprocess is the \emph{move parser}. It takes the +move, retrieves from somewhere the current (FEN-)position of the game +and tries to figure out what the move is exactly doing. + +In \packagename{xskak} only the commands \cs{mainline} and +\cs{hidemoves} calls the move parser, \cs{variation} uses only the +PGN parser. + +The main difference between \packagename{xskak} and +\packagename{skak} is how they handle the information gathered by +the move parser: \Skaksty uses the results of the move parser mainly +to update the board and after the move throws almost all other +information away -- including previous positions. \xskak saves all +information about the moves for later use. Here a simple example: + +\begin{LTXexample} + \newchessgame + \mainline{1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6} + + \xskakset{moveid=2w}% + \chessboard[setfen=\xskakget{nextfen}]\\[1ex] + Position after 2.\,\xskakget{lan} +\end{LTXexample} + +So in short you start a game with \cs{newchessgame}, you enter moves +with \cs{mainline} (or \cs{hidemoves}), you set the move for which +you want to retrieve data with \cs{xskakset}, and then you retrieve +the data with \cs{xskakget}. + + +The storing of the moves and positions is not restricted to the main +game. You can store and retrieve as much variation levels you want. + + +\minisec{Printing styles} + +The following example shows how to use different styles for different +variation levels. But it also shows the problems: It can be quite +tiresome to get a good printing result. You must pay attention to the +levels and the spaces after commands, and for each variation you have +to start a new game and resume older games if you go back to them. + +\begin{LTXexample} +\longmoves \xskakset{style=UF} +\newchessgame[id=main] +\mainline{1.e4 e5} +% + (Alternatives are + \newchessgame[newvar=main,id=var1]% + \mainline[invar]{1... d5} which is answered by + \mainline{2. exd5 Qxd5} + % + \newchessgame[newvar=var1,id=var1-1] + (\mainline[invar]{2... Nf6}) + % + or + \newchessgame[newvar=main,id=var2] + \mainline[outvar]{1... e6 2. d4}) +% +\resumechessgame[id=main]% +\mainline[outvar]{2.Nf3} + +\chessboard +\end{LTXexample} + + + +\bigskip + +In the following sections I will describe the finer points. This +includes +\begin{itemize} +\item how to handle more than one game at a time, +\item how to retrieve the data faster, +\item what data you can retrieve, +\item how to loop through a game, +\item how to export the data, +\item how to improve the printing of the games, +\item and some other changes/additions I made to \packagename{skak}. +\end{itemize} + + +\subsection{Warnings} + +\minisec{\packagename{xskak} and \packagename{skak}} + +\Xskak doesn't only define some new commands, it also changes some +quite central internal commands of \skaksty. This means +\begin{itemize} + \item it can break standard commands of \skaksty, + + \item it will possibly not work together with future versions of + \skaksty, + + \item loading \packagename{xskak.sty} can lead to problems with + packages like \packagename{texmate} which use internally + \packagename{skak}. +\end{itemize} + +\minisec{Local and global commands} + +In the package \packagename{chessboard} almost every setting is local +to the board. This was a quite natural decision as a board is a +confined space. In \packagename{xskak} the situation is quite +different: As a start \packagename{skak} already sets and saves some +information globally and the data saved by \packagename{xskak} +during the parsing must be saved globally or they wouldn't never +escape the \cs{mainline}. And secondly, as I wanted to use +\packagename{beamer} and \packagename{animate} a lot of data +must be preserved from one frame/picture to the next. So I decided to +use in most cases global commands unless -- like in the cases of +styles -- I could see a real advantage in keeping a setting local. + +So please be aware that settings made e.g. in a figure environment +can affect the following text. + + +\subsection{Some history} + +While the commands \cs{mainline} and \cs{hidemoves} parse a chess +game \skaksty updates an internal board and so can always show the +current position. Sadly a lot of the data gathered during the +parsing are thrown away after \packagename{skak} has updated the +board and has go on to the next move and so can not be used by the +user. E.g. there is no way to get the field a piece came from or to +store easily all positions of a game. + +Some years ago I tried to find out how to print a game in long +algebraic notation and I realized quite fast that I need some of +these lost data to be able to do it, and that it would be necessary +to patch some internal commands of \skaksty to save the data. At the +same time I also tried to insert some code that allows the parsing of +standard PGN-comment signs. Due to lack of time the whole project +didn't got very far but I had a working beta. Then a new version of +\skaksty came. It had even a -- sadly at the time not fully working -- command \cs{longmoves}% + \index{longmoves=\verb!*+\longmoves+>}% + \index{shortmoves=\verb!*+\shortmoves+>} +(and the counterpart \cs{shortmoves}) to switch to the long algebraic +notation. But I hadn't the time to test and adjust my package. + + \index{longmoves=\verb!*+\longmoves+>}% + \index{shortmoves=\verb!*+\shortmoves+>}% + +Then in 2006 I wrote \pchessboard and during the tests also tried to +make animated pdf's which show all positions of a game. That worked +fine but the input was so tiresome that I restarted the +\packagename{xskak}-project: Like in the case of the long algebraic +notation the main problem was the loss of previous positions. + + +\subsection{Bugs and errors} + +I'm quite sure that they are bugs and errors in the package. + +If you have questions ask them in the newsgroups +\nolinkurl{comp.text.tex}, \nolinkurl{de.comp.text.tex} or +\nolinkurl{fr.comp.text.tex} or at \url{http://tex.stackexchange.com/}. +I'm reading these groups regularly and +I'm much better in answering there than in answering e-mails. + +If you find errors in this text (this includes wrong english) or in +the package, you can write me a bugreport at +\nolinkurl{chess@nililand.de} or -- better -- add an issue to the github site +\url{https://github.com/u-fischer/xskak/issues/}. A bugreport should contain a complete, +running, \emph{minimal} example and the log-file of the pdf\LaTeX\ +run (that means the engine that makes a pdf!). + + +\subsection{Requirements} + +\Xskak uses some primitives of e\TeX. It needs version 1.4 or version +1.5 of \skaksty, a recent version of \chessfss (chess font selection) +and \packagename{xkeyval} (\textit{key=value}-syntax), version 1.5 of +\packagename{chessboard} (which in turns needs \packagename{pgf}) and +\packagename{xifthen}. + + +\subsection{Installation} + +Run \filetype{xskak.ins} through \LaTeX\ and then put the +\filetype{*.sty} where \LaTeX\ finds them. +(\path{<texmf>/tex/latex/xskak/} is a good place.) Update the +filename database. + + +\subsection{Loading and package options} + +Loading of the package is done with \verb+\usepackage{xskak}+. +Currently the package has only one option: \texttt{nopdfmatch}.% + \index{nopdfmatch (package option)} +The option will disable the use of the experimental \cs{pdfmatch} +used in the processing of the style levels (see section +\ref{sec:usestyles}). \packagename{xskak} will load \skaksty without +option (and won't pass options to it). So, if you want to load +\packagename{skak} with options, you must do it before loading +\xskak. + +\subsection{Adaption to \skaksty version 1.5} + +Above I warned that \xskak can break with newer versions of \skaksty. +When the version 1.5 of \packagename{skak} appeared +promptly a lot of things broke so I had to adapt and change my code. +Version 1.2 of \xskak will work with both versions of +\skaksty. + +In version 1.5 of \skaksty some fundamental things have changed. At +first \cs{longmoves} works now correctly, even as you can see for the +\cs{variation} command: + + +\LTXinputExample[label=ex:longmovesnew, + graphic={[trim=3cm 24cm 9cm + 4cm,clip]{skak-longmoves-test-new}}, + caption={The new + longmoves implementation of + \skaksty}]{skak-longmoves-test-new} + + +The more important change (from the point of my package) is that +\cs{variation} now parse the moves too (that's why it can show the +long algebraic notation). To achieve this the author of \skaksty, +Torben Hoffman, stores now the position before a move so that he can +go back to this position and start the variation from there. + +The main problem with this approach is that it imposes restrictions +on the move numbers of variations: All variations must start with the +move number of the last move in a \cs{mainline} command. So +separating two moves of a variation by some text is no longer +possible: + +\begin{lstlisting} + \documentclass{article} + \usepackage{skak} %=skak version 1.5 + \begin{document} + \newgame + \mainline{1.e4 e5 2. Nf3} + \variation{2. d3 d6} %works + \variation{2. c3} %works + and then + \variation{2...c6} %error + \end{document} +\end{lstlisting} + +To tell the truth, I'm not sure that this a very good idea. In any +case: \xskak overwrites the responsable definitions of \skaksty. With +\xskak \cs{variation} currently doesn't parse games (and so also +can't show moves in long algebraic notation -- if you want this you +will have to start with the commands described later in this +documentation a new game with another id). So the above example works +fine with \xskak. + + + + + +\subsection{The example} + +Almost all examples use as starting point a new game. But in some +cases the following position is used, which allows to show almost all +special cases (like enpassant, promotion, capture, castling, +ambiguous moves). The position is stored under the name «example» and +so can be retrieved e.g. with the key \key{restorefen=example} from +\packagename{chessboard} or the command +\lstinline+\restoregame{example}+ of the package +\packagename{skak}\footnote{One could also use key \key{tag} to +store the position and key \key{reffen} to retrieve it.}: + +\begin{LTXexample}[caption={The standard example position},width=.7\textwidth] + \newchessgame[id=example, + castling=Q, + setwhite={pa2,pc7,pg5,ph2,pe4, + ke1,ra1,bg4}, + addblack={pb4,ph7,pd5, + ke8,rh8,bh3,nf6,ne5}, + storefen=example]% + + \mbox{\Xskakexampleinitfen} + + \chessboard +\end{LTXexample} + + +\section{Improved parsing of comments}\label{sec:diagrams} + + \Skaksty can handle comments in the input if they follow +directly the move, if the commands are robust and if the spaces that +separate moves and numbers are not swallowed by a command. + +\LTXinputExample[label=ex:comments, + graphic={[trim=3cm 24cm 9cm + 4cm,clip]{skak-comment-test}}, + caption={comments in \skaksty}]{skak-comment-test} + + +This is quite okay for a few small comments in a small number of +games, but a bit tiresome if you want to handle a lot of games that +you have annotated with a chess application. The PGN export of such +games uses NAG's for short comments and curly braces for longer +comments. + + +With \xskak the commands \cs{mainline}, \cs{hidemoves} and +\cs{variation} now can parse NAG's and longer comments if the input +meet the following conditions: +%\end{document} +\begin{itemize} + \item There must be spaces between the moves, each NAG and the + comments. + + \item Text comments must be written as + \verb+\xskakcomment{+\meta{Text}\verb+}+% + \footnote{Braces are so frequent in \TeX\ that is simply not + possible to identify the comments simply by looking for a brace + -- at least not without a lot of complicated hacks.} + +\end{itemize} + +While parsing the comments the spaces before and between them will be +swallowed. If you want a space you must add it to the text. The +NAG's (\$1, \$2 etc) are translated following the definitions in +\filetype{xskak-nagdef.sty}. The list there is neither complete nor +definite. For quite a lot NAG's I hadn't the faintest idea what do. +I'm open for suggestions/corrections. + +There exist two «fake» NAG's: \$d and \$D. If used in a \cs{mainline} +or \cs{hidemoves} both will save the identification of the current +move in an internal list and print whatever they have been defined +to. (Currently \$D will print \cs{chessdiagramname} which is defined +as \verb+\ (Diagram)\ +, \$d is +empty). This can be used to refer to diagrams printed later.% + \footnote{It is not a accidental that there is a similar command + «\cs{toD}» in \packagename{texmate}. That's where I got the idea + from.} + + + +\begin{LTXexample}[caption={NAG's, comments and diagram references in the input}] + \newchessgame[id=GameA] + \mainline{1.e4! $2 e5 $D 2.Nf3 Nf6 \xskakcomment{ What's that? }} + + \renewcommand\xskakcomment[1]{{\itshape #1}}% + \mainline{3. Nxe5 + \xskakcomment{ I took a pawn! } $D } + \variation[invar]{3. Nc3 $4 + \xskakcomment{ (boring) }} + + \makeatletter + \@for\mymoveid:=\XskakGameAdiagramlist\do{% + \xskakset{moveid=\mymoveid}% + \begin{tabular}{c} + \chessboard[tinyboard, + setfen=\xskakget{nextfen}]\\ + After move \xskakget{opennr}\xskakget{lan} + \end{tabular} } +\end{LTXexample} + + +\section{The core of \xskak: Saving games.} + +\Xskak redefines some internal commands of \skaksty to enable +\cs{mainline} and \cs{hidemoves} to store quite a lot% + \footnote{\textbf{Attention:} When I say «a lot» I really mean it. Currently + about 30 commands for each halfmove is saved plus about 30 commands + for each game. A lot of games with individual game identifications + can use a lot of memory. But in practice that shouldn't be a problem + as it is seldom necessary to use a lot of different game + identifications.} +data about the moves and the state of the game while parsing +the game. + +There are two sorts of data: Information related to the game as a +whole (e.g. the names of the players and the start position) and +information related to the moves. Both type of information use a +\meta{GameId} in the names of the commands to identify the game they +are referring to, the move data use additionally a \meta{MoveId}. + +\begin{shaded} +\minisec{Exkurs 1} + +It is important to understand one difference between the use of +\meta{GameId} and \meta{MoveId}: There is only \emph{one} command +that holds the current \meta{GameId}. The \meta{GameId} is a concept +specific to \xskak. The current value \meta{GameId} is stored in a +command and will be used (and can be changed) by all the commands +that store information \emph{and} by all the commands that retrieve +information. So if you are parsing a game in bits you should be +careful to use the same \meta{GameId} for each part. + +On the other sides there are \emph{three} different places where move +data are set or used: \skaksty uses in \cs{mainline} and +\cs{hidemoves} a counter called «\texttt{move}» and a boolean to keep +track of the current move and player. \Xskak has two internal +commands which are used to set up the start moves of games and to +retrieve the stored move data, and \cs{chessboard} has two keys that +set move data in FEN's. This can be sometimes a bit +confusing. \Skaksty will not like it if its move counter is changed +while parsing a game, but it is normally not a problem to change the +\packagename{xskak} move commands e.g. to retrieve data about +previous moves -- as long as you don't use commands like +\cs{newchessgame} that affects also the \packagename{skak} move +counter. +\end{shaded} + + +\begin{shaded} +\minisec{Exkurs 2} + +In chess we speak quite as often about the last move and the last +position than about the next move and the next position: A position +can be described as the one \emph{after} the \emph{last} move, the +result of a move. But it can also be described as the one +\emph{before} the \emph{next} move. + +The keys and commands described later reflect this: Given a move +number you can access e.g. the position \emph{before} the move +through the key word \key{pastfen} and the position \emph{after} the +move through the key word \key{nextfen}. Given a \emph{tag} -- that +is a label between two moves, you can refer to the move +\textit{before} the tag through keys with the prefix \key{past} and +to the move \emph{after} the tag through keys with the prefix +\key{next}. + +In short: \key{past} looks back and \key{next} looks forward. + +The first position of a game and the first move have the prefix +\key{init}. The last position (after the last move) and the last move +have the prefix \key{last}. + +\end{shaded} + + +\subsection{Initialization of the game} + +\DescribeMacro{\newchessgame}% +When using \xskak you should start a new game with +\cs{newchessgame}\keyoarg{} instead of \cs{newgame}. It will set the +identification \meta{GameId} of the game, the start position, start +move and quite a lot of other variables to sensible values. + +In the optional argument you can use the following keys: + +\begin{description} +\item[\key{id=}\meta{GameId}] + \index{newchessgame=\verb!*+\newchessgame+>id (key)}% + \index{id (\texttt{\textbackslash newchessgame} key)}% + This key sets the string that identifies the game and is used in + the following parsing commands to store the data. + It is possible to use commands and counters e.g. for automatic numbering of + the games. + If you don't use the key or if you use the key without + argument (\verb+\newchessgame[id]+) a default is used. + The initial value of this default is \texttt{game}, but it can be changed with + \cs{xskakset}. + You can use the key \key{id} in each \cs{newchessgame} only once. + +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \newchessgame[white=Bob]% + \mainline{1. e4 e5} + + \newchessgame[id=MY,white=Bill]% + \mainline{1. e4 e5} + + \newcounter{gamecounter}% + \stepcounter{gamecounter}% + \xskakset{defaultid=Game\Alph{gamecounter}}% + + \newchessgame[white=Harry]% + \mainline{1. e4 e5} + + \stepcounter{gamecounter}% + \newchessgame[white=Thomas]% + \mainline{1. d4 d5} + + \Xskakgamewhite, \XskakMYwhite, + \XskakGameAwhite, \XskakGameBwhite% +\end{LTXexample} + +\item[\key{movenr=}\meta{number}, \key{player=}\meta{«w» or «b»}, \key{moveid=}\meta{number + «w» or «b»}] + \index{newchessgame=\verb!*+\newchessgame+>movenr (key)}% + \index{movenr (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>player (key)}% + \index{player (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>moveid (key)}% + \index{moveid (\texttt{\textbackslash newchessgame} key)}% + With this keys you can change the start move for the parsing + commands \cs{mainline} and \cs{hidemoves}. + Setting this keys will change the counter and boolean + of \packagename{skak} \emph{and} the internal commands of + \packagename{xskak}. + The changes are global. + Default is \texttt{moveid=1w}, this default can be changed with + \cs{xskakset}. + Move number and player given through one of the FEN-keys of \cs{chessboard} + will not affect the move counter of \packagename{skak}! + + +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \newchessgame + \mainline{1. e4} + + \newchessgame[moveid=4w] + \mainline{4. e4 e5} + + \xskakset{defaultmoveid=5b} + \newchessgame + \mainline{5... c4} + \xskakset{defaultmoveid=1w} %back to normal +\end{LTXexample} + +\item[\key{newvar=}\meta{GameId}] + \index{newchessgame=\verb!*+\newchessgame+>newvar (key)}% + \index{newvar (\texttt{\textbackslash newchessgame} key)}% + + If you use this key \cs{newchessgame} will use the position + and the \meta{moveid} \emph{before} the last + move of the game \meta{GameId} as start position. If you don't + give a value the current meaning of \meta{GameId} is used. This + can be used to start variations. The new game inherits only the + start position of the reference game! + + +\item[\key{ref\ldots=}\meta{tag}] + +The \meta{GameId} and the start move can also be set with keys which +use values saved with a \key{tag}. The keys are described in section +\ref{sec:labeling}. + + +\item[keys to set PGN-infos] + \index{newchessgame=\verb!*+\newchessgame+>result (key)}% + \index{result (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>white (key)}% + \index{white (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>black (key)}% + \index{black (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>whiteelo (key)}% + \index{whiteelo (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>blackelo (key)}% + \index{blackelo (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>site (key)}% + \index{site (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>date (key)}% + \index{date (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>event (key)}% + \index{event (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>round (key)}% + \index{round (\texttt{\textbackslash newchessgame} key)}% + \index{PGN-infos |see (\texttt{\textbackslash newchessgame} keys)}% + With the keys \key{result}, \key{white}, \key{black}, + \key{whiteelo}, \key{blackelo}, \key{site}, \key{date}, + \key{event} and \key{round} you can store the content of the + PGN-infos. Unused keys are set to default values. These defaults + can be changed with \cs{xskakset}. + + \DescribeMacro{\xskaknewpgninfo}% + With \cs{xskaknewpgninfo}\oarg{default value}\marg{keyname} you can define a own PGN-info key. This + will also define a key \key{default\meta{name}} to change the default value later. + +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \xskaknewpgninfo[Tom]{commentary} + + \newchessgame[white=Harry,date=2007] + \xskakgetgame{white}, \xskakgetgame{date}, + \xskakgetgame{event}, + \xskakgetgame{commentary} + + \xskakset{defaultevent=My open} + + \newchessgame[commentary=Müller] + \xskakgetgame{commentary}, + \xskakgetgame{event} + +\end{LTXexample} + + +\item[using chessboard keys] + \index{newchessgame=\verb!*+\newchessgame+>using chessboard keys}% + You can use any key that can be used in the optional argument of + \cs{chessboard} from the package \packagename{chessboard}. + \cs{newchessgame} will pass all keys to an internal + \cs{chessboard}% + \footnote{That's why you will get an error from \cs{chessboard} if you use an unknown key.}. + \cs{chessboard} will set a position and give it back as the start position for the + game. + All \packagename{chessboard} keys are processed normally. + You can even print directly the board by using the key \key{print}. + The only exceptions\footnote{They don't gives + error but they will have no effect.} are the keys \key{maxfield} + and \key{zero} that change the size of the board -- + \packagename{skak} doesn't like unusual sizes of the board -- + and the keys \key{mover} and \key{fullmove} which are overwritten + by the (eventually default) value of key \key{moveid}. The castling + possibilities and the enpassant field are set accordingly the + values in the default fen, you only need to set them if you want + to use other values. + Read the documentation of \packagename{chessboard} for more information. + + +\begin{LTXexample} +\newchessgame[ + moveid=4b,print, + showmover, + mover=w,% has no effect + castling=Q,enpassant=a3, + setwhite={pa4,pc7,pg5,ph2,pe4,ke1,ra1,bg4}, + addblack={pb4,ph7,pd5,ke8,rh8,bh3,nf6,ne5}]% + +\mainline{4... bxa3} +\chessboard +\end{LTXexample} +\end{description} + + To use a position of another game as a start position you can use + e.g. this sequence of keys + (a shorter method that use a label/ref-method will + be described in the section \ref{sec:labeling}): + + \cs{newchessgame}\verb+[id=+\meta{old id}% + \verb+, moveid=+\meta{old move id}% + \verb+,+\\\phantom{(newchessgame[}% + \verb+setfen=\xskakget{+\meta{\ttfamily\upshape nextfen|pastfen}\verb+}+% + \verb+,+\\\phantom{(newchessgame[}% + \verb+id=+\meta{new id}\verb+, moveid=+\meta{new initmove id}% + \verb+]+ + + \textbf{Attention:} A new game is a \emph{new} game. It doesn't inherit moves of + another game -- it only reuses a position. + So if the new and the old game have identical \meta{GameId} + then the old game will be more or less lost. + + In case that you want to go one half move back and start a new + game from there you can use the key \key{newvar}: + + \cs{newchessgame}\verb+[newvar=+\meta{old id}% + \verb+, id=+\meta{new id}\verb+]+ + + +\begin{LTXexample} + \newchessgame[id=A]% + \mainline{1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O} + + \newchessgame[ + id=A,moveid=3w,print, + setfen=\xskakget{nextfen}, + %fen after move 3w + id=B,moveid=1b] + + \mainline{1... Nf6} + + \newchessgame[id=C] + \mainline{1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O} + + \newchessgame[print, + id=C, + % we retrieve the number of the last move + % of game C and set it as first number + % of the new game B at the same time: + moveid=\xskakgetgame{lastmoveid}, + setfen=\xskakget{pastfen}, + id=B] + + \mainline{5. d3} +\end{LTXexample} + + +\subsection{Continuing a game} + +\DescribeMacro{\resumechessgame}% + \Skaksty doesn't have a problem if you split a game in pieces. + You can use as many \cs{mainline} commands as you want. It even + doesn't matter if you started the game in another group. But if + you mix two games you must first reset the + position and the move counter to the end position of the old game + before you can continue it. This is possible with + \cs{resumechessgame}\keyoarg. You can use + \cs{chessboard}-keys in the optional argument but all the keys + that tries to change the position will have no effect. It is also + not possible to store the new moves under a new game identification or + to renumber the moves. + + The command accepts the following additional keys in the optional + argument: + +\begin{description} +\item[\key{id=}\meta{GameId}] + \index{resumechessgame=\verb!*+\resumechessgame+>id (key)}% + \index{id (\texttt{\textbackslash resumechessgame} key)}% + This key identifies the game that should be continued (as a + default the currently active identification is used). The key + changes \meta{GameId} globally! + + +\item[\key{movenr=}\meta{number}, \key{player=}\meta{«w» or «b»}, \key{moveid}\meta{number + «w» or «b»}] + \index{resumechessgame=\verb!*+\resumechessgame+>movenr (key)}% + \index{movenr (\texttt{\textbackslash resumechessgame} key)}% + \index{resumechessgame=\verb!*+\resumechessgame+>player (key)}% + \index{player (\texttt{\textbackslash resumechessgame} key)}% + \index{resumechessgame=\verb!*+\resumechessgame+>moveid (key)}% + \index{moveid (\texttt{\textbackslash resumechessgame} key)}% + This keys set the move from which on the game should be + restarted. With the keys it is possible to go back and then + continue the game along another variation (in this case the moves + of the first variation will be lost). + The values describes the \emph{next} move that means the position \emph{before} the move is + used. + As a default \cs{resumechessgame} continues the game. + +\begin{LTXexample}[width=0.5\textwidth,preset=\parskip1ex] + \newchessgame[id=main] + \mainline{1. e4 e5 2. Nf3 Nc6 3. Bb5} + + That reminds me another game + some years ago where I played + \newchessgame[id=exkurs] + \mainline{1. d4 Nf6 2. c4 e6} + \ldots\ lots of text \ldots\ + + Let's continue the second game with -- + as a reminder -- the last move of + black + \resumechessgame[id=exkurs,moveid=2b]% + \mainline{2... e6 3. Nc3} + + Let us now go back to the first game\\ + \resumechessgame[id=main,print, + tinyboard,showmover]% + \mainline{3... a6} +\end{LTXexample} + +\item[\key{newvar=}\meta{GameId}] + \index{resumechessgame=\verb!*+\resumechessgame+>newvar (key)}% + \index{newvar (\texttt{\textbackslash resumechessgame} key)}% + + This key moves you one halfmove back. + This can be used to write down a lot of variations. With the + (optional) value of the key you set the \meta{GameId}. If you don't + give a value the current meaning of \meta{GameId} is used. + +\begin{LTXexample}[width=0.5\textwidth,preset=\parskip1ex] + \newchessgame[id=main] + \mainline{1. e4 e5 2. Nf3 Nc6 3. Bb5} + + + \newchessgame[id=exkurs] + \mainline{1. d4 Nf6 2. c4 e6} + + \resumechessgame[newvar=main] + \mainline{3. Bc4} + + + \resumechessgame[newvar] + \mainline{3. Nc3} + \chessboard + + \xskakset{id=exkurs} + \resumechessgame[newvar] + \mainline{2... c5} + \chessboard + +\end{LTXexample} + +\item[\key{ref\ldots=}\meta{tag}] +The \meta{GameId} and start move can also be set with this keys which +use values saved with a \key{tag}. The keys are described in section +\ref{sec:labeling}. + +\end{description} + +\subsection{The stored information} + +The following lists describes all the types of information stored +during the parsing of a game. As you will see some data are stored +more than once with only slight differences. I did it because it is +easier to store the redundant data than to have to convert them +later. + +There are also commands which contains the \meta{GameId} and the +\meta{MoveId}. That looks a bit senseless as you need to know this +values to be able to retrieve them but they allow easy access to the +values without having to know or use the internal command names. + + +\subsubsection{Essential game related information} + +\begin{description} + +\item[\textbackslash Xskak\meta{GameId}initfen]% + \index{game data >Xskakinitfen=\textbackslash Xskak\meta{GameId}initfen}% + \index{Xskakinitfen=\textbackslash Xskak\meta{GameId}initfen}% + The position before the first move. Set by \cs{newchessgame}. + + +\item[\textbackslash Xskak\meta{GameId}initplayer]% + \index{game data >Xskakinitplayer=\textbackslash Xskak\meta{GameId}initplayer}% + \index{Xskakinitplayer=\textbackslash Xskak\meta{GameId}initplayer}% + «w» or «b». The color of the next (first) player, (must be identical + to the color in the initfen). Also set by \cs{newchessgame}. + +\item[\textbackslash Xskak\meta{GameId}initmovenr]% + \index{game data >Xskakinitmovenr=\textbackslash Xskak\meta{GameId}initmovenr}% + \index{Xskakinitmovenr=\textbackslash Xskak\meta{GameId}initmovenr}% + The number of the first move (must be identical to the fullmove + number in the initfen). Also set by \cs{newchessgame}. + +\item[\textbackslash Xskak\meta{GameId}initmoveid]% + \index{game data >Xskakinitmoveid=\textbackslash Xskak\meta{GameId}initmoveid}% + \index{Xskakinitmoveid=\textbackslash Xskak\meta{GameId}initmoveid}% + Combination of \key{initmovenr} and \key{initplayer}. + +\begin{LTXexample} + \newchessgame[id=show, + setfen=2K/k/7R, + moveid=10b, + print] + + \mbox{\xskakgetgame{initfen}},\\ + \xskakgetgame{initplayer}, + \xskakgetgame{initmovenr}, + \xskakgetgame{initmoveid} +\end{LTXexample} + + + +\item[\textbackslash Xskak\meta{GameId}lastfen]% + \index{game data >Xskaklastfen=\textbackslash Xskak\meta{GameId}lastfen}% + \index{Xskaklastfen=\textbackslash Xskak\meta{GameId}lastfen}% + The fen \emph{after} the last move, set during parsing. + +\item[\textbackslash Xskak\meta{GameId}lastplayer]% + \index{game data >Xskaklastplayer=\textbackslash Xskak\meta{GameId}lastplayer}% + \index{Xskaklastplayer=\textbackslash Xskak\meta{GameId}lastplayer}% + «w» or «b». The player which made the last move, set by + \cs{newchessgame}, by \cs{resumechessgame} and during + parsing. Identical to color in the fen \emph{before} the last + move! \emph{Not} identical to the color in {\texttt\textbackslash + Xskak\meta{GameId}lastfen}! + +\item[\textbackslash Xskak\meta{GameId}lastmovenr]% + \index{game data >Xskaklastmovenr=\textbackslash Xskak\meta{GameId}lastmovenr}% + \index{Xskaklastmovenr=\textbackslash Xskak\meta{GameId}lastmovenr}% + The number of the last move, set during parsing. Identical to + fullmove in the fen \emph{before} the last move! \emph{Not} + necessarily identical to the number in {\texttt\textbackslash + Xskak\meta{GameId}lastfen}! + +\item[\textbackslash Xskak\meta{GameId}lastmoveid]% + \index{game data >Xskaklastmoveid=\textbackslash Xskak\meta{GameId}lastmoveid}% + \index{Xskaklastmoveid=\textbackslash Xskak\meta{GameId}lastmoveid}% + Combination of \key{lastmovenr} and \key{lastplayer}. + +\begin{LTXexample} + \newchessgame[id=show, + setfen=2K/k/7R, + castling={}, + % sets correct castling in the FEN + moveid=10b] + \mainline{10... Ka8} + + \chessboard + + \mbox{\xskakgetgame{lastfen}},\\ + \xskakgetgame{lastplayer}, + \xskakgetgame{lastmovenr}, + \xskakgetgame{lastmoveid} +\end{LTXexample} + + +\item[\textbackslash Xskak\meta{GameId}nextplayer]% + \index{game data >Xskaknextplayer=\textbackslash Xskak\meta{GameId}nextplayer}% + \index{Xskaknextplayer=\textbackslash Xskak\meta{GameId}nextplayer}% + «w» or «b». The player which will make the next move, set by + \cs{newchessgame}, by \cs{resumechessgame} and during parsing. + Identical to the color in {\texttt\textbackslash Xskak\meta{GameId}lastfen}. + +\item[\textbackslash Xskak\meta{GameId}nextmovenr]% + \index{game data >Xskaknextmovenr=\textbackslash Xskak\meta{GameId}nextmovenr}% + \index{Xskaknextmovenr=\textbackslash Xskak\meta{GameId}nextmovenr}% + The number of the next move, set during parsing. Identical to + fullmove in {\texttt\textbackslash Xskak\meta{GameId}lastfen}. + +\item[\textbackslash Xskak\meta{GameId}nextmoveid]% + \index{game data >Xskaknextmoveid=\textbackslash Xskak\meta{GameId}nextmoveid}% + \index{Xskaknextmoveid=\textbackslash Xskak\meta{GameId}nextmoveid}% + Combination of \key{nextmovenr} and \key{nextplayer}. + +\begin{LTXexample}[width=0.5\textwidth] + \newchessgame[id=show, + setfen=2K/k/7R, + moveid=10b] + \mainline{10... Ka8} + + \chessboard + + \xskakgetgame{nextplayer}, + \xskakgetgame{nextmovenr}, + \xskakgetgame{nextmoveid} +\end{LTXexample} + + +\item[\textbackslash Xskak\meta{GameId}diagramlist]% + \index{game data >Xskakdiagramlist=\textbackslash Xskak\meta{GameId}diagramlist}% + \index{Xskakdiagramlist=\textbackslash Xskak\meta{GameId}diagramlist}% + A comma separated list of moves (a combination of movenr and + player), (e.g. 3b,20w). Records the moves with an \$d or \$D + after the move. See section \ref{sec:diagrams}. + + +\item[\textbackslash Xskak\meta{GameId}gameid]% + \index{game data >Xskakgameid=\textbackslash Xskak\meta{GameId}gameid}% + \index{Xskakgameid=\textbackslash Xskak\meta{GameId}gameid}% + This command holds the game identification (the value is equal to the value of \meta{GameId}). + +\begin{LTXexample} + \newchessgame[id=game\arabic{section}] + The id of the current game is \xskakgetgame{gameid} +\end{LTXexample} + + +\end{description} + + +\subsubsection{Optional game information: PGN-infos} + +\DescribeMacro{\xskaknewpgninfo}% +The following commands store various optional information which are +normally stored in the so-called PGN-infos. You can set them in +\cs{newchessgame} and retrieve them later. New PGN-infos can be +defined with the \cs{xskaknewpgninfo}\oarg{default}\marg{name}. With +the exception of «result» all currently defined commands are empty +by default. + +\begin{description} +\item[\textbackslash Xskak\meta{GameId}result]% + \index{PGN-info data >Xskakresult=\textbackslash Xskak\meta{GameId}result}% + \index{Xskakresult=\textbackslash Xskak\meta{GameId}result}% + Default is \verb+*+, value should be 1-0, or 1/2-1/2, 0-1 or + something like that. + +\item[\textbackslash Xskak\meta{GameId}white]% + \index{PGN-info data >Xskakwhite=\textbackslash Xskak\meta{GameId}white}% + \index{Xskakwhite=\textbackslash Xskak\meta{GameId}white}% + The name of the white player. + +\item[\textbackslash Xskak\meta{GameId}black]% + \index{PGN-info data >Xskakblack=\textbackslash Xskak\meta{GameId}black}% + \index{Xskakblack=\textbackslash Xskak\meta{GameId}black}% + The name of the black player. + + +\item[\textbackslash Xskak\meta{GameId}whiteelo]% + \index{PGN-info data >Xskakwhiteelo=\textbackslash Xskak\meta{GameId}whiteelo}% + \index{Xskakwhiteelo=\textbackslash Xskak\meta{GameId}whiteelo}% + The elo of the white player. + +\item[\textbackslash Xskak\meta{GameId}blackelo]% + \index{PGN-info data >Xskakblackelo=\textbackslash Xskak\meta{GameId}blackelo}% + \index{Xskakblackelo=\textbackslash Xskak\meta{GameId}blackelo}% + The elo of the black player. + + +\item[\textbackslash Xskak\meta{GameId}site]% + \index{PGN-info data >Xskaksite=\textbackslash Xskak\meta{GameId}site}% + \index{Xskaksite=\textbackslash Xskak\meta{GameId}site}% + The site of the tournament. + +\item[\textbackslash Xskak\meta{GameId}event]% + \index{PGN-info data >Xskakevent=\textbackslash Xskak\meta{GameId}event}% + \index{Xskakevent=\textbackslash Xskak\meta{GameId}event}% +The name of the tournament. + + + +\item[\textbackslash Xskak\meta{GameId}date]% + \index{PGN-info data >Xskakdate=\textbackslash Xskak\meta{GameId}date}% + \index{Xskakdate=\textbackslash Xskak\meta{GameId}date}% +The date of the game. + +\item[\textbackslash Xskak\meta{GameId}round]% + \index{PGN-info data >Xskakround=\textbackslash Xskak\meta{GameId}round}% + \index{Xskakround=\textbackslash Xskak\meta{GameId}round}% +The round of game. + +\end{description} + +\subsubsection{The move related data}\label{sec:movedata} + +The move data are stored during the parsing of a game with +\cs{mainline} and/or \cs{hidemoves}. You can split the game in as +much pieces as you want but {\bfseries you must start a game with +\cs{newchessgame} and you must use the same game identification for +each piece} if you don't want to end with broken games. + +All values depends on the parsing from \skaksty which in turn depends +heavily on the correct input: \skaksty knows a bit about the position +of the game (it needs it e.g. to find out where a piece came from) +but doesn't analyze it thoroughly. The main work is done by analyzing +the \emph{notation} e.g. \skaksty will recognize a check by the ++-sign. Quite often \skaksty doesn't recognize illegal moves or wrong +input syntax (e.g. \texttt{0-0} for casting instead the correct +\texttt{O-O}) but fails some moves later or shows a wrong position: + +\begin{LTXexample} + \newchessgame + \mainline{1.d4 e5 2.Bc4} + \chessboard +\end{LTXexample} + +\paragraph{Piece data} + +The following types store the piece which was moved and the piece +that was perhaps captured. The variants differ in the storing of +black pieces and pawns: + +\begin{description} +\item[pgnpiece] + \index{Move data >pgnpiece}% + \index{pgnpiece (move data type)}% + K,Q,R,B or N. Is empty for pawn and + castling moves. + +\item[piecechar] + \index{Move data >piecechar}% + \index{piecechar (move data type)}% + K,Q,R,B,N or p. Is empty for castling. + + +\item[piece] + \index{Move data >piece}% + \index{piece (move data type)}% + K,Q,R,B,N or P or k,q,r,b,n or p (for black). Is empty for castling. + + +\item[pgnlostpiece] + \index{Move data >pgnlostpiece}% + \index{pgnlostpiece (move data type)}% + In case of a capture move: K,Q,R,B, or N. + +\item[lostpiecechar] + \index{Move data >lostpiecechar}% + \index{lostpiecechar (move data type)}% + In case of a capture move: K,Q,R,B,N or p, empty + else. + + +\item[lostpiece] + \index{Move data >lostpiece}% + \index{lostpiece (move data type)}% + In case of a capture move it stores the lost piece as K,Q,R,B,N or P or + k,q,r,b,n or p. + +\end{description} + + +\paragraph{Move data} + +\begin{description} +\item[movefrom] + \index{Move data >movefrom}% + \index{movefrom (move data type)}% + The field were the piece came from. Two fields in case of castling moves e.g. «e1,h1». + +\item[pgnmovefrom] + \index{Move data >pgnmovefrom}% + \index{pgnmovefrom (move data type)}% + This contains the additional «movefrom» information in the PGN + for ambiguous moves or pawn captures. + E.g. In case of \wmove{exd5} the value is + «e», in case of \wmove{Nbd2} it is «b». + +\item[moveto] + \index{Move data >moveto}% + \index{moveto (move data type)}% + The field were the piece move to. Two fields in case of castling moves e.g. «g1,f1». + +\item[enpassant] + \index{Move data >enpassant}% + \index{enpassant (move data type)}% + Sets the boolean \texttt{xskakboolenpassant} to true if the move + was an enpassant capture. + +\item[enpassantsquare] + \index{Move data >enpassantsquare}% + \index{enpassantsquare (move data type)}% + A field, after e.g. e4 the value is e3. Indicates if the next + pawn move can be an enpassant capture. + +\begin{LTXexample} + \newchessgame[restorefen=example] + \mainline{1. a4 h5} + \chessboard[lastmoveid, + pgfstyle=border, + color=red, + markfield=\xskakget{enpassantsquare}, + moveid=1w, color=blue, + markfield=\xskakget{enpassantsquare}] +\end{LTXexample} + +\item[castling] + \index{Move data >castling}% + \index{castling (move data type)}% + Sets the boolean \texttt{xskakboolcastling}, is true for short + *and* long castling! + + +\item[longcastling] + \index{Move data >longcastling}% + \index{longcastling (move data type)}% + Sets the boolean \texttt{xskakboollongcastling}. + +\item[capture] + \index{Move data >capture}% + \index{capture (move data type)}% + Sets the boolean \texttt{xskakboolcapture}. + + +\item[promotion] + \index{Move data >promotion}% + \index{promotion (move data type)}% + Sets the boolean \texttt{xskakboolpromotion}. + + +\item[promotionpiece] + \index{Move data >promotionpiece}% + \index{promotionpiece (move data type)}% + Q,R,B or N or q,r,b or n or empty. + +\item[promotionpiecechar] + \index{Move data >promotionpiecechar}% + \index{promotionpiecechar (move data type)}% + Q,R,B or N or empty. + +\begin{LTXexample} + \newcommand\testpromotion{% + \xskakget{promotion}% + \ifthenelse{\boolean{xskakboolpromotion}} + {A pawn promoted to + \figsymbol{\xskakget{promotionpiecechar}}} + {No promotion in this move}} + \newchessgame[restorefen=example] + \mainline{1. c8=Q+ Ke7} + + \xskakset{moveid=1w} + \testpromotion + + \xskakset{moveid=1b} + \testpromotion +\end{LTXexample} + + +\end{description} + +\paragraph{Other data/combinations} + +\begin{description} +\item[addpieces] + \index{Move data >addpieces}% + \index{addpieces (move data type)}% + contains the (list of) piece(s) that should be put on the + board.\\ E.g. \verb+{kg8,rf8}+ in case of black short castling. + +\item[clearfields] + \index{Move data >clearfields}% + \index{clearfields (move data type)}% + The list of fields that should be emptied on the board (equal + to the movefrom field with the exception of enpassant moves). + +\item[nextfen] + \index{Move data >nextfen}% + \index{nextfen (move data type)}% + The fen position \emph{after} the current move. + +\item[pastfen] + \index{Move data >pastfen}% + \index{pastfen (move data type)}% + The fen position \emph{before} the current move (identical to + the fen \emph{after} the previous move). + +\item[san] + \index{Move data >san}% + \index{san (move data type)}% + The standard algebraic notation of the move. It use chess + commands: E.g. + \\\verb+\textsymfigsymbol{R}a2+ for \textsymfigsymbol{R}a2 + \\\verb+e\capturesymbol d5+ for e\capturesymbol d5, + \\\verb+\castlingchar\castlinghyphen\castlingchar+ for + \castlingchar\castlinghyphen\castlingchar\\ + It contains also the signs for chess and mate, but not the + comments. + +\item[lan] + \index{Move data >lan}% + \index{lan (move data type)}% + Long algebraic notation of the move, similar to \texttt{san}. + +\medskip +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \newchessgame + \mainline{1.f3 e5 2. g4?? Qh4+#!} + + \xskakset{moveid=2w}% + \xskakget{san}, \xskakget{lan} + + \xskakset{moveid=2b}% + \xskakget{san}, \xskakget{lan} +\end{LTXexample} + + + +\item[opennr] + \index{Move data >opennr}% + \index{opennr (move data type)}% + This contains the code to print the number like \skaksty would do + it if you start or continue a game with this move. The style must be set independantly either with + a \cs{styleX} of \packagename{skak} or -- if you use the new interface of + \packagename{xskak} to set a style -- with \cs{xskakset} and \cs{mainlinestyle} or \cs{variationstyle}. + +\medskip +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \newchessgame + \mainline{1.e4 e5} + + \xskakset{moveid=1w}% + \xskakget{opennr}\xskakget{lan}, + {\styleB\mainlinestyle + \xskakget{opennr}\xskakget{lan}} + + + \xskakset{moveid=1b}% + \xskakget{opennr}\xskakget{lan} + \xskakset{style=styleA,level=1} + {\mainlinestyle + \xskakget{opennr}\xskakget{lan}} + + \xskakset{style=UF}%return to my style +\end{LTXexample} + +\item[comments]% + \index{Move data >comments}% + \index{comments (move data type)}% + contains the short comments after a move (!,? \withattack{} etc) + +\medskip +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \newchessgame + \mainline{1.f3 e5 2. g4?? Qh4+#!} + + \xskakset{moveid=2w}% + \xskakget{comments} + + \xskakset{moveid=2b}% + \xskakget{comments} +\end{LTXexample} + + +\item[nag] + \index{Move data >nag}% + \index{nag (move data type)} + NAG's and comments inputed with \cs{xskakcomment}. + +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \newchessgame + \mainline{1.f3 e5 2. g4 + $4 \xskakcomment{ Why this? } Qh4+#!} + + \xskakset{moveid=2w}% + \xskakget{nag} +\end{LTXexample} + +\end{description} + +\subsection{Exporting the games} + +\DescribeMacro{\xskakexportgames}% +With \cs{xskakexportgames}\keyoarg{} you can export games to a file. +As default the command exports the game data of the game with the +default \meta{GameId} to the file \texttt{xskakgames.xsk}\footnote{I +didn't find any other application that use this extension. So I think +it is quite safe.}. + +The command accept the following keys: +\begin{description} +\item[\key{file=}\meta{string}] + \index{xskakexportgames=\verb!*+\xskakexportgames+>file (key)}% + \index{file (\texttt{\textbackslash xskakexportgames} key)} + This changes the name of the file. The extension can not be changed. +\item[\key{games=\{}\meta{comma separated list of games}\texttt{\}}] + \index{xskakexportgames=\verb!*+\xskakexportgames+>games (key)}% + \index{games (\texttt{\textbackslash xskakexportgames} key)}% + With this key you can chose the games that should be exported. +\end{description} + + +You can then input the games in other document and use there the game +data without have to do all the parsing with \cs{mainline} again +(which can be quite slow). The export file is also quite handy to +debug the game parsing and saving. + +As an example I exported in another document the following two games +which I will use later in this documentation: + +\begin{lstlisting} + \newchessgame[id=export,white=Deep Blue, black=Kasparov,result=1-0] + \mainline{1.e4 c6 2.d4 d5 3.Nc3 dxe4 4.Nxe4 Nd7 5.Ng5 Ngf6 6.Bd3 e6 + 7.N1f3 h6 8.Nxe6 Qe7 9.O-O fxe6 10.Bg6+ Kd8 \xskakcomment{Kasparov + schüttelt kurz den Kopf} 11.Bf4 b5 12.a4 Bb7 13.Re1 Nd5 14.Bg3 Kc8 + 15.axb5 cxb5 16.Qd3 Bc6 17.Bf5 exf5 18.Rxe7 Bxe7 19.c4} + + \newchessgame[white=none,black=none,id=exportb] + \mainline{1. e4 e5} + + \xskakexportgames[games={export,exportb}] +\end{lstlisting} + +\DescribeMacro{\xskakendgamedata}% +\DescribeMacro{\xskakcurrentgameid}% +The export consists more or less of a long list of definitions with +one notable exception: At the end of each game there is the command +\cs{xskakendgamedata}. As a default the command does nothing but if +you redefine it e.g. to \cs{printchessgame} (see section +\ref{sec:print}), it can be used to print all games during the input. +\cs{xskakcurrentgameid} holds the \meta{GameId} of the previous game. + +\begin{LTXexample} + \renewcommand\xskakendgamedata + {\xskakset{id=\xskakcurrentgameid}% + \xskakgetgame{white}--\xskakgetgame{black}: + \printchessgame[style=styleB,level=1] + \par\bigskip} + \input{xskakgames.xsk} +\end{LTXexample} + + + +\subsection{The inner technique: how the data are stored} + +The game related data are stored in commands with names of +the following structure:\\[0.5ex] +% +\indent{\ttfamily Xskak\meta{GameId}\meta{type of Information}}\\[0.5ex] +% +If \meta{GameId} is a simple string of characters you can use the +command by putting a backslash before the name, in other case you +will have to use \cs{csname}\ldots\cs{endcsname}. + +The move related data are stored in commands with names that +have the following structure:\\[0.5ex] +{\ttfamily Xskak.\meta{GameId}.\meta{movenr}.\meta{player}.\meta{type +of Information}}\\[0.5ex] +As the names contain points and a number it is not possible to +execute the commands by putting a backslash before the name. If you +want to use them you will have to surround the name by +\cs{csname}\ldots\cs{endcsname} + -- something that probably will not be necessary in normal cases as +there are user commands that allows «normal» access. + +During storing the data \meta{movenr} and \meta{player} are taken +from the current move as processed by \skaksty, that is +\verb+\mainline{15... Nf3}+ will store the data in \\{\ttfamily +Xskak.\meta{GameId}.15.b.\meta{type of Information}}. \\Renumbering +the moves during storing is not possible\footnote{But it would be +probably not difficult to implement. So if you need it badly, sent me +a feature request.}. + +Example \ref{ex:internal} on page \pageref{ex:internal} shows an +example that use the internal commands. As you can see, the +\cs{csname}--\cs{endcsname}-input is quite powerful: You can +construct a command with the help of other (expandable) commands or +use the value of counters. + +\minisec{Warning!} \verb+\csname whatever\endcsname+ doesn't give an +error if the command isn't defined. It simply defines \cs{whatever} +as \cs{relax} and then executes it. So it is easy to overlook typing +errors -- and then to wonder why one doesn't get the expected output. + + +\begin{LTXexample}[pos=t, + width=\textwidth, + float,caption=Using the internal commands, + label=ex:internal, + language=TeX, + texcs={mainline,figsymbol,xskakgameAlastmovenr, + xskakgameinitmovenr,xskakgameinitmovenr, + newchessgame,xskakgameinitmovenr,chessboard}, + texcsstyle=*\color{blue}, + texcs={[2]{ifthenelse,boolean,csname,endcsname,the,value,numexpr,relax}}, + texcsstyle={*[2]{\color{red}}}] + \begin{multicols}{2} + \minisec{Game 1}\newchessgame[id=gameA]% + \mainline{1. e4 e5 2. Nf3 Nc6 3. Bb5 Nf6 4. O-O Nxe4 5.Bxc6 bxc6} + + \minisec{Game 2}\newchessgame[id=game,restorefen=example,moveid=15w]% + \mainline{15. c8=Q+ Ke7 16. Rd1} + + \minisec{Comments}\setcounter{enumi}{1}% + In the first game, white moved at first a + \figsymbol{\csname Xskak.gameA.\the\value{enumi}.w.piecechar\endcsname}, + then a \figsymbol{% + \csname Xskak.gameA.\the\numexpr\the\value{enumi}+1\relax.w.piecechar\endcsname} + and a \figsymbol{% + \csname Xskak.gameA.\the\numexpr\the\value{enumi}+2\relax.w.piecechar\endcsname}. + In his last move black took a + \figsymbol{\csname Xskak.gameA.\XskakgameAlastmovenr.b.lostpiecechar\endcsname}, + white took a \figsymbol{\csname + Xskak.gameA.5.w.lostpiecechar\endcsname}. + + In the second game the second move of white was + \figsymbol{% + \csname Xskak.game.\the\numexpr \Xskakgameinitmovenr +1\relax.w.piece\endcsname}% + \csname Xskak.game.16.w.movefrom\endcsname--% + \csname Xskak.game.16.w.moveto\endcsname. + + The position in the first game after the third move of black was: + + \chessboard[tinyboard, setfen=\csname Xskak.gameA.3.b.nextfen\endcsname] + The fourth move of white was\csname + Xskak.gameA.4.w.castling\endcsname + \ifthenelse{\boolean{xskakboolcastling}}{}{not} a castling move. + \end{multicols} +\end{LTXexample} + +\clearpage + + +\section{Retrieving the stored information} + +\subsection{Setting the variables} + +\DescribeMacro{\xskakset}% +It should be clear that to retrieve the information you must tell +\packagename{xskak} the game and the move for which you want to get +data. This is done with \cs{xskakset}\keymarg{} which will set the +variables \meta{GameId} and/or \meta{MoveId} to the values listed in +the \keylist. + +Some possible\footnote{More keys are described later.} keys are: +\begin{description} +\item[\key{id=}\meta{name}] + \index{xskakset=\verb!*+\xskakset+>id (key)}% + \index{id (\texttt{\textbackslash xskakset} key)}% +The key will set/change globally the active game identification, the +\meta{GameId}. This will also affect the storing of the following +moves! So if you change the \meta{GameId} in the middle of the +parsing of a game, don't forget to reset it to the old value before +continuing! + + +\item[\key{movenr=}\meta{number}, \key{player=}\meta{«w» or «b»}, +\key{moveid=}\meta{number + «w» or «b»}] + \index{xskakset=\verb!*+\xskakset+>movenr (key)}% + \index{movenr (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>player (key)}% + \index{player (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>moveid (key)}% + \index{moveid (\texttt{\textbackslash xskakset} key)}% + The keys will set the move number and the player. The values are global but + the values of \key{movenr} and \key{player} are not expanded + directly while the value of \key{moveid} is. The keys change only + the internal commands that are used to retrieve information, the + move counter and the boolean of \cs{mainline} are not affected by this keys. + +\item[\key{stepmoveid=}\meta{number}] + \index{xskakset=\verb!*+\xskakset+>stepmoveid (key)}% + \index{stepmoveid (\texttt{\textbackslash xskakset} key)}% +\key{stepmoveid} picks up the current value of the move variables of +\packagename{xskak} and «adds» the given number of halfmoves. When no +number is given the value 1 is used and this gives the next move. +E.g. if the current move is \texttt{10w} and you use +\texttt{stepmoveid=3} then you get \texttt{11b}. Negative numbers can +be used, if this results in a move number smaller than 1, a warning +is given but not an error: This gives you the possibility e.g. in +loops to handle the case yourself. + + + +\item[\key{lastmoveid=}\meta{GameId}] + \index{xskakset=\verb!*+\xskakset+>lastmoveid (key)}% + \index{lastmoveid (\texttt{\textbackslash xskakset} key)}% + This key sets the \packagename{xskak} move identification + commands + to the number/color of the last move + of the game \meta{GameId}. \meta{GameId} is optional. + \texttt{lastmoveid=A} ist equivalent to + \texttt{id=A,lastmoveid}. + + + + +\item[\key{tag=}\meta{name}, \key{ref\ldots=}\meta{name}] + \index{xskakset=\verb!*+\xskakset+>tag (key)}% + \index{tag (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refid (key)}% + \index{refid (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refnextmoveid(key)}% + \index{refnextmoveid (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refpastmoveid(key)}% + \index{refpastmoveid (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refpastmovenr (key)}% + \index{refpastmovenr (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refpastplayer (key)}% + \index{refpastplayer (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refnextmovenr (key)}% + \index{refnextmovenr (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refnextplayer (key)}% + \index{refnextplayer (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refpast (key)}% + \index{refpast (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refnext (key)}% + \index{refnext (\texttt{\textbackslash xskakset} key)}% + + +\key{tag} saves the current values of \meta{GameId} and the move in +internal commands. They can then later be retrieved by the keys of +type \key{ref}. + +For more information on the labeling and referencing see section +\ref{sec:labeling}. + +\item[\key{defaultid=}\meta{name}] + \index{xskakset=\verb!*+\xskakset+>defaultid (key)}% + \index{defaultid (\texttt{\textbackslash xskakset} key)}% + With this key you can change the default game identification. + The change is global. + +\begin{LTXexample} + \setcounter{gamecounter}{4} + \xskakset{defaultid=game\Alph{gamecounter}} + + \newchessgame[white=John] + \mainline{1. e4 e5} + + \stepcounter{gamecounter} + \newchessgame[white=Jack] + \mainline{1. d4 d5} + + The white players were \XskakgameDwhite\ and \XskakgameEwhite. +\end{LTXexample} + + +\item[\key{defaultmovenr=}\meta{number}, + \key{defaultplayer=}\meta{«w» or «b»},] +\item[\key{defaultmoveid=}\meta{number}\meta{«w» or «b»}] + \index{xskakset=\verb!*+\xskakset+>defaultmoveid (key)}% + \index{defaultmoveid (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>defaultmovenr (key)}% + \index{defaultmovenr (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>defaultplayer (key)}% + \index{defaultplayer (\texttt{\textbackslash xskakset} key)}% + With this keys you can change the default start move for the + subsequent games. The change is global. + +\item[\key{defaultfen=}\meta{FEN}] + \index{xskakset=\verb!*+\xskakset+>defaultfen (key)}% + \index{defaultfen (\texttt{\textbackslash xskakset} key)}% + As a default \cs{newchessgame} sets the start position to a new + game. You can change this default with this key. The change is + global. + +\end{description} + + + +\subsection{Getting the game information} + +\DescribeMacro{\xskakgetgame}% +With \cs{xskakgetgame}\marg{type} you can retrieve game data +for the currently active \meta{GameId} (which can be set/changed with +the commands \cs{newchessgame}, \cs{resumechessgame} and +\cs{xskakset}). + +\begin{LTXexample}[width=0.5\textwidth] + \newchessgame[id=A,white=John White, + black=Jack Black, + result=1--0] + \minisec{\xskakgetgame{white}-- + \xskakgetgame{black}} + \mainline{1.e4 e5 2.Bc4 Nc6 3. Qh5 Nf6 4.Qxf7#} + \mbox{\xskakgetgame{result}} + + + \newchessgame[id=B, + white=Harry Red, + black=Tom Green, + result=0--1, + setwhite={kd1}, + addblack={kd3,rc5}] + \chessboard[setfen={\xskakgetgame{initfen}}] + \minisec{\xskakgetgame{white} -- + \xskakgetgame{black}} + \mainline{1. Ke1 Rf5 2. Kd1 Rf1#} \mbox{\xskakgetgame{result}} +\end{LTXexample} + +It is also possible to get the stored information by simply calling +the command\\ \cs{xskak}\meta{gameid}\meta{type} (if \meta{gameid} +consists of letters). + +\begin{LTXexample}[width=0.5\textwidth] + \newchessgame[id=A,white=John White, + black=Jack Black, result=1--0] + \minisec{\XskakAwhite\ -- \XskakAblack} + \mainline{1.e4 e5 2.Bc4 Nc6 3. Qh5 Nf6 4.Qxf7#} + \mbox{\XskakAresult} + \newchessgame[id=B,white=Harry Red, + black=Tom Green, result=0--1] + \minisec{\XskakBwhite\ -- \XskakBblack} + \mainline{1.f3 e5 2.g4 Qh4#} + \mbox{\XskakBresult} + + \minisec{List of Results} + \begin{tabular}[t]{l@{\,--\,}lr} + \XskakAwhite&\XskakAblack&\XskakAresult\\ + \XskakBwhite&\XskakBblack&\XskakBresult + \end{tabular} + + \minisec{Final positions} + \chessboard[tinyboard,lastmoveid=A, + setfen=\xskakget{nextfen}] + \chessboard[tinyboard,lastmoveid=B, + setfen=\xskakget{nextfen}] +\end{LTXexample} + +%If \meta{gameid} contains non-letter chars (e.g. a number) you must +%use\\ +%\cs{csname}\texttt{~xskak}\meta{gameid}\meta{type}\cs{endcsname}. +% +%If the \meta{gameid} or the \meta{type} are stored in commands you +%can use this commands in \cs{csname}\texttt{\ldots}\cs{endcsname}: +%\cs{csname}\texttt{~xskak}\cs{mygameid}\cs{mygametype}\cs{endcsname} + + + +\subsection{Getting the move information} + +Move data are bit more difficult as they depend on more +variables. + +At first, you can naturally use a +\cs{csname}\texttt{\ldots}\cs{endcsname}:\\ +\cs{csname}\texttt{~xskak}.\meta{gameid}.\meta{movenr}.\meta{player}.\meta{type}\cs{endcsname}. + + +But normally you should use a +\cs{xskakset}/\cs{xskakget}-combination% +\footnote{I had to implement the retrieving as a two-step-method to + be able to use the retrieving command in the \keylist of +\cs{chessboard}. As the values are expanded during + the processing complicated commands which use internally \cs{def} + and \cs{setkeys} can not be used as values.}. + + +\DescribeMacro{\xskakget}% +\cs{xskakget}\marg{type} will pick up the current values of the +variables for the \meta{GameId} and the \meta{MoveId} and then +retrieve/print the content of type \meta{type}. + + \index{Move data >movenr (virtual type)}% + \index{movenr (virtual move data type)}% + \index{Move data >moveid (virtual type)}% + \index{moveid (virtual move data type)}% + \index{Move data >player (virtual type)}% + \index{player (virtual move data type)}% +\meta{type} can be any of the types described in \ref{sec:movedata} +and additionally the three virtual types \textsf{movenr}, +\textsf{player} and \textsf{moveid} can be used which will output the +current move identification. This allows easier retrieving of the +current value of the internal variables e.g. in loops and tests. + +\textbf{Attention:} The move variables are not changed by the parsing +command of \skaksty. And they are not stored like the other types -- +you can't retrieve them with a +\cs{csname}\texttt{\ldots}\cs{endcsname} construction. + +\begin{LTXexample} +\newchessgame[moveid=10b] +\mainline{10... e5} + +The game started with move \xskakget{moveid}. + +\xskakset{moveid=5w} +Now the moveid has value \xskakget{movenr}\xskakget{player}. +\end{LTXexample} + + + +\subsection{Using the data with \texttt{\textbackslash chessboard}} + +The move data can naturally be used with \cs{chessboard} e.g. to +highlight the last move with an arrow. The \meta{MoveId} you want to +refer to can be set before the board with \cs{xskakset} but if this +were the sole possibility this would mean that you couldn't get data +from other moves. So I defined a bunch of new keys for +\cs{chessboard} (and changed some existing keys) which allows to +retrieve during building the board all available move datas. The most +important ones are keys that tells \cs{chessboard} the \meta{GameId} +and the \meta{MoveId} for which you want to retrieve datas: + +\begin{description} +\item[\key{id=}\meta{name}] + \index{chessboard=\verb!*+\chessboard+>id (key)}% + \index{movenr (\texttt{\textbackslash chessboard} key)}% + Like the other \key{id}-keys this one sets the variable that + identifies the game. But setting this key will \emph{not} affect + the value of the game identification outside the board, any + change is local to the board. + +\textbf{Attention:} Setting this key will \emph{not} change the +default position shown by \cs{chessboard}. This is always the +«current» game. + +\item[\key{movenr=}\meta{number}, \key{player=}\meta{«w» or «b»}, \key{moveid=}\meta{number + «w» or «b»}] + \index{chessboard=\verb!*+\chessboard+>movenr (key)}% + \index{movenr (\texttt{\textbackslash chessboard} key)}% + \index{chessboard=\verb!*+\chessboard+>player (key)}% + \index{player (\texttt{\textbackslash chessboard} key)}% + \index{chessboard=\verb!*+\chessboard+>moveid (key)}% + \index{moveid (\texttt{\textbackslash chessboard} key)}% + This keys stores the number and player for which you want to retrieve + move related information. Again any setting is local to the board. + + + +\item[\key{stepmoveid=}\meta{number}] + \index{xskakset=\verb!*+\chessboard+>stepmoveid (key)}% + \index{stepmoveid (\texttt{\textbackslash chessboard} key)}% +Like the similar key of \cs{xskakset} \key{stepmoveid} picks up the +current value of the move variables of \packagename{xskak} and «adds» +the given number of halfmoves. But again when you use the key in the +argument of \cs{chessboard} the change is local to the board. + +\textbf{Attention:} If you set the \meta{MoveId} with the above keys +to a value «outside» the game and then try to retrieve a data you +will probably get horrible errors. + + +\item[\key{lastmoveid=}\meta{gameid}] + \index{chessboard=\verb!*+\chessboard+>lastmoveid (key)}% + \index{lastmoveid (\texttt{\textbackslash chessboard} key)} +The usual case is probably that you want to use the (currently) last +move of a game. This can be done with this key. The (optional) value +lets you specify a game identification. \texttt{lastmoveid=A} ist +equivalent to \texttt{id=A,lastmoveid}. Again the setting is local to +the board. + +\end{description} + + \index{xskakget=\verb!*+\xskakget+ (with \texttt{\textbackslash chessboard})}% +After you have set the move variables, you can use the command +\cs{xskakget}\marg{type} described above used without +problems\footnote{I hope but I haven't tested any possible usage.} +inside \cs{chessboard} as long as the value expands to something the +keys can handle (\key{markmove} e.g. will not like it if you ask it +to process a fen). + +\begin{LTXexample}[width=0.4\textwidth] + \newchessgame[id=A,white=John White, + black=Jack Black, result=1--0] + \mainline{1.e4 e5 2.Bc4 Nc6 3. Qh5 Nf6 4.Qxf7#} + + \newchessgame % a game between A and the board + \mainline{1.e4} + + \setchessboard{shortenend=5pt,color=red}% + \chessboard[lastmoveid=A,setfen=\xskakget{nextfen}, + pgfstyle=border,color=red, + markfields={\xskakget{moveto},\xskakget{movefrom}}, + pgfstyle=straightmove, + markmove=\xskakget{movefrom}-\xskakget{moveto}] +\end{LTXexample} + + +\begin{LTXexample}[width=0.4\textwidth,escapechar=/] + \newchessgame[id=A] + \mainline{1.e4 e5 2.Bc4 Nc6 3. Qh5 Nf6 4.Qxf7#} + + \xskakget{moveid}% to show /\meta{MoveId} is still 1w/ + + \setchessboard{shortenend=5pt,color=red}% + \chessboard[lastmoveid=A,setfen=\xskakget{nextfen}, + moveid=1w, + pgfstyle=straightmove, + markmove=\xskakget{movefrom}-\xskakget{moveto}, + stepmoveid=2,color=green, + markmove=\xskakget{movefrom}-\xskakget{moveto}, + stepmoveid=2,color=blue, + markmove=\xskakget{movefrom}-\xskakget{moveto}, + stepmoveid=2,color=yellow, + markmove=\xskakget{movefrom}-\xskakget{moveto}] + +\xskakget{moveid}% to show that /\meta{MoveId} is again 1w/ +\end{LTXexample} + + +\subsection{Labeling a game}\label{sec:labeling} + +It is a bit tedious to have to remember the number and the color of +the moves when you want to start or to continue a game, or for which +you want to draw a diagram or retrieve another move information. So +there is a sort of labeling system. In difference to the labeling in +normal \LaTeX\ it doesn't write the values to auxiliary files. That +means that you can't reference labels which come later in the +document (at my opinion this would lead to chaos anyway). + + + +To set a label you use the command \cs{xskakset} with the key +\key{tag}\footnote{The name «label» is used by \cs{chessboard} to set +the labels of the boards.}.% + \index{xskakset=\verb!*+\xskakset+>tag (key)}% + \index{tag (\texttt{\textbackslash xskakset} key)} +It saves the current value of the move counter (the +\packagename{skak} counter!), the value of the (\packagename{skak}!) +boolean that holds the player and the \meta{GameId}. If you haven't +started any game yet (more precisely: if the move counter has value +0) then \xskak will issue a warning and do nothing. + +You can set the tag between two \cs{mainline} (or \cs{hidemoves}) +commands, but it works also if you put them directly in the argument +of \cs{mainline}: + +\begin{LTXexample} + \newchessgame% + \mainline{1. e4 e5\xskakset{tag=A} + 2. Nf3\xskakset{tag=B} Nc6 + 3. Bb5 Nf6 + 4. O-O Nxe4 + 5.Bxc6 bxc6} + +\end{LTXexample} + + +The saved values can be retrieved with various keys of type \key{ref} +(e.g. \key{refpastmoveid}, \key{refnextplayer}), or by the command +\cs{xskakget}. + +The label is set in most cases between two moves. There probably will +be cases when you need the \meta{MoveId} of the move \emph{before} +the tag e.g. to show the position or to comment on the last move, and +there will be cases when you will need the \meta{MoveId} of the move +\emph{after} the tag e.g. to continue the game. So there are ref-keys +for both cases. + +\subsubsection{Retrieving the tagged values with \texttt{\textbackslash +xskakget}} + +Retrieving the \meta{GameId} and/or \meta{MoveId} values stored by a +\key{tag} is again a more-than-one-step procedure: At first you must +tell \packagename{xskak} the tag name you want to use, and then use a +\cs{xskakget}\marg{list of ref types}, where \meta{ref type} is one +of the following keywords: {\ttfamily refid, refpastmoveid, +refnextmoveid, refpastmovenr, refnextmovenr, refpastplayer, +refnextplayer}. + + + \index{resumechessgame=\verb!*+\resumechessgame+>reftag (key)}% + \index{reftag (\texttt{\textbackslash resumechessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>reftag (key)}% + \index{reftag (\texttt{\textbackslash newchessgame} key)}% + \index{xskakset=\verb!*+\xskakset+>reftag (key)}% + \index{reftag (\texttt{\textbackslash xskakset} key)}% + \index{xskakloop=\verb!*+\xskakloop+>reftag (key)}% + \index{reftag (\texttt{\textbackslash xskakloop} key)}% + \index{printchessgame=\verb!*+\xskakloop+>reftag (key)}% + \index{reftag (\texttt{\textbackslash printchessgame} key)}% + \index{chessboard=\verb!*+\chessboard+>reftag (key)}% + \index{reftag (\texttt{\textbackslash chessboard} key)}% +Setting the tag name is done with the key \key{reftag}, which you can +use with all commands that accept the key \key{id}. If you use the +key in the optional argument of \cs{chessboard} it will change the +tag name locally for the board. In all other cases the tag name is +set globally. + +\begin{LTXexample}[escapechar=/] + \newchessgame[id=new] % to set a new id + \chessboard[ + reftag=B,%from previous example + id=\xskakget{refid}, + %retrieves and sets the /\meta{Gameid}/ from tag B + moveid=\xskakget{refnextmoveid}, + %retrieves and sets the /\meta{Moveid}/ from tag B + setfen=\xskakget{pastfen}] +\end{LTXexample} + + +\subsubsection{The \key{ref}-keys} + +As the more-step-procedure to use the tags is a bit longuish there +exist keys that shorten the procedure. This keys too work in the +arguments of all commands that can also handle the correspondant keys +\key{id}, \key{moveid} etc. The effect will be identical to setting +the values directly: Keys used in the optional argument of +\cs{chessboard} will set their values only local to the board, in the +other cases the values are set globally. + +\begin{description} +\item[\key{refid=}\meta{tag}] + \index{resumechessgame=\verb!*+\resumechessgame+>refid (key)}% + \index{refid (\texttt{\textbackslash resumechessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>refid (key)}% + \index{refid (\texttt{\textbackslash newchessgame} key)}% + \index{xskakset=\verb!*+\xskakset+>refid (key)}% + \index{refid (\texttt{\textbackslash xskakset} key)}% + \index{xskakloop=\verb!*+\xskakloop+>refid (key)}% + \index{refid (\texttt{\textbackslash xskakloop} key)}% + \index{chessboard=\verb!*+\chessboard+>refid (key)}% + \index{refid (\texttt{\textbackslash chessboard} key)}% + +This key will set the \meta{GameId} to the value stored in the tag. +It is a shortcut for\\ +\key{reftag=}\meta{tag},\key{id=}\cs{xskakget}verb+{refid}+ + + +\item[\key{refpastmoveid=}\meta{tag}, \key{refpastmovenr=}\meta{tag}, \key{refpastplayer=}\meta{tag} ] + \index{resumechessgame=\verb!*+\resumechessgame+>refpastmoveid (key)}% + \index{refpastmoveid (\texttt{\textbackslash resumechessgame} key)}% + \index{resumechessgame=\verb!*+\resumechessgame+>refpastmovenr (key)}% + \index{refpastmovenr (\texttt{\textbackslash resumechessgame} key)}% + \index{resumechessgame=\verb!*+\resumechessgame+>refpastplayer (key)}% + \index{refpastplayer (\texttt{\textbackslash resumechessgame} key)}% + % + \index{newchessgame=\verb!*+\newchessgame+>refpastmovenr (key)}% + \index{refpastmovenr (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>refpastmoveid (key)}% + \index{refpastmoveid (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>refpastplayer (key)}% + \index{refpastplayer (\texttt{\textbackslash newchessgame} key)}% + % + \index{xskakset=\verb!*+\xskakset+>refpastmoveid (key)}% + \index{refpastmoveid (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refpastmovenr (key)}% + \index{refpastmovenr (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refpastplayer (key)}% + \index{refpastplayer (\texttt{\textbackslash xskakset} key)}% + % + \index{chessboard=\verb!*+\chessboard+>refpastmoveid (key)}% + \index{refpastmoveid (\texttt{\textbackslash chessboard} key)}% + \index{chessboard=\verb!*+\chessboard+>refpastmovenr (key)}% + \index{refpastmovenr (\texttt{\textbackslash chessboard} key)}% + \index{chessboard=\verb!*+\chessboard+>refpastplayer (key)}% + \index{refpastplayer (\texttt{\textbackslash chessboard} key)}% + + +This keys will set the respective move information to the value of +the move before the tag. If the tag is before the move 1w, then the +value 0b is used. + +\item[\key{refnextmoveid=}\meta{tag}, \key{refnextmovenr=}\meta{tag}, \key{refnextplayer=}\meta{tag} ] + \index{resumechessgame=\verb!*+\resumechessgame+>refnextmoveid (key)}% + \index{refnextmoveid (\texttt{\textbackslash resumechessgame} key)}% + \index{resumechessgame=\verb!*+\resumechessgame+>refnextmovenr (key)}% + \index{refnextmovenr (\texttt{\textbackslash resumechessgame} key)}% + \index{resumechessgame=\verb!*+\resumechessgame+>refnextplayer (key)}% + \index{refnextplayer (\texttt{\textbackslash resumechessgame} key)}% + % + \index{newchessgame=\verb!*+\newchessgame+>refnextmovenr (key)}% + \index{refnextmovenr (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>refnextmoveid (key)}% + \index{refnextmoveid (\texttt{\textbackslash newchessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>refnextplayer (key)}% + \index{refnextplayer (\texttt{\textbackslash newchessgame} key)}% + % + \index{xskakset=\verb!*+\xskakset+>refnextmoveid (key)}% + \index{refnextmoveid (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refnextmovenr (key)}% + \index{refnextmovenr (\texttt{\textbackslash xskakset} key)}% + \index{xskakset=\verb!*+\xskakset+>refnextplayer (key)}% + \index{refnextplayer (\texttt{\textbackslash xskakset} key)}% + % + \index{chessboard=\verb!*+\chessboard+>refnextmoveid (key)}% + \index{refnextmoveid (\texttt{\textbackslash chessboard} key)}% + \index{chessboard=\verb!*+\chessboard+>refnextmovenr (key)}% + \index{refnextmovenr (\texttt{\textbackslash chessboard} key)}% + \index{chessboard=\verb!*+\chessboard+>refnextplayer (key)}% + \index{refnextplayer (\texttt{\textbackslash chessboard} key)}% + + +This keys will set the respective move information to the value of +the move after the tag. + +\item[\key{refpast=}\meta{tag}, \key{refnext=}\meta{tag}] + \index{resumechessgame=\verb!*+\resumechessgame+>refpast (key)}% + \index{refpast (\texttt{\textbackslash resumechessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>refpast (key)}% + \index{refpast (\texttt{\textbackslash newchessgame} key)}% + \index{xskakset=\verb!*+\xskakset+>refpast (key)}% + \index{refpast (\texttt{\textbackslash xskakset} key)}% + \index{resumechessgame=\verb!*+\resumechessgame+>refnext (key)}% + \index{refnext (\texttt{\textbackslash resumechessgame} key)}% + \index{newchessgame=\verb!*+\newchessgame+>refnext (key)}% + \index{refnext (\texttt{\textbackslash newchessgame} key)}% + \index{xskakset=\verb!*+\xskakset+>refnext (key)}% + \index{refnext (\texttt{\textbackslash xskakset} key)}% + \index{chessboard=\verb!*+\chessboard+>refpast (key)}% + \index{refpast (\texttt{\textbackslash chessboard} key)}% + \index{chessboard=\verb!*+\chessboard+>refnext (key)}% + \index{refnext (\texttt{\textbackslash chessboard} key)}% + + +This keys will set the \meta{GameId} and the \meta{MoveId} in one go. +E.g. \key{refpast} is a shortcut for\\ +\key{reftag=}\meta{tag},\key{id=}\cs{xskakget}verb+{refid}+,\key{moveid=}\cs{xskakget}verb+{refpastmoveid}+ + + + + +\item[\key{reffen=}\meta{tag}] + \index{chessboard=\verb!*+\chessboard+>reffen (key)}% + \index{reffen (\texttt{\textbackslash chessboard} key)}% + \index{newchessgame=\verb!*+\newchessgame+>reffen (key)}% + \index{reffen (\texttt{\textbackslash newchessgame} key)}% + +This is a \cs{chessboard} key. It will add the position at the tag on +the board, its effect is identical to using the key {\ttfamily +addfen =}\meta{Position at tag} described in the documentation of +\pchessboard. So be aware that it really only places pieces on the +board. It will not change the \meta{GameId} nor the \meta{MoveId} or +the move counter of \packagename{skak}. So it is quite possible to +use a position where black should move next to start a game with +white to move. + + +\begin{LTXexample} + \newchessgame[id=new]% to set a new id + \chessboard[reffen=B] +\end{LTXexample} + + + + +\begin{LTXexample} + \newchessgame[id=A]% + \mainline{1.e4 e5 2. Nf3\xskakset{tag=C} Nc6 + 3. Bb5 Nf6 4. O-O Nxe4 5.Bxc6 bxc6} + + + \newchessgame[id=B,reffen=C] + \mainline{1. Nc3} + + \chessboard + + \chessboard[reffen=C, + markstyle=circle, + color=red, + %from game B: + markfield=\xskakget{movefrom}, + refpast=C, + color=green, + %from game A: + markfield=\xskakget{movefrom}] +\end{LTXexample} +\end{description} + +\section{Looping} + +Looping with the \cs{whiledo} command of the package +\packagename{ifthen} is not very difficult. But to adjust to the +special numbering of chessmoves (1w, 1b, 2w, 2b, 3w \ldots) one needs +some special commands to step through the moves and test for the end +of the loop. + +\DescribeMacro{\xskaktestmoveid}% +Stepping can be done with the key \key{stepmoveid} described +earlier.\\ \cs{xskaktestmoveid}\marg{movenr}\marg{player} is a test +(defined with the help of package \packagename{xifthen}) which you +can use in the first argument of \cs{whiledo}. It will give true if +the move is in the current game. + +\begin{LTXexample} + \newchessgame[id=A] + \mainline{1. e4 e5 2. Nf3 Nf6} + + \newchessgame[id=B] + (a second game) + + Reprinting the first game: + \xskakset{id=A, + moveid=\xskakgetgame{initmoveid}} + \whiledo{\xskaktestmoveid + {\xskakget{movenr}}{\xskakget{player}}} + {\ifthenelse% + {\equal{\xskakget{player}}{w}} + { \xskakget{movenr}.\,} + { }% + \xskakget{lan}% + \xskakset{stepmoveid}} + + Reprinting only the black moves: + \xskakset{% + id=A, + moveid=\xskakgetgame{initmoveid},stepmoveid} + \whiledo{\xskaktestmoveid + {\xskakget{movenr}}{\xskakget{player}}} + { \xskakget{lan}% + \xskakset{stepmoveid=2}} +\end{LTXexample} + + +\DescribeMacro{\xskakloop}% +\cs{xskakloop}\keyoarg\marg{code} is a wrapper command for such a +\cs{whiledo} loop. + +The possible keys are: + +\begin{description} +\item[\key{id=}\meta{string}] + \index{xskakloop=\verb!*+\xskakloop+>id (key)}% + \index{id (\texttt{\textbackslash xskakloop} key)}% + Which sets the game identification. The setting is global. + +\item[\key{initmovenr=}\meta{number}, \key{initplayer=}\meta{«w» or «b»}, +\key{initmoveid=}\meta{number + «w» or «b»}] + \index{xskakloop=\verb!*+\xskakloop+>initmovenr (key)}% + \index{initmovenr (\texttt{\textbackslash xskakloop} key)}% + \index{xskakloop=\verb!*+\xskakloop+>initplayer (key)}% + \index{initplayer (\texttt{\textbackslash xskakloop} key)}% + \index{xskakloop=\verb!*+\xskakloop+>initmoveid (key)}% + \index{initmoveid (\texttt{\textbackslash xskakloop} key)}% + This sets the move the loop should start with. Default is the + first move of the game. + +\item[\key{stopmovenr =}\meta{number}, \key{stopplayer =}\meta{«w» or «b»}, +\key{stopmoveid=}\meta{number + «w» or «b»}] + \index{xskakloop=\verb!*+\xskakloop+>stopmovenr (key)}% + \index{stopmovenr (\texttt{\textbackslash xskakloop} key)}% + \index{xskakloop=\verb!*+\xskakloop+>stopplayer (key)}% + \index{stopplayer (\texttt{\textbackslash xskakloop} key)}% + \index{xskakloop=\verb!*+\xskakloop+>stopmoveid (key)}% + \index{stopmoveid (\texttt{\textbackslash xskakloop} key)}% + This sets the move where the loop should stop. Default is the + last move of the game. + +\item[\key{step=}\meta{number}] + \index{xskakloop=\verb!*+\xskakloop+>step (key)}% + \index{step (\texttt{\textbackslash xskakloop} key)}% + This sets the length of the steps of the loop. The number gives the number of + halfmoves. Default is one. + + +\item[\key{showlast=}\meta{true|false}] + \index{xskakloop=\verb!*+\xskakloop+>showlast (key)}% + \index{showlast (\texttt{\textbackslash xskakloop} key)}% + When you are using the key \key{step} with a number unequal to + one, it is possible that the last move (possibly set by + \key{stopmoveid}) is left out. With the key \key{showlast} you can force \cs{xskakloop} to process + the code for the last move. +\end{description} + + +\begin{LTXexample}[pos=t,width=\textwidth] + \newchessgame + \mainline{% + 1.d4 Nf6 2.c4 g6 3.Nc3 Bg7 4.e4 d6 5.Nge2 O-O 6.Ng3 c6 7.Be2 a6 8.a4 + a5 9.h4 h5 10.Be3 Na6 11.f3 e5 12.d5 Nd7 13.Nf1 Ndc5 14.Nd2 Qb6 + 15.Qb1 Nb4 16.Nb3 Ncd3+ 17.Kd2 Qxe3+} + + \xskakloop[step=6,showlast]{% + \begin{tabular}{c} + \chessboard[tinyboard, + setfen=\xskakget{nextfen}] + \\ + \xskakget{opennr}\xskakget{lan}% + \end{tabular}\quad}% +\end{LTXexample} + +With the help of the package \packagename{animate} and \cs{xskakloop} +you can make animated boards:\mynobreakpar +\begingroup + \setchessboard{boardfontsize=0.8cm,shortenend=5pt, margin=false}% + \setboardfontencoding{LSBC4}% + \newskaklanguage{german}{KDTLSB}\skaklanguage[german]% + % + \newcommand\getmovestyle[1]{% + \ifthenelse + {\equal{#1}{N}}%knight move + {\def\mymovestyle{[clockwise=false,style=knight]curvemove}} + {\ifthenelse + {\equal{#1}{}}% castling + {\def\mymovestyle{curvemove}} + {\def\mymovestyle{straightmove}}}}% + % + \newchessgame[white=Paethz,black=Dirr,result=0-1,id=anim]% + \hidemoves{% + 1.d4 Sf6 2.c4 g6 3.Sc3 Lg7 4.e4 d6 5.Sge2 O-O + 6.Sg3 c6 7.Le2 a6 8.a4 a5 9.h4 h5 10.Le3 Sa6 + 11.f3 e5 12.d5 Sd7 13.Sf1 Sdc5 14.Sd2 Db6 + 15.Db1 Sb4 16.Sb3 Scd3+ 17.Kd2 Dxe3+}% + % + \unitlength0.8cm\relax + \begin{animateinline}[autoplay,loop,controls]{0.5}% + \begin{picture}(11,11) + \put(1.5,1.5){\chessboard[setfen=\xskakgetgame{initfen}]}% + \end{picture} + \newframe + \xskakloop{% + \getmovestyle{\xskakget{piecechar}}% + \begin{picture}(11,11) + \put(1.5,1.5){% + \chessboard[pgfstyle=\mymovestyle, color=blue, + pgfshortenend=0.3em,arrow=to, + markmoves=\xskakget{move}, + coloremph,piececolor=blue, + emphfields={\xskakget{moveto}}, + setfen=\xskakget{nextfen}]}% + \end{picture}% + \newframe}% + \begin{picture}(11,11) + \put(1.5,1.5){\chessboard[setfen=\xskakgetgame{lastfen}]}% + \end{picture} + \end{animateinline} +\endgroup + +\bigskip +The board was made with the following code: + +\begin{lstlisting} + \setchessboard{boardfontsize=0.8cm,shortenend=5pt, margin=false}% + \setboardfontencoding{LSBC4}% + \newskaklanguage{german}{KDTLSB}\skaklanguage[german]% + % + \newcommand\getmovestyle[1]{% + \ifthenelse + {\equal{#1}{N}}%knight move + {\def\mymovestyle{[clockwise=false,style=knight]curvemove}} + {\ifthenelse + {\equal{#1}{}}% castling + {\def\mymovestyle{curvemove}} + {\def\mymovestyle{straightmove}}}}% + % + \newchessgame[white=Paethz,black=Dirr,result=0-1,id=anim]% + \hidemoves{% + 1.d4 Sf6 2.c4 g6 3.Sc3 Lg7 4.e4 d6 5.Sge2 O-O + 6.Sg3 c6 7.Le2 a6 8.a4 a5 9.h4 h5 10.Le3 Sa6 + 11.f3 e5 12.d5 Sd7 13.Sf1 Sdc5 14.Sd2 Db6 + 15.Db1 Sb4 16.Sb3 Scd3+ 17.Kd2 Dxe3+}% + % + \unitlength0.8cm\relax + \begin{animateinline}[autoplay,loop,controls]{0.5}% + \begin{picture}(11,11) + \put(1.5,1.5){\chessboard[setfen=\xskakgetgame{initfen}]}% + \end{picture} + \newframe + \xskakloop{% + \getmovestyle{\xskakget{piecechar}}% + \begin{picture}(11,11) + \put(1.5,1.5){% + \chessboard[pgfstyle=\mymovestyle, color=blue, + pgfshortenend=0.3em,arrow=to, + markmoves=\xskakget{move}, + coloremph,piececolor=blue, + emphfields={\xskakget{moveto}}, + setfen=\xskakget{nextfen}]}% + \end{picture}% + \newframe}% + \begin{picture}(11,11) + \put(1.5,1.5){\chessboard[setfen=\xskakgetgame{lastfen}]}% + \end{picture} + \end{animateinline} +\end{lstlisting} + +\section{Printing} +\subsection{\texttt{\textbackslash longmoves} revisitated}\index{longmoves=\verb!*+\longmoves+>}% + + + +In the example on page \ref{ex:longmoves} I showed that the +\cs{longmoves} of \skaksty doesn't work correctly. This is due to the +asynchronous parsing and printing of the \packagename{skak}-engine +(\packagename{skak} -- like \TeX~-- has sometimes to look a bit +ahead). With \xskak the problem can be easily solved as it is now +possible to retrieve information about previous moves. So \xskak +redefines the internal commands to get \cs{longmoves} working. + +\textbf{Attention!} The new \cs{longmoves} command works only +correctly if the internal engine parses the moves -- so {\em it +doesn't work with \cs{variation}}. So starting with version 1.2 +\xskak forces \cs{variation} to use \cs{shortmoves}. + + +The redefinition of \cs{longmoves} is done by first defining a +printing command and then (re-)defining \cs{longmoves} such that the +internal \cs{printmove} now use the new command. The listing below +shows the code\footnote{The code doesn't show the complete truth. In +the real code \cs{longmoves} also has to change the printing mode for +\cs{printchessgame}. See \ref{sec:print}}. You can take it as a +template for your own special printing commands. +\cs{WhiteToMove}\marg{code for white}\marg{code for black} is a +command of \skaksty that executes the first argument if white is to +move and the second if its black turn. The main trick in the new +printing command is to go back one halfmove. The new printing command +defines only the printing format for the move itself as the number is +printed by \skaksty at another place. + +\begin{lstlisting} +\def\xskak@do@printmove@algebraic{% + \csname Xskak.\xskak@val@gameid.% + \WhiteToMove{\the\numexpr\the\c@move-1\relax}{\the\c@move}.% + \WhiteToMove{b}{w}.lan\endcsname + \csname Xskak.\xskak@val@gameid.% + \WhiteToMove{\the\numexpr\the\c@move-1\relax}{\the\c@move}.% + \WhiteToMove{b}{w}.comments\endcsname{}} + +\def\longmoves{% + \let\printmove=\xskak@do@printmove@algebraic} +\end{lstlisting} + +\DescribeMacro{\xskakenpassanttext}% +The new printing command inserts a test for enpassant moves. You can +suppress it by redefining \cs{xskakenpassantext}. + + + +\begin{LTXexample} + \longmoves + \newchessgame + \mainline{1.e4 e5 2.Nf3 Nf6} + + \newchessgame[restorefen=example] + \mainline{1. a4 bxa3!} + + \renewcommand\xskakenpassanttext{} + \newchessgame[restorefen=example] + \mainline{1. a4 bxa3!} +\end{LTXexample} + + + +\subsection{An user interface for styles}\label{sec:interface} + +To format a game \skaksty puts during parsing commands before and +between the moves and the counter. You can see the names of this +commands in the following example (the style \key{test} is a simple +local style predefined by \packagename{xskak} which contains +different tests. In level 1 and 2 it contains style items to show +commands. The optional argument \texttt{[invar]} force \cs{variation} +to use level 2). + +\begin{LTXexample}[pos=t,width=\textwidth,caption={The internal commands to format the output}] + \newchessgame + \xskakset{% + style=test, + level=1} + \color{blue} + + \mainline{1.d4 Nf6 2.c4} + + \mainline{2... g6 3.Nc3 Bg7 4.e4} + + \mainline{4... O-O 5. Nf3 Re8} + + \mainline{6. Be3 e6} + + \variation[invar]{6... d6} +\end{LTXexample} + +By judiciously (re-)definining the commands \packagename{skak} +inserts one can get almost every chess style one want. +\packagename{skak} itself defines three examples that demonstrates +the possibilities. These styles can be chosen by the commands +\cs{styleA}, \cs{styleB} and \cs{styleC}. The first two are inline +styles, the third uses for \cs{mainline} a tabbing environment and +switches to an inline style for \cs{variation}. But this styles are +really no more than examples. There is no user interface to change +and define styles. And due to some dependencies between the +predefined styles (\cs{styleB} is not only a stand-alone style but it +is also used in the definition of \cs{styleC} for the variation +level) adapting the styles is not easy. + + +So I decided to define a real user interface to define styles and +switch from one to another. The user interface supports an unlimited +number of levels: Each style is a bundle of \emph{levels} where the +look on each level is describe by a \emph{style item}\index{style +item} and some optional commands. Defining a style is therefore done +in two steps: + +\begin{lstlisting} + % Define items: + \xskaknewstyleitem{A}{% + beforenumber={}, + whiteopen={.\,}, + ...} + \xskaknewstyleitem{B}{...} + + %Define style + \xskaknewstyle[% + level=1,styleitem=A, + font=\bfseries, %add special command to level 1. + level=2,styleitem=A, + level=3,styleitem=B, + ...]{mystyle} + \end{lstlisting} + + +\textbf{Attention!} The (almost) indefinite number of levels comes at +a price: \cs{mainline} and \cs{variation} no longer use +automatically different styles. If a \cs{variation} should switch to +a «variation style» you will have to use e.g. the option +\texttt{[invar]} mentioned above (but you can define your own +«variation» commands that do this switch). Please read section +\ref{sec:usestyles} for more information. + + + +\subsubsection{Defining style items} + +\DescribeMacro{\xskaknewstyleitem}% +With \cs{xskaknewstyleitem}\keyoarg\marg{item} you define the style +item \meta{item}. You can use the following keys: + + +\begin{description} +\item[\meta{command name}=\meta{commands}] + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>opencommands (key)}% + \index{opencommands (\texttt{\textbackslash xskaknewstyleitem} key)}% + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>closecommands (key)}% + \index{closecommands (\texttt{\textbackslash xskaknewstyleitem} key)}% + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>beforenumber (key)}% + \index{beforenumber (\texttt{\textbackslash xskaknewstyleitem} key)}% + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>whiteopen (key)}% + \index{whiteopen (\texttt{\textbackslash xskaknewstyleitem} key)}% + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>beforewhite (key)}% + \index{beforewhite (\texttt{\textbackslash xskaknewstyleitem} key)}% + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>afterwhite (key)}% + \index{afterwhite (\texttt{\textbackslash xskaknewstyleitem} key)}% + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>blackopen (key)}% + \index{blackopen (\texttt{\textbackslash xskaknewstyleitem} key)}% + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>beforeblack (key)}% + \index{beforeblack (\texttt{\textbackslash xskaknewstyleitem} key)}% + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>afterblack (key)}% + \index{afterblack (\texttt{\textbackslash xskaknewstyleitem} key)}% + +{\raggedright where \meta{command name} is one of +\\\texttt{opencommands}, \texttt{closecommands}, +\texttt{beforenumber}, \texttt{whiteopen}, \texttt{blackopen}, +\texttt{beforewhite}, \texttt{beforeblack}, \texttt{afterwhite}, +\texttt{afterblack}.\par} + + +There are endless possibilities for the value \meta{commands} -- as +there are endless possibilities to get more or less horrible errors. +So I will give only some general advices for the definitions of style +items: + +\begin{itemize} +\item While processing \keylists\/ \packagename{xkeyval} strips spaces. +So if you want to set one of the commands to a space use +either commands like \verb+\ +, \verb+\space+ and \verb+~+, or +protect the space by enough layers of braces. + +\item While processing \keylists\/ \packagename{xkeyval} strips also braces. +If you need some grouping use \cs{begingroup} and \cs{endgroup} or +protect the «real» braces by enough other braces. + +\item Use if possible switches (like \cs{bfseries}) instead of commands with arguments. + +\item Think about how you want to handle spaces at the start and the end of (bits of) a game +or a variation. An input like + \verb+\mainline{1. e4}+\verb*+ \variation{1.e5}+ will already insert a + space so avoid to insert another one through e.g. \key{opencommands}. + + +\item It is possible to open a group (with +\cs{begingroup}) or a environment in one command and close it in +another command. If you do this check carefully that you have +balanced groups in all four combinations of white/black opening and +ending the game! Check also if everything works if you have only one +move. + +\item You don't have to give a definition for all keys/commands. +Unused keys are set to empty. + +\item If you want to force a style (or a style item) to use the long +or the short algebraic notation you can add +\cs{longmoves}/\hspace{0pt}\cs{shortmoves} to \key{opencommands}. + \index{longmoves=\verb!*+\longmoves+>}% + \index{shortmoves=\verb!*+\shortmoves+>}% +\end{itemize} + + +\item[\meta{beforeNAG}=\meta{commands}, \meta{beforecomment}=\meta{commands}] + +\packagename{xskak} puts around each NAG and comment given by +\cs{xskakcomment} a group and before each NAG's and comment a +formatting command. This commands are named \cs{xskak@beforeNAG} and +\cs{xskak@beforecomment}. With the keys \key{beforeNAG} and +\key{beforecomment} you can change this commands and so to some +extend change the formatting of NAG and long comments (the styles of +short comments like + or ! are not affected!). The last command in +\meta{commands} can be a command that has one argument. NAG and the +content of the comment will then be used as this argument. This makes +is e.g. possible to gobble commands: + +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \providecommand\gobble[1]{} + \xskaknewstyleitem[% + template=UF,%a predefined style item + beforeNAG=\gobble, + beforecomment=\gobble]{gobblecomments} + + \xskakaddtostyle[% + level=gobble, + styleitem=gobblecomments]{test} + + \variation[style=test,level=gobble]{1. e4! $1 \xskakcomment{expected} e5 $2} +\end{LTXexample} + + + + + + +\item[\key{template}=\meta{item}] + \index{xskaknewstyleitem=\verb!*+\xskaknewstyleitem+>template (key)}% + \index{template (\texttt{\textbackslash xskaknewstyleitem} key)}% + +With this key you can reuse the definitions from another style item. +\end{description} + + +\subsubsection{Defining style} + + +\DescribeMacro{\xskaknewstyle}% +\DescribeMacro{\xskakaddtostyle}% +With \cs{xskaknewstyle}\keyoarg\marg{style} you define the style +\meta{style}. \\With \cs{xskakaddtostyle}\keyoarg\marg{style} you can +add more levels (or overwrite existing ones) to a style. Both +commands can handle four keys: \key{level}, \key{styleitem}, +\key{font} and \key{xfont}. + + +\begin{description} +\item[\key{level}=\meta{number}] + \index{xskaknewstyle=\verb!*+\xskaknewstyle+>level (key)}% + \index{level (\texttt{\textbackslash xskaknewstyle} key)}% + +With this key you set the number of the level for which you want to +declared a «look» with the following keys. The «highest» level number +is 1. Normally it should contain the description of the style for the +main game. Variation styles should have larger numbers. But the +\meta{number} don't need to be a number, strings are also possible. + + +If you want to keep everything simple: Use only (positive) numbers +with levels. Then the levels have a well-defined order which is easy +to handle. Key \key{invar} will add 1 to a level number, key +\key{outvar} will substract 1 and if you set the level to a number +for which no style item as been declared \packagename{xskak} will +simply substract 1 from this number until it finds a level with a +style item it can use. + +But you can also use level names with chars e.g. to define variants +for a specific variation level. So you could e.g. define levels +\texttt{1open}, \texttt{1close}, \texttt{1middle}, +\texttt{1betteris}. + +In this case it depends on your compiler how the keys \key{invar} +and \key{outvar} and levels without declared style items are handled: + +\begin{description} +\item[Case 1:] You have an old pdf\TeX\ where the (experimental) primitive +\cs{pdfmatch} is not defined (or you did use the package option +\texttt{nopdfmatch}).\mynobreakpar + +Then the keys \key{invar} and \key{outvar} will not work when the +current level contains chars or other non-numerical tokens. They will +issue more or less bewildering errors. + +Levels without a declared style item will issue errors too. + +\item[Case 2:] You have a recent pdf\TeX\ where the (experimental) primitive +\cs{pdfmatch} is defined (and you didn't use the package option +\texttt{nopdfmatch}).\mynobreakpar + + \begin{description} + \item[Case a)] The level name doesn't contain any number, e.g. \texttt{level=gobble}:\mynobreakpar + + Then you will get an error if you try to set the level and you haven't declared a style item for this level. + + If the current level is \texttt{gobble} then the keys \key{invar} and \key{outvar} will issue a warning + and let the level unchanged. + + \item[Case b)] The level name do contain numbers, e.g. \texttt{level=a12b567}:\mynobreakpar + + Then \packagename{xskak} will use the following substituation if you try to set the level and there is no style + item declared: + \packagename{xskak} will extract the + first number from the name (in this case «12»), substract one + from this number and try the name with the new number in it. If + the first number is 1, level 1 is used (it is always defined). If + the first number is 0 you will get an error. + + In the example \packagename{xskak} will try the levels in the following order until it finds one that it can use: + {\ttfamily a12b567 $\rightarrow$ a11b567 $\rightarrow$ a10b567 $\rightarrow$ \ldots a2b567 $\rightarrow$ a1b567 $\rightarrow$ 1} + \end{description} + +\end{description} + + +\item[\key{styleitem}=\meta{item}] + \index{xskaknewstyle=\verb!*+\xskaknewstyle+>styleitem (key)}% + \index{styleitem (\texttt{\textbackslash xskaknewstyle} key)}% + +With this key you set the style item used by the current level +\emph{and all following levels} until another \key{styleitem} is set. + + +\item[\key{font}=\meta{commands}] + \index{xskaknewstyle=\verb!*+\xskaknewstyle+>font (key)}% + \index{font (\texttt{\textbackslash xskaknewstyle} key)}% + +With this key you can add some specific commands to the current +level (\emph{and only to the current level}). While the key is meant +to add font switches to a level it can also be used to overwrite some +commands of a style item. + + + +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] + \xskaknewstyleitem[% + template=UF,%a predefined style item + beforenumber=\color{red},% + whiteopen=.\,\color{black}, + blackopen=\ldots\,\color{black}]{rednumbers} + + %% add to existing style test + \xskakaddtostyle[% + level=10,styleitem=rednumbers, + level=12, + font=\def\beforenumber{\color{green}}\bfseries] + {test} + + + \newchessgame + \mainline[style=test,level=12]{1. Nf3 Nf6 2. d4} + + \variation[level=10]{2. Nc3} + + + \mainline[level=11]{2... d5} + \end{LTXexample} + +\begin{LTXexample}[varwidth=false,width=0.3\textwidth] +\xskakset{style=test}% + \xskaknewstyleitem[% + template=UF,%a predefined style item + beforeNAG=\color{blue}, + beforecomment=\mdseries]{mycomments} + + \xskakaddtostyle[level=13,styleitem=mycomments, + font=\bfseries]{test} + + \variation[level=13]{1. e4 $1 \xskakcomment{ as expected} e5} + + \makeatletter + \xskakaddtostyle[% + level=gobbleB,styleitem=gobblecomments, + font=\renewcommand\xskak@beforeNAG{\color{red}}]% + {test} + \makeatother + + \variation[level=gobbleB]{1. e4! $1 \xskakcomment{ I expected it} e5 $2} + \end{LTXexample} + +\item[\key{xfont}=\meta{commands}] + \index{xskaknewstyle=\verb!*+\xskaknewstyle+>xfont (key)}% + \index{xfont (\texttt{\textbackslash xskaknewstyle} key)}% + +With this key you can add some specific commands to all levels with +the same first number in their name. It needs a recent pdf\TeX\ with +the command \cs{pdfmatch}. + +As an example lets add three levels to the test style used above: the +first (main) level should use a bold font, the second \cs{mdseries} +and the third an italic font. For each level we will define a variant +which puts a \cs{betteris} (\betteris) before the first move. + +The example also demonstrates how to retrieve the current level. +Please note the braces around some of the \cs{variations} which keep +the level change local. + +\begin{LTXexample}[width=0.3\textwidth,varwidth=false,caption=«betteris» style,label=sty:betteris] + \xskaknewstyleitem[% + template=UF, + opencommands=(\betteris, + closecommands=)]{betteris} + + + \xskakaddtostyle + [level=20 ,styleitem=UF,xfont=\bfseries, + level=20bis,styleitem=betteris, + level=21 ,xfont=\mdseries, + level=22 ,xfont=\itshape]{test} + + \xskakset{style=test} + + \variation[level=20]{1. e4 e5} (level \xskakget{level}) + \variation[level=20bis]{1... e6} (level \xskakget{level}) + + \variation[level=21]{1. e4 e5} (level \xskakget{level}) + \variation[level=21bis]{1... e6} (level \xskakget{level}) + + \variation[level=22]{1. e4 e5} (level \xskakget{level}) + \variation[level=22bis]{1... e6} (level \xskakget{level}) + + + \variation[level=20]{1. e4 e5} + {\variation[level=\xskakget{level}bis]{1... e6} + \variation[invar]{1... e6} \variation[invar]{1... e6}} + + \variation[invar]{1. e4 e5} %to level 21 + {\variation[level=\xskakget{level}bis]{1... e6}} + + \variation[invar]{1. e4 e5} %to level 22 + {\variation[level=\xskakget{level}bis]{1... e6}} + +\end{LTXexample} + + +\end{description} + + +The previous examples demonstrate some important points to consider +when defining styles: + +\begin{itemize} +\item You can define as much levels as you want. + +\item The number of the levels don't have to be consecutive (they even need to be numbers). If there +is no definition for a level (in the first example level 11), the +style item of a previous level (in this case level 10) is used if +\packagename{xskak} is able to figure out what the previous level +could be. + +\item While it is often sensible to store the settings for the main level +in level 1, and for the first variation level in level 2 and so on, +you can also chose other orders or use more than one level for each +logical variation level. If you e.g. want sometimes to add braces +through \key{opencommands} you could define variants $n$a, $n$b etc +of the involved variation level. + + + +\item While it is easy to define style items and styles it is not +easy sort and bundle them in a sensible way. + +\end{itemize} + + +\subsection{Using the styles}\label{sec:usestyles} + +The names of the commands \cs{mainline} and \cs{variation} give the +impression that you should use the first for the main game and the +second for the variations. But at my opinion this impression is +wrong: You should use + \begin{itemize} + \item \cs{mainline} if you want to parse \emph{and} print chess moves, + \item \cs{variation} if you want only to print chess moves, + \item \cs{hidemoves} if you want only to parse moves and + \item \cs{printchessgame} (described later) if you want to + (re)print a previously parsed game. + \end{itemize} + +This means that each of the printing commands can be used for the +main game and for variations. And so it should be possible for each +of the printing commands to set and use every style level. + +In consequence this means that if you use the new interface -- you +don't have to -- \cs{variation} will no longer switch to another +style. + +You can set the style and the level either with \cs{xskakset} or in +the optional argument of the three printing commands. The keys you +can use in both cases are: + + + +\begin{description} +\item[\key{style}=\meta{style name}] + \index{xskakset=\verb!*+\xskakset+>style (key)}% + \index{style (\texttt{\textbackslash xskakset} key)}% + \index{mainline=\verb!*+\mainline+>style (key)}% + \index{style (\texttt{\textbackslash mainline} key)}% + \index{variation=\verb!*+\variation+>style (key)}% + \index{style (\texttt{\textbackslash variation} key)}% + \index{printchessgame=\verb!*+\printchessgame+>style (key)}% + \index{style (\texttt{\textbackslash printchessgame} key)}% + +This key sets the name of the style the following printing commands +should use. The setting is always local to the current group (even +with \cs{xskakset}\footnote{At first \cs{xskakset} did the settings +globally. I changed it after the third time I had to correct the +documentation because I forgot to reset a style after an example.}. + + +\item[\key{gstyle}=\meta{style name}] + \index{xskakset=\verb!*+\xskakset+>gstyle (key)}% + \index{gstyle (\texttt{\textbackslash xskakset} key)}% + \index{mainline=\verb!*+\mainline+>gstyle (key)}% + \index{gstyle (\texttt{\textbackslash mainline} key)}% + \index{variation=\verb!*+\variation+>gstyle (key)}% + \index{gstyle (\texttt{\textbackslash variation} key)}% + \index{printchessgame=\verb!*+\printchessgame+>gstyle (key)}% + \index{gstyle (\texttt{\textbackslash printchessgame} key)}% + +This key sets the name of the style globally. + + +\item[\key{level}=\meta{number}] + \index{xskakset=\verb!*+\xskakset+>level (key)}% + \index{level (\texttt{\textbackslash xskakset} key)}% + \index{mainline=\verb!*+\mainline+>level (key)}% + \index{level (\texttt{\textbackslash mainline} key)}% + \index{variation=\verb!*+\variation+>level (key)}% + \index{level (\texttt{\textbackslash variation} key)}% + \index{printchessgame=\verb!*+\printchessgame+>level (key)}% + \index{level (\texttt{\textbackslash printchessgame} key)}% + +This key sets the level the following printing commands should use. +The setting is always local to the current group. + +\item[\key{glevel}=\meta{number}] + \index{xskakset=\verb!*+\xskakset+>glevel (key)}% + \index{glevel (\texttt{\textbackslash xskakset} key)}% + \index{mainline=\verb!*+\mainline+>glevel (key)}% + \index{glevel (\texttt{\textbackslash mainline} key)}% + \index{variation=\verb!*+\variation+>glevel (key)}% + \index{glevel (\texttt{\textbackslash variation} key)}% + \index{printchessgame=\verb!*+\printchessgame+>glevel (key)}% + \index{glevel (\texttt{\textbackslash printchessgame} key)}% + +This key sets the level globally. + +\item[\key{invar}] + \index{xskakset=\verb!*+\xskakset+>invar (key)}% + \index{invar (\texttt{\textbackslash xskakset} key)}% + \index{mainline=\verb!*+\mainline+>invar (key)}% + \index{invar (\texttt{\textbackslash mainline} key)}% + \index{variation=\verb!*+\variation+>invar (key)}% + \index{invar (\texttt{\textbackslash variation} key)}% + \index{printchessgame=\verb!*+\printchessgame+>invar (key)}% + \index{invar (\texttt{\textbackslash printchessgame} key)}% + +This will add 1 to the first number in the current level (so it goes +towards «higher» (deeper) levels). Again the change is local to the +group. This key can break if the current value of the level is not a +number. + +\item[\key{ginvar}] + \index{xskakset=\verb!*+\xskakset+>ginvar (key)}% + \index{ginvar (\texttt{\textbackslash xskakset} key)}% + \index{mainline=\verb!*+\mainline+>ginvar (key)}% + \index{ginvar (\texttt{\textbackslash mainline} key)}% + \index{variation=\verb!*+\variation+>ginvar (key)}% + \index{ginvar (\texttt{\textbackslash variation} key)}% + \index{printchessgame=\verb!*+\printchessgame+>ginvar (key)}% + \index{ginvar (\texttt{\textbackslash printchessgame} key)}% + +This is the global variant of \key{invar}. + +\item[\key{outvar}] + \index{xskakset=\verb!*+\xskakset+>outvar (key)}% + \index{outvar (\texttt{\textbackslash xskakset} key)}% + \index{mainline=\verb!*+\mainline+>outvar (key)}% + \index{outvar (\texttt{\textbackslash mainline} key)}% + \index{variation=\verb!*+\variation+>outvar (key)}% + \index{outvar (\texttt{\textbackslash variation} key)}% + \index{printchessgame=\verb!*+\printchessgame+>outvar (key)}% + \index{outvar (\texttt{\textbackslash printchessgame} key)}% + +This will substract 1 to the first number in the current level (so it +goes towards level 1 as the main level). This key can break if the +current value of the level is not a number. + +\item[\key{goutvar}] + \index{xskakset=\verb!*+\xskakset+>goutvar (key)}% + \index{goutvar (\texttt{\textbackslash xskakset} key)}% + \index{mainline=\verb!*+\mainline+>goutvar (key)}% + \index{goutvar (\texttt{\textbackslash mainline} key)}% + \index{variation=\verb!*+\variation+>goutvar (key)}% + \index{goutvar (\texttt{\textbackslash variation} key)}% + \index{printchessgame=\verb!*+\printchessgame+>goutvar (key)}% + \index{goutvar (\texttt{\textbackslash printchessgame} key)}% + +This is the global variant of \key{outvar}. +\end{description} + + +\subsection{The predefined styles} + +\Xskak predefines five styles: \texttt{styleA}, \texttt{styleB} and +\texttt{styleC} imitate the predefined styles of \packagename{skak} +with the addition that they change to italic in the third level. +Style \texttt{UF} is my style and style \texttt{test} is a large +container for all sorts of tests. + + +\begin{LTXexample}[width=0.4\textwidth,varwidth=false] +\minisec{style \enquote{styleA}} +\newchessgame + \xskakset{style=styleA} + \mainline[level=1]{% + 1. e4 e6 2. d4 d5 3. e5 c5 4. c3 Qb6} + (\variation[invar]{4... Ne7 5. Nf3 Nec6} + (\variation[invar]{5... Nf5 6. h4 Be7 + 7. Bd3 cxd4 8. cxd4 Nc6 9. Bxf5 exf5 10. Bg5 $14}) + \variation[outvar]{6. Bd3} + (\variation[invar]{6. h4 Nd7 7. h5 f6 $1 $132})) + \mainline[outvar,outvar]{ 5. Nf3 Bd7} + +\end{LTXexample} + + +\begin{LTXexample}[width=0.4\textwidth,varwidth=false] +\minisec{style \enquote{styleB}} +\newchessgame + \xskakset{style=styleB} + \mainline[level=1]{% + 1. e4 e6 2. d4 d5 3. e5 c5 4. c3 Qb6} + (\variation[invar]{4... Ne7 5. Nf3 Nec6} + (\variation[invar]{5... Nf5 6. h4 Be7 + 7. Bd3 cxd4 8. cxd4 Nc6 9. Bxf5 exf5 10. Bg5 $14}) + \variation[outvar]{6. Bd3} + (\variation[invar]{6. h4 Nd7 7. h5 f6 $1 $132})) + \mainline[outvar,outvar]{ 5. Nf3 Bd7} + +\end{LTXexample} + +\begin{LTXexample}[width=0.4\textwidth,varwidth=false] +\minisec{style \enquote{UF}} +\newchessgame + \xskakset{style=UF} + \mainline[level=1]{% + 1. e4 e6 2. d4 d5 3. e5 c5 4. c3 Qb6} + (\variation[invar]{4... Ne7 5. Nf3 Nec6} + (\variation[invar]{5... Nf5 6. h4 Be7 + 7. Bd3 cxd4 8. cxd4 Nc6 9. Bxf5 exf5 10. Bg5 $14}) + \variation[outvar]{6. Bd3} + (\variation[invar]{6. h4 Nd7 7. h5 f6 $1 $132})) + \mainline[outvar,outvar]{ 5. Nf3 Bd7} + +\end{LTXexample} + +\minisec{style \enquote{styleC}} +styleC sets the moves in a tabbing and should be used only for the main moves. +\begin{LTXexample}[width=0.4\textwidth,varwidth=false] +\newchessgame + \mainline[style=styleC,level=1]{% + 1. e4 e6 2. d4 d5 3. e5 c5 4. c3 Qb6} + (\variation[invar]{4... Ne7 5. Nf3 Nec6} + (\variation[invar]{5... Nf5 6. h4 Be7 + 7. Bd3 cxd4 8. cxd4 Nc6 9. Bxf5 exf5 10. Bg5 $14}) + \variation[outvar]{6. Bd3} + (\variation[invar]{6. h4 Nd7 7. h5 f6 $1 $132})) + \mainline[outvar,outvar]{ 5. Nf3 Bd7} + +\end{LTXexample} + + +\subsection{The new \texorpdfstring{\texttt{xskak}}{xskak} printing +command}\label{sec:print} + +\DescribeMacro{\printchessgame}% +As one of the aims of \packagename{xskak} is to separate the parsing +from the printing of a game there is naturally also a printing +command. With \cs{printchessgame}\keyoarg{} you can print a +previously parsed and saved game. Without any options +\cs{printchessgame} will print the game with the currently active +\meta{GameId} from start to end. + + + +As keys you can use +\begin{description} +\item[\key{id}=\meta{GameId}, \key{refid}=\meta{tag}] + \index{printchessgame=\verb!*+\printchessgame+>id (key)}% + \index{id (\texttt{\textbackslash printchessgame} key)}% + \index{printchessgame=\verb!*+\printchessgame+>refid (key)}% + \index{refid (\texttt{\textbackslash printchessgame} key)}% + +This keys change only for the printing the current \meta{GameId}. +Afterwards the old \meta{GameId} is restored. + +\item[\key{initmovenr=}\meta{number}, \key{initplayer=}\meta{«w» or «b»}, \key{initmoveid=}\meta{number + «w» or «b»}]\index{printchessgame=\verb!*+\printchessgame+>initmovenr (key)}% + \index{initmovenr (\texttt{\textbackslash printchessgame} key)}% + \index{printchessgame=\verb!*+\printchessgame+>initplayer (key)}% + \index{initplayer (\texttt{\textbackslash printchessgame} key)}% + \index{printchessgame=\verb!*+\printchessgame+>initmoveid (key)}% + \index{initmoveid (\texttt{\textbackslash printchessgame} key)}% +~\\ This keys sets the move the printing should start with. If the +move isn't in the game a warning is issued and the first move of the +game is used instead. + +\item[\key{stopmovenr=}\meta{number}, \key{stopplayer=}\meta{«w» or «b»}, \key{stopmoveid=}\meta{number + «w» or «b»}] + \index{printchessgame=\verb!*+\printchessgame+>stopmovenr (key)}% + \index{stopmovenr (\texttt{\textbackslash printchessgame} key)}% + \index{printchessgame=\verb!*+\printchessgame+>stopplayer (key)}% + \index{stopplayer (\texttt{\textbackslash printchessgame} key)}% + \index{printchessgame=\verb!*+\printchessgame+>stopmoveid (key)}% + \index{stopmoveid (\texttt{\textbackslash printchessgame} key)}% +~\\ This keys sets the move the printing should end with. If the move +isn't in the game a warning is issued and the last move of the game +is used instead. + +\item[\key{reftag}=\meta{tag}] + \index{printchessgame=\verb!*+\printchessgame+>reftag (key)}% + \index{reftag (\texttt{\textbackslash printchessgame} key)}% + +This sets the tag name in case that you want to use tagged moves as +start or end of the printing. There are no keys like +\key{initrefpastmoveid} (I thought so long names are no longer +manageable), so you will have to use e.g. \texttt{reftag=}\meta{tag}, +\texttt{initmovenr=}\cs{xskakget}\verb+{refpast}+. + + +\item[\key{style}, \key{level}, key{invar} and \key{outvar}]% + \index{printchessgame=\verb!*+\printchessgame+>level (key)}% + \index{level (\texttt{\textbackslash printchessgame} key)}% + \index{printchessgame=\verb!*+\printchessgame+>invar (key)}% + \index{invar (\texttt{\textbackslash printchessgame} key)}% + \index{printchessgame=\verb!*+\printchessgame+>outvar (key)}% + \index{outvar (\texttt{\textbackslash printchessgame} key)}% + \index{printchessgame=\verb!*+\printchessgame+>style (key)}% + \index{style (\texttt{\textbackslash printchessgame} key)}% + +\cs{printchessgame} use the same formatting commands as +\packagename{skak}, so the style can be change through the interface +defined and described in section \ref{sec:interface}. + + +To set the level and the style you can use the keys described in +section \ref{sec:usestyles} in the optional argument of +\cs{printchessgame}. Like with \cs{mainline} and \cs{variation} the +keys sets the values locally for the current group. + +To print the actual moves, \cs{printchessgame} doesn't use the +command \cs{printmove} from \packagename{skaksty} but an internal +command named \cs{xskak@do@printmove}. So commands like +\cs{longmoves} must set this command appropriately. + + +\end{description} + +\begin{LTXexample} + \input{xskakgames.xsk} + \printchessgame[style=UF,level=1,id=export, + initmoveid=7w,stopmoveid=12b] +\end{LTXexample} + + +\subsection{Game titles and chessboard captions} + +There are no pre-made commands. You will have to define them with the +help of the stored game data/move data. For titles I advise you to +use a sort of sectioning command -- this will prevent page breaks +between the title and the game. Look e.g. at the definition of +\cs{minisec} in one of the classes from the KOMA-bundle. For +captions: look at the package \packagename{caption}. + + + + +\section{PGN2LTX or How to sort the input} + +While \packagename{skak}/\packagename{xskak} can handle games in +PGN-notation they can't handle PGN-files: neither the PGN-infos +(which is a small nuisances) nor the variations and the comments in +the game notation (which makes it tedious to print large games with a +lot of annotations). + +There exists a small number of perl scripts and applications to help +to convert PGN to \LaTeX\ but none is really satisfactory. One of the +problems that prevents better solutions is that there is no clear +description what should be the result of a conversion from PGN to +\LaTeX. In this section I will make some remarks about what I think +would be a good output from such a converter for +\packagename{xskak}\footnote{\packagename{texmate} needs another +output.} and where I see problems. The description should also help +you to enter or convert complicated games manually. + + +\minisec{The PGN-infos} + +The «tag pair» section of a chess game in PGN shouldn't pose problems +to a converter. The tags should be simply converted to the equivalent +keys of a \cs{newchessgame}: + +\begin{lstlisting} + [Round "29"] + [White "Fischer, Robert J."] + [Black "Spassky, Boris V."] + [Result "1/2-1/2"] +\end{lstlisting} +% +\begin{lstlisting}[escapechar=/] + \newchessgame[id=/\meta{GameId}/, %see below + round={29}, + white={Fischer, Robert J.}, + black={Spassky, Boris V.}, + result={1/2-1/2}] +\end{lstlisting} + +\xskakset{style=UF}% +If the game use a \texttt{SetUp} and a \texttt{FEN} tag to set an +alternative starting position, the converter will have to extract the +start move from the FEN and set it with the key \key{moveid}. + +\minisec{The \meta{GameId}} + +While it is probably possible to give each game an unique +\meta{GameId} I don't think that it is sensible or really necessary. +I would suggest, that each game gets uses\\ +\verb+\newchessgame[id=main\xskakaddtoid,...]+ where +\cs{xskakaddtoid} is empty by default but can be redefined to allow +some automatic numbering. + +\minisec{The parsing command} + +As you will probably sometimes use \cs{mainline} and sometimes +\cs{hidemoves} it is probably best if the converter use an general +\cs{parsechessgame} which can be \cs{let} to both commands. + +\minisec{NAG's} + +Most NAG's don't need any special handling as \packagename{xskak} can +parse them. + +But some chess applications seems to put NAG's \emph{after} a move to +denote a symbol that should go \emph{before} the move. E.g. + \verb+1. e5 $142+ +% +should become \betteris\variation{1. e5}. + +Putting such symbols before a move number is in most cases only +possible at the start of a \cs{mainline} or \cs{variation} so the +converter will have probably to split the input and add the symbol +either directly or through a style. A converter will need a list of +all this special cases and good rules how to handle them. + + + + +\minisec{Long comments} + +Longer commands (in the PGN in curly braces) could be handled either +by adding a \cs{xskakcomment} at the begin of the comment or by +ending the parsing and starting it again after the comment. The first +method has the advantage that one can use styles to format to some +extend the comments (or gobble them) but can cause problems if the +comment contains something that isn't allowed in the argument of a +command. + +I think some real examples are needed to decide what is the best way. + + +\minisec{The content of long comments} + +I don't think that is possible to handle all possible contents +automatically and get a suitable result for \LaTeX. You will either +have to follow some rules while inputing the comments or tidy them up +later. + +But a converter will probably be able to identify moves like +\texttt{4.\,\,Nf3} and to surround them by suitable +\verb+\variation[style=...,level=...]{...}+. + +\minisec{Diagrams} + +Some chess applications let you put markers at places where you would +like to print a diagram. E.g. chessbase put +\texttt{Diagramm~\#}\footnote{I don't know if «Diagramm» is language +dependent. Probably yes.} in a comment. + +A converter should also be able to recognize such markers for +diagrams. But it is not easy to decide what should be done with this +markers. In some cases you would probably not want to print boards at +all. Sometimes the game should be interrupted and the diagram printed +directly. Sometimes it should float. And I recall that someone once +tried to put all diagrams in the order there were mentioned in the +margin. If such markers are used it is probably the best if the +converter sets a tag and sets one of the fake NAG's \texttt{\$D} and +\texttt{\$d}. Then \cs{printchessgame} and the list of diagrams could +be used to print the moves and the diagrams in the intended order +(but it will probably need some coding to get the right results). The +tag and the NAG should be move outside of the comment as the comment +isn't processed in all cases. + +\begin{lstlisting}[caption={Input and suggested output for diagram +markers}] + 10. c3 e5 $1 {Diagramm # Die energische und konsequente + Fortsetzung, Schwarz öffnet das Zentrum, um seine Figuren zu + aktivieren.} 11. h3 +\end{lstlisting} + +\begin{lstlisting} + \mainline{10. c3 e5\xskakset{tag=dia1} $d $1 + \xskakcomment{ Die energische und konsequente Fortsetzung, + Schwarz öffnet das Zentrum, um seine Figuren zu aktivieren. } + 11. h3} +\end{lstlisting} + + + + +\minisec{Variations} + +Here starts the real problems. Even if we forget for the moment the +parsing of moves and diagrams it is not easy to describe a suitable +output. The main problems come from the fact that styles and good +typesetting are involved: E.g. PGN code two variations in a row as +\texttt{(1...~e5) (1...~e6)}. But you would probably print this as +(\variation{1... e5}; \variation{1... e6}). + +So the converter will have to look ahead and use suitable «open», +«middle», «close» and «single» styles in the different combinations. + +If you make long analyzes you will probably want to use numbered list +for the variations -- but not every variation is so important that +it need its own number. In this case there must be a marker that +tells the converter to handle this variation differently. + +I haven't solved all this problems but I think that the following +code could be used as starting point for further discussion about a +\LaTeX-chess input\footnote{If one really wants to parse all +variations a better naming for the nodes is needed.}: + +\begin{lstlisting} + \newchessgame[id=main, ...] + \mainline{...} + %new var level + \newchessgame[newvar=main,id=var1a]% + \mainline[level=1open]{.....} + %same var level + \newchessgame[newvar=main,id=var1b]% + \mainline[level=1close]{....} + %new var level + \newchessgame[newvar=var1b,id=var2a]% + \mainline[level=2single]{....} + %% return to var1b: + \resumechessgame[id=var1b] + \mainline[level=1open]{....} +\end{lstlisting} + + +\minisec{Initialization and title} + +Until now I have only discussed the game itself. But you would +probably want to print titles, make table of contents and other +lists. So one should also add some generic commands or environments +like \verb+\begin{chessgame}+/\hspace{0pt}\verb+\end{chessgame}+ and +\verb+{\chessgameheader}+ to each game. + + + + + + +\section{Compability issues} +\subsection{\texorpdfstring{\packagename{xskak} and +\packagename{texmate}}{xskak and texmate}}\index{texmate} + +It will probably work fine to use both packages in one document. + +\cs{newchessgame} and \cs{resumechessgame} will both internally issue +a \cs{fenposition} command that will setup the games also for +\packagename{texmate}. This naturally means in return that both +commands interfere with \packagename{texmate}! + +You can't benefit of the extended input possibilities for NAG's and +comments. \packagename{texmate} has its own parsing method. + +Btw: If you are using \packagename{texmate} you should always indent +your input as the package doesn't recognize new lines as spaces. + +\subsection{\texorpdfstring{\packagename{xskak} and +\packagename{beamer}}{xskak and beamer}}\index{beamer} + +When making presentations with \packagename{beamer} you should +remember two things: First you can't use verbatim material or other +commands that relies on catcode changes in the +\texttt{frame}-environment or -command. That means for \skaksty that +you can't use \# in a \cs{mainline} but should replace it by +\cs{mate}. + +Second, if you are using overlays the content of the frame is +processed more than once. That means that you should be careful to +reset counters if you don't want to run into never ending loops. + +The following listing shows an example how to print a chessgame with +beamer. If your pdf-reader can handle annotations you can see the +result in the attached file: \attachfile{xskak_and_beamer.pdf} It +uses overlays (which worked fine) and also shows how you can handle +games in another language: + +\lstinputlisting{xskak_and_beamer.tex} + +\phantomsection +\makeatletter\def\index@prologue{\section*{Index}\addcontentsline{toc}{section}{Index}}\makeatother +\printindex +\end{document} + +\end{document} |