TweetFollow Us on Twitter

Aug 95 Challenge
Volume Number:11
Issue Number:8
Column Tag:Programmer’s Challenge

Programmer’s Challenge

By Bob Boonstra, Westford, Massachusetts

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

Diff-Warrior

Authors frequently use a software tool to compare different versions of the same document and identify what changes have been made between versions. Something like the well-known diff utility for programmers, but operating on a words instead of a lines. This month your Challenge is to write a simplified version of such a file comparison tool.

The prototype of the code you should write is:

#define ulong unsigned long

typedef enum { 
/* describes type of text change between old and new versions of text */
  deletedText=0, insertedText, movedText } DiffType;

typedef struct {
DiffType type;
/* The meaning of the remaining fields depends on type.
    For type == deletedText:
    rangeStart -   offset in oldText of first char deleted
    rangeEnd -     offset in oldText of last char deleted
    position -  offset in newText before which text would be inserted to convert 
    newText into oldText
    For type == insertedText:
    rangeStart -   offset in newText of first char inserted
    rangeEnd -     offset in newText of last char inserted
    position -  offset in oldText before which text would be inserted to convert 
    oldText into newText
    For type == movedText:
    rangeStart-    offset in oldText of first char moved
    rangeEnd-      offset in oldText of last char moved
     position-  offset in oldText before which text would be inserted to convert 
    oldText into newText
*/
ulong rangeStart; 
ulong rangeEnd;
ulong position; 
} DiffRec;

short /* numDiffsFound */ FindWordDifferences (
char *oldText,     /* pointer to old version of text */
char *newText,     /* pointer to new version of text */
ulong numOldChars, /* number of characters in oldText */
ulong numNewChars, /* number of characters in newText */
DiffRec diffs[],   /* pointer to preallocated array where text differences are to 
  be stored */
ulong maxDiffRecs  /* number of DiffRecs preallocated */
);

FindWordDifferences should store a DiffRec in the diffs array for each sequence of words that were deleted or moved from oldText, and for each sequence inserted into newText. So, for example, if newText and oldText contained the following characters

oldText->The quick brown fox jumps over the lazy dog.
newText->The brown and white lazy fawn jumps over the dog.

you would return the value 5 and store the following into the diffs array:

diffs[0]={deletedText,  4, 9, 4}  (deleted "quick ")
diffs[1]={insertedText,10,19,16}  (inserted "and white ")
diffs[2]={movedText,   35,39,16}  (moved "lazy ")
diffs[3]={deletedText, 16,18,25}  (deleted "fox")
diffs[4]={insertedText,25,28,16}  (inserted "fawn")

The solution to this problem is clearly not unique. For example, each problem has a trivial solution where all of the oldText is deleted, and all of the newText is inserted. To encourage nontrivial and optimal solutions, selection of the winner will be based on the quality of the FindWordDifferences job you do, as well as how quickly you find a solution. Quality will be measured first by the number of characters deleted, inserted, and moved (the sum of the (rangeEnd-rangeStart+1) values in your DiffRec array), and next on the number of differences found (numDiffsFound), with smaller being better in both cases. The fastest solution within 10% of the best quality score (both parameters) will be declared the winner. These criteria place a premium on finding movedText (as opposed to deletedText / insertedText pairs) and on finding larger contiguous sections of inserted / deleted text (as opposed to sequences of smaller changes).

Now for the fine print. Notice that the comparison is based on words, not just on characters (look at “fox” and “fawn” above), so be careful when calculating offsets. Words are delimited by white space (spaces, CR, NL, tabs), or punctuation. Extra/missing white space and/or punctuation should also result in a DiffRec. Your solution should be case sensitive (i.e., “The” is different from “the”). You may not change the input text pointed to by newText and oldText. The DiffRec offsets calculated by your program should apply to the unchanged input oldText and newText (i.e., they should be independent of changes implied by any other DiffRecs). Correctness will be determined by using the DiffRecs you produce to convert the oldText into the newText, and vice versa (ignoring CRs and NLs). In doing the conversions, the DiffRecs will be applied in order of decreasing position / rangeStart value, and (in case of duplicates) in reverse order of the DiffRec array. Testing will use text files averaging 5-20K characters in size, and at least one test case will exceed 64K.

Thanks to the generosity of Metrowerks, who provided a copy of CodeWarrior for use in the Challenge, and in response to requests from several readers, this Challenge will be scored using the CodeWarrior compiler. The target instruction set is the 680x0 family; I’ll be testing on a 68040. (We’ll have a PowerPC Challenge in a couple of months.)

Finally, I want to express the gratitude that all Challenge participants feel toward Mike Scanlin for his excellent work writing this column. I am honored to have the opportunity to take over and hope to maintain the high standard Mike set. If any of you have suggestions on how to make the column and the Challenge even better, please send them to me at one of the Programmer’s Challenge e-mail addresses, or directly to boonstra@ultranet.com.

Two Months Ago Winner

Apparently there are at least a few chess players among MacTech Challenge readers. Of the six entries I received for the Check Checkmate Challenge, four worked correctly. Congratulations to Gary Beith (Largo, FL) for his efficient and instructive solution. Gary’s win is especially notable because this is his first entry in the Programmer’s Challenge.

Here are the times and code sizes for the entries that worked correctly. Numbers in parens after a person’s name indicate that person’s cumulative point total for all previous Challenges, not including this one:

Name time code

Gary Beith 188 4282

Ernst Munter (60) 260 19810

Xan Gregg (24) 639 4242

David Rees 2919 2604

Gary’s solution demonstrates several features associated with efficient solutions. He employs an appropriate representation of the problem data, including a chessboard representation that includes a border area, allowing efficient computation of chess moves with a minimum of special code for board boundaries. Gary takes maximal advantage of the untimed initialization routine, setting up move tables for each type of chesspiece. The problem statement provides opportunities for optimization; in this case, the problem is a legal chess position, and Gary uses that to determine whether a move places the opponent’s king in check. He applies knowledge of the problem domain to limit the number of possibilities his code examines, for example, by identifying which pieces are pinned and which axes of movement need not be considered, and in constraining the possible moves for the case of a king in check. Gary’s solution is not only an excellent one for the specific problem posed, but offers an instructive approach to Challenges in general. Nice job!

Top 20 Contestants of All Time

Here are the Top 20 Contestants for the 36 Programmer’s Challenges to date. The numbers below include points awarded for this month’s entrants. (Note: ties are listed alphabetically by last name - there are 25 people listed this month because 6 people have 20 points each.)

1. [Name deleted] 176

2. Karsh, Bill 71

3. Munter, Ernst 70

4. Stenger, Allen 65

5. Larsson, Gustav 60

6. Riha, Stepan 51

7. Goebel, James 49

8. Nepsund, Ronald 47

9. Cutts, Kevin 46

10. Mallett, Jeff 44

11. Kasparian, Raffi 42

12. Vineyard, Jeremy 40

13. Darrah, Dave 31

14. Gregg, Xan 31

15. Landry, Larry 29

16. Elwertowski, Tom 24

17. Lee, Johnny 22

18. Noll, Robert 22

19. Anderson, Troy 20

20. Beith, Gary 20

21. Burgoyne, Nick 20

22. Galway, Will 20

23. Israelson, Steve 20

24. Landweber, Greg 20

25. Pinkerton, Tom 20

There are three ways to earn points: (1) scoring in the top 5 of any Challenge, (2) being the first person to find a bug in a published winning solution or, (3) being the first person to suggest a Challenge that I use. The points you can win are:

1st place 20 points

2nd place 10 points

3rd place 7 points

4th place 4 points

5th place 2 points

finding bug 2 points

suggesting Challenge 2 points

Here is Gary’s winning solution:


ChessMoveEnumerator.c

Copyright ©1995 Gary Beith

/* =========================================================
Objective: To determine all legal moves (excluding castling and en passant captures) available for a given 
chess position.  It is NOT required to single out intelligent moves!
========================================================= */

/* ---------------------------------------------------------
    Items required by the problem statement
--------------------------------------------------------- */

#pragma options ( mc68020, !mc68881, require_protos )
#pragma options ( pack_enums, align_arrays )

typedef enum { rowA = 0, rowB, rowC, rowD, rowE, rowF, rowG, 
    rowH } Row;
typedef enum { col1 = 0, col2, col3, col4, col5, col6, col7,
    col8 } Col;
