Author: Gerd Isenberg
Date: 19:54:34 06/03/04
Go up one level in this thread
On June 03, 2004 at 17:56:22, Volker Böhm wrote:
>Hi Gerd,
>
>perhaps you can take a look at another piece of code I use to implement
>incremental attack tables. I have not any idears to improve it any more.
>
>The function is called after I remove a piece to add attacks blocked by the now
>removed piece.
>
>I have a 0x88 board representation with 3 lines border above and below. thus A1
>== 0x30. I am able to loop out of the board.
>
>void AdjustRemove(int aPos)
>{
>int i;
>int aDir;
>int aCur;
>int aDiff;
>int aDirBit;
>int aFld;
>int aBitPos;
>
>// the mAFld is the attack table
>// it has 8 bits for 8 directions indicating from witch direction the field
>// is attacked. The following line seperates the bits from others and shifts
>// them to position 0..7
>// This line could be changed to (mAFld[aPos] >> cQueenShift) but that didn´t
>// increase speed and does only work if the direction bits are the most
>// significant bits (they are now).
>aFld = (mAFld[aPos] & cRangeMask) >> cQueenShift;
>
>// as long as the field is attacked from any direction ..
>for (i = 0; aFld != 0; i++, aFld >>= 1)
>{
> // Looks for the next bit that is set (array-lookup 8 bit)
> aBitPos = cLastBitPos[aFld];
> // i is holding the number of the direction
> i += aBitPos;
> // shift away all "0"´s
> aFld >>= aBitPos;
>
> // gets the direction from a table with 8 entries
> aDir = cAttackDirs[i];
>
> // looks for the piece attacking. Don´t know what kind it
> // is. Maybe queen or bishop for diagonals and rook or queen
> // for horizontals. There is not enough space for 8 "is-queen"
> // bits in the attack table field.
> for (aCur = aPos + aDir; IsEmpty(aCur); aCur += aDir);
>
> // Gets the shape of the piece from the board and
> // converts it to a "kind-of-piece-bit"
> aDiff = cBitLookup[GetP(aCur)];
> // Get the direction bit
> aDirBit = cQueenBit << i;
> // loops through every field now attacked
> // IsEmpty(aCur) compares the board field to 0. The same
> // as GetP(aCur) == 0
> for (aCur = aPos - aDir; IsEmpty(aCur); aCur -= aDir)
> {
> // sets the king-of-piece-bit to the attack signature
> // and the attacked from direction bit
> mAFld[aCur] += aDiff + aDirBit;
> }
> // sets the not empty field. Either a piece or a border field
> // doesn´t matter that a border field could be attacked.
> mAFld[aCur] += aDiff + aDirBit;
>}
>}
At the first glance i can't see much to improve - may be others?
Nested loops look expensive, even if they terminate fast.
Cheers,
Gerd
This page took 0 seconds to execute
Last modified: Thu, 15 Apr 21 08:11:13 -0700
Current Computer Chess Club Forums at Talkchess. This site by Sean Mintz.