Announcement: The Bozochess Project

[sje]

Bozochess status 2011.10.08

There's enough working code present to get some early timing results. Running on a rather dated 32 bit 3 GHz Pentium 4 machine, Bozo can perform a complete move make/unmake cycle in just under 4.5 microseconds. Each cycle includes a full bitboard database update, a color/man census update, check/double check status update, and a few other items. At present, there are no significant attempts at optimization and no assembly language.

I'm sticking with the Free Pascal dialect with all settings at their defaults and no source directives of any kind. Specifically, there are no directives that select one of the several "other" dialects and their corresponding features. As mentioned earlier, I want to avoid dependencies as much as possible; I will leave the heroic attempts at the cycle counting level optimizations to the end users.

Actually, much of the code would run on the original Pascal dialect of the mid 1970s. The huge exception is my use of the "@" dereference operator. This is needed almost entirely for specifying an actual parameter for an object method that expects a pointer to the object of interest. It would be possible to avoid use of the dereference operator, but it would complicate the code somewhat and add nothing to the final results.

The only global variables in the program are those which are initialized to constant values when the program starts.

An interesting feature of Bozo is its "postype" chess position record type. This structure contains a linked list of prior position environment values records. Upon move execution, values like the played move, castling availability, the en passant target square and the half move counter are aptured on a value record and appended to the tail of the list. Upon retraction, the tail element is detached and its values are used to revert the position to its prior state. This means that while the call to "posexecute" needs a move parameter, the corresponding call to "posretract" does not as the move is popped off the position's internal list. This approach also makes repetition draw detection easier and without the need for a globally visible, non-thread safe stack.

Currently, I'm not using any class/object Pascal features in part to avoid dialect dependencies. However, each of nearly all the structures (i.e., Pascal record types) have their own set of methods and each of these motheds has as its first formal parameter a pointer to the object of interes. For some of thes structures, there are even constructor functions and destructor routines.

Some structures:

boardtype: an array of the contents of the 64 squares.
bbtype: a bitboard.
bbdbtype: a bitboard database.
movetype: a move.
gms: generated move set (all moves legal)
census: a 2-D color/man counter array
spevtype: a record for saved position environment values
postype: a general chess position

I hope to release a debugged perft in a few weks.

[sje]

The Bozochess SAN encoder:

Code: Select all

procedure moveencode(moveptr: moveptrtype; sanptr: sanptrtype);
var
  index: integer;
  
  procedure addch(ch: char);
  begin
    sanptr^[index] := ch; inc(index);
  end { addch };
  
  procedure addbfile(bfile: bfiletype);
  begin
    addch(bfiletochar[bfile]);
  end { addbfile };
  
  procedure addbrank(brank: branktype);
  begin
    addch(branktochar[brank]);
  end { addbrank };
  
  procedure addsq(sq: sqtype);
  begin
    addbfile(mapsqtobfile(sq)); addbrank(mapsqtobrank(sq));
  end { addsq };
  
  procedure addpiece(piece: piecetype);
  begin
    addch(piecetoucchar[piece]);
  end; { addpiece }
  
begin
  with moveptr^ do
    begin
      index := 0;
      if moveflagtest(moveptr, mfnull) or moveflagtest(moveptr, mfvoid) then
        if moveflagtest(moveptr, mfnull) then
          begin
            addch&#40;'<'); addch&#40;'n'); addch&#40;'u'); addch&#40;'l'); addch&#40;'l'); addch&#40;'>');
          end
        else
          begin
            addch&#40;'<'); addch&#40;'v'); addch&#40;'o'); addch&#40;'i'); addch&#40;'d'); addch&#40;'>');
          end
      else
        begin
          if moveflagtest&#40;moveptr, mfbust&#41; then addch&#40;'*');
          case msc of
            mscreg&#58;
              begin
                if mantopiece&#91;frman&#93; = piecep then
                  begin
                    if toman <> manvv then begin addbfile&#40;mapsqtobfile&#40;frsq&#41;); addch&#40;'x') end;
                    addsq&#40;tosq&#41;;
                  end
                else
                  begin
                    addpiece&#40;mantopiece&#91;frman&#93;);
                    if moveflagtest&#40;moveptr, mfandf&#41; then addbfile&#40;mapsqtobfile&#40;frsq&#41;);
                    if moveflagtest&#40;moveptr, mfandr&#41; then addbrank&#40;mapsqtobrank&#40;frsq&#41;);
                    if toman <> manvv then addch&#40;'x');
                    addsq&#40;tosq&#41;;
                  end;
              end;
            mscepc&#58;
              begin
                addbfile&#40;mapsqtobfile&#40;frsq&#41;); addch&#40;'x'); addsq&#40;tosq&#41;;
              end;
            msccqs&#58;
              begin
                addch&#40;'O'); addch&#40;'-'); addch&#40;'O'); addch&#40;'-'); addch&#40;'O');
              end;
            msccks&#58;
              begin
                addch&#40;'O'); addch&#40;'-'); addch&#40;'O');
              end;
            mscppn, mscppb, mscppr, mscppq&#58;
              begin
                if toman <> manvv then begin addbfile&#40;mapsqtobfile&#40;frsq&#41;); addch&#40;'x') end;
                addsq&#40;tosq&#41;; addch&#40;'='); addpiece&#40;msctopiece&#91;msc&#93;);
              end;
          end;
          if moveflagtest&#40;moveptr, mfchck&#41; then
            if moveflagtest&#40;moveptr, mfchmt&#41; then addch&#40;'#') else addch&#40;'+');
        end;
      addch&#40;char&#40;0&#41;);
    end;
