Well, I think A and Q are distributed on differently colored squares already by the numbering scheme. But the covering of every pawn and the avoiding of neighbored bishops are done by filtering after randomizing the position.
Of course the filtering could be disabled e.g. by introducing a new menu option. But I experienced the raising of some unacceptable high advantage for the beginning white side in some special starting arrays. Especially when too much Bishop compatible pieces e.g. are very far left and the opposite King is standing far right. Thus I decided to avoid a lot of such extremes by default. Nevertheless there still some dangerous arrays are possible.
Anything new about the ChessV Project?
Moderators: hgm, Rebel, chrisw
-
smrf
- Posts: 484
- Joined: Mon Mar 13, 2006 11:08 am
- Location: Klein-Gerau, Germany
-
hgm
- Posts: 27837
- Joined: Fri Mar 10, 2006 10:06 am
- Location: Amsterdam
- Full name: H G Muller
Re: Anything new about the ChessV Project?
OK, the code below seems to work. To convert the random number to a position, I peel off bits from the low end, by taking remainder, and use that to place the next piece or piece pair. For CRC the piece order isMatthias Gemuh wrote:I can recode my shuffling according to what your more complex shuffling demands, so just go ahead and fully define a standard.
B(light), B(dark), C, A, Q, N(pair) and fill remaining holes with KRK.
Both B are assigned with 5 possibilities, on their respective colors.
C then with 8 possibilities on any color,
A with 7
Q with 6
the N pair with 20 (= 5*4/2)
for a total of 25*8*7*6*20 = 168,000 shuffles
When I shuffle in variant capablanca, rather then caparandom, I place K and R first in their orthoox position, (f1, a1 and j1), after which the order is:
light B 3 possibilities (b1, d1, h1)
dark B 4 possibilities (c1, e1, g1, i1)
C with 5
A with 4
Q with 3
and the holes filled with Knights
This gives 12*5*4*3 = 720 possibilities.
Code: Select all
// [HGM] shuffle: a more general way to suffle opening setups, applicable to arbitrry variants.
// All positions will have equal probability, but the current method will not provide a unique
// numbering scheme for arrays that contain 3 or more pieces of the same kind.
#define DARK 1
#define LITE 2
#define ANY 3
int squaresLeft[4];
int piecesLeft[(int)BlackPawn];
long long int seed, nrOfShuffles;
int put(Board board, int pieceType, int rank, int n, int shade)
// put the piece on the (n-1)-th empty squares of the given shade
{
int i;
for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
if( ((i-BOARD_LEFT)&1)+1 & shade && board[rank][i] == EmptySquare && n-- == 0) {
board[rank][i] = (ChessSquare) pieceType;
squaresLeft[(i-BOARD_LEFT&1) + 1]--;
squaresLeft[ANY]--;
piecesLeft[pieceType]--;
return i;
}
}
return -1;
}
void AddOnePiece(Board board, int pieceType, int rank, int shade)
// calculate where the next piece goes, (any empty square), and put it there
{
int i;
i = seed % squaresLeft[shade];
nrOfShuffles *= squaresLeft[shade];
seed /= squaresLeft[shade];
put(board, pieceType, rank, i, shade);
}
void AddTwoPieces(Board board, int pieceType, int rank)
// calculate where the next 2 identical pieces go, (any empty square), and put it there
{
int i, n=squaresLeft[ANY], j=n-1, k;
k = n*(n-1)/2; // nr of possibilities, not counting permutations
i = seed % k; // pick one
nrOfShuffles *= k;
seed /= k;
while(i >= j) i -= j--;
j = n - 1 - j; i += j;
put(board, pieceType, rank, j, ANY);
put(board, pieceType, rank, i, ANY);
}
void SetUpShuffle(Board board, int number)
{
int i, p, first=1;
seed = number, nrOfShuffles = 1;
if(number < 0) {
srand(time(0));
for(i=0; i<50; i++) seed += rand();
seed = rand() ^ rand()<<16;
}
squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
squaresLeft[ANY] = BOARD_RGHT - BOARD_LEFT;
squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
p = (int) board[0][i];
if(p < (int) BlackPawn) piecesLeft[p] ++;
board[0][i] = EmptySquare;
}
if(PosFlags(0) & F_ALL_CASTLE_OK) {
// shuffles restricted to allow normal castling put KRR first
if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
put(board, WhiteKing, 0, (BOARD_LEFT+BOARD_RGHT+1)/2, ANY);
else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
put(board, WhiteUnicorn, 0, (BOARD_LEFT+BOARD_RGHT+1)/2, ANY);
if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
put(board, WhiteRook, 0, BOARD_RGHT-2, ANY);
if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
put(board, WhiteRook, 0, BOARD_LEFT, ANY);
// in variants with super-numerary Kings and Rooks, we leave these for the shuffle
}
if((BOARD_RGHT-BOARD_LEFT & 1) == 0)
// only for even boards make effort to put pairs of colorbound pieces on opposite colors
for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
while(piecesLeft[p] >= 2) {
AddOnePiece(board, p, 0, LITE);
AddOnePiece(board, p, 0, DARK);
}
// Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
}
for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
// Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
// but we leave King and Rooks for last, to possibly obey FRC restriction
if(p == (int)WhiteRook) continue;
while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY); // add the odd piece
}
// now everything is placed, except perhaps King (Unicorn) and Rooks
if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
// Last King gets castling rights
while(piecesLeft[(int)WhiteUnicorn]) {
i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
initialRights[2] = initialRights[5] = castlingRights[0][2] = castlingRights[0][5] = i;
}
while(piecesLeft[(int)WhiteKing]) {
i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
initialRights[2] = initialRights[5] = castlingRights[0][2] = castlingRights[0][5] = i;
}
} else {
while(piecesLeft[(int)WhiteKing]) AddOnePiece(board, WhiteKing, 0, ANY);
while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
}
// Only Rooks can be left; simply place them all
while(piecesLeft[(int)WhiteRook]) {
i = put(board, WhiteRook, 0, 0, ANY);
if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
if(first) {
first=0;
initialRights[1] = initialRights[4] = castlingRights[0][1] = castlingRights[0][4] = i;
}
initialRights[0] = initialRights[3] = castlingRights[0][0] = castlingRights[0][3] = i;
}
}
for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
board[BOARD_HEIGHT-1][i] = (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
}
if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
}
-
Matthias Gemuh
- Posts: 3245
- Joined: Thu Mar 09, 2006 9:10 am
Re: Anything new about the ChessV Project?
hgm wrote:OK, the code below seems to work. To convert the random number to a position, I peel off bits from the low end, by taking remainder, and use that to place the next piece or piece pair. For CRC the piece order isMatthias Gemuh wrote:I can recode my shuffling according to what your more complex shuffling demands, so just go ahead and fully define a standard.
B(light), B(dark), C, A, Q, N(pair) and fill remaining holes with KRK.
Both B are assigned with 5 possibilities, on their respective colors.
C then with 8 possibilities on any color,
A with 7
Q with 6
the N pair with 20 (= 5*4/2)
for a total of 25*8*7*6*20 = 168,000 shuffles
When I shuffle in variant capablanca, rather then caparandom, I place K and R first in their orthoox position, (f1, a1 and j1), after which the order is:
light B 3 possibilities (b1, d1, h1)
dark B 4 possibilities (c1, e1, g1, i1)
C with 5
A with 4
Q with 3
and the holes filled with Knights
This gives 12*5*4*3 = 720 possibilities.
Code: Select all
// [HGM] shuffle: a more general way to suffle opening setups, applicable to arbitrry variants. // All positions will have equal probability, but the current method will not provide a unique // numbering scheme for arrays that contain 3 or more pieces of the same kind. #define DARK 1 #define LITE 2 #define ANY 3 int squaresLeft[4]; int piecesLeft[(int)BlackPawn]; long long int seed, nrOfShuffles; void SetUpShuffle(Board board, int number) { int i, p, first=1; .... }
Thanks for the stuff. I will integrate it into ChessGUI soon.
Matthias.
.
My engine was quite strong till I added knowledge to it.
http://www.chess.hylogic.de
http://www.chess.hylogic.de
-
Matthias Gemuh
- Posts: 3245
- Joined: Thu Mar 09, 2006 9:10 am
Re: Anything new about the ChessV Project?
hgm wrote:OK, the code below seems to work. To convert the random number to a position, I peel off bits from the low end, by taking remainder, and use that to place the next piece or piece pair. For CRC the piece order isMatthias Gemuh wrote:I can recode my shuffling according to what your more complex shuffling demands, so just go ahead and fully define a standard.
B(light), B(dark), C, A, Q, N(pair) and fill remaining holes with KRK.
Both B are assigned with 5 possibilities, on their respective colors.
C then with 8 possibilities on any color,
A with 7
Q with 6
the N pair with 20 (= 5*4/2)
for a total of 25*8*7*6*20 = 168,000 shuffles
When I shuffle in variant capablanca, rather then caparandom, I place K and R first in their orthoox position, (f1, a1 and j1), after which the order is:
light B 3 possibilities (b1, d1, h1)
dark B 4 possibilities (c1, e1, g1, i1)
C with 5
A with 4
Q with 3
and the holes filled with Knights
This gives 12*5*4*3 = 720 possibilities.
Code: Select all
// [HGM] shuffle: a more general way to suffle opening setups, applicable to arbitrry variants. // All positions will have equal probability, but the current method will not provide a unique // numbering scheme for arrays that contain 3 or more pieces of the same kind. #define DARK 1 #define LITE 2 #define ANY 3 int squaresLeft[4]; int piecesLeft[(int)BlackPawn]; long long int seed, nrOfShuffles; void SetUpShuffle(Board board, int number) { int i, p, first=1; seed = number, nrOfShuffles = 1; ... if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize }
Hi HGM,
In SetUpShuffle() you refer to strange chess pieces, so I don't understand things like "(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil)". Can you provide an indexed list of them all ?
Code: Select all
int piecesLeft[(int)BlackPawn];Best,
Matthias.
.
My engine was quite strong till I added knowledge to it.
http://www.chess.hylogic.de
http://www.chess.hylogic.de
-
hgm
- Posts: 27837
- Joined: Fri Mar 10, 2006 10:06 am
- Location: Amsterdam
- Full name: H G Muller
Re: Anything new about the ChessV Project?
In WinBoard 4.3.13 the list is (low to high):
Pawn
Knight
Bishop
Rook
Queen
Ferz
Elephant (Alfil)
Archbishop (Angel)
Chancellor (Marshal)
Wazir
Commoner (Man)
Cannon
Nightrider
Cardinal
Dragon
Grasshopper
Silver
Falcon
Lance
Cobra
Unicorn
King
The Alfil and Ferz are color-bound pieces, like the Bishop, which is why I treat them with priority if there are pairs.
But you can simply skip all pieces that your GUI does not implement, as in games where they do not occur they would be skipped anyway, and games were yhey do occur the GUI could not handle at all, and there would be no reason to shuffle them. So for the variants ChessGUI implements you can simply use the order P,N,B,R,Q,A,C,K. And K and R are treated separately depending on castling flavor. So the only thing that remains is that B-pairs go first, and within the remaining group the order is C,A,Q,N.
Pawn
Knight
Bishop
Rook
Queen
Ferz
Elephant (Alfil)
Archbishop (Angel)
Chancellor (Marshal)
Wazir
Commoner (Man)
Cannon
Nightrider
Cardinal
Dragon
Grasshopper
Silver
Falcon
Lance
Cobra
Unicorn
King
The Alfil and Ferz are color-bound pieces, like the Bishop, which is why I treat them with priority if there are pairs.
But you can simply skip all pieces that your GUI does not implement, as in games where they do not occur they would be skipped anyway, and games were yhey do occur the GUI could not handle at all, and there would be no reason to shuffle them. So for the variants ChessGUI implements you can simply use the order P,N,B,R,Q,A,C,K. And K and R are treated separately depending on castling flavor. So the only thing that remains is that B-pairs go first, and within the remaining group the order is C,A,Q,N.