typedef enum { whiteSide = 0, blackSide } Side;
typedef enum { king = 0, queen, rook, bishop, knight, pawn }
    ChessPiece;

typedef struct Square {
 Row    row;
 Col    col;
} Square;

typedef struct PiecePosition {
 Square sq;
 Side   side;
 ChessPiece piece;
} PiecePosition;

typedef struct ChessMove {
 Square fromSq;
 Square toSq;
 BooleanmoveIsCapture;
 BooleanopponentPlacedInCheck;
} ChessMove;

short /* numberOfMoves */ LegalChessMoves(
 PiecePosition piecePositionArray[],
 short  numberOfPieces,
 Side   sideToMove,
 ChessMovelegalMoveArray[],
 void   *privateDataPtr
);

void InitChess(void *privateDataPtr);


/* =========================================================
    From here on, I’m on my own :-)
========================================================= */

#define kMaxChessPiece    pawn

typedef Square *SquarePtr;
typedef PiecePosition *PiecePosPtr;
typedef ChessMove *ChessMovePtr;

typedef enum {
 stmPawnSq0 = 0, stmPawnSq1, stmPieceSq0, stmPieceSq1,
 offBoardSq0, offBoardSq1, emptySq0, emptySq1,
 oppPieceSq0, oppPieceSq1, oppPawnSq0, oppPawnSq1
} MySquare, *MySquarePtr;

/* 
The attack flag is used to denote squares near the King known to be under attack, thus preventing the King 
from moving to them.  State “0” for each square type represents attack flag not set, state “1” represents 
flag set.  The attack mask is used to clear the flag when testing for empty squares.
 */
#define kAttackFlag0x01
#define kAttackMask0x0e

typedef char MySquareIncr, *MySqIncrPtr;
typedef unsigned char MyAxis, *MyAxisPtr;
typedef short MySquareDiff, *MySqDiffPtr;

typedef struct {
 MySqIncrPtrsqIncrArrayPtr;
 MyAxisPtraxisArrayPtr;
 short  numberOfAxes;
} MyPieceTable;

typedef struct {
 MySquarePtrsqPtr;
 MyPieceTable    pcTable;
 Square fromSq;
 MyAxis discAxis, pinAxis;
} MyPiece, *MyPiecePtr, **MyPieceHandle;

typedef struct {
 MyPieceHandle   pcHandle;
 MyPieceTable    pcTable;
 MySquare sqType;
} MyPieceInfo, *MyPcInfoPtr;

/* 
    My internal square numbering scheme:
  ** Opponent **
 [175] -   -   - .... -   - [185]
   -   -   -   - .... -   -   -   -   -   -   - [174]
   -   - (145) - .... - (152) -   -   -   -   -   -
  < six more rows here >
   -   - ( 33) - .... - ( 40) -   -   -   -   -   -
 [ 15] -   -   - .... -   -   -   -   -   -   -   -
     [  0] -   - .... -   -   -   -   -   -   - [ 14]
  ** Side to move **

Numbers in parentheses indicate corners of the actual chess board.  Some reasons for choosing this scheme:
1.A border of at least two off-board squares is provided around the board to facilitate the determination of 
valid Knight moves.
2.Adjacent squares in a column have an absolute index difference of 16 (efficient power of 2).  A difference 
of at least 15 was required so that index values for squares in the same row would always differ by less than 
those for squares in different rows.
3.The perspective of the side to move is used rather than that of either White or Black exclusively.  This 
enables the identical move enumeration algorithm to be used for either side - differences such as pawn movement 
direction are accounted for when converting from and to the problem statement’s board format.
*/
#define kLowerLeftSqIndex 33
#define kMin4thRankSqIndex81
#define kMin5thRankSqIndex97
#define kMin8thRankSqIndex145
#define kUpperRightSqIndex152
#define kMaxSqIndex185

/* Maximum square index differential on the board = kUpperRightSqIndex - kLowerLeftSqIndex */
#define kMaxSqDiff 119

/* 
For purposes of this program, “long move” pieces are defined as consisting of Queens, Rooks, and Bishops. 
 These pieces may move as many unobstructed spaces in each of their permitted directions as are available 
on the board.  The maximum counts given for long move pieces and Knights allow for the potential for all 
eight Pawns to romote to such pieces.
*/
#define kMaxLongMovePieces13
#define kMaxKnights10
#define kMaxPawns8
 
typedef struct {
 MyPiecePtr endSTMKingPtr, endOppKingPtr,
 endSTMLMPiecePtr, endOppLMPiecePtr,
 endSTMKnightPtr, endOppKnightPtr,
 endSTMPawnPtr;
 MySquare sqArray[kMaxSqIndex + 1];
} MyChessBoard;

typedef struct {
 MyChessBoard  chessBoard, emptyBoard;
 MyPiecestmKing, oppKing,
 stmLMPieceArray[kMaxLongMovePieces],
 oppLMPieceArray[kMaxLongMovePieces],
 stmKnightArray[kMaxKnights],
 oppKnightArray[kMaxKnights],
 stmPawnArray[kMaxPawns];
 MyPiecePtr pcPtrArray[kMaxSqIndex + 1];
 Square whiteSqArray[kMaxSqIndex + 1],
 blackSqArray[kMaxSqIndex + 1];
 SquarePtrstmSqArrayPtr;
 MyPieceInfostmPcInfoArray[kMaxChessPiece + 1],
 oppPcInfoArray[kMaxChessPiece + 1];
 MySquareIncr  queenSqIncrArray[2 * kMaxSqDiff + 1],
 rookSqIncrArray[2 * kMaxSqDiff + 1],
 bishopSqIncrArray[2 * kMaxSqDiff + 1];
 BooleanknightMoveArray[2 * kMaxSqDiff + 1];
 MyAxis queenAxisArray[4], rookAxisArray[2],
 bishopAxisArray[2];
 MySquareDiff  knightSqDiffArray[8],
 kingSqDiffArray[8];
} MyData, *MyDataPtr;

Local function prototypes

void SetUpMyChessBoard(MyDataPtr dataPtr,
  PiecePosition piecePositionArray[],
  short numberOfPieces,
  Side sideToMove);

short FindChecksAndPins(MyDataPtr dataPtr,
 MySquarePtr *checkSqHandle,
 MySquareIncr *checkSqIncrPtr);

void EnumerateNonKingMoves(MyDataPtr dataPtr,
 ChessMovePtr *moveHandle);

void EnumerateNonKingCapturesOfCheckingPiece(      
 MyDataPtr dataPtr,
 MySquarePtr checkSqPtr,
 ChessMovePtr *moveHandle);

void EnumerateInterpositionMoves(MyDataPtr dataPtr,
 MySquarePtr checkSqPtr,
   MySquareIncr checkSqIncr,
   ChessMovePtr *moveHandle);

void EnumerateKingMoves(MyDataPtr dataPtr,
 ChessMovePtr *moveHandle);


LegalChessMoves

/* =========================================================
    Timed legal move enumeration routine
========================================================= */

short LegalChessMoves(PiecePosition piecePositionArray[],
 short numberOfPieces,
 Side sideToMove,
 ChessMove legalMoveArray[],
 void *privateDataPtr)
{
 MyDataPtrdataPtr = privateDataPtr;
 short  numberOfChecks;
 MySquarePtrcheckSqPtr;
 MySquareIncr    checkSqIncr;
 ChessMovePtr    movePtr = legalMoveArray;

 SetUpMyChessBoard(dataPtr, piecePositionArray,
 numberOfPieces, sideToMove);

 numberOfChecks = FindChecksAndPins(dataPtr, &checkSqPtr,
  &checkSqIncr);


 if (numberOfChecks == 0)
 {
 EnumerateNonKingMoves(dataPtr, &movePtr);
 }
 else if (numberOfChecks == 1)
 {
 EnumerateNonKingCapturesOfCheckingPiece(dataPtr,              
 checkSqPtr,
 &movePtr);
 if (checkSqIncr)
 {
 EnumerateInterpositionMoves(dataPtr, checkSqPtr,
 checkSqIncr, &movePtr);
 }
 }
    /* else if (numberOfChecks == 2)
     Only King moves are possible (if any exist). */

 EnumerateKingMoves(dataPtr, &movePtr);

 return (movePtr - legalMoveArray); /* Number of moves */
}


SetUpMyChessBoard