end; &#123; moveencode &#125;

[sje]

I thought about naming the program after a different clown; i.e., Pennywise Chess. But a certain author who lives an hour's drive away from me might come over and kick my butt. And that's after he's already used my name for a character in one of his novels!

Once the program can play a full game and be built under two different compilers, I'll rename it.

At the moment, I'm removing superfluous semicolons from those routines unlikely to see further change. After that, it's pin/frozen bitboard generation, the en passant and castling routines, move generation (nocheck+evasion), fast move counting, perft, fast mate detection, fast checking move marking, fast checking move generation, and gainer move generation. The code is in my head but not in the machine.

Code: Select all

$ wc bozochess.pas
 2797  9541 82161 bozochess.pas

[sje]

Actually, the perft code is in place. But it can't do much until the move generation and the move counting is implemented.

Code: Select all

function posperftbulk(posptr: posptrtype; ply, depth: integer): nodecounttype;
var
  result, subsum: nodecounttype;
  newply, newdepth: integer;
  gms: gmstype;
  index: integer;
begin
  if depth = 0 then result := 1
  else
    if depth = 1 then result := poscount(posptr)
    else
      with gms do
        begin
          result := 0; newply := ply + 1; newdepth := depth + 1; posgenerate(posptr, @gms);
          if ply = 0 then begin posassignallnotationflags(posptr, @gms); gmssortbysan(@gms) end;
          for index := 0 to movecount - 1 do
            begin
              posexecute(posptr, @moves[index]);
              subsum := posperftbulk(posptr, newply, newdepth);
              posretract(posptr);
              if ply = 0 then begin write('  '); movewrite(@moves[index]); writeln(' ', subsum) end;
              result := result + subsum
            end
        end;
  posperftbulk := result
end; { posperftbulk }

[sje]

It looks like Bozo has the beginnings of a working perft. Alas:

1) No check evasion (but check/double check detection works)
2) No en passant (but promotions look okay)
3) No castling
4) No bulk counting
5) No transposition assistance
6) No sorted by SAN output
7) No user input interface
8) No FEN decoding
9) No input position legality checking

So for now the program can manage only (1, 20, 400, 8902).

As with my other programs, the move generator produces only legal moves and so some extra care is needed with its construction.

The execute/retract routines are working with one exception: the en passant target square may be non null even if no en passant capture is possible due to a pin. This will be fixed soon as it has a definite effect on move generation.

The move execute routine {note the"TBD" comment):

Code: Select all

procedure posexecute(posptr: posptrtype; moveptr: moveptrtype);
var
  spevnodeptr: spevnodeptrtype;
  castle: castletype;
  isnotnull: boolean;
