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;
}

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

CrossOver 14.1.6 - Run Windows apps on y...
CrossOver can get your Windows productivity applications and PC games up and running on your Mac quickly and easily. CrossOver runs the Windows software that you need on Mac at home, in the office,... Read more
Printopia 2.1.14 - Share Mac printers wi...
Run Printopia on your Mac to share its printers to any capable iPhone, iPad or iPod Touch. Printopia will also add virtual printers, allowing you to save print-outs to your Mac and send to apps.... Read more
Google Drive 1.24 - File backup and shar...
Google Drive is a place where you can create, share, collaborate, and keep all of your stuff. Whether you're working with a friend on a joint research project, planning a wedding with your fiancé, or... Read more
Chromium 45.0.2454.85 - 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. Version 45.0.2454.85: Note: Does not contain the "... Read more
OmniFocus 2.2.5 - GTD task manager with...
OmniFocus helps you manage your tasks the way that you want, freeing you to focus your attention on the things that matter to you most. Capturing tasks and ideas is always a keyboard shortcut away in... Read more
iFFmpeg 5.7.1 - Convert multimedia files...
iFFmpeg is a graphical front-end for FFmpeg, a command-line tool used to convert multimedia files between formats. The command line instructions can be very hard to master/understand, so iFFmpeg does... Read more
VOX 2.6 - Music player that supports man...
VOX is a beautiful music player that supports many filetypes. The beauty is in its simplicity, yet behind the minimal exterior lies a powerful music player with a ton of features and support for all... Read more
Box Sync 4.0.6567 - Online synchronizati...
Box Sync gives you a hard-drive in the Cloud for online storage. Note: You must first sign up to use Box. What if the files you need are on your laptop -- but you're on the road with your iPhone? No... Read more
Carbon Copy Cloner 4.1.4 - Easy-to-use b...
Carbon Copy Cloner backups are better than ordinary backups. Suppose the unthinkable happens while you're under deadline to finish a project: your Mac is unresponsive and all you hear is an ominous,... Read more
OmniGraffle Pro 6.3.1 - Create diagrams,...
OmniGraffle Pro helps you draw beautiful diagrams, family trees, flow charts, org charts, layouts, and (mathematically speaking) any other directed or non-directed graphs. We've had people use... Read more

Rock(s) Rider - HD Edition (Games)
Rock(s) Rider - HD Edition 1.0.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0.0 (iTunes) Description: *** PLEASE NOTE: Compatible with iPhone 4s, iPad 2, iPad mini, iPod touch (5th generation) or newer *** Do you... | Read more »
Rebuild 3: Gangs of Deadsville (Games)
Rebuild 3: Gangs of Deadsville 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: It's been a few years since the zombpocalypse turned the world's cities into graveyards and sent the few... | Read more »
Power Ping Pong (Games)
Power Ping Pong 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: Do you wield your bat with zen-like focus or do your balls of fury give you a killer spin? Table tennis goes mobile with a... | Read more »
Z.O.N.A Project X (Games)
Z.O.N.A Project X 1.00 Device: iOS Universal Category: Games Price: $1.99, Version: 1.00 (iTunes) Description: Z.O.N.A Project X - shooter in the post-apocalyptic world. | Read more »
Trick Shot (Games)
Trick Shot 1.0.6 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0.6 (iTunes) Description: A game where all you have to do is throw a ball into a box, simple? Trick Shot is a minimalist physics puzzler with 90 levels... | Read more »
Goat Simulator MMO Simulator (Games)
Goat Simulator MMO Simulator 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: ** IMPORTANT - SUPPORTED DEVICESiPhone 4S, iPad 2, iPod Touch 5 or better.** Coffee Stain Studios brings next-gen... | Read more »
Worms™ 4 (Games)
Worms™ 4 1.02 Device: iOS Universal Category: Games Price: $4.99, Version: 1.02 (iTunes) Description: The latest instalment in the worldwide mega hit franchise! Coming soon to iPhone, iPad and iPod touch. When the guys and girls at... | Read more »
The Deer God (Games)
The Deer God 1.0 Device: iOS Universal Category: Games Price: $6.99, Version: 1.0 (iTunes) Description: 30% off launch sale!!! “It can be a struggle, but it's all worth it when you're shooting fire out your antlers.” Kotaku “The... | Read more »
AppSpy's Patreon campaign kicks off
Occasionally you'll see us use AppSpy's videos here on 148Apps to support an article we've written. That's because we're part of Steel Media, and AppSpy is Steel's video arm, so we're all part of one happy family. [Read more] | Read more »
We're Sorry to Report that Moonrise...
Moonrise is a very promising-looking, Pokemon-esque monster collecting and battling game that we were really looking forward to reviewing, but unfortunately it looks like that's never going to happen. [Read more] | Read more »

