LCOV - code coverage report
Current view: top level - src - sqmove.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 26 26 100.0 %
Date: 2019-01-29 11:06:41 Functions: 10 10 100.0 %

          Line data    Source code
       1             : //////////////////////////////////////////////////////////////////////
       2             : //
       3             : //  FILE:       sqmove.h
       4             : //              Square movement lookup table
       5             : //
       6             : //  Part of:    Scid (Shane's Chess Information Database)
       7             : //  Version:    3.4
       8             : //
       9             : //  Notice:     Copyright (c) 1999-2002  Shane Hudson.  All rights reserved.
      10             : //
      11             : //  Author:     Shane Hudson (sgh@users.sourceforge.net)
      12             : //
      13             : //////////////////////////////////////////////////////////////////////
      14             : 
      15             : #ifndef SCID_SQMOVE_H
      16             : #define SCID_SQMOVE_H
      17             : 
      18             : #include "common.h"
      19             : 
      20             : constexpr uint MAX_SQUARELIST = 65; // 64 squares plus null square
      21             : 
      22             : class SquareList {
      23             :         uint ListSize;
      24             :         squareT Squares[MAX_SQUARELIST];
      25             : 
      26             : public:
      27     7352807 :         SquareList() { ListSize = 0; }
      28             : 
      29             :         void Init() { ListSize = 0; }
      30     6557057 :         void Clear() { ListSize = 0; }
      31     1126231 :         void Add(squareT sq) {
      32     1126231 :                 Squares[ListSize] = sq;
      33     1126231 :                 ListSize++;
      34     1126231 :         }
      35     6611963 :         uint Size() { return ListSize; }
      36             : 
      37       54719 :         squareT Get(uint index) {
      38       54719 :                 ASSERT(index < ListSize);
      39       54719 :                 return Squares[index];
      40             :         }
      41             : 
      42             :         bool Contains(squareT sq) {
      43             :                 for (uint i = 0; i < ListSize; i++) {
      44             :                         if (Squares[i] == sq) {
      45             :                                 return true;
      46             :                         }
      47             :                 }
      48             :                 return false;
      49             :         }
      50             : 
      51             :         void Remove(uint index) {
      52             :                 ASSERT(index < ListSize);
      53             :                 ListSize--;
      54             :                 if (index != ListSize) {
      55             :                         Squares[index] = Squares[ListSize];
      56             :                 }
      57             :         }
      58             : };
      59             : 
      60             : class SquareSet {
      61             :         uint Bits_a1h4;
      62             :         uint Bits_a5h8;
      63             : 
      64             : public:
      65       54768 :         SquareSet() { Bits_a1h4 = Bits_a5h8 = 0; }
      66             :         SquareSet(squareT* squares) {
      67             :                 Bits_a1h4 = Bits_a5h8 = 0;
      68             :                 AddAll(squares);
      69             :         }
      70             : 
      71             :         void Clear(void) { Bits_a1h4 = Bits_a5h8 = 0; }
      72             :         void AddAll(void) { Bits_a1h4 = Bits_a5h8 = 0xFFFFFFFFu; }
      73             : 
      74      112320 :         void Add(squareT sq) {
      75      112320 :                 ASSERT(sq <= H8);
      76      112320 :                 if (sq <= H4) {
      77       56763 :                         Bits_a1h4 |= (1 << sq);
      78             :                 } else {
      79       55557 :                         Bits_a5h8 |= (1 << (sq & 31));
      80             :                 }
      81      112320 :         }
      82             : 
      83             :         void AddAll(squareT* squares) {
      84             :                 while (true) {
      85             :                         squareT sq = *squares;
      86             :                         if (sq == NULL_SQUARE) {
      87             :                                 break;
      88             :                         }
      89             :                         ASSERT(sq <= H8);
      90             :                         squares++;
      91             :                         if (sq <= H4) {
      92             :                                 Bits_a1h4 |= (1 << sq);
      93             :                         } else {
      94             :                                 Bits_a5h8 |= (1 << (sq & 31));
      95             :                         }
      96             :                 }
      97             :         }
      98             : 
      99     1055273 :         bool Contains(squareT sq) {
     100     1055273 :                 ASSERT(sq <= H8);
     101     1055273 :                 if (sq <= H4) {
     102      529281 :                         return (Bits_a1h4 & (1 << sq)) != 0;
     103             :                 } else {
     104      525992 :                         return (Bits_a5h8 & (1 << (sq & 31))) != 0;
     105             :                 }
     106             :         }
     107             : 
     108             :         void Remove(squareT sq) {
     109             :                 ASSERT(sq <= H8);
     110             :                 if (sq <= H4) {
     111             :                         Bits_a1h4 &= ~(1 << sq);
     112             :                 } else {
     113             :                         Bits_a5h8 &= ~(1 << (sq & 31));
     114             :                 }
     115             :         }
     116             : };
     117             : 
     118             : //~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     119             : // sqMove
     120             : //   Array indexed by square value and direction, giving the square
     121             : //   obtained by moving from the square in that direction.
     122             : constexpr squareT
     123             : sqMove[66][11] = {
     124             :                 /* UP DOWN    LEFT UL  DL    RIGHT UR  DR */
     125             :    { /* A1 */  NS, A2, NS, NS, NS, NS, NS, NS, B1, B2, NS   },
     126             :    { /* B1 */  NS, B2, NS, NS, A1, A2, NS, NS, C1, C2, NS   },
     127             :    { /* C1 */  NS, C2, NS, NS, B1, B2, NS, NS, D1, D2, NS   },
     128             :    { /* D1 */  NS, D2, NS, NS, C1, C2, NS, NS, E1, E2, NS   },
     129             :    { /* E1 */  NS, E2, NS, NS, D1, D2, NS, NS, F1, F2, NS   },
     130             :    { /* F1 */  NS, F2, NS, NS, E1, E2, NS, NS, G1, G2, NS   },
     131             :    { /* G1 */  NS, G2, NS, NS, F1, F2, NS, NS, H1, H2, NS   },
     132             :    { /* H1 */  NS, H2, NS, NS, G1, G2, NS, NS, NS, NS, NS   },
     133             :    { /* A2 */  NS, A3, A1, NS, NS, NS, NS, NS, B2, B3, B1   },
     134             :    { /* B2 */  NS, B3, B1, NS, A2, A3, A1, NS, C2, C3, C1   },
     135             :    { /* C2 */  NS, C3, C1, NS, B2, B3, B1, NS, D2, D3, D1   },
     136             :    { /* D2 */  NS, D3, D1, NS, C2, C3, C1, NS, E2, E3, E1   },
     137             :    { /* E2 */  NS, E3, E1, NS, D2, D3, D1, NS, F2, F3, F1   },
     138             :    { /* F2 */  NS, F3, F1, NS, E2, E3, E1, NS, G2, G3, G1   },
     139             :    { /* G2 */  NS, G3, G1, NS, F2, F3, F1, NS, H2, H3, H1   },
     140             :    { /* H2 */  NS, H3, H1, NS, G2, G3, G1, NS, NS, NS, NS   },
     141             :    { /* A3 */  NS, A4, A2, NS, NS, NS, NS, NS, B3, B4, B2   },
     142             :    { /* B3 */  NS, B4, B2, NS, A3, A4, A2, NS, C3, C4, C2   },
     143             :    { /* C3 */  NS, C4, C2, NS, B3, B4, B2, NS, D3, D4, D2   },
     144             :    { /* D3 */  NS, D4, D2, NS, C3, C4, C2, NS, E3, E4, E2   },
     145             :    { /* E3 */  NS, E4, E2, NS, D3, D4, D2, NS, F3, F4, F2   },
     146             :    { /* F3 */  NS, F4, F2, NS, E3, E4, E2, NS, G3, G4, G2   },
     147             :    { /* G3 */  NS, G4, G2, NS, F3, F4, F2, NS, H3, H4, H2   },
     148             :    { /* H3 */  NS, H4, H2, NS, G3, G4, G2, NS, NS, NS, NS   },
     149             :    { /* A4 */  NS, A5, A3, NS, NS, NS, NS, NS, B4, B5, B3   },
     150             :    { /* B4 */  NS, B5, B3, NS, A4, A5, A3, NS, C4, C5, C3   },
     151             :    { /* C4 */  NS, C5, C3, NS, B4, B5, B3, NS, D4, D5, D3   },
     152             :    { /* D4 */  NS, D5, D3, NS, C4, C5, C3, NS, E4, E5, E3   },
     153             :    { /* E4 */  NS, E5, E3, NS, D4, D5, D3, NS, F4, F5, F3   },
     154             :    { /* F4 */  NS, F5, F3, NS, E4, E5, E3, NS, G4, G5, G3   },
     155             :    { /* G4 */  NS, G5, G3, NS, F4, F5, F3, NS, H4, H5, H3   },
     156             :    { /* H4 */  NS, H5, H3, NS, G4, G5, G3, NS, NS, NS, NS   },
     157             :    { /* A5 */  NS, A6, A4, NS, NS, NS, NS, NS, B5, B6, B4   },
     158             :    { /* B5 */  NS, B6, B4, NS, A5, A6, A4, NS, C5, C6, C4   },
     159             :    { /* C5 */  NS, C6, C4, NS, B5, B6, B4, NS, D5, D6, D4   },
     160             :    { /* D5 */  NS, D6, D4, NS, C5, C6, C4, NS, E5, E6, E4   },
     161             :    { /* E5 */  NS, E6, E4, NS, D5, D6, D4, NS, F5, F6, F4   },
     162             :    { /* F5 */  NS, F6, F4, NS, E5, E6, E4, NS, G5, G6, G4   },
     163             :    { /* G5 */  NS, G6, G4, NS, F5, F6, F4, NS, H5, H6, H4   },
     164             :    { /* H5 */  NS, H6, H4, NS, G5, G6, G4, NS, NS, NS, NS   },
     165             :    { /* A6 */  NS, A7, A5, NS, NS, NS, NS, NS, B6, B7, B5   },
     166             :    { /* B6 */  NS, B7, B5, NS, A6, A7, A5, NS, C6, C7, C5   },
     167             :    { /* C6 */  NS, C7, C5, NS, B6, B7, B5, NS, D6, D7, D5   },
     168             :    { /* D6 */  NS, D7, D5, NS, C6, C7, C5, NS, E6, E7, E5   },
     169             :    { /* E6 */  NS, E7, E5, NS, D6, D7, D5, NS, F6, F7, F5   },
     170             :    { /* F6 */  NS, F7, F5, NS, E6, E7, E5, NS, G6, G7, G5   },
     171             :    { /* G6 */  NS, G7, G5, NS, F6, F7, F5, NS, H6, H7, H5   },
     172             :    { /* H6 */  NS, H7, H5, NS, G6, G7, G5, NS, NS, NS, NS   },
     173             :    { /* A7 */  NS, A8, A6, NS, NS, NS, NS, NS, B7, B8, B6   },
     174             :    { /* B7 */  NS, B8, B6, NS, A7, A8, A6, NS, C7, C8, C6   },
     175             :    { /* C7 */  NS, C8, C6, NS, B7, B8, B6, NS, D7, D8, D6   },
     176             :    { /* D7 */  NS, D8, D6, NS, C7, C8, C6, NS, E7, E8, E6   },
     177             :    { /* E7 */  NS, E8, E6, NS, D7, D8, D6, NS, F7, F8, F6   },
     178             :    { /* F7 */  NS, F8, F6, NS, E7, E8, E6, NS, G7, G8, G6   },
     179             :    { /* G7 */  NS, G8, G6, NS, F7, F8, F6, NS, H7, H8, H6   },
     180             :    { /* H7 */  NS, H8, H6, NS, G7, G8, G6, NS, NS, NS, NS   },
     181             :    { /* A8 */  NS, NS, A7, NS, NS, NS, NS, NS, B8, NS, B7   },
     182             :    { /* B8 */  NS, NS, B7, NS, A8, NS, A7, NS, C8, NS, C7   },
     183             :    { /* C8 */  NS, NS, C7, NS, B8, NS, B7, NS, D8, NS, D7   },
     184             :    { /* D8 */  NS, NS, D7, NS, C8, NS, C7, NS, E8, NS, E7   },
     185             :    { /* E8 */  NS, NS, E7, NS, D8, NS, D7, NS, F8, NS, F7   },
     186             :    { /* F8 */  NS, NS, F7, NS, E8, NS, E7, NS, G8, NS, G7   },
     187             :    { /* G8 */  NS, NS, G7, NS, F8, NS, F7, NS, H8, NS, H7   },
     188             :    { /* H8 */  NS, NS, H7, NS, G8, NS, G7, NS, NS, NS, NS   },
     189             :    { /* NS */  NS, NS, NS, NS, NS, NS, NS, NS, NS, NS, NS   },
     190             :    { /* NS */  NS, NS, NS, NS, NS, NS, NS, NS, NS, NS, NS   }
     191             :  };
     192             : 
     193             : //~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     194             : // sqLast
     195             : //   Array indexed by square value and direction, giving the last
     196             : //   square reached by moving from the square in that direction.
     197             : //   The last square is the same as the original square if moving
     198             : //   in the specified direction would move off the board.
     199             : constexpr squareT
     200             : sqLast[66][11] = {
     201             :                 /* UP DOWN    LEFT UL  DL    RIGHT UR  DR */
     202             :    { /* A1 */  NS, A8, A1, NS, A1, A1, A1, NS, H1, H8, A1   },
     203             :    { /* B1 */  NS, B8, B1, NS, A1, A2, B1, NS, H1, H7, B1   },
     204             :    { /* C1 */  NS, C8, C1, NS, A1, A3, C1, NS, H1, H6, C1   },
     205             :    { /* D1 */  NS, D8, D1, NS, A1, A4, D1, NS, H1, H5, D1   },
     206             :    { /* E1 */  NS, E8, E1, NS, A1, A5, E1, NS, H1, H4, E1   },
     207             :    { /* F1 */  NS, F8, F1, NS, A1, A6, F1, NS, H1, H3, F1   },
     208             :    { /* G1 */  NS, G8, G1, NS, A1, A7, G1, NS, H1, H2, G1   },
     209             :    { /* H1 */  NS, H8, H1, NS, A1, A8, H1, NS, H1, H1, H1   },
     210             :    { /* A2 */  NS, A8, A1, NS, A2, A2, A2, NS, H2, G8, B1   },
     211             :    { /* B2 */  NS, B8, B1, NS, A2, A3, A1, NS, H2, H8, C1   },
     212             :    { /* C2 */  NS, C8, C1, NS, A2, A4, B1, NS, H2, H7, D1   },
     213             :    { /* D2 */  NS, D8, D1, NS, A2, A5, C1, NS, H2, H6, E1   },
     214             :    { /* E2 */  NS, E8, E1, NS, A2, A6, D1, NS, H2, H5, F1   },
     215             :    { /* F2 */  NS, F8, F1, NS, A2, A7, E1, NS, H2, H4, G1   },
     216             :    { /* G2 */  NS, G8, G1, NS, A2, A8, F1, NS, H2, H3, H1   },
     217             :    { /* H2 */  NS, H8, H1, NS, A2, B8, G1, NS, H2, H2, H2   },
     218             :    { /* A3 */  NS, A8, A1, NS, A3, A3, A3, NS, H3, F8, C1   },
     219             :    { /* B3 */  NS, B8, B1, NS, A3, A4, A2, NS, H3, G8, D1   },
     220             :    { /* C3 */  NS, C8, C1, NS, A3, A5, A1, NS, H3, H8, E1   },
     221             :    { /* D3 */  NS, D8, D1, NS, A3, A6, B1, NS, H3, H7, F1   },
     222             :    { /* E3 */  NS, E8, E1, NS, A3, A7, C1, NS, H3, H6, G1   },
     223             :    { /* F3 */  NS, F8, F1, NS, A3, A8, D1, NS, H3, H5, H1   },
     224             :    { /* G3 */  NS, G8, G1, NS, A3, B8, E1, NS, H3, H4, H2   },
     225             :    { /* H3 */  NS, H8, H1, NS, A3, C8, F1, NS, H3, H3, H3   },
     226             :    { /* A4 */  NS, A8, A1, NS, A4, A4, A4, NS, H4, E8, D1   },
     227             :    { /* B4 */  NS, B8, B1, NS, A4, A5, A3, NS, H4, F8, E1   },
     228             :    { /* C4 */  NS, C8, C1, NS, A4, A6, A2, NS, H4, G8, F1   },
     229             :    { /* D4 */  NS, D8, D1, NS, A4, A7, A1, NS, H4, H8, G1   },
     230             :    { /* E4 */  NS, E8, E1, NS, A4, A8, B1, NS, H4, H7, H1   },
     231             :    { /* F4 */  NS, F8, F1, NS, A4, B8, C1, NS, H4, H6, H2   },
     232             :    { /* G4 */  NS, G8, G1, NS, A4, C8, D1, NS, H4, H5, H3   },
     233             :    { /* H4 */  NS, H8, H1, NS, A4, D8, E1, NS, H4, H4, H4   },
     234             :    { /* A5 */  NS, A8, A1, NS, A5, A5, A5, NS, H5, D8, E1   },
     235             :    { /* B5 */  NS, B8, B1, NS, A5, A6, A4, NS, H5, E8, F1   },
     236             :    { /* C5 */  NS, C8, C1, NS, A5, A7, A3, NS, H5, F8, G1   },
     237             :    { /* D5 */  NS, D8, D1, NS, A5, A8, A2, NS, H5, G8, H1   },
     238             :    { /* E5 */  NS, E8, E1, NS, A5, B8, A1, NS, H5, H8, H2   },
     239             :    { /* F5 */  NS, F8, F1, NS, A5, C8, B1, NS, H5, H7, H3   },
     240             :    { /* G5 */  NS, G8, G1, NS, A5, D8, C1, NS, H5, H6, H4   },
     241             :    { /* H5 */  NS, H8, H1, NS, A5, E8, D1, NS, H5, H5, H5   },
     242             :    { /* A6 */  NS, A8, A1, NS, A6, A6, A6, NS, H6, C8, F1   },
     243             :    { /* B6 */  NS, B8, B1, NS, A6, A7, A5, NS, H6, D8, G1   },
     244             :    { /* C6 */  NS, C8, C1, NS, A6, A8, A4, NS, H6, E8, H1   },
     245             :    { /* D6 */  NS, D8, D1, NS, A6, B8, A3, NS, H6, F8, H2   },
     246             :    { /* E6 */  NS, E8, E1, NS, A6, C8, A2, NS, H6, G8, H3   },
     247             :    { /* F6 */  NS, F8, F1, NS, A6, D8, A1, NS, H6, H8, H4   },
     248             :    { /* G6 */  NS, G8, G1, NS, A6, E8, B1, NS, H6, H7, H5   },
     249             :    { /* H6 */  NS, H8, H1, NS, A6, F8, C1, NS, H6, H6, H6   },
     250             :    { /* A7 */  NS, A8, A1, NS, A7, A7, A7, NS, H7, B8, G1   },
     251             :    { /* B7 */  NS, B8, B1, NS, A7, A8, A6, NS, H7, C8, H1   },
     252             :    { /* C7 */  NS, C8, C1, NS, A7, B8, A5, NS, H7, D8, H2   },
     253             :    { /* D7 */  NS, D8, D1, NS, A7, C8, A4, NS, H7, E8, H3   },
     254             :    { /* E7 */  NS, E8, E1, NS, A7, D8, A3, NS, H7, F8, H4   },
     255             :    { /* F7 */  NS, F8, F1, NS, A7, E8, A2, NS, H7, G8, H5   },
     256             :    { /* G7 */  NS, G8, G1, NS, A7, F8, A1, NS, H7, H8, H6   },
     257             :    { /* H7 */  NS, H8, H1, NS, A7, G8, B1, NS, H7, H7, H7   },
     258             :    { /* A8 */  NS, A8, A1, NS, A8, A8, A8, NS, H8, A8, H1   },
     259             :    { /* B8 */  NS, B8, B1, NS, A8, B8, A7, NS, H8, B8, H2   },
     260             :    { /* C8 */  NS, C8, C1, NS, A8, C8, A6, NS, H8, C8, H3   },
     261             :    { /* D8 */  NS, D8, D1, NS, A8, D8, A5, NS, H8, D8, H4   },
     262             :    { /* E8 */  NS, E8, E1, NS, A8, E8, A4, NS, H8, E8, H5   },
     263             :    { /* F8 */  NS, F8, F1, NS, A8, F8, A3, NS, H8, F8, H6   },
     264             :    { /* G8 */  NS, G8, G1, NS, A8, G8, A2, NS, H8, G8, H7   },
     265             :    { /* H8 */  NS, H8, H1, NS, A8, H8, A1, NS, H8, H8, H8   },
     266             :    { /* NS */  NS, NS, NS, NS, NS, NS, NS, NS, NS, NS, NS   },
     267             :    { /* NS */  NS, NS, NS, NS, NS, NS, NS, NS, NS, NS, NS   }
     268             : };
     269             : 
     270             : // square_Move(): Return the new square resulting from moving in
     271             : //      direction d from x.
     272             : constexpr squareT
     273    21647158 : square_Move(squareT sq, directionT dir)
     274             : {
     275    21647158 :     return sqMove[sq][dir];
     276             : }
     277             : 
     278             : // square_Last():
     279             : //   Return the last square reached by moving as far as possible in
     280             : //   the direction d from the square sq. If sq is a valid on-board
     281             : //   square and d is a valid direction, the result will always be
     282             : //   a valid on-board square; the result will be the same as the
     283             : //   input square if moving in the specified direction would end
     284             : //   up off the board.
     285             : constexpr squareT
     286    11768450 : square_Last (squareT sq, directionT dir)
     287             : {
     288    11768450 :     return sqLast[sq][dir];
     289             : }
     290             : 
     291             : #endif
     292             : 
     293             : //////////////////////////////////////////////////////////////////////
     294             : //  EOF: sqmove.h
     295             : //////////////////////////////////////////////////////////////////////
     296             : 

Generated by: LCOV version 1.13