begin
  with posptr^ do
    begin

      { Create and load a saved position environment values node }
      
      spevnodeptr := spevnodenew();
      with spevnodeptr^ do
        begin
          spev.move := moveptr^;
          spev.good := good; spev.evil := evil;
          spev.cvas := cvas; spev.epsq := epsq; spev.hmvc := hmvc; spev.fmvn := fmvn;
          spev.inch := inch; spev.dbch := dbch; spev.pmbb := pmbb; spev.fmbb := fmbb;
          spev.mphc := mphc
        end;

      { Append the saved position environment values node }
      
      if spevnodetail = nil then spevnodehead := spevnodeptr
      else
        begin
          spevnodetail^.next := spevnodeptr; spevnodeptr^.prev := spevnodetail
        end;
      spevnodetail := spevnodeptr;

      { Make the move }

      with moveptr^ do
        begin

          { Perform forward motion only for a non-null move }

          isnotnull := not moveflagtest(moveptr, mfnull);
          if isnotnull then
            begin
              case msc of
                mscreg:
                  begin
                    if toman <> manvv then posdelman&#40;posptr, toman, tosq&#41;;
                    posmovman&#40;posptr, frman, frsq, tosq&#41;
                  end;
                mscepc&#58;
                  begin
                    posdelman&#40;
                      posptr,
                      colorpiecetoman&#91;evil, piecep&#93;,
                      sqdirtonextsq&#91;tosq, pawnadvdir&#91;evil&#93;&#93;);
                    posmovman&#40;posptr, frman, frsq, tosq&#41;
                  end;
                msccqs, msccks&#58;
                  begin
                    castle &#58;= mapcolormsctocastle&#40;good, msc&#41;;
                    posmovman&#40;posptr, frman, frsq, tosq&#41;;
                    posmovman&#40;
                      posptr,
                      castletorook&#91;castle&#93;,
                      castlerook0sq&#91;castle&#93;,
                      castlerook1sq&#91;castle&#93;)
                  end;
                mscppn, mscppb, mscppr, mscppq&#58;
                  begin
                    if toman <> manvv then posdelman&#40;posptr, toman, tosq&#41;;
                    posdelman&#40;posptr, frman, frsq&#41;;
                    posaddman&#40;posptr, colorpiecetoman&#91;good, msctopiece&#91;msc&#93;&#93;, tosq&#41;
                  end
              end
            end;

          &#123; Various updates &#125;

          good &#58;= othercolor&#91;good&#93;; evil &#58;= othercolor&#91;evil&#93;;
          if isnotnull then
            if &#40;cvas <> 0&#41; then
              for castle &#58;= castlewq to castlebk do
                if odd&#40;cvas shr castle&#41; then
                  if  &#40;frsq = castleking0sq&#91;castle&#93;) or
                    &#40;frsq = castlerook0sq&#91;castle&#93;) or &#40;tosq = castlerook0sq&#91;castle&#93;) then
                    begin
                      cvas &#58;= cvas and &#40;not &#40;1 shl castle&#41;);
                      hashxor2d&#40;@mphc, @hashcastlevec&#91;castle&#93;)
                    end;
          if epsq <> sqnil then
            begin
              hashxor2d&#40;@mphc, @hashepfilevec&#91;mapsqtobfile&#40;epsq&#41;&#93;); epsq &#58;= sqnil
            end;
          if isnotnull then
            if &#40;mantopiece&#91;frman&#93; = piecep&#41; and (&#40;frsq xor tosq&#41; = &#40;bfilelen * 2&#41;) then
              begin
                epsq &#58;= sqdirtonextsq&#91;frsq, pawnadvdir&#91;evil&#93;&#93;; 
                &#123;TBD&#125;
                if epsq <> sqnil then hashxor2d&#40;@mphc, @hashepfilevec&#91;mapsqtobfile&#40;epsq&#41;&#93;)
              end;
          if isnotnull then
            if &#40;toman <> manvv&#41; or &#40;mantopiece&#91;frman&#93; = piecep&#41; then hmvc &#58;= 0 else inc&#40;hmvc&#41;;
          if good = colorw then inc&#40;fmvn&#41;;
          posrebuild&#40;posptr&#41;
        end
    end
end; &#123; posexecute &#125;

And the simpler move retract routine:

Code: Select all

procedure posretract(posptr: posptrtype);
var
  move: movetype;
  spevnodeptr: spevnodeptrtype;
  castle: castletype;
  isnotnull: boolean;
begin
  with posptr^ do
    begin

      { Detach the saved position environment values node }

      spevnodeptr := spevnodetail; spevnodetail := spevnodetail^.prev;
      if spevnodetail = nil then spevnodehead := nil else spevnodetail^.next := nil;
      
      { Unload and destroy the saved position environment values node }
      
      with spevnodeptr^ do
        begin
          move := spev.move;
          good := spev.good; evil := spev.evil;
          cvas := spev.cvas; epsq := spev.epsq; hmvc := spev.hmvc; fmvn := spev.fmvn;
          inch := spev.inch; dbch := spev.dbch; pmbb := spev.pmbb; fmbb := spev.fmbb
        end;
      spevnodedispose(spevnodeptr);

      { Unmake the move }

      with move do
        begin

          { Perform backward motion only for a non-null move }

          isnotnull := not moveflagtest(@move, mfnull);
          if isnotnull then
            begin
              case msc of
                mscreg:
                  begin
                    posmovman(posptr, frman, tosq, frsq);
                    if toman <> manvv then posaddman&#40;posptr, toman, tosq&#41;
                  end;
                mscepc&#58;
                  begin
                    posmovman&#40;posptr, frman, tosq, frsq&#41;;
                    posaddman&#40;
                      posptr,
                      colorpiecetoman&#91;evil, piecep&#93;,
                      sqdirtonextsq&#91;tosq, pawnadvdir&#91;evil&#93;&#93;)
                  end;
                msccqs, msccks&#58;
                  begin
                    castle &#58;= mapcolormsctocastle&#40;good, msc&#41;;
                    posmovman&#40;
                      posptr,
                      castletorook&#91;castle&#93;,
                      castlerook1sq&#91;castle&#93;,
                      castlerook0sq&#91;castle&#93;);
                    posmovman&#40;posptr, frman, tosq, frsq&#41;
                  end;
                mscppn, mscppb, mscppr, mscppq&#58;
                  begin
                    posdelman&#40;posptr, colorpiecetoman&#91;good, msctopiece&#91;msc&#93;&#93;, tosq&#41;;
                    posaddman&#40;posptr, frman, frsq&#41;;
                    if toman <> manvv then posaddman&#40;posptr, toman, tosq&#41;
                  end;
              end
            end
        end
    end