Price Scanner via MacPrices.net

Will You Buy An iPad Pro? – The ‘Book Mystiqu...
It looks like we may not have to wait much longer to see what finally materializes as a new, larger-panel iPad (Pro/Plus?) Usually reliable Apple product prognosticator KGI Securities analyst Ming-... Read more
eFileCabinet Announces SMB Document Managemen...
Electronic document management (EDM) eFileCabinet, Inc., a hosted solutions provider for small to medium businesses, has announced that its SecureDrawer and eFileCabinet Online services will be... Read more
WaterField Designs Unveils American-Made, All...
San Francisco’s WaterField Designs today unveiled their all-leather Cozmo 2.0 — an elegant attach laptop bag with carefully-designed features to suit any business environment. The Cozmo 2.0 is... Read more
Apple’s 2015 Back to School promotion: Free B...
Purchase a new Mac or iPad at The Apple Store for Education and take up to $300 off MSRP. All teachers, students, and staff of any educational institution qualify for the discount. Shipping is free,... Read more
128GB MacBook Airs on sale for $100 off MSRP,...
B&H Photo has 11″ & 13″ MacBook Airs with 128GB SSDs on sale for $100 off MSRP. Shipping is free, and B&H charges NY sales tax only: - 11″ 1.6GHz/128GB MacBook Air: $799.99, $100 off MSRP... Read more
13-inch 2.5GHz MacBook Pro (refurbished) avai...
The Apple Store has Apple Certified Refurbished 13″ 2.5GHz MacBook Pros available for $829, or $270 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free: - 13″ 2.... Read more
27-inch 3.2GHz iMac on sale for $1679, save $...
B&H Photo has the 27″ 3.2GHz iMac on sale for $1679.99 including free shipping plus NY sales tax only. Their price is $120 off MSRP. Read more
Apple and Cisco Partner to Deliver Fast-Lane...
Apple and Cisco have announced a partnership to create a “fast lane” for iOS business users by optimizing Cisco networks for iOS devices and apps. The alliance integrates iPhone with Cisco enterprise... Read more
Apple offering refurbished 2015 13-inch Retin...
The Apple Store is offering Apple Certified Refurbished 2015 13″ Retina MacBook Pros for up to $270 (15%) off the cost of new models. An Apple one-year warranty is included with each model, and... Read more
Apple refurbished 2015 MacBook Airs available...
The Apple Store has Apple Certified Refurbished 2015 11″ and 13″ MacBook Airs (the latest models), available for up to $180 off the cost of new models. An Apple one-year warranty is included with... Read more

Jobs Board

*Apple* Desktop Analyst - KDS Staffing (Unit...
…field and consistent professional recruiting achievement. Job Description: Title: Apple Desktop AnalystPosition Type: Full-time PermanentLocation: White Plains, NYHot Read more
Simply Mac *Apple* Specialist- Repair Techn...
Simply Mac is the greatest premier retailer of Apple products expertise in North America. We're looking for dedicated individuals to provide personalized service and Read more
Simply Mac *Apple* Specialist- Service Repa...
Simply Mac is the greatest premier retailer of Apple products expertise in North America. We're looking for dedicated individuals to provide personalized service and Read more
*Apple* Desktop Analyst - KDS Staffing (Unit...
…field and consistent professional recruiting achievement. Job Description: Title: Apple Desktop AnalystPosition Type: Full-time PermanentLocation: White Plains, NYHot Read more
Simply Mac- *Apple* Specialist- Store Manag...
Simply Mac is the largest premier retailer for Apple products and solutions. We're looking for dedicated individuals with a passion to simplify and enhance the Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.