void SetUpMyChessBoard(MyDataPtr dataPtr,
  PiecePosition piecePositionArray[],
  short numberOfPieces,
  Side sideToMove)
{
 PiecePosPtrposPtr, endPosPtr;
 short  sqIndex;
 MyPcInfoPtrpcInfoPtr;
 MySquarePtrsqPtr;
 MyPiecePtr pcPtr;

 dataPtr->chessBoard = dataPtr->emptyBoard;

 posPtr = piecePositionArray;
 endPosPtr = posPtr + numberOfPieces;


 if (sideToMove) /* == blackSide */
 {
 dataPtr->stmSqArrayPtr = dataPtr->blackSqArray;
 do
 {
 sqIndex = kUpperRightSqIndex -
 ((posPtr->sq.row << 4) + posPtr->sq.col);

 pcInfoPtr = (posPtr->side) ?
 dataPtr->stmPcInfoArray + posPtr->piece :
 dataPtr->oppPcInfoArray + posPtr->piece;

 sqPtr  = dataPtr->chessBoard.sqArray + sqIndex;
 if ((*sqPtr = pcInfoPtr->sqType) != oppPawnSq0)
 {
 dataPtr->pcPtrArray[sqIndex] =
 pcPtr = (*pcInfoPtr->pcHandle)++;

 pcPtr->sqPtr = sqPtr;
 pcPtr->pcTable = pcInfoPtr->pcTable;
 pcPtr->fromSq = posPtr->sq;
 pcPtr->discAxis = pcPtr->pinAxis = 0;
 }
 }
 while (++posPtr != endPosPtr);
 }
 else
 {
 dataPtr->stmSqArrayPtr = dataPtr->whiteSqArray;
 do
 {
 sqIndex = kLowerLeftSqIndex +
 ((posPtr->sq.row << 4) + posPtr->sq.col);

 pcInfoPtr = (posPtr->side) ?
 dataPtr->oppPcInfoArray + posPtr->piece :
 dataPtr->stmPcInfoArray + posPtr->piece;

 sqPtr  = dataPtr->chessBoard.sqArray + sqIndex;
 if ((*sqPtr = pcInfoPtr->sqType) != oppPawnSq0)
 {
 dataPtr->pcPtrArray[sqIndex] =
 pcPtr = (*pcInfoPtr->pcHandle)++;

 pcPtr->sqPtr = sqPtr;
 pcPtr->pcTable = pcInfoPtr->pcTable;
 pcPtr->fromSq = posPtr->sq;
 pcPtr->discAxis = pcPtr->pinAxis = 0;
 }
 }
 while (++posPtr != endPosPtr);
 }
}


FindChecksAndPins

