all-up-in-your-elo 0.0.2

data/ext/bayeselo/listi.h

@@ -0,0 +1,125 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// listi.h
+//
+// CListIterator<class T> template definition
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef LISTI_H
+#define LISTI_H
+
+#include "list.h"       // CList template
+
+////////////////////////////////////////////////////////////////////////////
+// CListIterator class definition
+////////////////////////////////////////////////////////////////////////////
+template<class T>
+class CListIterator // listi
+{
+ private: //////////////////////////////////////////////////////////////////
+  CList<T> *plt;
+  CListCell<T> *pcellCurrent;
+  CListCell<T> *pcellPrevious;
+
+ public: ///////////////////////////////////////////////////////////////////
+  CListIterator(CList<T>& ltInit);
+
+  void Increment();
+  void Remove();
+  void Insert();
+  void Reset();
+
+  T& Value();
+  int IsFirst() const {return !pcellPrevious;}
+  int IsAtTheEnd() const {return !pcellCurrent;}
+};
+
+////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////
+template<class T>
+CListIterator<T>::CListIterator(CList<T>& ltInit)
+{
+ plt = &ltInit;
+ pcellPrevious = 0;
+ pcellCurrent = ltInit.pcellFirst;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Resets an iterator to the beginning of its list
+////////////////////////////////////////////////////////////////////////////
+template<class T>
+void CListIterator<T>::Reset()
+{
+ pcellPrevious = 0;
+ pcellCurrent = plt->pcellFirst;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Moves to the next position in a list
+////////////////////////////////////////////////////////////////////////////
+template<class T>
+INLINE
+void CListIterator<T>::Increment()
+{
+ ASSERT(!IsAtTheEnd());
+ pcellPrevious = pcellCurrent;
+ pcellCurrent = pcellCurrent->Next();
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Insert one cell at the current position
+////////////////////////////////////////////////////////////////////////////
+template<class T>
+void CListIterator<T>::Insert()
+{
+ if (!pcellPrevious)
+ {
+  plt->Add();
+  pcellCurrent = plt->pcellFirst;
+ }
+ else
+ {
+  CListCell<T> *pcellNew = plt->AllocateCell();
+  pcellNew->Link(pcellCurrent);
+  pcellPrevious->Link(pcellNew);
+  pcellCurrent = pcellNew;
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Removes one cell from the list
+////////////////////////////////////////////////////////////////////////////
+template<class T>
+void CListIterator<T>::Remove()
+{
+ ASSERT(!IsAtTheEnd());
+
+ {
+  CListCell<T> *pcell = pcellCurrent;
+  pcellCurrent = pcellCurrent->Next();
+  plt->FreeCell(pcell);
+ }
+
+ if (pcellPrevious)
+  pcellPrevious->Link(pcellCurrent);
+ else
+  plt->pcellFirst = pcellCurrent;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Reads the value contained by the current cell
+////////////////////////////////////////////////////////////////////////////
+template<class T>
+INLINE
+T& CListIterator<T>::Value()
+{
+ ASSERT(!IsAtTheEnd());
+ return pcellCurrent->Value();
+}
+
+#endif

data/ext/bayeselo/move.cpp

@@ -0,0 +1,249 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// move.cpp
+//
+// CMove class
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#include <cstring>
+#include <iostream>
+
+#include "move.h"
+#include "square.h"   // CSquare
+#include "player.h"   // CPlayer
+#include "piece.h"    // CPiece
+#include "position.h" // CPosition
+
+using namespace std;
+
+CMove CMove::moveNull(0, 0, 0, 0);
+
+////////////////////////////////////////////////////////////////////////////
+// Function to write a move string
+// psz must point to a string with at least MaxMoveString characters
+////////////////////////////////////////////////////////////////////////////
+#define ADD(c) do {*psz = (c); psz++;} while(0)
+void CMove::MakeString(char *psz, int Notation) const
+{
+ //
+ // Null move
+ //
+ if (!sqFrom && !sqTo)
+ {
+  ADD('n');
+  ADD('u');
+  ADD('l');
+  ADD('l');
+  ADD(0);
+  return;
+ }
+ 
+ static const char PieceLetter[] = "?KQRBNP";
+ static int Conversion[] = {1, 2, 3, 3, 4, 4, 5, 5, 6};
+
+ if (Notation == Basic || Notation == ChessBase)
+ {
+  ADD('a' + (sqFrom & 7));
+  ADD('1' + (sqFrom / 8));
+  ADD('a' + (sqTo & 7));
+  ADD('1' + (sqTo / 8));
+  
+  if (ucType & Promotion)
+  {
+   if (Notation == Basic)
+    ADD('=');
+   ADD(PieceLetter[Conversion[ucType & 0x0f]]);
+  }
+  
+  if (ucType == ep && Notation == Basic)
+  {
+   ADD('e');
+   ADD('p');
+  }
+  
+  if ((ucType == OO || ucType == OOO) && Notation == Basic)
+   ADD('c');
+ }
+ else
+ {
+  //
+  // Short castle
+  //
+  if (ucType == OO)
+  {
+   ADD('O');
+   ADD('-');
+   ADD('O');
+  }
+
+  //
+  // Long castle
+  //
+  else if (ucType == OOO)
+  {
+   ADD('O');
+   ADD('-');
+   ADD('O');
+   ADD('-');
+   ADD('O');
+  }
+
+  //
+  // Other moves
+  //
+  else
+  {
+   //
+   // Origin square
+   //
+   if ((ucSAN & 0x07) == Pawn &&
+       (ucSAN & Capture) &&
+       Notation == StandardAlgebraic)
+    ADD('a' + (sqFrom & 7));
+   else if ((ucSAN & 0x07) != Pawn || Notation == LongAlgebraic)
+   {
+    if ((ucSAN & 0x07) != Pawn)
+     ADD(PieceLetter[ucSAN & 0x07]);
+    if ((ucSAN & File) || Notation == LongAlgebraic)
+     ADD('a' + (sqFrom & 7));
+    if ((ucSAN & Rank) || Notation == LongAlgebraic)
+     ADD('1' + (sqFrom / 8));
+   }
+
+   //
+   // Capture indication
+   //
+   if (ucSAN & Capture)
+    ADD('x');
+   else if (Notation == LongAlgebraic)
+    ADD('-');
+ 
+   //
+   // Destination square
+   //
+   ADD('a' + (sqTo & 7));
+   ADD('1' + (sqTo / 8));
+
+   //
+   // Promotions
+   //
+   if (ucType & Promotion)
+   {
+    ADD('=');
+    ADD(PieceLetter[Conversion[ucType & 0x0f]]);
+   }
+  }
+ 
+  //
+  // Check and mate
+  //
+  if (FullSANComputed())
+  {
+   if (ucSAN & Mate)
+    ADD('#');
+   else if (ucSAN & Check)
+    ADD('+');
+  }  
+ }
+ 
+ //
+ // End of move string
+ //
+ ADD(0);
+}
+#undef ADD
+
+////////////////////////////////////////////////////////////////////////////
+// Function to parse a move string
+// Return value : 0 when sucessfully parsed, 1 otherwise
+////////////////////////////////////////////////////////////////////////////
+int CMove::ParseString(const char *psz)
+{
+ ucType = 0;
+ ucSAN = 0;
+
+ //
+ // null move
+ //
+ if (psz[0] == 'n' && psz[1] == 'u' && psz[2] == 'l' && psz[3] == 'l')
+  *this = moveNull;
+
+ //
+ // sqFrom and sqTo;
+ //
+ sqFrom = CSquare(psz);
+ sqTo = CSquare(psz + 2);
+ if (sqFrom > CSquare::h8 || sqTo > CSquare::h8)
+  return 1;  
+  
+ //
+ // Castling
+ //
+ if (psz[4] == 'c')
+ {
+  if (psz[2] == 'g')
+   ucType = CMove::OO;
+  else
+   ucType = CMove::OOO;
+ }
+
+ //
+ // Promotion
+ //
+ if (psz[4] == '=')
+ {
+  switch(psz[5])
+  {
+   case 'Q': ucType = Promotion | CPiece::Queen; break;
+   case 'R': ucType = Promotion | CPiece::Rook; break;
+   case 'B': ucType = Promotion | CPiece::Bishop; break;
+   case 'N': ucType = Promotion | CPiece::Knight; break;
+  }
+ }
+ 
+ //
+ // capture "en passant"
+ //
+ if (psz[4] == 'e')
+  ucType = ep;
+
+ return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// output operator
+////////////////////////////////////////////////////////////////////////////
+ostream &operator<<(ostream &ostr, const CMove &move)
+{
+ char szMove[CMove::MaxMoveString];
+ if (move.FullSANComputed())
+  move.MakeString(szMove, CMove::StandardAlgebraic);
+ else
+  move.MakeString(szMove, CMove::Basic);
+ return ostr << szMove;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Function to get the gnuchess notation of a move
+////////////////////////////////////////////////////////////////////////////
+void CMove::GNUChessNotation(char *pszString) const
+{
+#define ADD(c) do {*pszString = c; pszString++;} while(0)
+ ADD('a' + (GetFrom() & 7));
+ ADD('1' + (GetFrom() / 8));
+ ADD('a' + (GetTo() & 7));
+ ADD('1' + (GetTo() / 8));
+
+ static const char PieceLetter[] = "?kqrbnp";
+ static int Conversion[] = {1, 2, 3, 3, 4, 4, 5, 5, 6};
+
+ if (GetType() & Promotion)
+  ADD(PieceLetter[Conversion[GetType() & 0x0f]]);
+
+ ADD(0);  
+#undef ADD
+}

data/ext/bayeselo/move.h

@@ -0,0 +1,139 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// move.h
+//
+// CMove class definition
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef MOVE_H
+#define MOVE_H
+
+#include <iostream>
+
+class CPosition;
+class CMove;
+
+std::ostream &operator<<(std::ostream &ostr, const CMove &move);
+
+class CMove // move
+{
+ private: //////////////////////////////////////////////////////////////////
+  unsigned char sqFrom;
+  unsigned char sqTo;
+  unsigned char ucType;
+  unsigned char ucSAN;
+
+ public: ///////////////////////////////////////////////////////////////////
+  //
+  // Move type flags
+  //
+  enum
+  {
+   Normal    = 0x00,
+   OO        = 0x80,
+   OOO       = 0x40,
+   ep        = 0x20,
+   Promotion = 0x10
+  };
+
+  //
+  // SAN flags
+  //
+  enum
+  {
+   King    = 0x01,
+   Queen   = 0x02,
+   Rook    = 0x03,
+   Bishop  = 0x04,
+   Knight  = 0x05,
+   Pawn    = 0x06,
+   File    = 0x08,
+   Rank    = 0x10,
+   Capture = 0x20,
+   Check   = 0x40,
+   Mate    = 0x80,
+   Partial = Mate | File | Rank
+   
+   // Mate without Check is impossible in a fully computed set of SAN flags
+   // This is the reason why mate without check is used as an indicator that
+   // the full SAN flags have not been computed
+   // (see 'int FullSANComputed() const')
+
+  };
+
+  //
+  // Notations
+  //
+  enum
+  {
+   StandardAlgebraic, // Only when FullSANComputed()
+   LongAlgebraic,     // Partial SAN flags required
+   Basic,             // Does not use ucSAN. No ppos required for parsing
+   ChessBase
+  };
+
+  //
+  // Maximum characters of move strings (counting '\0' at the end)
+  //
+  enum {MaxMoveString = 10};
+  
+  //
+  // Constructors
+  //
+  CMove() {}
+  CMove(const char *psz) {ParseString(psz);}
+  
+  CMove(unsigned char sqFromNew,
+        unsigned char sqToNew,
+        unsigned char ucTypeNew = Normal,
+        unsigned char ucSANNew = 0)
+  {
+   Set(sqFromNew, sqToNew, ucTypeNew, ucSANNew);
+  }
+
+  //
+  // Basic sets and gets
+  //
+  void SetFrom(unsigned char sq) {sqFrom = sq;}
+  void SetTo(unsigned char sq) {sqTo = sq;}
+  void SetType(unsigned char uc) {ucType = uc;}
+  void SetSAN(unsigned char uc) {ucSAN = uc;}
+  void AddSAN(unsigned char uc) {ucSAN |= uc;}
+  void Set(unsigned char sqFromNew,
+           unsigned char sqToNew,
+           unsigned char ucTypeNew = Normal,
+           unsigned char ucSANNew = 0)
+  {
+   SetFrom(sqFromNew);
+   SetTo(sqToNew);
+   SetType(ucTypeNew);
+   SetSAN(ucSANNew);
+  }
+
+  unsigned char GetFrom() const {return sqFrom;}
+  unsigned char GetTo() const {return sqTo;}
+  unsigned char GetType() const {return ucType;}
+  unsigned char GetSAN() const {return ucSAN;}
+
+  //
+  // Other functions
+  //
+  int FullSANComputed() const
+  {
+   return ucSAN && (!(ucSAN & Mate) || (ucSAN & Check));
+  }
+  int ParseString(const char *psz);
+  void MakeString(char *psz, int Notation = StandardAlgebraic) const;
+  void GNUChessNotation(char *pszString) const;
+
+  //
+  // Null move
+  //
+  static CMove moveNull;
+};
+
+#endif