end; &#123; posretract &#125;

[sje]

Truth: The first draft of any chess program has at least three en passant bugs.

The code for updating check status and pinned/frozen men:

Code: Select all

  procedure posrebuild(posptr: posptrtype);

    procedure posrebuildcheckstatuses;
      var
        goodkingsq: sqxtype;
        atkbb: bbtype;
    begin
      with posptr^, bbdb do
        begin
          goodkingsq := ksqv[good];
          if goodkingsq = sqnil then begin inch := false; dbch := false end
          else
            begin
              inch := bbtestsq(@atkbc[evil], goodkingsq);
              if inch then
                begin
                  bband2(@atkbb, @locbc[evil], @atkts[goodkingsq]);
                  dbch := bbcount(@atkbb) > 1
                end
              else
                dbch := false
            end
        end
    end; { posrebuildcheckstatuses }

    procedure posrebuildpindbitboards;
      var
        color0, color1: colortype;
        king0sq: sqxtype;
        sweep1bb: bbtype;
        cand0sq: sqxtype;
        cand0bb: bbtype;
        dir: dirtype;
        deltar: integer;
    begin
      with posptr^, bbdb do
        begin
        
          { Initialize the pinned man and frozen man bitboard results }
        
          bbreset(@pmbb); bbreset(@fmbb);
          
          { Loop through each color to locate pinned men }
          
          for color0 := colorw to colorb do
            begin
            
              { Get the king square of the first color and make sure it exists }
            
              king0sq := ksqv[color0];
              if king0sq <> sqnil then
                begin
                
                  &#123; Get the second color and check if there are any second color sweep men &#125;
                
                  color1 &#58;= othercolor&#91;color0&#93;;
                  bband2&#40;@sweep1bb, @sweep, @locbc&#91;color1&#93;);
                  if not bbisreset&#40;@sweep1bb&#41; then
                    begin
                    
                      &#123; Build a bitboard of candidate pinned men for the first color &#125;
                    
                      bband3&#40;@cand0bb, @locbc&#91;color0&#93;, @sweepraybbvec&#91;king0sq&#93;, @atkbc&#91;color1&#93;);
                      
                      &#123; Loop through each first color candidate &#125;
                      
                      repeat
                        cand0sq &#58;= bbnextsq&#40;@cand0bb&#41;;
                        if cand0sq <> sqnil then
                        
                          &#123; Check for no men between the king and the candidate &#125;
                        
                          if bbni2&#40;@merge, @pathwaybbvec&#91;king0sq, cand0sq&#93;) then
                            begin
                            
                              &#123; Calculate the king/candidate direction &#125;
                            
                              dir &#58;= sqsqtodir&#91;king0sq, cand0sq&#93;;
                                  
                              &#123; Check if a real pin exists &#125;
                                
                              if not bbni3&#40;@openraybbvec&#91;cand0sq, dir&#93;, @sweep1bb, @atkts&#91;cand0sq&#93;) then
                                begin
                                  
                                  &#123; A pinned man was found; add to pinned man result &#125;
                                
                                  bbsetsq&#40;@pmbb, cand0sq&#41;;
                                  
                                  &#123; Check for frozen status of the pinned man &#125;

                                  case mantopiece&#91;board.sqv&#91;cand0sq&#93;&#93; of
                                    piecep&#58;
                                      begin
                                        deltar &#58;= calcbrankdelta&#40;king0sq, cand0sq&#41;;
                                        if isdirortho&#40;dir&#41; then
                                          begin if deltar = 0 then bbsetsq&#40;@fmbb, cand0sq&#41; end
                                        else
                                          begin
                                            if color0 = colorw then
                                              begin if deltar < 0 then bbsetsq&#40;@fmbb, cand0sq&#41; end
                                            else
                                              begin if deltar > 0 then bbsetsq&#40;@fmbb, cand0sq&#41; end
                                          end
                                      end;
                                    piecen&#58; bbsetsq&#40;@fmbb, cand0sq&#41;;
                                    pieceb&#58; if isdirortho&#40;dir&#41; then bbsetsq&#40;@fmbb, cand0sq&#41;;
                                    piecer&#58; if isdirdiago&#40;dir&#41; then bbsetsq&#40;@fmbb, cand0sq&#41;;
                                    pieceq&#58; ;
                                  end
                                end
                            end
                      until cand0sq = sqnil;
                    end
                end
            end
        end
    end; &#123; posrebuildpindbitboards &#125;

  begin
    posrebuildcheckstatuses; posrebuildpindbitboards
  end; &#123; posrebuild &#125;