short FindChecksAndPins(MyDataPtr dataPtr,
 MySquarePtr *checkSqHandle,
 MySquareIncr *checkSqIncrPtr)
{
 MySquarePtrkingSqPtr, sqPtr;
 MyPiecePtr endPcPtr, pcPtr;
 short  sqIncr, stmPcSqIndex, numberOfChecks = 0;

/* 
Since I must report all moves which place the opponent in check, I first scan for possible discovered checks. 
 These occur when only one piece (which must belong to the side to move) stands between one of the mover’s 
long move pieces and the enemy King, and that piece is moved off of the line of attack.  Because I am only 
required to analyze legal positions, I know that at least one piece will exist on any such line of attack.
*/
 kingSqPtr = dataPtr->oppKing.sqPtr;

 endPcPtr = dataPtr->chessBoard.endSTMLMPiecePtr;
 for (pcPtr = dataPtr->stmLMPieceArray;
  pcPtr < endPcPtr; pcPtr++)
 {
 sqPtr = pcPtr->sqPtr;
 sqIncr = pcPtr->pcTable.sqIncrArrayPtr
  [kingSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 continue;/* King not “in line” with this piece */

 sqPtr += sqIncr;
 stmPcSqIndex = 0;
 while (*sqPtr <= emptySq1) /* Not opponent’s piece */
 {
 if (*sqPtr < emptySq0)   /* Is mover’s piece */
 {
 if (stmPcSqIndex)
 break; /* More than one piece in its path */

 stmPcSqIndex = sqPtr - dataPtr->chessBoard.sqArray;
 }

 if ((sqPtr += sqIncr) == kingSqPtr)
 {
    /* Record line of attack for future reference */
 dataPtr->pcPtrArray[stmPcSqIndex]->discAxis =
 (sqIncr < 0) ? -sqIncr : +sqIncr;
 break;
 }
 }
 }

/* 
A similar analysis determines if any pieces are“pinned," i.e., they stand in the way of an attack on the mover’s 
King by an enemy piece.  A pinned piece can move only along the line of attack (if such a move is permitted 
for the piece; in particular, a pinned Knight is never able to move).
*/
 kingSqPtr = dataPtr->stmKing.sqPtr;

 endPcPtr = dataPtr->chessBoard.endOppLMPiecePtr;
 for (pcPtr = dataPtr->oppLMPieceArray;
  pcPtr < endPcPtr; pcPtr++)
 {
 sqPtr = pcPtr->sqPtr;
 sqIncr = pcPtr->pcTable.sqIncrArrayPtr
  [kingSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 continue;

 if ((sqPtr += sqIncr) == kingSqPtr)
 {
/* 
Piece is adjacent to King.  The King may capture it if it is not protected by another piece.  However, no interposition 
moves are possible.
*/
 sqPtr[+sqIncr] |= kAttackFlag;
 *checkSqHandle = pcPtr->sqPtr;
 *checkSqIncrPtr = 0;
 numberOfChecks++;
 continue;
 }

 stmPcSqIndex = 0;
 while (*sqPtr <= emptySq1)
 {
 if (*sqPtr < emptySq0)
 {
 if (stmPcSqIndex)
 break;

 stmPcSqIndex = sqPtr - dataPtr->chessBoard.sqArray;
 }

 if ((sqPtr += sqIncr) == kingSqPtr)
 {
 if (stmPcSqIndex) /* Pinned piece was found */
 {
 dataPtr->pcPtrArray[stmPcSqIndex]->pinAxis =
 (sqIncr < 0) ? -sqIncr : +sqIncr;
 }
 else
 {
/* 
King is in check “from a distance.”  If the King moves, it must leave the line of attack, which is recorded so 
that interposition moves can be determined later on.
*/
 sqPtr[+sqIncr] |= kAttackFlag;
 sqPtr[-sqIncr] |= kAttackFlag;
 *checkSqHandle = pcPtr->sqPtr;
 *checkSqIncrPtr = sqIncr;
 numberOfChecks++;
 }

 break;
 }
 }
 }

/* 
The maximum number of checks possible is two, only one of which can come from a Pawn or Knight.
*/
 if (numberOfChecks < 2)
 {
/* 
Per ANSI standard, a sequence point occurs after the evaluation of each operand of the Logical Or and Logical 
And operators.  Therefore, I can validly rely on the value of sqPtr being set in exactly the order specified 
in the next expression (and others like it). That is not generally true of most other operators.
*/
 if ((*(sqPtr = kingSqPtr + 15) >= oppPawnSq0) ||
 (*(sqPtr += 2) >= oppPawnSq0))
 {
 *checkSqHandle = sqPtr;
 *checkSqIncrPtr = 0;
 numberOfChecks++;
 }
 else
 {
 endPcPtr = dataPtr->chessBoard.endOppKnightPtr;
 for (pcPtr = dataPtr->oppKnightArray;
  pcPtr < endPcPtr; pcPtr++)
 {
 sqPtr = pcPtr->sqPtr;
 if (dataPtr->knightMoveArray
 [kingSqPtr - sqPtr + kMaxSqDiff])
 {
 *checkSqHandle = sqPtr;
 *checkSqIncrPtr = 0;
 numberOfChecks++;
 break;
 }
 }
 }
 }

 return numberOfChecks;
}


EnumerateNonKingMoves

void EnumerateNonKingMoves(MyDataPtr dataPtr,
  ChessMovePtr *moveHandle)
{
 MySquarePtroppKingSqPtr, toSqPtr, sqPtr;
 MyPiecePtr endPcPtr, pcPtr;
 MyAxisPtraxisPtr, endAxisPtr;
 short  toSqIncr, sqIncr, toSqIndex;
 ChessMovePtr    movePtr = *moveHandle;
 MySqDiffPtrsqDiffPtr, endSqDiffPtr;

 oppKingSqPtr = dataPtr->oppKing.sqPtr;

 endPcPtr = dataPtr->chessBoard.endSTMLMPiecePtr;
 for (pcPtr = dataPtr->stmLMPieceArray;
  pcPtr < endPcPtr; pcPtr++)
 {
/* 
The move table for long move pieces consists of a set of axes of movement for the particular type of piece 
(i.e., Queen, Rook, or Bishop).  The positive and negative values of each axis are used as square increments, 
beginning at the piece’s current square pointer, and continuing until further movement is blocked by another 
piece or by the end ofthe board. In the event the blockage is caused by an oppenent’s piece, one additional 
move results; that of capturing the piece by moving onto its square.
*/
 axisPtr = pcPtr->pcTable.axisArrayPtr;
 endAxisPtr = axisPtr + pcPtr->pcTable.numberOfAxes;
 do
 {
 if (pcPtr->pinAxis && (pcPtr->pinAxis != *axisPtr))
 continue; /* Piece is pinned on some other axis */

 toSqIncr = *axisPtr;
 do
 {
 toSqPtr = pcPtr->sqPtr;
 do
 {
 if (*(toSqPtr += toSqIncr) < emptySq0)
 break; /* Square off-board or holds own piece */

 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq =
 dataPtr->stmSqArrayPtr
 [toSqPtr - dataPtr->chessBoard.sqArray];
 movePtr->moveIsCapture = (*toSqPtr > emptySq1);

/* 
If a long move piece has a discovered check axis, it is not able to move along that axis.  Otherwise, it would 
be checking the enemy King, and the position would not be legal with this side to move.  Therefore, any move 
of such a piece will result in a discovered check.
*/
 if (pcPtr->discAxis)
 {
 (movePtr++)->opponentPlacedInCheck = true;
 continue;
 }

 sqIncr = pcPtr->pcTable.sqIncrArrayPtr
  [oppKingSqPtr - toSqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 {
 (movePtr++)->opponentPlacedInCheck = false;
 continue;
 }

/* 
Scan along the path to the enemy King from the target square for this move.  If the first occupied square 
is that of the King, a check will result from the move; otherwise, no check.
*/
 sqPtr = toSqPtr;
 do
 {
 sqPtr += sqIncr;
 }
 while ((*sqPtr & kAttackMask) == emptySq0);

 (movePtr++)->opponentPlacedInCheck =
 (sqPtr == oppKingSqPtr);
 }
 while (*toSqPtr <= emptySq1);
 }
 while ((toSqIncr = -toSqIncr) < 0);
 }
 while (++axisPtr != endAxisPtr);
 }

 endPcPtr = dataPtr->chessBoard.endSTMKnightPtr;
 for (pcPtr = dataPtr->stmKnightArray;
  pcPtr < endPcPtr; pcPtr++)
 {
 if (pcPtr->pinAxis)
 continue;

 toSqPtr = pcPtr->sqPtr;

/* 
Unlike long move pieces, each move of a Knight may be evaluated independently from all of its other moves. 
 Thus, the move table consists of a set of relative square differentials, each added in turn to the previous 
move’s square pointer, rather than basing all of the moves on the Knight’s current square pointer.
*/
 sqDiffPtr = dataPtr->knightSqDiffArray;
 endSqDiffPtr = sqDiffPtr + 8;
 do
 {
 if (*(toSqPtr += *sqDiffPtr) >= emptySq0)
 {
 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq =
 dataPtr->stmSqArrayPtr
 [toSqPtr - dataPtr->chessBoard.sqArray];
 movePtr->moveIsCapture = (*toSqPtr > emptySq1);
 (movePtr++)->opponentPlacedInCheck =
 (pcPtr->discAxis ||
  dataPtr->knightMoveArray
  [oppKingSqPtr - toSqPtr + kMaxSqDiff]);
 }
 }
 while (++sqDiffPtr != endSqDiffPtr);
 }

 endPcPtr = dataPtr->chessBoard.endSTMPawnPtr;
 for (pcPtr = dataPtr->stmPawnArray;
  pcPtr < endPcPtr; pcPtr++)
 {
/* 
Pawns require two different move evaluations; one for captures, and a different one for non-capture moves.
*/
 for (toSqIncr = 15; toSqIncr <= 17; toSqIncr += 2)
 {
 if ((pcPtr->pinAxis &&
  (pcPtr->pinAxis != toSqIncr)) ||
 (*(toSqPtr = pcPtr->sqPtr + toSqIncr) <=
  emptySq1))
 {
 continue; /* Pawn pinned or no capture available */
 }

 toSqIndex = toSqPtr - dataPtr->chessBoard.sqArray;

 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq = dataPtr->stmSqArrayPtr[toSqIndex];
 movePtr->moveIsCapture = true;

 if (pcPtr->discAxis)
 {
 (movePtr++)->opponentPlacedInCheck = true;
 continue;
 }

 if (toSqIndex < kMin8thRankSqIndex)
 {
 (movePtr++)->opponentPlacedInCheck =
 (((toSqPtr + 15) == oppKingSqPtr) ||
  ((toSqPtr + 17) == oppKingSqPtr));
 continue;
 }

/* 
Pawn promotion brings up two interesting points.  One, the value of “opponentPlacedInCheck” becomes 
ambiguous, since the Pawn can promote to a Queen, Rook, Bishop, or Knight, and the squares that it attacks 
will vary accordingly.  Since a Pawn most often promotes to a Queen, I have chosen to set “opponentPlacedInCheck” 
on that basis.  The second point concerns the “ghost image” of the Pawn after it moves.  In other cases, 
it does not matter that the piece being moved is still recorded as being on its original square, since a line 
of attack to the enemy King which goes through that square must be blocked anyway; otherwise, the piece 
would have checked the King from its original square, and the position would be illegal.  In the case of a promoted 
Pawn, however, this assumption does not hold true.  Therefore, I compare the square pointer with the Pawn’s 
original position; if they match, I treat the square as though it were empty.
*/
 sqIncr = dataPtr->queenSqIncrArray
  [oppKingSqPtr - toSqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 {
 (movePtr++)->opponentPlacedInCheck = false;
 continue;
 }

 sqPtr = toSqPtr;
 do
 {
 sqPtr += sqIncr;
 }
 while (((*sqPtr & kAttackMask) == emptySq0) ||
  (sqPtr == pcPtr->sqPtr));

 (movePtr++)->opponentPlacedInCheck =
 (sqPtr == oppKingSqPtr);
 }

 if (pcPtr->pinAxis & 0x0f) /* i.e., axis not 0 or 16 */
 continue;

/* 
Ordinarily, the Pawn advances only one square, but it may continue to a second square if it is not blocked 
and has not yet reached the fourth rank.
*/
 toSqPtr = pcPtr->sqPtr;
 do
 {
 if ((*(toSqPtr += 16) & kAttackMask) != emptySq0)
 break;

 toSqIndex = toSqPtr - dataPtr->chessBoard.sqArray;

 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq = dataPtr->stmSqArrayPtr[toSqIndex];
 movePtr->moveIsCapture = false;

 if (pcPtr->discAxis & 0x0f)
 {
 (movePtr++)->opponentPlacedInCheck = true;
 continue;
 }

 if (toSqIndex < kMin8thRankSqIndex)
 {
 (movePtr++)->opponentPlacedInCheck =
 (((toSqPtr + 15) == oppKingSqPtr) ||
  ((toSqPtr + 17) == oppKingSqPtr));
 continue;
 }

 sqIncr = dataPtr->queenSqIncrArray
  [oppKingSqPtr - toSqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 {
 (movePtr++)->opponentPlacedInCheck = false;
 break;
 }

 sqPtr = toSqPtr;
 do
 {
 sqPtr += sqIncr;
 }
 while (((*sqPtr & kAttackMask) == emptySq0) ||
  (sqPtr == pcPtr->sqPtr));

 (movePtr++)->opponentPlacedInCheck =
 (sqPtr == oppKingSqPtr);
 break;
 }
 while (toSqIndex < kMin4thRankSqIndex);
 }

 *moveHandle = movePtr;
}


EnumerateNonKingCapturesOfCheckingPiece

void EnumerateNonKingCapturesOfCheckingPiece
  (MyDataPtr dataPtr,
   MySquarePtr checkSqPtr,
 ChessMovePtr *moveHandle)
{
 MySquarePtroppKingSqPtr, sqPtr;
 short  checkSqIndex, sqIncr, fromSqIncr;
 Square checkSq;
 MyPiecePtr endPcPtr, pcPtr;
 ChessMovePtr    movePtr = *moveHandle;

 oppKingSqPtr = dataPtr->oppKing.sqPtr;

 checkSqIndex = checkSqPtr - dataPtr->chessBoard.sqArray;
 checkSq = dataPtr->stmSqArrayPtr[checkSqIndex];

 endPcPtr = dataPtr->chessBoard.endSTMLMPiecePtr;
 for (pcPtr = dataPtr->stmLMPieceArray;
  pcPtr < endPcPtr; pcPtr++)
 {
 if (pcPtr->pinAxis)
 continue;

 sqPtr = pcPtr->sqPtr;
 sqIncr = pcPtr->pcTable.sqIncrArrayPtr
  [checkSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 continue;

 do
 {
 sqPtr += sqIncr;
 }
 while((*sqPtr & kAttackMask) == emptySq0);

 if (sqPtr != checkSqPtr)
 continue;

 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq = checkSq;
 movePtr->moveIsCapture = true;

 if (pcPtr->discAxis)
 {
 (movePtr++)->opponentPlacedInCheck = true;
 continue;
 }

 sqIncr = pcPtr->pcTable.sqIncrArrayPtr
  [oppKingSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 {
 (movePtr++)->opponentPlacedInCheck = false;
 continue;
 }

 do
 {
 sqPtr += sqIncr;
 }
 while ((*sqPtr & kAttackMask) == emptySq0);

 (movePtr++)->opponentPlacedInCheck =
 (sqPtr == oppKingSqPtr);
 }

 endPcPtr = dataPtr->chessBoard.endSTMKnightPtr;
 for (pcPtr = dataPtr->stmKnightArray;
  pcPtr < endPcPtr; pcPtr++)
 {
 if (pcPtr->pinAxis == 0)
 {
 if (dataPtr->knightMoveArray
 [checkSqPtr - pcPtr->sqPtr + kMaxSqDiff])
 {
 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq = checkSq;
 movePtr->moveIsCapture = true;
 (movePtr++)->opponentPlacedInCheck =
 (pcPtr->discAxis ||
  dataPtr->knightMoveArray
  [oppKingSqPtr - checkSqPtr + kMaxSqDiff]);
 }
 }
 }

 for (fromSqIncr = 15; fromSqIncr <= 17; fromSqIncr += 2)
 {
 if (*(sqPtr = checkSqPtr - fromSqIncr) > stmPawnSq1)
 continue; /* Square does not contain mover’s Pawn */

 pcPtr = dataPtr->pcPtrArray
 [sqPtr - dataPtr->chessBoard.sqArray];
 if (pcPtr->pinAxis)
 continue;

 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq = checkSq;
 movePtr->moveIsCapture = true;

 if (pcPtr->discAxis)
 {
 (movePtr++)->opponentPlacedInCheck = true;
 continue;
 }

 sqPtr = checkSqPtr;
 if (checkSqIndex < kMin8thRankSqIndex)
 {
 (movePtr++)->opponentPlacedInCheck =
 (((sqPtr + 15) == oppKingSqPtr) ||
  ((sqPtr + 17) == oppKingSqPtr));
 continue;
 }

 sqIncr = dataPtr->queenSqIncrArray
  [oppKingSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 {
 (movePtr++)->opponentPlacedInCheck = false;
 continue;
 }

 do
 {
 sqPtr += sqIncr;
 }
 while (((*sqPtr & kAttackMask) == emptySq0) ||
  (sqPtr == pcPtr->sqPtr));

 (movePtr++)->opponentPlacedInCheck =
 (sqPtr == oppKingSqPtr);
 }

 *moveHandle = movePtr;
}


EnumerateInterpositionMoves

void EnumerateInterpositionMoves(MyDataPtr dataPtr,
  MySquarePtr checkSqPtr,
  MySquareIncr checkSqIncr,
  ChessMovePtr *moveHandle)
{
 MySquarePtroppKingSqPtr, toSqPtr, sqPtr;
 short  toSqIndex, sqIncr;
 Square toSq;
 MyPiecePtr endPcPtr, pcPtr;
 ChessMovePtr    movePtr = *moveHandle;

 oppKingSqPtr = dataPtr->oppKing.sqPtr;

/* 
This “monster” do-loop repeats for each square which lies between the checking piece and the mover’s King.
*/
 toSqPtr = checkSqPtr + checkSqIncr;
 do
 {
 toSqIndex = toSqPtr - dataPtr->chessBoard.sqArray;
 toSq = dataPtr->stmSqArrayPtr[toSqIndex];

 endPcPtr = dataPtr->chessBoard.endSTMLMPiecePtr;
 for (pcPtr = dataPtr->stmLMPieceArray;
  pcPtr < endPcPtr; pcPtr++)
 {
 if (pcPtr->pinAxis)
 continue;

 sqPtr = pcPtr->sqPtr;
 sqIncr = pcPtr->pcTable.sqIncrArrayPtr
  [toSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 continue;

 while ((sqPtr += sqIncr) != toSqPtr)
 {
 if ((*sqPtr & kAttackMask) != emptySq0)
 goto NextLMPiece; /* Break while, continue for */
 }

 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq = toSq;
 movePtr->moveIsCapture = false;
 
 if (pcPtr->discAxis)
 {
 (movePtr++)->opponentPlacedInCheck = true;
 continue;
 }
 
 sqIncr = pcPtr->pcTable.sqIncrArrayPtr
  [oppKingSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 {
 (movePtr++)->opponentPlacedInCheck = false;
 continue;
 }
 
 do
 {
 sqPtr += sqIncr;
 }
 while ((*sqPtr & kAttackMask) == emptySq0);
 
 (movePtr++)->opponentPlacedInCheck =
 (sqPtr == oppKingSqPtr);

 NextLMPiece:
 ;
 }
 
 endPcPtr = dataPtr->chessBoard.endSTMKnightPtr;
 for (pcPtr = dataPtr->stmKnightArray;
  pcPtr < endPcPtr; pcPtr++)
 {
 if (pcPtr->pinAxis == 0)
 {
 if (dataPtr->knightMoveArray
 [toSqPtr - pcPtr->sqPtr + kMaxSqDiff])
 {
 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq = toSq;
 movePtr->moveIsCapture = false;
 (movePtr++)->opponentPlacedInCheck =
 (pcPtr->discAxis ||
  dataPtr->knightMoveArray
  [oppKingSqPtr - toSqPtr + kMaxSqDiff]);
 }
 }
 }

/* 
Pawn interposition is not possible if the square in the same column in the previous row does not contain a 
mover’s Pawn, AND any one of the following is true:
1.The square where interposition is to take place is not on the fourth rank,
2.The square in the same column on the third rank is not empty,
3.The square in the same column on the second rank does not contain a mover’s Pawn.
*/
 if ((*(sqPtr = toSqPtr - 16) > stmPawnSq1) &&
 ((toSqIndex >= kMin5thRankSqIndex) ||
  (toSqIndex < kMin4thRankSqIndex) ||
  ((*sqPtr & kAttackMask) != emptySq0) ||
  (*(sqPtr -= 16) > stmPawnSq1)))
 {
 continue;
 }

 pcPtr = dataPtr->pcPtrArray
 [sqPtr - dataPtr->chessBoard.sqArray];
 if (pcPtr->pinAxis)
 continue;

 movePtr->fromSq = pcPtr->fromSq;
 movePtr->toSq = toSq;
 movePtr->moveIsCapture = false;

 if (pcPtr->discAxis & 0x0f)
 {
 (movePtr++)->opponentPlacedInCheck = true;
 continue;
 }

 sqPtr = toSqPtr;
 if (toSqIndex < kMin8thRankSqIndex)
 {
 (movePtr++)->opponentPlacedInCheck =
 (((sqPtr + 15) == oppKingSqPtr) ||
  ((sqPtr + 17) == oppKingSqPtr));
 continue;
 }

 sqIncr = dataPtr->queenSqIncrArray
  [oppKingSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr == 0)
 {
 (movePtr++)->opponentPlacedInCheck = false;
 continue;
 }

 do
 {
 sqPtr += sqIncr;
 }
 while (((*sqPtr & kAttackMask) == emptySq0) ||
  (sqPtr == pcPtr->sqPtr));

 (movePtr++)->opponentPlacedInCheck =
 (sqPtr == oppKingSqPtr);
 }
 while (*(toSqPtr += checkSqIncr) >= emptySq0);

 *moveHandle = movePtr;
}


EnumerateKingMoves

void EnumerateKingMoves(MyDataPtr dataPtr,
 ChessMovePtr *moveHandle)
{
 MySquarePtrstmKingSqPtr, sqPtr, toSqPtr;
 short  discAxis, sqIncr;
 MySqDiffPtrsqDiffPtr, endSqDiffPtr;
 MyPiecePtr endPcPtr, pcPtr;
 ChessMovePtr    movePtr = *moveHandle;

 stmKingSqPtr = dataPtr->stmKing.sqPtr;
 discAxis = dataPtr->stmKing.discAxis;

 sqPtr = dataPtr->oppKing.sqPtr;
 sqIncr = stmKingSqPtr - sqPtr;
 if ((sqIncr >= -34) && (sqIncr <= +34))
 {
/* 
The opposing King might be within range of squares to which this King could move, so set the attack flag 
for all squares the opposing King attacks.  This will include some squares to which this King cannot move 
- it did not seem worth the trouble to code a fancy algorithm which ensures that only     squares to which this 
King can move have the attack flag set.  In most normal chess positions (excluding the endgame), the two 
Kings are at opposite ends of the board, so this code won’t be executed very often anyway.
*/
 sqDiffPtr = dataPtr->kingSqDiffArray;
 endSqDiffPtr = sqDiffPtr + 8;
 do
 {
 *(sqPtr += *sqDiffPtr) |= kAttackFlag;
 }
 while (++sqDiffPtr != endSqDiffPtr);
 }

 toSqPtr = stmKingSqPtr;

 sqDiffPtr = dataPtr->kingSqDiffArray;
 endSqDiffPtr = sqDiffPtr + 8;
 do
 {
/* 
The King cannot move to this square if:
1.It is off-board or occupied by mover’s own piece,
2.It is flagged as known to be under attack,
3.It is within capture range of an enemy Pawn.
*/
 if ((*(toSqPtr += *sqDiffPtr) < emptySq0) ||
 (*toSqPtr & kAttackFlag) ||
 (*(sqPtr = toSqPtr + 15) >= oppPawnSq0) ||
 (*(sqPtr += 2) >= oppPawnSq0))
 {
 continue;
 }

    /* 
    The square is also blocked if a long move piece or Knight attacks the square.
    */
 endPcPtr = dataPtr->chessBoard.endOppLMPiecePtr;
 for (pcPtr = dataPtr->oppLMPieceArray;
    pcPtr < endPcPtr; pcPtr++)
 {
 sqPtr = pcPtr->sqPtr;
 sqIncr = pcPtr->pcTable.sqIncrArrayPtr
  [toSqPtr - sqPtr + kMaxSqDiff];
 if (sqIncr)
 {
 do
 {
 if ((sqPtr += sqIncr) == toSqPtr)
 goto NextKingMove;

/* 
Set an “audit trail” of attacked squares for this piece.  Most of these attack flags will be useless, but they 
cost very little to set, and they make the test for empty squares easier.  If one does happen to fall in a square 
next to the mover’s King, it will save time by removing that square from consideration immediately.
*/
 *sqPtr |= kAttackFlag;
 }
 while (*sqPtr == emptySq1);
 }
 }

 endPcPtr = dataPtr->chessBoard.endOppKnightPtr;
 for (pcPtr = dataPtr->oppKnightArray;
    pcPtr < endPcPtr; pcPtr++)
 {
 if (dataPtr->knightMoveArray
 [toSqPtr - pcPtr->sqPtr + kMaxSqDiff])
 {
 goto NextKingMove;
 }
 }

 movePtr->fromSq = dataPtr->stmKing.fromSq;
 movePtr->toSq =
 dataPtr->stmSqArrayPtr
 [toSqPtr - dataPtr->chessBoard.sqArray];
 movePtr->moveIsCapture = (*toSqPtr > emptySq1);

    /* 
    The only checks which can result from a King move are checks.
    */
 if (discAxis == 0)
 {
 (movePtr++)->opponentPlacedInCheck = false;
 }
 else
 {
 sqIncr = toSqPtr - stmKingSqPtr;
 (movePtr++)->opponentPlacedInCheck =
 ((discAxis != sqIncr) && (discAxis != -sqIncr));
 }

 NextKingMove:
 ;
 }
 while (++sqDiffPtr != endSqDiffPtr);

 *moveHandle = movePtr;
}


InitChess

/* =========================================================
    Untimed initialization routine
========================================================= */

void InitChess(void *privateDataPtr)
{
 MyDataPtrdataPtr = privateDataPtr;
 MySquarePtrsqPtr;
 int    index, sqRow, sqCol;
 SquarePt whiteSqPtr, blackSqPtr;
 MySqIncrPtrposQueenSqIncrPtr, negQueenSqIncrPtr,
 posRookSqIncrPtr, negRookSqIncrPtr,
 posBishopSqIncrPtr, negBishopSqIncrPtr;
 Boolean*posKnightMovePtr, *negKnightMovePtr;

/* 
Quoting from the problem statement: “The privateDataPtr parameter will be the same pointer provided to 
InitChess."  Therefore, I can set pointers based on its value in my private data structure.  This would not 
be possible if the parameter were guaranteed only to point to a copy of the same data, but not necessarily 
to have the same value.
*/
 dataPtr->emptyBoard.endSTMKingPtr = &dataPtr->stmKing;
 dataPtr->emptyBoard.endOppKingPtr = &dataPtr->oppKing;
 dataPtr->emptyBoard.endSTMLMPiecePtr =
 dataPtr->stmLMPieceArray;
 dataPtr->emptyBoard.endOppLMPiecePtr =
 dataPtr->oppLMPieceArray;
 dataPtr->emptyBoard.endSTMKnightPtr =
 dataPtr->stmKnightArray;
 dataPtr->emptyBoard.endOppKnightPtr =
 dataPtr->oppKnightArray;
 dataPtr->emptyBoard.endSTMPawnPtr =
 dataPtr->stmPawnArray;

    /* 
    Initialize the empty chess board structure and the square coordinate arrays.
    */
 sqPtr = dataPtr->emptyBoard.sqArray;
 for (index = 0; index <= kMaxSqIndex; index++)
 {
 *sqPtr++ = offBoardSq0;
 }

 sqPtr = dataPtr->emptyBoard.sqArray + kLowerLeftSqIndex;
 whiteSqPtr = dataPtr->whiteSqArray + kLowerLeftSqIndex;
 blackSqPtr = dataPtr->blackSqArray + kUpperRightSqIndex;
 for (sqRow = 0; sqRow < 8; sqRow++)
 {
 for (sqCol = 0; sqCol < 8; sqCol++)
 {
 *sqPtr++ = emptySq0;
 whiteSqPtr->row = sqRow;
 blackSqPtr->row = sqRow;
 (whiteSqPtr++)->col = sqCol;
 (blackSqPtr--)->col = sqCol;
 }
 sqPtr += 8; whiteSqPtr += 8; blackSqPtr -= 8;
 }

    /* 
    Initialize the piece information arrays.
    */
 dataPtr->stmPcInfoArray[king].pcHandle =
 &dataPtr->chessBoard.endSTMKingPtr;
 dataPtr->stmPcInfoArray[king].sqType = stmPieceSq0;

 dataPtr->stmPcInfoArray[queen].pcHandle =
 &dataPtr->chessBoard.endSTMLMPiecePtr;
 dataPtr->stmPcInfoArray[queen].pcTable.sqIncrArrayPtr =
 dataPtr->queenSqIncrArray;
 dataPtr->stmPcInfoArray[queen].pcTable.axisArrayPtr =
 dataPtr->queenAxisArray;
 dataPtr->stmPcInfoArray[queen].pcTable.numberOfAxes = 4;
 dataPtr->stmPcInfoArray[queen].sqType = stmPieceSq0;

 dataPtr->stmPcInfoArray[rook].pcHandle =
 &dataPtr->chessBoard.endSTMLMPiecePtr;
 dataPtr->stmPcInfoArray[rook].pcTable.sqIncrArrayPtr =
 dataPtr->rookSqIncrArray;
 dataPtr->stmPcInfoArray[rook].pcTable.axisArrayPtr =
 dataPtr->rookAxisArray;
 dataPtr->stmPcInfoArray[rook].pcTable.numberOfAxes = 2;
 dataPtr->stmPcInfoArray[rook].sqType = stmPieceSq0;

 dataPtr->stmPcInfoArray[bishop].pcHandle =
 &dataPtr->chessBoard.endSTMLMPiecePtr;
 dataPtr->stmPcInfoArray[bishop].pcTable.sqIncrArrayPtr =
 dataPtr->bishopSqIncrArray;
 dataPtr->stmPcInfoArray[bishop].pcTable.axisArrayPtr =
 dataPtr->bishopAxisArray;
 dataPtr->stmPcInfoArray[bishop].pcTable.numberOfAxes = 2;
 dataPtr->stmPcInfoArray[bishop].sqType = stmPieceSq0;

 dataPtr->stmPcInfoArray[knight].sqType = stmPieceSq0;
 dataPtr->stmPcInfoArray[knight].pcHandle =
 &dataPtr->chessBoard.endSTMKnightPtr;

 dataPtr->stmPcInfoArray[pawn].pcHandle =
 &dataPtr->chessBoard.endSTMPawnPtr;
 dataPtr->stmPcInfoArray[pawn].sqType = stmPawnSq0;

 dataPtr->oppPcInfoArray[king].pcHandle =
 &dataPtr->chessBoard.endOppKingPtr;
 dataPtr->oppPcInfoArray[king].sqType = oppPieceSq0;

 dataPtr->oppPcInfoArray[queen].pcHandle =
 &dataPtr->chessBoard.endOppLMPiecePtr;
 dataPtr->oppPcInfoArray[queen].pcTable.sqIncrArrayPtr =
 dataPtr->queenSqIncrArray;
 dataPtr->oppPcInfoArray[queen].pcTable.axisArrayPtr =
 dataPtr->queenAxisArray;
 dataPtr->oppPcInfoArray[queen].pcTable.numberOfAxes = 4;
 dataPtr->oppPcInfoArray[queen].sqType = oppPieceSq0;

 dataPtr->oppPcInfoArray[rook].pcHandle =
 &dataPtr->chessBoard.endOppLMPiecePtr;
 dataPtr->oppPcInfoArray[rook].pcTable.sqIncrArrayPtr =
 dataPtr->rookSqIncrArray;
 dataPtr->oppPcInfoArray[rook].pcTable.axisArrayPtr =
 dataPtr->rookAxisArray;
 dataPtr->oppPcInfoArray[rook].pcTable.numberOfAxes = 2;
 dataPtr->oppPcInfoArray[rook].sqType = oppPieceSq0;

 dataPtr->oppPcInfoArray[bishop].pcHandle =
 &dataPtr->chessBoard.endOppLMPiecePtr;
 dataPtr->oppPcInfoArray[bishop].pcTable.sqIncrArrayPtr =
 dataPtr->bishopSqIncrArray;
 dataPtr->oppPcInfoArray[bishop].pcTable.axisArrayPtr =
 dataPtr->bishopAxisArray;
 dataPtr->oppPcInfoArray[bishop].pcTable.numberOfAxes = 2;
 dataPtr->oppPcInfoArray[bishop].sqType = oppPieceSq0;

 dataPtr->oppPcInfoArray[knight].pcHandle =
 &dataPtr->chessBoard.endOppKnightPtr;
 dataPtr->oppPcInfoArray[knight].sqType = oppPieceSq0;

 dataPtr->oppPcInfoArray[pawn].sqType = oppPawnSq0;

    /* 
    Initialize the piece movement look-up tables.
    */
 posQueenSqIncrPtr = negQueenSqIncrPtr =
 dataPtr->queenSqIncrArray + kMaxSqDiff;
 posRookSqIncrPtr = negRookSqIncrPtr =
 dataPtr->rookSqIncrArray + kMaxSqDiff;
 posBishopSqIncrPtr = negBishopSqIncrPtr =
 dataPtr->bishopSqIncrArray + kMaxSqDiff;
 posKnightMovePtr = negKnightMovePtr =
 dataPtr->knightMoveArray + kMaxSqDiff;

 for (sqRow = 0; sqRow < 8; sqRow++)
 {
 *posQueenSqIncrPtr++= 0;
 *negQueenSqIncrPtr--= 0;
 *posRookSqIncrPtr++ = 0;
 *negRookSqIncrPtr-- = 0;
 *posBishopSqIncrPtr++  = 0;
 *negBishopSqIncrPtr--  = 0;
 *posKnightMovePtr++ = false;
 *negKnightMovePtr-- = false;

 for (sqCol = sqRow ? -7 : +1; sqCol < 8; sqCol++)
 {
 if (sqRow == 0)
 {
 *posQueenSqIncrPtr++= + 1;
 *negQueenSqIncrPtr--= - 1;
 *posRookSqIncrPtr++ = + 1;
 *negRookSqIncrPtr-- = - 1;
 *posBishopSqIncrPtr++  =   0;
 *negBishopSqIncrPtr--  =   0;
 *posKnightMovePtr++ = false;
 *negKnightMovePtr-- = false;
 }
 else if (sqRow + sqCol == 0)
 {
 *posQueenSqIncrPtr++= +15;
 *negQueenSqIncrPtr--= -15;
 *posRookSqIncrPtr++ =   0;
 *negRookSqIncrPtr-- =   0;
 *posBishopSqIncrPtr++  = +15;
 *negBishopSqIncrPtr--  = -15;
 *posKnightMovePtr++ = false;
 *negKnightMovePtr-- = false;
 }
 else if (sqCol == 0)
 {
 *posQueenSqIncrPtr++= +16;
 *negQueenSqIncrPtr--= -16;
 *posRookSqIncrPtr++ = +16;
 *negRookSqIncrPtr-- = -16;
 *posBishopSqIncrPtr++  =   0;
 *negBishopSqIncrPtr--  =   0;
 *posKnightMovePtr++ = false;
 *negKnightMovePtr-- = false;
 }
 else if (sqRow == sqCol)
 {
 *posQueenSqIncrPtr++= +17;
 *negQueenSqIncrPtr--= -17;
 *posRookSqIncrPtr++ =   0;
 *negRookSqIncrPtr-- =   0;
 *posBishopSqIncrPtr++  = +17;
 *negBishopSqIncrPtr--  = -17;
 *posKnightMovePtr++ = false;
 *negKnightMovePtr-- = false;
 }
 else
 {
 *posQueenSqIncrPtr++= 0;
 *negQueenSqIncrPtr--= 0;
 *posRookSqIncrPtr++ = 0;
 *negRookSqIncrPtr-- = 0;
 *posBishopSqIncrPtr++  = 0;
 *negBishopSqIncrPtr--  = 0;

/* A Knight moves only to those squares within two rows and columns that a Queen cannot reach. */
 if ((sqRow < 3) &&
 (sqCol > -3) && (sqCol < 3))
 {
 *posKnightMovePtr++ = true;
 *negKnightMovePtr-- = true;
 }
 else
 {
 *posKnightMovePtr++ = false;
 *negKnightMovePtr-- = false;
 }
 }
 }
 }

 dataPtr->queenAxisArray[0] =  1;
 dataPtr->queenAxisArray[1] = 15;
 dataPtr->queenAxisArray[2] = 16;
 dataPtr->queenAxisArray[3] = 17;

 dataPtr->rookAxisArray[0]=  1;
 dataPtr->rookAxisArray[1]= 16;

 dataPtr->bishopAxisArray[0]= 15;
 dataPtr->bishopAxisArray[1]= 17;
 
 dataPtr->knightSqDiffArray[0]= -33;
 dataPtr->knightSqDiffArray[1]= + 2;
 dataPtr->knightSqDiffArray[2]= +13;
 dataPtr->knightSqDiffArray[3]= + 4;
 dataPtr->knightSqDiffArray[4]= +28;
 dataPtr->knightSqDiffArray[5]= + 4;
 dataPtr->knightSqDiffArray[6]= +13;
 dataPtr->knightSqDiffArray[7]= + 2;

 dataPtr->kingSqDiffArray[0]= -17;
 dataPtr->kingSqDiffArray[1]= + 1;
 dataPtr->kingSqDiffArray[2]= + 1;
 dataPtr->kingSqDiffArray[3]= +14;
 dataPtr->kingSqDiffArray[4]= + 2;
 dataPtr->kingSqDiffArray[5]= +14;
 dataPtr->kingSqDiffArray[6]= + 1;
 dataPtr->kingSqDiffArray[7]= + 1;
}

 
AAPL
$100.96
Apple Inc.
-0.83
MSFT
$47.52
Microsoft Corpora
+0.84
GOOG
$596.08
Google Inc.
+6.81

MacTech Search:
Community Search:

Software Updates via MacUpdate

Audio Hijack Pro 2.11.3 - Record and enh...
Audio Hijack Pro drastically changes the way you use audio on your computer, giving you the freedom to listen to audio when you want and how you want. Record and enhance any audio with Audio Hijack... Read more
Airfoil 4.8.9 - Send audio from any app...
Airfoil allows you to send any audio to AirPort Express units, Apple TVs, and even other Macs and PCs, all in sync! It's your audio - everywhere. With Airfoil you can take audio from any... Read more
WhatRoute 1.13.0 - Geographically trace...
WhatRoute is designed to find the names of all the routers an IP packet passes through on its way from your Mac to a destination host. It also measures the round-trip time from your Mac to the... Read more
Chromium 37.0.2062.122 - Fast and stable...
Chromium is an open-source browser project that aims to build a safer, faster, and more stable way for all Internet users to experience the web. FreeSMUG-Free OpenSource Mac User Group build is... Read more
Attachment Tamer 3.1.14b9 - Take control...
Attachment Tamer gives you control over attachment handling in Apple Mail. It fixes the most annoying Apple Mail flaws, ensures compatibility with other email software, and allows you to set up how... Read more
Duplicate Annihilator 5.0 - Find and del...
Duplicate Annihilator takes on the time-consuming task of comparing the images in your iPhoto library using effective algorithms to make sure that no duplicate escapes. Duplicate Annihilator detects... Read more
jAlbum Pro 12.2 - Organize your digital...
jAlbum Pro has all the features you love in jAlbum, but comes with a commercial license. With jAlbum, you can create gorgeous custom photo galleries for the Web without writing a line of code!... Read more
jAlbum 12.2 - Create custom photo galler...
With jAlbum, you can create gorgeous custom photo galleries for the Web without writing a line of code! Beginner-friendly, with pro results Simply drag and drop photos into groups, choose a design... Read more
Quicken 2015 2.0.4 - Complete personal f...
Quicken 2015 helps you manage all your personal finances in one place, so you can see where you're spending and where you can save. Quicken automatically categorizes your financial transactions,... Read more
iMazing 1.0 - Complete iOS device manage...
iMazing (formerly DiskAid) is the ultimate iOS device manager with capabilities far beyond what iTunes offers. With iMazing and your iOS device (iPhone, iPad, or iPod), you can: Copy music to and... Read more

Latest Forum Discussions

See All

View Source – HTML, JavaScript and CSS...
View Source – HTML, JavaScript and CSS 1.0 Device: iOS Universal Category: Utilities Price: $.99, Version: 1.0 (iTunes) Description: View Source is an app plus an iOS 8 Safari extension that makes it easy to do one key web developer... | Read more »
Avenged Sevenfold’s Hail To The King: De...
Avenged Sevenfold’s Hail To The King: Deathbat is Coming to iOS on October 16th Posted by Jessica Fisher on September 19th, 2014 [ permalink ] Just in time for Halloween, on October 16 Avenged Sevenfold will be launching | Read more »
Talisman Has Gone Universal – Can Now be...
Talisman Has Gone Universal – Can Now be Played on the iPhone Posted by Jessica Fisher on September 19th, 2014 [ permalink ] | Read more »
Tap Army Review
Tap Army Review By Jennifer Allen on September 19th, 2014 Our Rating: :: SHOOT EM ALLUniversal App - Designed for iPhone and iPad Mindless but fun, Tap Army is a lane-based shooter that should help you relieve some stress.   | Read more »
Monsters! Volcanoes! Loot! Epic Island f...
Monsters! Volcanoes! Loot! | Read more »
Plunder Pirates: Tips, Tricks, Strategie...
Ahoy There, Seadogs: Interested in knowing our thoughts on all this plundering and pirating? Check out our Plunder Pirates Review! Have you just downloaded the rather enjoyable pirate-em-up Plunder Pirates and are in need of some assistance? Never... | Read more »
Goat Simulator Review
Goat Simulator Review By Lee Hamlet on September 19th, 2014 Our Rating: :: THE GRUFFEST OF BILLY GOATSUniversal App - Designed for iPhone and iPad Unleash chaos as a grumpy goat in this humorous but short-lived casual game.   | Read more »
A New and Improved Wunderlist is Here fo...
A New and Improved Wunderlist is Here for iOS 8 Posted by Jessica Fisher on September 19th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Evernote Update for iOS 8 Adds Web Clipp...
Evernote Update for iOS 8 Adds Web Clipping, Quick Notes, and More Posted by Ellis Spice on September 19th, 2014 [ permalink ] | Read more »
Apple Names Ultimate Productivity Bundl...
Apple Names Ultimate Productivity Bundle by Readdle as the Essential Bundle on the App Store Posted by Jessica Fisher on September 19th, 2014 [ permalink | Read more »

Price Scanner via MacPrices.net

iFixIt Tears Down iPhone 6; Awards Respectabl...
iFixit notes that even the smaller 4.7″ iPhone 6 is a giant among iPhones; so big that Apple couldn’t fit it into the familiar iPhone form factor. In a welcome reversal of a recent trend to more or... Read more
Phone 6 Guide – Tips Book For Both iPhone 6...
iOS Guides has announced its latest eBook: iPhone 6 Guide. Brought to you by the expert team at iOS Guides, and written by best-selling technology author Tom Rudderham, iPhone 6 Guide is packed with... Read more
How to Upgrade iPhone iPad to iOS 8 without D...
PhoneClean, a iPhone cleaner utility offered by iMobie Inc., reveals a solution for upgrading iPhone and iPad to iOS 8 without deleting photos, apps, the new U2 album or anything. Thanks to more than... Read more
Inpaint 6 – Photo Retouching Tool Gets Faster...
TeoreX has announced Inpaint 6, a simple retouching tool for end users that helps remove scratches, watermarks, and timestamps as well as more complex objects like strangers, unwanted elements and... Read more
Worldwide PC Monitor Market Sees Growth in To...
Worldwide PC monitor shipments totaled 32.5 million units in the second quarter of 2014 (2Q14), a year-over-year decline of -2.9%, according to the International Data Corporation (IDC) Worldwide... Read more
Updated Price Trackers
We’ve updated our Mac Price Trackers with the latest information on prices, bundles, and availability on systems from Apple’s authorized internet/catalog resellers: - 15″ MacBook Pros - 13″ MacBook... Read more
Mac Pros available for up to $260 off MSRP
Adorama has Mac Pros on sale for up to $260 off MSRP. Shipping is free, and Adorama charges sales tax in NY & NJ only: - 4-core Mac Pro: $2839.99, $160 off MSRP - 6-core Mac Pro: $3739.99, $260... Read more
13-inch 2.6GHz/256GB Retina MacBook Pros avai...
B&H Photo has the 13″ 2.6GHz/256GB Retina MacBook Pro on sale for $1379 including free shipping plus NY sales tax only. Their price is $120 off MSRP. Read more
Previous-generation 15-inch 2.0GHz Retina Mac...
B&H Photo has leftover previous-generation 15″ 2.0GHz Retina MacBook Pros now available for $1599 including free shipping plus NY sales tax only. Their price is $400 off original MSRP. B&H... Read more
21″ 2.7GHz iMac available for $1179, save $12...
Adorama has 21″ 2.7GHz Hawell iMacs on sale for $1179.99 including free shipping. Their price is $120 off MSRP. NY and NJ sales tax only. Read more

Jobs Board

*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Position Opening at *Apple* - Apple (United...
**Job Summary** At the Apple Store, you connect business professionals and entrepreneurs with the tools they need in order to put Apple solutions to work in their Read more
Position Opening at *Apple* - Apple (United...
**Job Summary** The Apple Store is a retail environment like no other - uniquely focused on delivering amazing customer experiences. As an Expert, you introduce people Read more
Position Opening at *Apple* - Apple (United...
**Job Summary** As businesses discover the power of Apple computers and mobile devices, it's your job - as a Solutions Engineer - to show them how to introduce these Read more
Position Opening at *Apple* - Apple (United...
…Summary** As a Specialist, you help create the energy and excitement around Apple products, providing the right solutions and getting products into customers' hands. You Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.