Comments by rescharn

//========================================
// Valid CRC / Chess960 Position generator
//========================================
// Reference Implementation, (C) 2005 by
// Reinhard Scharnagl, Munich, Germany
//----------------------------------------
// Correction 2005-Feb-28 (GC-Nearness)
//========================================

#include < string.h>
#include < stdio.h>

#define TXT_LIM 160

static char FenZone[TXT_LIM];

// insert a symbol into FEN-String 
// -------------------------------
// color could be:
// col <  0 => not specified
// col == 0 => bright square
// col == 1 => dark square
void PlaceIntoFEN
  (int cntFree, char symbol, int fieldColor)
{
  for (int pos = 0, free = 0; ; ++pos) {
    if (fieldColor < 0 || ((fieldColor ^ pos) & 1)) {
      if (!FenZone[pos] && cntFree == free++) {
        FenZone[pos] = symbol;
        break;
      }
    }
  }
}

// generating of FEN strings
// -------------------------
// nr could be
// nr >= 0 creating Chess960 position (1 ... 960)
// nr <  0 creating CRC position    (1 ... 48000)
const char *GetFen(int nr)
{
  // knight distributions over 5 free squares
  static const int knight_pos[10] = {
     3, // xx--- (binary encoded)
     5, // x-x--
     9, // x--x-
    17, // x---x
     6, // -xx--
    10, // -x-x-
    18, // -x--x
    12, // --xx-
    20, // --x-x
    24  // ---xx
  };

  // clear the working area
  int bit, pos = TXT_LIM;
  while (--pos >= 0) { FenZone[pos] = '\0'; }

  // test whether CRC is requested
  bool isCRC = (nr <= 0);

  if (isCRC) {
    nr = -nr;
    bool q_first = ((nr % 2) != 0);
    nr /= 2;
    PlaceIntoFEN(nr % 5, q_first ? 'q' : 'a', 0);
    nr /= 5;
    PlaceIntoFEN(nr % 5, q_first ? 'a' : 'q', 1);
    nr /= 5;
  }

  PlaceIntoFEN(nr % 4, 'b', 0);
  nr /= 4;
  PlaceIntoFEN(nr % 4, 'b', 1);
  nr /= 4;
  PlaceIntoFEN(nr % 6, isCRC ? 'c' : 'q', -1);
  nr /= 6;
  pos = knight_pos[nr % 10];
  for (bit = 5; --bit >= 0; ) {
    if ((pos & (1 << bit)) != 0)
      PlaceIntoFEN(bit, 'n', -1);
  }

  PlaceIntoFEN(2, 'r', -1);
  PlaceIntoFEN(1, 'k', -1);
  PlaceIntoFEN(0, 'r', -1);

  int width = isCRC ? 10 : 8;
  char *pC = &FenZone[width];
  *pC++ = '/';
  for (pos = width; --pos >= 0; ) {
    *pC++ = 'p';
  }
  for (pos = 4; --pos >= 0; ) {
    *pC++ = '/';
    if (width >= 10) {
      *pC++ = '1';
    }
    *pC++ = (char)('0' + width % 10);
  }
  *pC++ = '/';
  for (pos = width; --pos >= 0; ) {
    *pC++ = 'P'; 
  }
  *pC++ = '/';
  for (pos = 0; pos < width; ++pos) {
    *pC++ = FenZone[pos] ^ ('a'^'A');
  }
  strcpy(pC, ' w KQkq - 0 1');

  return FenZone;
}

// check if FEN is valid for CRC
// -----------------------------
bool IsValidCRC(const char *pFen) 
{
  // to be avoided GC position
  static const char *gcArray = 'rnbqckabnr';
  // pawn covering pieces (like a rook)
  static const char *covNear = 'rcqk';
  // pawn covering pieces (like a bishop)
  static const char *covDiag = 'baqk';
  // pawn covering pieces (like a knight)
  static const char *covDist = 'nac';

  int size = (int)(strchr(pFen, '/') - pFen);
  int diff = 0;
  for (int n = size; --n >= 0; ) {
    // different to GC?
    if (pFen[n] != gcArray[n]) {
      ++diff;
    }
    // unprotected pawns?
    if (strchr(covNear, pFen[n]))
      continue;
    if ((n+1) < size && strchr(covDiag, pFen[n+1]))
      continue;
    if ((n-1) >=   0 && strchr(covDiag, pFen[n-1]))
      continue;
    if ((n+2) < size && strchr(covDist, pFen[n+2]))
      continue;
    if ((n-2) >=   0 && strchr(covDist, pFen[n-2]))
      continue;
    return false;
  }
  // GC-near position?
  if (diff < 3 && size == (int)strlen(gcArray)) {
    return false;
  }

  return true;
}

// test output
// -----------
int main(void)
{
  puts('\nfirst Chess960 positions');
  for (int nrFRC = 0; ++nrFRC <= 10; ) {
    printf('(%03d) %s\n',
      nrFRC, GetFen(nrFRC));
  }

  puts('\nfirst CRC positions');
  int cntValid = 0;
  for (int nrCRC = 0; ++nrCRC <= 48000; ) {
    const char *pFEN = GetFen(-nrCRC);
    bool valid = IsValidCRC(pFEN); 
    if (nrCRC <= 32) {
      printf('(%05d %s) %s\n',
        nrCRC, valid ? 'ok' : '--', pFEN);
    }
    if (valid) {
      ++cntValid;
    }
  }

  printf('\n%d valid CRC arrays\n', cntValid);

  return 0;
}