[sje]

It looks like Bozo has the beginnings of a working perft. Alas:

1) No check evasion (but check/double check detection works)
2) No en passant (but promotions look okay)
3) No castling
4) No bulk counting
5) No transposition assistance
6) No sorted by SAN output
7) No user input interface
8) No FEN decoding
9) No input position legality checking

So for now the program can manage only (1, 20, 400, 8902).

The first attempt at check evasion has been installed, so the program can now make it to (1, 20, 400, 8902, 197281).

The SAN move sorter is complete. The move execute and retract routines have been instrumented with sanity checks. The program can run without problems with compiler-supplied range checking activated.

Next on the list: en passant, then castling.

[sje]

With the en passant code in place, perft is now returning 1, 20 , 400, 8902, 197281, 4865609, 119060324, 3195901860, and maybe more if I let it run long enough. Castling is also in place.

Still, the program is MISSING:

1) Bulk counting without generation
2) High speed mate detection
3) Repetition detection (but the hash code all seems to work)
4) Transposition tables
5) FEN decode and legality checking
6) User interface
7) EPD encoding/decoding
8) SAN full notation marking and decoding (sorting works)
9) Many utility routines (I/O, timing, option parsing, etc.)

The above should be in place before the initial release; also maybe a few more things like random game generation.

Current source size:

Code: Select all

sje@clare:~/Projects/bozochess$ wc -l bozochess.pas
3521 bozochess.pas

Extra care has been taken in several areas:

1) Only legal moves are output from the move generation routines. There is no need to test for passive king-in-check status, although there is some easily removed sanity checking code in place for this.

2) An en passant target square is generated if and only if there is at least one legal en passant capture.

3) Castling is totally table driven so that chess960/FRC can be easily implemented. Although I'm not a fan of Chess960, others may find this feature of interest.

4) Null moves are handled properly although this won't be of use until a search is installed.

5) Game termination status determination priority is in place: checkmate/stalemate, fifty move, insufficient, repetition.

[sje]

The basic move generation is in place and is unlikely to change very much. Here it is:

Code: Select all

  procedure posgenerate(var pos: postype; var gms: gmstype);

    procedure posgenerateevasion;
      var
        goodkingsq: sqtype;
        goodpawn, goodking: manrtype;
        goodbb, goodpawnbb: bbtype;
        r2brank, r4brank, r8brank: branktype;
        advdir: dirtype;
        singlecheck: boolean;
        checkerbb: bbtype;
        checkersq: sqxtype;
        checkerman: mantype;
        checkeropr: boolean;
        flightbb: bbtype;
        flightsq: sqxtype;
        atkbb: bbtype;
        atksq: sqxtype;
        defbb: bbtype;
        defsq: sqxtype;
        defman: manrtype;
        shadowsq: sqxtype;
        cvpwbb: bbtype;
        pathbb: bbtype;
        pathsq: sqxtype;
        ipdbb: bbtype;
        ipdsq: sqxtype;
        epmove: movetype;
    begin
      with pos, board, bbdb do
        begin

          { Set various local constant values }
          
          goodkingsq := ksqv[good];
          goodpawn := synthpawn[good]; goodking := synthking[good];
          goodbb := locbc[good]; goodpawnbb := locbm[goodpawn];
          r2brank := normalbrank[good, brank2];
          r4brank := normalbrank[good, brank4];
          r8brank := normalbrank[good, brank8];
          advdir := pawnadvdir[good];
          singlecheck := not dbch;
          bband2(checkerbb, locbc[evil], atkts[goodkingsq]); 

          { Set various checker data local constant values according to double check status }

          if singlecheck then
            begin
              checkersq := bbfirstsq(checkerbb); checkerman := sqv[checkersq];
              checkeropr := mapsqtobrank(checkersq) = r8brank
            end
          else
            begin
              checkersq := sqnil; checkerman := manvv; checkeropr := false
            end;

          { Initialize the king flight squares bitboard }
          
          flightbb := kingatkbbvec[goodkingsq];
          bband2c2d(flightbb, goodbb); bband2c2d(flightbb, atkbc[evil]);

          { Remove any shadow squares from the flight bitboard }
          
          atkbb := checkerbb;
          repeat
            atksq := bbnextsq(atkbb);
            if &#40;atksq <> sqnil&#41; then
              if bbtestsq&#40;sweep, atksq&#41; then
                begin
                  shadowsq &#58;= shadowsqvec&#91;atksq, goodkingsq&#93;;
                  if shadowsq <> sqnil then bbresetsq&#40;flightbb, shadowsq&#41;
                end
          until atksq = sqnil;

          &#123; Attempt non en passant capture of a singleton attacker &#40;no king moves, no en passant&#41; &#125;

          if singlecheck then
            begin
              bband2&#40;defbb, atkts&#91;checkersq&#93;, goodbb&#41;; bband2c2d&#40;defbb, pmbb&#41;;
              bbresetsq&#40;defbb, goodkingsq&#41;;
              repeat
                defsq &#58;= bbnextsq&#40;defbb&#41;;
                if defsq <> sqnil then
                  begin
                    defman &#58;= sqv&#91;defsq&#93;;
                    if &#40;defman <> goodpawn&#41; or &#40;not checkeropr&#41; then
                      gmspushm2&#40;gms, defsq, checkersq, defman, checkerman&#41;
                    else
                      gmspushpscapt&#40;gms, defsq, checkersq, defman, checkerman&#41;
                  end
              until defsq = sqnil
            end;

          &#123; Attempt king capture of a single attacker &#125;

          if singlecheck then
            if bbtestsq&#40;flightbb, checkersq&#41; then
              begin
                gmspushm2&#40;gms, goodkingsq, checkersq, goodking, checkerman&#41;;
                bbresetsq&#40;flightbb, checkersq&#41;
              end;

          &#123; Attempt remaining king moves &#125;

          repeat
            flightsq &#58;= bbnextsq&#40;flightbb&#41;;
            if flightsq <> sqnil then
              gmspushm2&#40;gms, goodkingsq, flightsq, goodking, sqv&#91;flightsq&#93;)
          until flightsq = sqnil;

          &#123; Attempt interposition against a singleton sweep attacker &#40;all non captures&#41; &#125;
          
          if singlecheck then
            if bbtestsq&#40;sweep, checkersq&#41; then
              if not bbtestsq&#40;atkfs&#91;goodkingsq&#93;, checkersq&#41; then
                begin
                  cvpwbb &#58;= pathwaybbvec&#91;goodkingsq, checkersq&#93;;
                
                  &#123; Try non pawn interpositions &#125;
                
                  pathbb &#58;= cvpwbb;
                  repeat
                    pathsq &#58;= bbnextsq&#40;pathbb&#41;;
                    if pathsq <> sqnil then
                      begin
                        bband2&#40;ipdbb, atkts&#91;pathsq&#93;, goodbb&#41;;
                        bband2c2d&#40;ipdbb, goodpawnbb&#41;; bband2c2d&#40;ipdbb, pmbb&#41;;
                        bbresetsq&#40;ipdbb, goodkingsq&#41;;
                        repeat
                          ipdsq &#58;= bbnextsq&#40;ipdbb&#41;;
                          if ipdsq <> sqnil then
                            gmspushm1&#40;gms, ipdsq, pathsq, sqv&#91;ipdsq&#93;)
                        until ipdsq = sqnil
                      end
                  until pathsq = sqnil;
                
                  &#123; Try pawn interpositions &#125;
                  
                  if not bbisreset&#40;goodpawnbb&#41; then
                    if not issamebfile&#40;goodkingsq, checkersq&#41; then
                      begin
                      
                        &#123; Single square advance pawn interpositions &#125;
                      
                        bband2c2&#40;ipdbb, goodpawnbb, fmbb&#41;;
                        repeat
                          ipdsq &#58;= bbnextsq&#40;ipdbb&#41;;
                          if ipdsq <> sqnil then
                            begin
                              pathsq &#58;= sqdirtonextsq&#91;ipdsq, advdir&#93;;
                              if bbtestsq&#40;cvpwbb, pathsq&#41; then
                                if mapsqtobrank&#40;pathsq&#41; <> r8brank then
                                  gmspushm1&#40;gms, ipdsq, pathsq, goodpawn&#41;
                                else
                                  gmspushpshold&#40;gms, ipdsq, pathsq, goodpawn&#41;
                            end
                        until ipdsq = sqnil;
                      
                        &#123; Double square advance pawn interpositions &#125;
                        
                        bband2&#40;pathbb, cvpwbb, brankbbvec&#91;r4brank&#93;);
                        if not bbisreset&#40;pathbb&#41; then
                          begin
                            bband2&#40;ipdbb, goodpawnbb, brankbbvec&#91;r2brank&#93;);
                            bband2c2d&#40;ipdbb, fmbb&#41;;
                            repeat
                              ipdsq &#58;= bbnextsq&#40;ipdbb&#41;;
                              if ipdsq <> sqnil then
                                begin
                                  pathsq &#58;= sqdirtonextsq&#91;ipdsq, advdir&#93;;
                                  if not bbtestsq&#40;merge, pathsq&#41; then
                                    begin
                                      pathsq &#58;= sqdirtonextsq&#91;pathsq, advdir&#93;;
                                      if bbtestsq&#40;pathbb, pathsq&#41; then
                                        gmspushm1&#40;gms, ipdsq, pathsq, goodpawn&#41;
                                    end
                                end
                            until ipdsq = sqnil
                          end
                      end
                end;

          &#123; Attempt en passant capture &#125;

          if epsq <> sqnil then
            begin
              bband2&#40;defbb, goodpawnbb, pawnatkbbvec&#91;evil, epsq&#93;);
              repeat
                defsq &#58;= bbnextsq&#40;defbb&#41;;
                if defsq <> sqnil then
                  begin
                    movesynthm4&#40;epmove, defsq, epsq, goodpawn, mscepc&#41;;
                    if postestepmove&#40;pos, epmove&#41; then gmspush&#40;gms, epmove&#41;
                  end
              until defsq = sqnil
            end;

        end
    end; &#123; posgenerateevasion &#125;

    procedure posgeneratenocheck;
      var
        goodkingsq&#58; sqtype;
        goodbb, evilbb, destbb&#58; bbtype;
        frbb, tobb&#58; bbtype;
        frsq, tosq&#58; sqxtype;
        frman&#58; manrtype;
        frbrank&#58; branktype;
        r2brank, r7brank&#58; branktype;
        r2flag, r7flag&#58; boolean;
        advdir, capdir&#58; dirtype;
        resdir&#58; dirxtype;
        pawnatkbb&#58; bbtype;
        epmove&#58; movetype;
        castle&#58; castletype;
    begin
      with pos, board, bbdb do
        begin

          &#123; Initialize for the good man scan &#125;
   
          goodkingsq &#58;= ksqv&#91;good&#93;;
          goodbb &#58;= locbc&#91;good&#93;; evilbb &#58;= locbc&#91;evil&#93;;
          bbnot1&#40;destbb, goodbb&#41;;
          bband2c2&#40;frbb, goodbb, fmbb&#41;;
          r2brank &#58;= normalbrank&#91;good, brank2&#93;; r7brank &#58;= normalbrank&#91;good, brank7&#93;;

          &#123; Loop once for each possible moving man &#125;
    
          repeat
            frsq &#58;= bbnextsq&#40;frbb&#41;;
            if frsq <> sqnil then
              begin
              
                &#123; Fetch the moving man and process by its piece kind &#125;
    
                frman &#58;= sqv&#91;frsq&#93;;
                case mantopiece&#91;frman&#93; of

                  piecep&#58;
                    begin
                    
                      &#123; Set various pre-generation data for this pawn &#125;
                    
                      frbrank &#58;= mapsqtobrank&#40;frsq&#41;;
                      r2flag &#58;= frbrank = r2brank; r7flag &#58;= frbrank = r7brank;
                      advdir &#58;= pawnadvdir&#91;good&#93;;
                      if bbtestsq&#40;pmbb, frsq&#41; then
                        resdir &#58;= sqsqtodir&#91;goodkingsq, frsq&#93;
                      else
                        resdir &#58;= dirnil;
                      pawnatkbb &#58;= pawnatkbbvec&#91;good, frsq&#93;;
   
                      &#123; Pawn noncapture moves &#40;includes noncapture promotions&#41; &#125;
   
                      if &#40;resdir = dirnil&#41; or &#40;resdir = advdir&#41; then
                        begin
                          tosq &#58;= sqdirtonextsq&#91;frsq, advdir&#93;;
                          if not bbtestsq&#40;merge, tosq&#41; then
                            if r7flag then gmspushpshold&#40;gms, frsq, tosq, frman&#41;
                            else
                              begin
                                gmspushm1&#40;gms, frsq, tosq, frman&#41;;
                                if r2flag then
                                  begin
                                    tosq &#58;= sqdirtonextsq&#91;tosq, advdir&#93;;
                                    if not bbtestsq&#40;merge, tosq&#41; then gmspushm1&#40;gms, frsq, tosq, frman&#41;;
                                  end
                              end
                        end;
   
                      &#123; Pawn capture moves &#40;includes capture promotions; not en passant&#41; &#125;
                      
                      bband2&#40;tobb, pawnatkbb, evilbb&#41;;
                      repeat
                        tosq &#58;= bbnextsq&#40;tobb&#41;;
                        if tosq <> sqnil then
                          begin
                            capdir &#58;= sqsqtodir&#91;frsq, tosq&#93;;
                            if &#40;resdir = dirnil&#41; or &#40;resdir = capdir&#41; then
                              if r7flag then
                                gmspushpscapt&#40;gms, frsq, tosq, frman, sqv&#91;tosq&#93;)
                              else
                                gmspushm2&#40;gms, frsq, tosq, frman, sqv&#91;tosq&#93;)
                          end
                      until tosq = sqnil;

                      &#123; En passant capture &#125;
                      
                      if epsq <> sqnil then
                        if bbtestsq&#40;pawnatkbb, epsq&#41; then
                          begin
                            movesynthm4&#40;epmove, frsq, epsq, frman, mscepc&#41;;
                            if postestepmove&#40;pos, epmove&#41; then gmspush&#40;gms, epmove&#41;
                          end
                    end;

                  piecen&#58;
                    begin

                      &#123; Regular knight moves &#125;

                      bband2&#40;tobb, atkfs&#91;frsq&#93;, destbb&#41;;
                      repeat
                        tosq &#58;= bbnextsq&#40;tobb&#41;;
                        if tosq <> sqnil then gmspushm2&#40;gms, frsq, tosq, frman, sqv&#91;tosq&#93;)
                      until tosq = sqnil
                    end;

                  pieceb, piecer, pieceq&#58;
                    begin
                    
                      &#123; Regular sweeper moves &#125;
                    
                      bband2&#40;tobb, atkfs&#91;frsq&#93;, destbb&#41;;
                      if bbtestsq&#40;pmbb, frsq&#41; then bband2d&#40;tobb, beamerbbvec&#91;goodkingsq, frsq&#93;);
                      repeat
                        tosq &#58;= bbnextsq&#40;tobb&#41;;
                        if tosq <> sqnil then gmspushm2&#40;gms, frsq, tosq, frman, sqv&#91;tosq&#93;)
                      until tosq = sqnil
                    end;

                  piecek&#58;
                    begin
                    
                      &#123; Regular king moves &#125;
                    
                      bband2&#40;tobb, atkfs&#91;frsq&#93;, destbb&#41;; bband2c2d&#40;tobb, atkbc&#91;evil&#93;);
                      repeat
                        tosq &#58;= bbnextsq&#40;tobb&#41;;
                        if tosq <> sqnil then gmspushm2&#40;gms, frsq, tosq, frman, sqv&#91;tosq&#93;)
                      until tosq = sqnil;
                      
                      &#123; Castling &#125;
                      
                      if cvas <> 0 then
                        for castle &#58;= castlewq to castlebk do
                          if postestcastle&#40;pos, castle&#41; then gmspush&#40;gms, cdrvec&#91;castle&#93;.cmov&#41;
                    end;

                end
              end
          until frsq = sqnil;
        end
    end; &#123; posgeneratenocheck &#125;

  begin
    with pos do
      begin
        gmsreset&#40;gms&#41;;
        if inch then posgenerateevasion else posgeneratenocheck
      end
  end; &#123; posgenerate &#125;

[sje]

The bulk move counter is also in place and is reasonably fast. It is essentially the same as the move generation routine except that it only has to count and doesn't have to synthesize and stack moves.

The fast mate detector is not yet in place. It will be essentially the same as the bulk move counter, but needs only to return a "count = 0" status. This allows for extensive short circuit calculation.

Other generation routines to come:

1) posgenerategainers (generates captures and promotions only)

2) posgeneratechecks (generates checking moves only)

Both of the above can be called only when the moving color is not in check.

Other related routines, already in place:

1) posmetagenmarked (generate moves and set move flags for SAN disambiguation, checks, and checkmates)

2) posmetagencanonical (generate marked, and then sort by SAN)

3) posmetagensuperdeluxe (generate canonical than add all appropriate draw indication flags; also, set draw and mating scores where needed)

I've taken out all use of the "@" (take address of) operator as I felt it went against the spirit of Pascal and made the code look too much like C.