To Fergus Duniho: you are obviously unsure on the grade of distinctness
between valid CRC arrays and the GC starting position. So let us do a
historic approach and try to calculate the distance between GC and
historic 10x8 starting arrays as from Carrera, Bird or Capablanca. I think
that there are more than three reported arrays from those people. 

When it has been possible to patent GC being only slightly different to
those positions, it should be sufficient to demand only the smallest 
there occurring distance. Comparing the GC array 'RNBQCKABNR' to one
reported as from Bird 'RNBCQKABNR' there is a Hamming distance of only
two. But I am not sure, if this Bird's array has been specified that way
- I am missing still the original source. If the smallest distance indeed
should be greater than three, the code I have supplied has to be changed
appropriately.

May be variant experts could help to solve that question doubtlessly.

To Fergus Duniho: Well, if that is indeed the historic array of Bird, then
a Hamming distance of at least three (as I have specified) would be more
than sufficient. So I would not change that demanded difference of three.


I would like to keep the Hamming distance, because shifting a group of
pieces has an immense effect on the properties of a starting array. And I
think that the so created valid CRC arrays obviously are distinct from
GC.

Today I have sent in an updated version of the CRC proposal. I hope that it
could replace the old initial version soon and that it then would be much
better to read.

I want to thank here Mr. Bodlaender and all others, who help together to
publish those new proposals within this 10-chess contest and for the big
efforts they are putting into this huge chessvariants project!

P.S.: Are there any ideas how to accomplish changed contents to become exchanged here on this site?

A) Sorry for not having accomplished to update the CRC content here.

B) There is a first public beta of Smirf (about 1.3 MB), unrestricted
until 2005/06/30. Of course this chess program is subject to further
improvements: http://de.geocities.com/rsmuenchen/

The program should be handled intuitively. But also notice:

a) the board could be turned by clicking on a corner of the board, 
b) in edit mode castling rights easyly could be switched by clicking the
file letters near the involved rooks. This simplifies a consistent
management of castling rights especially with Chess960 positions (maybe an
idea for Arena), 
c) you will find possibilities to select how move possibilities should be
shown or not in the help menu, 
d) double clicking on a move of the list of possible moves will show that
move and preselect it, 
e) double clicking on a move of the game list will reposition the game to
the related situation.

Hi Greg,

> I have been trying this version, but have some difficulties...
> I have been using Janus Chess for testing.

yes, from time to time there is a fully testable Smirf version, which is
only time limited by an attached testing key.

> First, no matter which timing mode I use, the program always seems
> to make its move in less than a second.

That is Smirf's behaviour when the testing key is wrong or timed out. The
current beta package has a working key valid until end of September. So I
prosume you are not testing the current package or have it repeatedly
installed into an already existing Smirf folder where an outtimed key has
been stored in its ini file (and would not be replaced). Thus repeat the
installing procedure but delete any existing Smirf INI file before.

In the reduced mode you are describing, Smirf abilities still could be
inspected, but thinking time and some abilities are reduced. This is
because Smirf is intended to become Shareware later.

> Second problem is that I do not see where you decide which side(s)
> are computer controlled.  After a manual move is entered, it starts
> thinking, but I see no way to make the computer play itself...

Well, Smirf does not play against itself. It is planned to install a 
special form of remote playing ability to enable playing with other 10x8 
chess programs. That would help to also test different engine versions 
to hopefully detect progresses.

There is a check box 'automatic'. Switch it off, and you could enter as
much moves as you like without Smirf's answering.

You also could switch into the edit mode and e.g. switch the active color.

> Otherwise, the program looks nice.  Keep up the good work!

Same for your ChessV! I hope for this there would be a remote protocol 
installed, too (and a beep). Ed Trice has proposed one, but it seems not
to be sufficiently flexible to also support other 10x8 Chess variants.
Thus I try to implement a compatible protocol superset. Do you have
matching ideas?

Regards, Reinhard.

Hi Greg, the only chess program I have inspected ever has been an early
version of GNU. I then immediately decided not to use anything from it. So
SMIRF is completely self developed. But some strategies as known and
documented in literature have influenced me. Actual today is SMIRF 1.28.

As far as I can see SMIRF has a very different data structure. It is a
flat interpreted 15x12 array. The pieces consist of bit encoded properties
and are members of two double linked always sorted lists. There are two
concurring pruning strategies: intelligence feed back (self invented) and
controlled single nullmove (less important). There is only ONE engine
playing a lot of 8x8 and 10x8 chess variants compatibly including
traditional chess rules, Fischer castlings and the extended Capablanca
piece set. One exceptional extension is Janus Chess with its symmetric
castling. The evaluation (still very weak) is not done at quiet nodes but
at deescalated nodes, which means, that also positional combinations are
terminated instead of only piece exchanges.