Mike Sherwin wrote: ↑Mon Mar 01, 2021 6:13 pm
It was an over night match at 8 seconds per move. It was to be 100 games. But even at 8 seconds a move it takes forever (during early development) to play 100 games. So I let the current game finish before aborting the match. The actual score was actually in TSCP's favor, +14, -6, =16. But, because Bric is in early dev it still does not have 3-fold draw detection. Principle variation search was just added and that is what was being tested. Every new addition needs tested. There is just not enough time. Anyway, using SF13 to judge the draws by repetition I awarded 11 of the 16 draws as wins for Bric. The adjusted score was Bric +17, -14, =5!
Bric's longest win.
[pgn][Event "Stafford.at"]
[Site "DESKTOP-HFVHK2B"]
[Date "2021.03.01"]
[Round "20"]
[White "Tscp181"]
[Black "Bricabrac"]
[Result "0-1"]
[BlackElo "2200"]
[ECO "B70"]
[Opening "Sicilian"]
[Time "05:16:43"]
[Variation "Dragon, 6.Be2 Bg7 7.O-O"]
[WhiteElo "2200"]
[TimeControl "0+8"]
[Termination "normal"]
[PlyCount "168"]
[WhiteType "human"]
[BlackType "human"]
1. e4 c5 2. Nf3 d6 3. d4 cxd4 4. Nxd4 Nf6 5. Nc3 g6 6. Be2 Bg7 7. O-O
{(e1g1 b8c6 d4c6 b7c6 c1e3 e7e5) +1.02/6 7} a6 {(a7a6 c1g5 b8d7 c3d5 e8g8
d5f6 d7f6 e2f3) -0.29/8 7} 8. Bg5 {(c1g5 e7e5 g5f6 g7f6 d4f3 b8c6) +0.95/6
7} Nbd7 {(b8d7 c3d5 e8g8 c2c4 e7e6 d5f6 d7f6 e2f3) -0.26/8 7} 9. Nf3 {(d4f3
e8g8 e2c4 b7b6 g5f6 d7f6) +1.00/6 7} O-O {(e8g8 a1c1 h7h6 g5h4 d7c5 e4e5
f6e4 c3e4) -0.06/8 8} 10. Qd4 {(d1d4 d8c7 d4d2 e7e6 g5f6 d7f6) +0.83/6 7}
h6 {(h7h6 g5h4 d7c5 h4f6 g7f6 d4e3 c8e6 a1e1 f6g7 h2h3) +0.29/10 7} 11. Bh4
{(g5h4 b7b6 a1d1 c8b7 h4f6 d7f6) +0.85/6 7} Nc5 {(d7c5 h4f6 g7f6 d4e3 c8e6
a1d1 f6c3 b2c3 a8c8 e3h6) +0.31/10 7} 12. Bxf6 {(h4f6 g7f6 e4e5 c5e6 d4d2
f6e5 f3e5 d6e5 d2h6) +0.83/7 7} Bxf6 {(g7f6 d4e3 f6g7 a1d1 c8e6 h2h3 d8b6
c3d5 e6d5 e4d5) +0.32/10 7} 13. e5 {(e4e5 f6g7 d4e3 c8f5 a1c1 d8b6 e5d6
e7d6) +0.60/7 7} Bg7 {(f6g7 d4e3 c8f5 f3d4 f5c8 d4f3 c8f5 c3d5 e7e6 d5f6)
+0.46/10 7} 14. Qe3 {(d4e3 c8f5 a1c1 d8b6 e5d6 e7d6) +0.60/6 8} Bf5 {(c8f5
f3d4 f5c8 d4f3 c8f5 a1c1 a8c8 f1d1 f8e8 c3d5 f5e4) +0.49/11 7} 15. Rac1
{(a1c1 a8c8 f1d1 d8b6 e5d6 e7d6) +0.60/6 7} Re8 {(f8e8 f3d4 f5d7 d4f3 d7c6
c1d1 c5e6 c3e4 d6d5) +0.51/9 7} 16. Bc4 {(e2c4 d8c8 e3d4 d6e5 f3e5 e7e6)
+0.50/6 7} Rc8 {(a8c8 f1d1 c5d7 c4d5 d6e5 d5b7 c8b8 e3a7 d8c7) +0.94/9 8}
17. Rfd1 {(f1d1 d8b6 c4b3 d6e5 f3e5 e7e6) +0.50/6 7} Nd7 {(c5d7 c4d3 d6e5
d3f5 g6f5 e3d3 e5e4 d3d7 d8d7 d1d7) +1.05/10 7} 18. Bd5 {(c4d5 d7e5 f3e5
g7e5 d5b7 c8b8) +0.72/6 7} dxe5 {(d6e5 d5b7 c8b8 b7e4 f5e4 e3e4 e7e6 e4c6
e8e7 c6d6 b8b2) +0.73/11 7} 19. Bxb7 {(d5b7 c8b8 b7c6 e5e4 c6d7 f5d7)
+1.05/6 7} Rb8 {(c8b8 b7e4 f5e4 c3e4 d8c7 e3d3 d7f6 e4f6 g7f6 d3c3 c7c3)
+0.75/11 7} 20. Bc6 {(b7c6 d8c8 c6d7 f5d7 c1b1 e5e4 f3d4 g7d4 d1d4) +0.98/7
8} Qc8 {(d8c8 c6d7 f5d7 b2b3 d7g4 h2h3 g4f3 e3f3 e7e6 d1d6 b8b4) +0.66/11
7} 21. Bxd7 {(c6d7 f5d7 b2b3 d7g4 c3e4 c8f5 e4g3) +0.90/7 7} Bxd7 {(f5d7
b2b3 f7f6 h2h3 e7e6 c3e4 c8c7 e4d6 e8d8 c2c3 d7c6) +0.59/11 7} 22. b3
{(c1b1 d7f5 d1d2 f7f6 c3e4 e7e6) +0.80/6 7} f6 {(f7f6 c3d5 d7c6 e3d3 c6d5
d3d5 e7e6 d5d6 e5e4) +0.67/9 7} 23. Ne2 {(c3e2 d7g4 c2c4 g4f3 e3f3 e7e6)
+1.08/6 7} Qb7 {(c8b7 h2h3 b8d8 e2g3 b7c7 c2c3 f6f5 e3e2 e5e4 f3d4)
+0.95/10 7} 24. Nd2 {(c2c4 d7c6 c1c3 c6f3 e3f3 e7e6) +1.08/6 7} Rbd8 {(b8d8
d2e4 b7c7 e2c3 d7c6 d1d8 e8d8 e4c5 c7d6 c3e4) +1.19/10 7} 25. c4 {(c2c4
d7f5 e2g3 e7e6 c4c5 a6a5) +1.22/6 7} f5 {(f6f5 e2c3 d7e6 d2f3 e5e4 f3h4
e6f7 d1d8 e8d8 c3d5) +1.15/10 7} 26. Qg3 {(e3g3 g6g5 c4c5 b7b5 g3f3 e7e6)
+1.51/6 7} Qc6 {(b7c6 e2c3 e5e4 c3d5 e7e5 g3h4 c6d6 d2f1 d7c6 f1g3)
+1.11/10 7} 27. c5 {(c4c5 f5f4 g3d3 d7g4 d3c4 e7e6 d2e4 g4e2 c4e2) +1.47/6
7} Bc8 {(d7c8 a2a3 f5f4 g3f3 c6f3 d2f3 c8e6 d1d8 e8d8 b3b4) +1.18/10 7} 28.
b4 {(b3b4 c8b7 a2a3 g6g5 e2c3 e7e6) +1.59/6 7} f4 {(f5f4 g3f3 c8b7 e2c3
d8d4 f3c6 b7c6 a2a3 e8d8 d2f3 d4d1) +1.35/11 7} 29. Qa3 {(g3a3 c8f5 d2c4
e7e6 c4d6 e8e7 e2c3) +1.47/7 7} Be6 {(c8e6 f2f3 d8d5 d2e4 e8d8 d1d5 c6d5
e2c3 d5d4 e4f2) +1.32/10 8} 30. Nc3 {(e2c3 e6d5 f2f3 e7e6 d2e4 d8d7)
+1.46/6 7} Rd3 {(d8d3 d2f3 e8d8 d1d3 d8d3 f3e1 d3d8 a3a5 c6a8 a5c7 d8e8)
+1.51/11 7} 31. Qa5 {(a3a5 e8d8 d2e4 d3d1 c3d1 d8d3 d1c3 g7f6) +1.58/7 7}
Bf7 {(e6f7 d2e4 d3d4 d1e1 c6c8 a5a4 f4f3 c1d1 c8g4) +1.49/9 7} 32. a4
{(a2a4 e8d8 d2f1 d3d1 c3d1 d8d3 d1c3) +1.58/7 7} Red8 {(e8d8 d2f3 d3d1 c3d1
d8b8 d1c3 e5e4 f3d2 e4e3 d2e4 b8e8 c1d1) +1.49/12 7} 33. Nf3 {(d2f3 d3d1
c3d1 d8b8 d1c3 e5e4 f3d2 g7c3 c1c3) +1.53/7 7} Rxd1+ {(d3d1 c3d1 d8b8 h2h3
e7e6 d1c3 e5e4 f3d2 e4e3 d2e4 g7d4 h3h4) +1.74/12 7} 34. Nxd1 {(c3d1 d8b8
d1c3 e5e4 f3d2 g7c3 c1c3 e7e5) +1.05/7 7} Rb8 {(d8b8 h2h3 e5e4 f3d2 e7e5
d1c3 e4e3 d2e4 e3f2 e4f2 f4f3) +1.71/11 7} 35. Nd2 {(f3d2 e5e4 d2c4 f7c4
c1c4 e7e5 d1c3) +1.10/7 7} Qd5 {(c6d5 b4b5 a6b5 a4b5 b8a8 a5c3 a8a2 c1c2
e5e4 c2a2 g7c3) +1.78/11 8} 36. b5 {(b4b5 a6b5 a4b5 e7e6 a5b4 b8b5 b4b5
d5d2) +1.88/7 7} axb5 {(a6b5 a4b5 b8d8 d2f1 d8b8 a5c7 d5d8 c7d8 b8d8 d1c3
d8d3) +1.61/11 7} 37. axb5 {(a4b5 e5e4 a5b4 g7d4 c1c4 e7e5 b5b6) +1.63/7 7}
Be8 {(f7e8 d2f3 e8b5 a5a7 b8c8 a7e7 e5e4 f3h4 c8e8 e7d6) +1.74/10 7} 38. b6
{(b5b6 e5e4 a5b4 e8c6 d2c4 e7e5 d1c3) +1.88/7 7} Bc6 {(e8c6 d2f3 e5e4 f3h4
d5f7 d1c3 e4e3 c1d1 b8e8 d1f1 g7f6) +1.99/11 7} 39. Nf3 {(d2f3 e5e4 f3h4
g6g5 h4g6 e7e5 d1c3) +1.95/7 7} e4 {(e5e4 f3h4 d5f7 a5a7 g7e5 a7a6 g6g5
b6b7 c6b7 a6g6 e5g7) +1.87/11 8} 40. Ne1 {(f3e1 g7d4 a5b4 e4e3 b4b1 e3f2
d1f2 d4c5 b1g6) +1.24/7 8} Ra8 {(b8a8 b6b7 c6b7 a5b4 a8d8 d1c3 d5c6 b4b3
e7e6 c1b1 b7a6) +2.48/11 7} 41. Qb4 {(a5b4 a8a4 b4b1 a4a1 b1c2 c6a4 c2c4
d5c4 c1c4 a4d1 c4e4) +0.20/8 7} Ra4 {(a8a4 b4b1 a4a1 b1c2 a1a2 c2b1 a2e2
b1b4 e4e3 e1f3 e7e5 b4c3) +2.86/12 7} 42. Qb1 {(b4b1 d5d2 d1c3 e4e3 e1d3
e3f2 d3f2 g7c3 b1g6) +0.14/8 7} Ra1 {(a4a1 b1c2 a1a2 c2b1 a2e2 b1b4 g7d4
c1c2 e2c2 e1c2 d4c5) +2.63/11 7} 43. Qc2 {(b1c2 a1a2 c2b1 a2a1) 0.00/8 7}
Ra2 {(a1a2 c2b1 a2d2 h2h3 c6b7 g1h1 e7e5 f2f3 e4e3 d1e3 f4e3) +2.77/11 7}
44. b7 {(c2b1 a2a1) 0.00/7 7} Bxb7 {(c6b7 c2c4 d5c4 c1c4 a2e2 g1f1 f4f3
d1e3 e2e3 f2e3 b7a6 e1f3) +4.78/12 7} 45. Qc4 {(c2c4 d5c4 c1c4 a2a1 c5c6
a1d1 c6b7 d1e1) -2.41/8 7} Qxc4 {(d5c4 c1c4 a2a1 c5c6 a1d1 c4e4 b7c6 e4e6
g7f6 h2h3 c6d5 e6e2 f4f3) +6.04/13 7} 46. Rxc4 {(c1c4 a2a1 c5c6 a1d1 c4e4
b7c6 e4e6 g8f7 e6c6 d1e1) -3.69/9 7} Ra1 {(a2a1 c5c6 a1d1 c4e4 b7c6 e4e7
g7c3 e7e6 d1e1 e6e1 c3e1 g2g3 f4f3 h2h3) +6.82/14 7} 47. c6 {(c5c6 a1d1
c4e4 b7c6 e4e6 g8f7 e6e2 g7c3 g1f1 c3e1 e2e1 c6g2) -5.19/9 7} Rxd1 {(a1d1
c4e4 b7c6 e4e7 g7c3 h2h3 d1e1 e7e1 c3e1 f2f3 e1c3 g1h2 c3d4 h2h1 c6d5)
+7.50/15 7} 48. h3 {(h2h3 d1e1 g1h2 b7c8 c6c7 e7e5 c4a4 e4e3 a4a8 e3f2
a8c8) -5.89/9 7} Rxe1+ {(d1e1 g1h2 b7c8 c4a4 e4e3 f2e3 f4e3 a4a8 g7e5 g2g3
e1e2 h2g1 e2e1 g1g2) +9.15/14 8} 49. Kh2 {(g1h2 b7c8 c6c7 e4e3 f2e3 f4e3
c4c6 g7e5 g2g3 e7e6) -6.71/8 7} Bc8 {(b7c8 c4a4 e4e3 f2e3 f4e3 a4a8 g7e5
g2g3 e1e2 h2g1 e2e1 g1g2) +9.15/12 7} 50. Rb4 {(c4b4 e1c1 b4e4 e7e5 e4a4
c1c6 a4a7 c8f5) -6.96/8 7} e3 {(e4e3 f2e3 f4e3 b4e4 e7e6 c6c7 g7c3 e4g4
c3e5 g2g3 g8g7 g4c4 e1e2) +9.45/13 7} 51. fxe3 {(f2e3 f4e3 h2g3 e1c1 g3f3
c1c6 f3e3 e7e5) -6.98/8 7} fxe3 {(f4e3 b4e4 g7f6 h2g3 c8f5 c6c7 g8h8 g3h2
h8g8 g2g4 e1e2 h2g1) +9.47/12 8} 52. Re4 {(h2g3 e1f1 b4e4 e7e5 h3h4 f1c1
g3f3 c1c6 f3e3) -7.02/7 7} Bf6 {(g7f6 h2g3 c8a6 c6c7 e3e2 c7c8n e1d1 c8e7
f6e7 e4e7 e2e1q e7e1) +9.82/12 7} 53. Kg3 {(h2g3 e7e5 e4a4 e1c1 g3f3 c1c6
f3e3 c8f5) -7.28/8 7} Ba6 {(c8a6 c6c7 e3e2 c7c8n a6c8 g3f2 c8b7 e4g4 e1g1
f2e2 g1g2 e2e1) +10.11/12 7} 54. c7 {(c6c7 e3e2 c7c8q a6c8 g3f2 c8b7 e4g4
e1g1 g4g6) -7.53/8 7} e2 {(e3e2 c7c8q a6c8 g3f2 c8b7 e4g4 e1f1 f2e2 b7a6
e2e3 f1e1) +9.57/11 7} 55. c8=Q+ {(c7c8q a6c8 g3f2 c8b7 e4g4 e1g1 f2e2 g1g2
g4g2 b7g2) -7.57/8 7} Bxc8 {(a6c8 g3f2 c8b7 e4g4 e1g1 f2e2 g1g2 e2d3 g2g4
h3g4 b7f3 d3c2 f3g4 c2b1 g4f3) +10.96/15 7} 56. Kf2 {(g3f2 c8b7 e4g4 e1g1
f2e2 g1g2 e2f1 g2g4 h3g4) -7.74/8 7} Bb7 {(c8b7 e4e6 e1f1 f2e2 b7g2 e6b6
g2h3 b6b8 g8h7 b8b7 f1c1 e2d2 f6g5 d2e2) +10.90/14 7} 57. Ra4 {(e4a4 e1g1
f2e2 g1g2 e2f1 e7e5 a4a7 g2b2 f1e1) -8.55/8 7} Rb1 {(e1b1 f2e2 b7g2 e2f2
g2h3 a4a8 g8g7 f2g3 h3e6 g3h2 f6e5 h2g2 e6b3) +11.12/13 7} 58. Kxe2 {(f2e2
b7g2 h3h4 e7e5 a4g4 b1b2 e2e3 g8f7 g4a4) -8.74/8 7} Bxg2 {(b7g2 h3h4 h6h5
e2d2 g2d5 d2c2 b1e1 a4a7 e7e6 a7c7 d5e4 c2b3 e1e2 c7c8) +11.11/14 8} 59. h4
{(h3h4 g8f7 a4g4 b1b2 e2e3 e7e5 g4c4 f7e6 e3d3) -8.94/8 7} Bd5 {(g2d5 a4g4
g8h7 h4h5 g6h5 g4f4 f6c3 f4f5 d5e6 f5f8 b1e1 e2f2) +11.08/12 7} 60. Rg4
{(a4g4 g8f7 g4a4 b1h1 a4a7 h1h4 e2d3 f7e6) -9.23/8 7} Kh7 {(g8h7 h4h5 g6h5
g4f4 f6c3 f4f5 e7e5 f5h5 d5e4 h5h3 c3d4 h3g3 h7h8) +11.21/13 7} 61. Ra4
{(g4a4 e7e6 a4f4 h7g7 e2f2 b1b2 f2g1 e6e5 f4a4) -9.14/8 7} Bc6 {(d5c6 a4f4
b1h1 e2d3 f6h4 d3c2 e7e5 f4c4 c6f3 c4c7 h7g8 c7c8 g8g7) +11.39/13 7} 62.
Ra7 {(a4a7 b1b2 e2d3 h6h5 a7c7 c6b5 d3e4 h7g7 e4d5 f6h4) -9.06/7 7} Bxh4
{(f6h4 e2d3 b1e1 d3c2 h4f2 a7c7 c6f3 c2b2 h7g8 c7c8 g8g7 c8c7 e1e2)
+11.64/13 7} 63. Rc7 {(a7c7 c6b5 e2f3 b1b3 f3e4 h7g7 e4d4 g7f6 c7c5 e7e6)
-9.63/8 7} Re1+ {(b1e1 e2d3 c6f3 d3c2 h4f2 c2b2 h7g8 c7c8 g8g7 c8c7 g7g8
c7c8 g8g7) +11.73/13 8} 64. Kd3 {(e2d3 e1d1 d3e2 d1d6 c7a7 c6d7 a7a5 d7g4
e2e3 e7e6) -9.43/7 7} Bf3 {(c6f3 d3c2 h4f2 c2b2 h7g8 c7c8 g8f7 c8c7 f2d4
b2a2 d4f2 c7d7 f7g8 a2b2) +11.58/14 7} 65. Ra7 {(d3d2 g6g5 c7c3 e1e2 d2c1
g5g4 c3c7 g4g3) -9.71/7 7} Bf2 {(h4f2 a7c7 f2g3 c7c8 e7e5 d3c2 e5e4 c8e8
e4e3 e8e7 h7g8 e7e8 g8g7) +12.15/13 7} 66. Ra2 {(a7a2 e1d1 d3c2 d1d7 a2a5
f2d4 c2c1 e7e5 c1d2) -10.16/8 7} Bc5 {(f2c5 a2b2 e7e5 b2b8 e1e2 b8e8 c5f2
d3c4 e5e4 e8e7 h7g8 c4b4) +12.03/12 7} 67. Kc4 {(d3c3 e7e5 a2c2 c5d4 c3b4
e1b1 b4c4 g6g5 c2d2) -10.20/7 7} Rc1+ {(e1c1 c4d3 e7e5 a2b2 c5a7 b2b5 a7d4
b5b8 d4f2 d3d2 c1e1 d2c2) +12.09/12 7} 68. Kd3 {(c4d3 e7e5 d3d2 c1d1 d2c3
g6g5 a2a4 c5d4 c3c4 h6h5) -10.49/7 7} e5 {(e7e5 a2b2 c5a7 d3d2 c1d1 d2c2
d1e1 b2b5 h7g8 b5b3 e1e2 c2b1) +12.10/12 7} 69. Kd2 {(d3d2 c1d1 d2c2 e5e4
a2a5 c5d4 a5d5 e4e3 d5d7) -10.54/8 7} Rd1+ {(c1d1 d2c2 d1e1 a2a6 e1e2 c2c1
e2e1 c1c2 e1e2 c2c1 e2e1 c1b2 c5f2) +12.41/13 7} 70. Kc2 {(d2c2 e5e4 a2a5
c5d4 a5d5 g6g5 d5d7 h7g6 c2b3) -10.64/7 7} Re1 {(d1e1 a2a6 e1e2 c2c1 e2e1
c1c2 h7g7 a6e6 g7f7 e6a6 f7g7 a6e6 c5f2) +12.35/13 7} 71. Ra4 {(a2a4 e1e2
c2b3 g6g5 a4a5 c5d4 b3c4 h6h5 c4d3) -10.54/8 7} Re2+ {(e1e2 c2b1 e2e1 b1c2
e1e2 c2b1 e2e1 b1c2 e1e2 c2b1 e2e1 b1b2 c5f2) +12.72/13 7} 72. Kc3 {(c2c3
g6g5 a4c4 c5b6 c4c8 h6h5 c8b8 b6d4) -10.64/7 7} Bd4+ {(c5d4 c3b4 e2e1 a4a3
f3b7 a3a5 b7f3 a5a3 e1f1 a3a6 f1b1 b4a3 b1e1) +12.53/13 7} 73. Kb4 {(c3b4
e2d2 a4a6 h7g7 a6e6 g7f7 e6d6 e5e4) -10.80/7 7} Bd5 {(f3d5 a4a3 e2b2 b4a5
b2e2 a3d3 h7g8 a5b4 e2b2 b4a3 b2e2 d3d1 d5f3) +12.64/13 7} 74. Kb5 {(b4b5
g6g5 a4a5 e2b2 b5a4 d5c6 a4a3 h6h5 a5a7 h7g6 a7c7) -10.99/8 8} Rc2 {(e2c2
a4a5 e5e4 b5a4 d5f7 a5b5 f7e8 a4b3 c2c3 b3b4 e8b5 b4b5) +13.43/12 7} 75.
Kb4 {(b5a5 g6g5 a5a6 h7g6 a6a5 h6h5 a5b5) -11.04/7 7} e4 {(e5e4 b4a5 d4f2
a5b5 e4e3 a4a7 h7g8 a7e7 e3e2 e7e8 g8f7 e8e5 e2e1q) +15.09/13 7} 76. Ka5
{(b4a5 d4f2 a4b4 e4e3 b4b1 e3e2 a5b5 e2e1q b1e1 f2e1) -13.88/8 7} Ra2
{(c2a2 a4a2 d5a2 a5a6 a2b3 a6b7 e4e3 b7b8 h7g8 b8c8 e3e2 c8b7 d4f2 b7b8)
+20.02/14 7} 77. Rxa2 {(a4a2 d5a2 a5b5 a2d5 b5a4 e4e3 a4a5 e3e2 a5b5 e2e1q)
-18.80/10 7} Bxa2 {(d5a2 a5b5 a2b3 b5c6 e4e3 c6b7 h7g8 b7c8 e3e2 c8b8 e2e1q
b8c7 e1h1 c7c8 h1h2 c8b7) +20.12/16 7} 78. Kb5 {(a5b5 a2d5 b5a6 e4e3 a6a5
e3e2 a5a4 g6g5 a4a3 e2e1q) -18.94/10 8} e3 {(e4e3 b5c6 a2b3 c6b7 h7g8 b7b8
e3e2 b8c8 e2e1q c8b8 d4f2 b8c7 e1e8 c7b7 e8e1) +20.26/15 7} 79. Kc6 {(b5c6
e3e2 c6d6 g6g5 d6d7 e2e1q d7c8 e1e7 c8b8 h6h5) -19.03/10 7} e2 {(e3e2 c6d6
e2e1q d6c6 a2b3 c6c7 h7g8 c7b7 d4f2 b7b8 e1e6 b8c7 e6e8 c7b7 e8e1)
+20.26/15 7} 80. Kd6 {(c6d6 g6g5 d6d7 e2e1q d7c8 e1e7 c8b8 h6h5) -19.03/8
7} Bb3 {(a2b3 d6c6 e2e1q c6d7 h7g8 d7c8 b3d5 c8b8 d4b6 b8c8 e1e8 c7b7 e8e1)
+M6/14 8} 81. Kd7 {(d6d7 g6g5 d7c8 e2e1q c8d8 e1e6 d8c7 h6h5) -19.13/8 7}
e1=Q {(e2e1q d7c8 b3d5 c8b8 d4b6 b8c8 e1e8 d6d7 d4b6 d7d6 b6f2 d6d7) +M4/13
7} 82. Kd6 {(d7d6 e1e8 d6c7 b3e6 c7b7 e8c8) -M3/7 4} Qe8 {(e1e8 d6c7 b3d5
c7d6 e8d8 d6e7 c8h3 e7d8) +M3/14 7} 83. Kc7 {(d6c7 b3d5 c7d6 e8d8) -M2/5}
Bd5 {(b3d5 c7d6 e8d8 b7b8) +M2/14 7} 84. Kd6 {(c7d6 e8d8) -M1/3} Qd8#
{(e8d8 d6d7) +M1/14 8} 0-1
[/pgn]
Bric's shortest win.
[pgn][Event "Stafford.at"]
[Site "DESKTOP-HFVHK2B"]
[Date "2021.03.01"]
[Round "13"]
[White "Bricabrac"]
[Black "Tscp181"]
[Result "1-0"]
[BlackElo "2200"]
[ECO "B17"]
[Opening "Caro-Kann"]
[Time "03:41:47"]
[Variation "Steinitz Variation"]
[WhiteElo "2200"]
[TimeControl "0+8"]
[Termination "normal"]
[PlyCount "53"]
[WhiteType "human"]
[BlackType "human"]
1. e4 c6 2. d4 d5 3. Nc3 dxe4 4. Nxe4 Nd7 5. Bg5 {(c1g5 d8b6 g1f3 b6b2 f1d3
h7h6 g5e3 f7f5 e4g3 b2c3) +0.42/10 7} Qb6 {(d8b6 b2b3 g8f6 g5f6 d7f6 f2f3)
-0.29/6 7} 6. Nf3 {(g1f3 b6b4 g5d2 b4b2 f1d3 b2b6 e1g1 g8f6 d2f4 f6e4 d3e4)
+0.61/11 7} Qxb2 {(b6b2 f1e2 g8f6 g5f6 d7f6 e2d3) +0.28/6 7} 7. Bd3 {(f1d3
h7h6 g5e3 g8f6 e1g1 f6d5 e3d2 e7e6 c2c4 b2a3 d3c2) +0.48/11 7} e5 {(g8f6
g5f6 e7f6 e1g1 f6f5 e4d2) +0.24/6 7} 8. O-O {(e1g1 h7h6 g5e3 f7f5 e4d2 e5e4
d2c4 b2b4 a2a3 b4e7) +0.52/10 7} f6 {(f7f6 g5e3 b2a3 c2c4 f8b4 d4e5 d7e5)
+0.15/7 7} 9. Be3 {(g5e3 f6f5 e4d2 e5e4 d2c4 b2b4 e3d2 b4e7 f1e1) +0.48/9
7} Qa3 {(f6f5 d4e5 f5e4 e3d4 b2a3 d3e4) +0.14/6 7} 10. dxe5 {(d4e5 f6e5
e4g5 g8f6 g5e6 f6d5 e3g5 d5c3) +0.79/8 7} fxe5 {(f6e5 e3c1 a3a4 c1e3 g8f6
c2c4 a4d1 a1d1 f6e4 d3e4) +0.24/7 7} 11. Neg5 {(e4g5 g8f6 g5e6 f6d5 e3g5
d5c3 d1d2 a8b8 a1e1 h7h6) +0.90/10 7} Ngf6 {(g8f6 g5e6 a3d6 d3f5 g7g6 e6g7)
+0.32/6 7} 12. Bc4 {(d3c4 e5e4 c4f7 e8e7 e3c1 a3d6 d1d6 e7d6) +0.81/8 8}
Ng4 {(f6g4 e3c1 a3d6 c4f7 e8d8 g5e4 d6d1 f1d1) +0.37/6 7} 13. Bf7+ {(c4f7
e8e7 e3c1 a3a5 h2h3 g4f6 c1d2 a5b6 d2c3 h7h6) +1.21/10 7} Ke7 {(e8e7 e3c1
a3d6 d1e2 b7b6 g5e4 d6c7) +0.27/6 7} 14. Bc1 {(e3c1 a3a5 c1d2 a5a3 a1b1
e7f6 b1b3 a3e7 h2h3 g4h6) +1.24/10 7} Qc5 {(a3c5 a2a4 c5d6 c1d2 g4f6 a1b1)
+0.16/6 7} 15. h3 {(h2h3 g4h6 a2a4 c5c3 c1d2 c3b2 f7c4 d7c5 c2c3) +1.49/9
7} Ngf6 {(g4f6 c1e3 c5a3 a1b1 e5e4 b1b3 a3d6) +0.26/7 7} 16. Bb3 {(f7b3
f6d5 c1b2 a7a5 f3e5 d7e5 b3d5 c5d5 d1d5) +1.36/9 8} e4 {(e5e4 f1e1 c5f5
f3d4 f5g6 c1e3) +0.21/6 7} 17. Re1 {(f1e1 e7e8 b3f7 e8e7 g5e6 c5f5 f3g5
d7e5 c1a3) +1.61/9 7} Ke8 {(e7e8 g5e4 f6e4 e1e4 f8e7 c1g5 d7f6 g5f6 g7f6)
-0.63/6 7} 18. Bf4 {(c1f4 c5f5 b3f7 e8d8 g5e6 d8e7 f3g5 d7e5 d1d8) +1.75/9
7} Qxg5 {(c5f5 b3f7 e8d8 f3d4 f5a5 g5e4 f8e7) -0.76/6 7} 19. Nxg5 {(f3g5
f8c5 g5e6 c5b4 e6g7 e8e7 g7f5 e7e8 f5d6 b4d6) +8.07/10 8} Bb4 {(f8b4 e1e3
b4c5 e3e2 h8f8 g5e4 f6e4 e2e4) -6.13/6 7} 20. Bd6 {(f4d6 b4d6 d1d6 h8f8
g5e6 a7a5 e6c7 e8d8 c7a8 a5a4 b3a4) +9.74/11 7} Bxd6 {(b4d6 d1d6 h8f8 g5e6
f6d5 e6f8 d7f8 b3d5 c6d5 d6d5) -8.25/7 7} 21. Qxd6 {(d1d6 h8f8 a1d1 h7h6
g5e4 f6d5 e4g5 e8d8 g5e6 d8e8) +11.17/10 7} Rf8 {(h8f8 g5e6 f6d5 e6f8 d7f8
b3d5 c6d5 d6d5) -8.25/6 7} 22. Rad1 {(a1d1 h7h6 g5e4 f6d5 e4f6 e8f7 e1e7
f7g6 f6d5) +11.50/9 7} Rb8 {(a8b8 g5e4 f6d5 e4c5 e8d8 c5d7 c8d7 d6f8)
-11.16/6 7} 23. Nxe4 {(g5e4 f6d5 e4f6 e8d8 f6d7 c8d7 d6f8 d8c7 f8g7 h7h5
b3d5) +14.41/11 7} Nxe4 {(f6e4 e1e4 e8d8 d6f8 d8c7 e4e7 c7b6 d1d7 c8d7
f8b8) -14.35/7 7} 24. Rxe4+ {(e1e4 e8d8 e4e7 f8e8 e7d7 c8d7 d6d7 h7h5 d1d7)
+M4/10 7} Kd8 {(e8d8 e4e7 f8f2 e7d7 c8d7 d6d7) -M3/6 2} 25. Re7 {(e4e7 f8e8
e7d7 c8d7 d6d7 c8d7 f8b8 d7f5) +M3/11 7} Rf7 {(f8f7 e7f7 b8a8 f7f8) -M2/5}
26. Rxf7 {(e7f7 b8a8 f7f8) +M2/12 7} Ra8 {(b8a8 f7f8) -M1/3} 27. Rf8#
{(f7f8 d8e8) +M1/14 7} 1-0
[/pgn]
It is different in some ways. The make move and take back only have one switch statement each and no "if" statements at all. Only castling in the move gen function has "if" statements. I use my own SISSY bitboards for move generation. They are slower than magic but I hope to optimize them to be faster. Just search SISSY at the CPW. It is setup for multithreading. Oh and castling is different than any other known engine. Right now it is just one function (3 fold rep) away from being a minimal engine. So not that much can be different. However, I have big plans!
Code: Select all
// Bricabrac
// A chess engine by Michael J Sherwin
// TommyTC - Chief problem solver and bug squisher
// Sven Schule - some bugs found
// HGM - help with branchless code
#include <intrin.h>
#include <iostream>
#include <stdio.h>
#include <ctype.h>
#include <string>
#include <time.h>
#include <math.h>
#include <assert.h>
#define equates 1
#ifdef equates
typedef signed char s08;
typedef unsigned char u08;
typedef int s32;
typedef unsigned long u32;
typedef long long s64;
typedef unsigned long long u64;
constexpr auto one = 1ull;
constexpr auto MATE = 0x7fff;
constexpr auto INF = 0x8000;
constexpr auto ColA = 0;
constexpr auto Row8 = 7;
constexpr auto ILLEGAL = 0x8001;
constexpr auto VP = 100;
constexpr auto VN = 290;
constexpr auto VB = 330;
constexpr auto VR = 500;
constexpr auto VQ = 900;
constexpr auto VK = 1600;
constexpr auto Vq = 800;
constexpr auto Vn = 200;
constexpr auto Vr = 400;
constexpr auto Vb = 200;
constexpr auto WOCCS = 0x0000000000000060;
constexpr auto WOCCL = 0x000000000000000e;
constexpr auto BOCCS = 0x6000000000000000;
constexpr auto BOCCL = 0x0e00000000000000;
constexpr auto WATKS = 0x0000000000000070;
constexpr auto WATKL = 0x000000000000001c;
constexpr auto BATKS = 0x7000000000000000;
constexpr auto BATKL = 0x1c00000000000000;
constexpr auto STALEMATE = 0;
enum { BLACK, WHITE };
enum { DEPTH, TIME };
enum { B, R, N, Q };
enum {
OO, WP, WN, WB, WR, WRC, WQ, WK, WC, BP, BN, BB, BR, BRC, BQ, BK, BC,
Wd, We, Wb, Wr, Wn, Wq, Bd, Be, Bb, Br, Bn, Bq, WS, WL, BS, BL
};
enum { RANK1, RANK2, RANK3, RANK4, RANK5, RANK6, RANK7, RANK8 };
enum {
A1, B1, C1, D1, E1, F1, G1, H1,
A2, B2, C2, D2, E2, F2, G2, H2,
A3, B3, C3, D3, E3, F3, G3, H3,
A4, B4, C4, D4, E4, F4, G4, H4,
A5, B5, C5, D5, E5, F5, G5, H5,
A6, B6, C6, D6, E6, F6, G6, H6,
A7, B7, C7, D7, E7, F7, G7, H7,
A8, B8, C8, D8, E8, F8, G8, H8
};
enum { EXIT, GETCMD, BRICABRAC, MOVE };
#endif
#define definitions 1
#ifdef definitions
struct bb8 {
u08 b0;
u08 b1;
u08 b2;
u08 b3;
u08 b4;
u08 b5;
u08 b6;
u08 b7;
};
union bb64 {
bb8 b8;
u64 b64;
};
struct Move {
s32 fs;
s32 ts;
s32 type;
s32 score;
s32 status;
};
struct Thread {
s32 wtm;
s32 ply;
s32 start;
s32 fpv;
s32 mat[2];
s32 pos[2] = { 0 };
s32 board[64];
u64 piece[2];
u64 king[2];
s32 possav[2][100] = { 0 };
u64 epbb[100];
s32 fifty[100];
Move move[10000];
};
#define wtm t->wtm
#define ply t->ply
#define start t->start
#define fpv t->fpv
#define mat t->mat
#define pos t->pos
#define board t->board
#define piece t->piece
#define king t->king
#define possav t->possav
#define epbb t->epbb
#define fifty t->fifty
#define move t->move
#endif
#define variables 1
#ifdef variables
Thread thread;
Thread* t;
s32 bricabrac;
s32 gamePly;
s32 xboard;
s32 force;
u32 nodes;
s32 dort;
s32 sd;
clock_t st;
clock_t begin;
clock_t end;
u64 wPawnMoves[64];
u64 wPawnCapts[64];
u64 bPawnMoves[64];
u64 bPawnCapts[64];
u64 knightMoves[64];
u64 kingMoves[64];
u64 qss[64][256][8];
u64 bss[64][128][6];
u64 bob[64];
u64 rob[64];
u64 above[64];
u64 below[64];
Move gameMoves[1000];
Move pvs[100][100];
s32 pvl[100];
s32 value[] = { OO, VP, VN, VB, VR, VR, VQ, VK, VK, VP, VN, VB, VR, VR, VQ, VK, VK,
OO, OO, Vb, Vr, Vn, Vq, OO, OO, Vb, Vr, Vn, Vq };
s32 promoType[2][4] = { {Bb, Br, Bn, Bq}, {Wb, Wr, Wn, Wq} };
char startFen[] = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
char fenString[100];
s32(*InCheck[2])(Thread*, u64);
u32 PerftDepth = 0;
s32 nulPST[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, };
s32 wpPST[] = {
0, 0, 0, 0, 0, 0, 0, 0,
-35, -1, -20, -23, -15, 24, 38, -22,
-26, -4, -4, -10, 3, 3, 33, -12,
-27, -2, -5, 12, 17, 6, 10, -25,
-14, 13, 6, 21, 23, 12, 17, -23,
-6, 7, 26, 31, 65, 56, 25, -20,
98, 134, 61, 95, 68, 126, 34, -11,
0, 0, 0, 0, 0, 0, 0, 0, };
s32 bpPST[] = {
0, 0, 0, 0, 0, 0, 0, 0,
98, 134, 61, 95, 68, 126, 34, -11,
-6, 7, 26, 31, 65, 56, 25, -20,
-14, 13, 6, 21, 23, 12, 17, -23,
-27, -2, -5, 12, 17, 6, 10, -25,
-26, -4, -4, -10, 3, 3, 33, -12,
-35, -1, -20, -23, -15, 24, 38, -22,
0, 0, 0, 0, 0, 0, 0, 0, };
s32 wnPST[] = {
-105, -21, -58, -33, -17, -28, -19, -23,
-29, -53, -12, -3, -1, 18, -14, -19,
-23, -9, 12, 10, 19, 17, 25, -16,
-13, 4, 16, 13, 28, 19, 21, -8,
-9, 17, 19, 53, 37, 69, 18, 22,
-47, 60, 37, 65, 84, 129, 73, 44,
-73, -41, 72, 36, 23, 62, 7, -17,
-167, -89, -34, -49, 61, -97, -15, -107, };
s32 bnPST[] = {
-167, -89, -34, -49, 61, -97, -15, -107,
-73, -41, 72, 36, 23, 62, 7, -17,
-47, 60, 37, 65, 84, 129, 73, 44,
-9, 17, 19, 53, 37, 69, 18, 22,
-13, 4, 16, 13, 28, 19, 21, -8,
-23, -9, 12, 10, 19, 17, 25, -16,
-29, -53, -12, -3, -1, 18, -14, -19,
-105, -21, -58, -33, -17, -28, -19, -23, };
s32 wbPST[] = {
-33, -3, -14, -21, -13, -12, -39, -21,
4, 15, 16, 0, 7, 21, 33, 1,
0, 15, 15, 15, 14, 27, 18, 10,
-6, 13, 13, 26, 34, 12, 10, 4,
-4, 5, 19, 50, 37, 37, 7, -2,
-16, 37, 43, 40, 35, 50, 37, -2,
-26, 16, -18, -13, 30, 59, 18, -47,
-29, 4, -82, -37, -25, -42, 7, -8, };
s32 bbPST[] = {
-29, 4, -82, -37, -25, -42, 7, -8,
-26, 16, -18, -13, 30, 59, 18, -47,
-16, 37, 43, 40, 35, 50, 37, -2,
-4, 5, 19, 50, 37, 37, 7, -2,
-6, 13, 13, 26, 34, 12, 10, 4,
0, 15, 15, 15, 14, 27, 18, 10,
4, 15, 16, 0, 7, 21, 33, 1,
-33, -3, -14, -21, -13, -12, -39, -21, };
s32 wrPST[] = {
-19, -13, 1, 17, 16, 7, -37, -26,
-44, -16, -20, -9, -1, 11, -6, -71,
-45, -25, -16, -17, 3, 0, -5, -33,
-36, -26, -12, -1, 9, -7, 6, -23,
-24, -11, 7, 26, 24, 35, -8, -20,
-5, 19, 26, 36, 17, 45, 61, 16,
27, 32, 58, 62, 80, 67, 26, 44,
32, 42, 32, 51, 63, 9, 31, 43, };
s32 brPST[] = {
32, 42, 32, 51, 63, 9, 31, 43,
27, 32, 58, 62, 80, 67, 26, 44,
-5, 19, 26, 36, 17, 45, 61, 16,
-24, -11, 7, 26, 24, 35, -8, -20,
-36, -26, -12, -1, 9, -7, 6, -23,
-45, -25, -16, -17, 3, 0, -5, -33,
-44, -16, -20, -9, -1, 11, -6, -71,
-19, -13, 1, 17, 16, 7, -37, -26, };
s32 wqPST[] = {
-1, -18, -9, 10, -15, -25, -31, -50,
-35, -8, 11, 2, 8, 15, -3, 1,
-14, 2, -11, -2, -5, 2, 14, 5,
-9, -26, -9, -10, -2, -4, 3, -3,
-27, -27, -16, -16, -1, 17, -2, 1,
-13, -17, 7, 8, 29, 56, 47, 57,
-24, -39, -5, 1, -16, 57, 28, 54,
-28, 0, 29, 12, 59, 44, 43, 45, };
s32 bqPST[] = {
-28, 0, 29, 12, 59, 44, 43, 45,
-24, -39, -5, 1, -16, 57, 28, 54,
-13, -17, 7, 8, 29, 56, 47, 57,
-27, -27, -16, -16, -1, 17, -2, 1,
-9, -26, -9, -10, -2, -4, 3, -3,
-14, 2, -11, -2, -5, 2, 14, 5,
-35, -8, 11, 2, 8, 15, -3, 1,
-1, -18, -9, 10, -15, -25, -31, -50, };
s32 wkPST[] = {
-15, 36, 12, -54, 8, -28, 24, 14,
1, 7, -8, -64, -43, -16, 9, 8,
-14, -14, -22, -46, -44, -30, -15, -27,
-49, -1, -27, -39, -46, -44, -33, -51,
-17, -20, -12, -27, -30, -25, -14, -36,
-9, 24, 2, -16, -20, 6, 22, -22,
29, -1, -20, -7, -8, -4, -38, -29,
-65, 23, 16, -15, -56, -34, 2, 13, };
s32 bkPST[] = {
-65, 23, 16, -15, -56, -34, 2, 13,
29, -1, -20, -7, -8, -4, -38, -29,
-9, 24, 2, -16, -20, 6, 22, -22,
-17, -20, -12, -27, -30, -25, -14, -36,
-49, -1, -27, -39, -46, -44, -33, -51,
-14, -14, -22, -46, -44, -30, -15, -27,
1, 7, -8, -64, -43, -16, 9, 8,
-15, 36, 12, -54, 8, -28, 24, 14, };
s32* pcePST[] = {
nulPST,
wpPST, wnPST, wbPST, wrPST, wrPST, wqPST, wkPST, wkPST,
bpPST, bnPST, bbPST, brPST, brPST, bqPST, bkPST, bkPST };
#endif
void PrintBoard(Thread* t) {
s32 x, y, sq, pce;
u08 fig[] = { ".PNBRRQKKpnbrrqkk" };
for (y = 7; y >= 0; y--) {
for (x = 0; x < 8; x++) {
sq = ((y << 3) + x);
pce = board[sq];
std::cout << " " << fig[pce];
}
std::cout << std::endl;
}
std::cout << std::endl;
}
s32 LoadFen(Thread* t, char* f) {
s32 row, col, sq, fs, pce;
for (sq = A1; sq <= H8; sq++) board[sq] = OO;
ply = 0;
col = ColA;
row = Row8;
fs = 56;
mat[WHITE] = OO;
mat[BLACK] = OO;
piece[WHITE] = OO;
piece[BLACK] = OO;
for (;; f++) {
if (*f == ' ') break;
switch (*f) {
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
col += *f - '0';
fs = (row * 8 + col) & 63;
continue;
case '/':
col = ColA;
row--;
fs = (row * 8 + col) & 63;
continue;
case 'P':
pce = WP;
mat[WHITE] += VP;
pos[WHITE] += wpPST[fs];
piece[WHITE] ^= one << fs;
break;
case 'N':
pce = WN;
mat[WHITE] += VN;
pos[WHITE] += wnPST[fs];
piece[WHITE] ^= one << fs;
break;
case 'B':
pce = WB;
mat[WHITE] += VB;
pos[WHITE] += wbPST[fs];
piece[WHITE] ^= one << fs;
break;
case 'R':
pce = WR;
mat[WHITE] += VR;
pos[WHITE] += wrPST[fs];
piece[WHITE] ^= one << fs;
break;
case 'Q':
pce = WQ;
mat[WHITE] += VQ;
pos[WHITE] += wqPST[fs];
piece[WHITE] ^= one << fs;
break;
case 'K':
pce = WK;
pos[WHITE] += wkPST[fs];
piece[WHITE] ^= one << fs;
king[WHITE] = one << fs;
break;
case 'p':
pce = BP;
mat[BLACK] += VP;
pos[BLACK] += bpPST[fs];
piece[BLACK] ^= one << fs;
break;
case 'n':
pce = BN;
mat[BLACK] += VN;
pos[BLACK] += bnPST[fs];
piece[BLACK] ^= one << fs;
break;
case 'b':
pce = BB;
mat[BLACK] += VB;
pos[BLACK] += bbPST[fs];
piece[BLACK] ^= one << fs;
break;
case 'r':
pce = BR;
mat[BLACK] += VR;
pos[BLACK] += brPST[fs];
piece[BLACK] ^= one << fs;
break;
case 'q':
pce = BQ;
mat[BLACK] += VQ;
pos[BLACK] += bqPST[fs];
piece[BLACK] ^= one << fs;
break;
case 'k':
pce = BK;
pos[BLACK] += bkPST[fs];
piece[BLACK] ^= one << fs;
king[BLACK] = one << fs;
break;
default:
return false;
}
board[fs] = pce;
col++;
fs = (row * 8 + col) & 63;
}
f++;
switch (*f++) {
case 'w':
wtm = WHITE;
break;
case 'b':
wtm = BLACK;
break;
default:
return false;
}
if (*f++ != ' ') return false;
if (*f == '-') {
f++;
if (*f++ != ' ') return false;
}
else {
for (;;) {
if (*f == ' ') {
f++;
break;
}
switch (*f++) {
case 'K':
board[E1] = WC;
board[H1] = WRC;
break;
case 'Q':
board[E1] = WC;
board[A1] = WRC;
break;
case 'k':
board[E8] = BC;
board[H8] = BRC;
break;
case 'q':
board[E8] = BC;
board[A8] = BRC;
break;
default:
return false;
}
}
}
epbb[OO] = OO;
if (*f == '-') f++;
else {
if (*f < 'a' || *f > 'h') return false;
if (*(f + 1) < '0' || *(f + 1) > '7') return false;
row = *(f + 1) - '1';
col = *f - 'a';
epbb[OO] = one << (row * 8 + col);
f += 2;
}
if (*f++ != ' ') return false;
fifty[OO] = OO;
for (;;) {
if (!isdigit(*f)) break;
fifty[OO] *= 10;
fifty[OO] += *f++ - '0';
}
if (*f++ != ' ') return false;
start = 0;
for (;;) {
if (!isdigit(*f)) break;
start *= 10;
start += *f++ - '0';
}
if (start < 1) return false;
while (*f == ' ') f++;
if (*f != '\0') return false;
return true;
}
void MakeMove(Thread* t, Move* m) {
s32 ctype = 0, sq;
nodes++;
board[m->fs] = OO;
piece[wtm] ^= one << m->fs;
piece[wtm] ^= one << m->ts;
possav[WHITE][ply] = pos[WHITE];
possav[BLACK][ply] = pos[BLACK];
switch (m->type) {
case OO: break;
case WP:
ctype = board[m->ts];
pos[WHITE] += (wpPST[m->ts] - wpPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WP;
break;
case WN:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wnPST[m->ts] - wnPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WN;
break;
case WB:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wbPST[m->ts] - wbPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WB;
break;
case WR:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wrPST[m->ts] - wrPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WR;
break;
case WRC:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wrPST[m->ts] - wrPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WR;
break;
case WQ:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wqPST[m->ts] - wqPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WQ;
break;
case WK:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wkPST[m->ts] - wkPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WK;
king[WHITE] ^= one << m->fs;
king[WHITE] ^= one << m->ts;
break;
case WC:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wkPST[m->ts] - wkPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WK;
king[WHITE] ^= one << m->fs;
king[WHITE] ^= one << m->ts;
break;
case BP:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bpPST[m->ts] - bpPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BP;
break;
case BN:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bnPST[m->ts] - bnPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BN;
break;
case BB:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bbPST[m->ts] - bbPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BB;
break;
case BR:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (brPST[m->ts] - brPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BR;
break;
case BRC:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (brPST[m->ts] - brPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BR;
break;
case BQ:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bqPST[m->ts] - bqPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BQ;
break;
case BK:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bkPST[m->ts] - bkPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BK;
king[BLACK] ^= one << m->fs;
king[BLACK] ^= one << m->ts;
break;
case BC:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bkPST[m->ts] - bkPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BK;
king[BLACK] ^= one << m->fs;
king[BLACK] ^= one << m->ts;
break;
case Wd:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wpPST[m->ts] - wpPST[m->fs]);
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WP;
epbb[ply + 1] = (u64)(m->fs + 16 == m->ts) << (m->fs + 8);
break;
case We:
sq = m->ts - ((epbb[ply] == (one << m->ts)) << 3);
ctype = board[sq];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wpPST[m->ts] - wpPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << sq;
board[sq] = OO;
board[m->ts] = WP;
break;
case Wb:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wbPST[m->ts] - wpPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WB;
mat[WHITE] += 200;
break;
case Wr:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wrPST[m->ts] - wpPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WR;
mat[WHITE] += 400;
break;
case Wn:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wnPST[m->ts] - wpPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WN;
mat[WHITE] += 200;
break;
case Wq:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
pos[WHITE] += (wqPST[m->ts] - wpPST[m->fs]);
pos[BLACK] -= pcePST[ctype][m->ts];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WQ;
mat[WHITE] += 800;
break;
case Bd:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bpPST[m->ts] - bpPST[m->fs]);
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BP;
epbb[ply + 1] = (u64)(m->fs - 16 == m->ts) << (m->fs - 8);
break;
case Be:
sq = m->ts + ((epbb[ply] == (one << m->ts)) << 3);
ctype = board[sq];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bpPST[m->ts] - bpPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << sq;
board[sq] = OO;
board[m->ts] = BP;
break;
case Bb:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bbPST[m->ts] - bpPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BB;
mat[BLACK] += 200;
break;
case Br:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (brPST[m->ts] - bpPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BR;
mat[BLACK] += 400;
break;
case Bn:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bnPST[m->ts] - bpPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BN;
mat[BLACK] += 200;
break;
case Bq:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
pos[BLACK] += (bqPST[m->ts] - bpPST[m->fs]);
pos[WHITE] -= pcePST[ctype][m->ts];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BQ;
mat[BLACK] += 800;
break;
case WS:
ctype = OO;
board[G1] = WK;
board[H1] = OO;
board[F1] = WR;
king[WHITE] ^= one << E1;
king[WHITE] ^= one << G1;
piece[WHITE] ^= one << H1;
piece[WHITE] ^= one << F1;
pos[WHITE] += (wkPST[G1] - wkPST[E1]);
pos[WHITE] += (wrPST[F1] - wrPST[H1]);
break;
case WL:
ctype = OO;
board[C1] = WK;
board[A1] = OO;
board[D1] = WR;
king[WHITE] ^= one << E1;
king[WHITE] ^= one << C1;
piece[WHITE] ^= one << A1;
piece[WHITE] ^= one << D1;
pos[WHITE] += (wkPST[C1] - wkPST[E1]);
pos[WHITE] += (wrPST[D1] - wrPST[A1]);
break;
case BS:
ctype = OO;
board[G8] = BK;
board[H8] = OO;
board[F8] = BR;
king[BLACK] ^= one << E8;
king[BLACK] ^= one << G8;
piece[BLACK] ^= one << H8;
piece[BLACK] ^= one << F8;
pos[BLACK] += (bkPST[G8] - bkPST[E8]);
pos[BLACK] += (brPST[F8] - brPST[H8]);
break;
case BL:
ctype = OO;
board[C8] = BK;
board[A8] = OO;
board[D8] = BR;
king[BLACK] ^= one << E8;
king[BLACK] ^= one << C8;
piece[BLACK] ^= one << A8;
piece[BLACK] ^= one << D8;
pos[BLACK] += (bkPST[C8] - bkPST[E8]);
pos[BLACK] += (brPST[D8] - brPST[A8]);
break;
}
m->type |= ctype << 6;
wtm = 1 - wtm;
ply++;
}
void TakeBack(Thread* t, Move* m) {
s32 ctype, sq;
ply--;
wtm = 1 - wtm;
pos[WHITE] = possav[WHITE][ply];
pos[BLACK] = possav[BLACK][ply];
piece[wtm] ^= one << m->ts;
piece[wtm] ^= one << m->fs;
ctype = m->type >> 6;
mat[1 - wtm] += value[ctype];
m->type &= 0x3f;
switch (m->type) {
case OO: break;
case WP:
board[m->ts] = ctype;
board[m->fs] = WP;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WN:
board[m->ts] = ctype;
board[m->fs] = WN;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WB:
board[m->ts] = ctype;
board[m->fs] = WB;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WR:
board[m->ts] = ctype;
board[m->fs] = WR;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WRC:
board[m->ts] = ctype;
board[m->fs] = WRC;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WQ:
board[m->ts] = ctype;
board[m->fs] = WQ;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WK:
board[m->ts] = ctype;
board[m->fs] = WK;
king[WHITE] ^= one << m->fs;
king[WHITE] ^= one << m->ts;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WC:
board[m->ts] = ctype;
board[m->fs] = WC;
king[WHITE] ^= one << m->fs;
king[WHITE] ^= one << m->ts;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case BP:
board[m->ts] = ctype;
board[m->fs] = BP;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BN:
board[m->ts] = ctype;
board[m->fs] = BN;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BB:
board[m->ts] = ctype;
board[m->fs] = BB;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BR:
board[m->ts] = ctype;
board[m->fs] = BR;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BRC:
board[m->ts] = ctype;
board[m->fs] = BRC;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BQ:
board[m->ts] = ctype;
board[m->fs] = BQ;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BK:
board[m->ts] = ctype;
board[m->fs] = BK;
king[BLACK] ^= one << m->fs;
king[BLACK] ^= one << m->ts;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BC:
board[m->ts] = ctype;
board[m->fs] = BC;
king[BLACK] ^= one << m->fs;
king[BLACK] ^= one << m->ts;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Wd:
board[m->ts] = ctype;
board[m->fs] = WP;
epbb[ply + 1] = OO;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case We:
sq = m->ts - ((epbb[ply] == (one << m->ts)) << 3);
board[m->ts] = OO;
board[sq] = ctype;
piece[BLACK] ^= (u64)(ctype != OO) << sq;
board[m->fs] = WP;
break;
case Wb:
board[m->ts] = ctype;
board[m->fs] = WP;
mat[WHITE] -= 200;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case Wr:
board[m->ts] = ctype;
board[m->fs] = WP;
mat[WHITE] -= 400;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case Wn:
board[m->ts] = ctype;
board[m->fs] = WP;
mat[WHITE] -= 200;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case Wq:
board[m->ts] = ctype;
board[m->fs] = WP;
mat[WHITE] -= 800;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case Bd:
board[m->ts] = ctype;
board[m->fs] = BP;
epbb[ply + 1] = OO;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Be:
sq = m->ts + ((epbb[ply] == (one << m->ts)) << 3);
board[m->ts] = OO;
board[sq] = ctype;
piece[WHITE] ^= (u64)(ctype != OO) << sq;
board[m->fs] = BP;
break;
case Bb:
board[m->ts] = ctype;
board[m->fs] = BP;
mat[BLACK] -= 200;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Br:
board[m->ts] = ctype;
board[m->fs] = BP;
mat[BLACK] -= 400;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Bn:
board[m->ts] = ctype;
board[m->fs] = BP;
mat[BLACK] -= 200;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Bq:
board[m->ts] = ctype;
board[m->fs] = BP;
mat[BLACK] -= 800;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case WS:
board[G1] = OO;
board[E1] = WC;
board[H1] = WRC;
board[F1] = OO;
king[WHITE] ^= one << G1;
king[WHITE] ^= one << E1;
piece[WHITE] ^= one << H1;
piece[WHITE] ^= one << F1;
break;
case WL:
board[C1] = OO;
board[E1] = WC;
board[A1] = WRC;
board[D1] = OO;
king[WHITE] ^= one << C1;
king[WHITE] ^= one << E1;
piece[WHITE] ^= one << A1;
piece[WHITE] ^= one << D1;
break;
case BS:
board[G8] = OO;
board[E8] = BC;
board[H8] = BRC;
board[F8] = OO;
king[BLACK] ^= one << G8;
king[BLACK] ^= one << E8;
piece[BLACK] ^= one << H8;
piece[BLACK] ^= one << F8;
break;
case BL:
board[C8] = OO;
board[E8] = BC;
board[A8] = BRC;
board[D8] = OO;
king[BLACK] ^= one << C8;
king[BLACK] ^= one << E8;
piece[BLACK] ^= one << A8;
piece[BLACK] ^= one << D8;
break;
}
}
s32 AtkByWhite(Thread* t, u64 bb) {
u32 ts, fs;
u64 b, aPieces = piece[WHITE] | piece[BLACK];
do {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
b = bPawnCapts[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WP) return true;
}
b = knightMoves[ts] & piece[WHITE];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WN) return true;
}
b = kingMoves[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WK || board[fs] == WC)
return true;
}
b = qss[ts][(aPieces >> (ts & 56)) & 127][0]
& qss[ts][(aPieces >> 8) & 255][1]
& qss[ts][(aPieces >> 16) & 255][2]
& qss[ts][(aPieces >> 24) & 255][3]
& qss[ts][(aPieces >> 32) & 255][4]
& qss[ts][(aPieces >> 40) & 255][5]
& qss[ts][(aPieces >> 48) & 255][6]
& bob[ts]
& piece[WHITE];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WB || board[fs] == WQ) return true;
}
b = qss[ts][(aPieces >> (ts & 56)) & 127][0]
& qss[ts][(aPieces >> 8) & 255][1]
& qss[ts][(aPieces >> 16) & 255][2]
& qss[ts][(aPieces >> 24) & 255][3]
& qss[ts][(aPieces >> 32) & 255][4]
& qss[ts][(aPieces >> 40) & 255][5]
& qss[ts][(aPieces >> 48) & 255][6]
& rob[ts]
& piece[WHITE];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WR || board[fs] == WQ || board[fs] == WRC) return true;
}
} while (bb);
return false;
}
s32 AtkByBlack(Thread* t, u64 bb) {
u32 ts, fs;
u64 b, aPieces = piece[WHITE] | piece[BLACK];
do {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
b = wPawnCapts[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BP) return true;
}
b = knightMoves[ts] & piece[BLACK];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BN) return true;
}
b = kingMoves[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BK || board[fs] == BC)
return true;
}
b = qss[ts][(aPieces >> (ts & 56)) & 127][0]
& qss[ts][(aPieces >> 8) & 255][1]
& qss[ts][(aPieces >> 16) & 255][2]
& qss[ts][(aPieces >> 24) & 255][3]
& qss[ts][(aPieces >> 32) & 255][4]
& qss[ts][(aPieces >> 40) & 255][5]
& qss[ts][(aPieces >> 48) & 255][6]
& bob[ts]
& piece[BLACK];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BB || board[fs] == BQ) return true;
}
b = qss[ts][(aPieces >> (ts & 56)) & 127][0]
& qss[ts][(aPieces >> 8) & 255][1]
& qss[ts][(aPieces >> 16) & 255][2]
& qss[ts][(aPieces >> 24) & 255][3]
& qss[ts][(aPieces >> 32) & 255][4]
& qss[ts][(aPieces >> 40) & 255][5]
& qss[ts][(aPieces >> 48) & 255][6]
& rob[ts]
& piece[BLACK];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BR || board[fs] == BQ || board[fs] == BRC) return true;
}
} while (bb);
return false;
}
void SortRoot(Thread* t, Move* m, u64 n) {
s32 i, j;
Move temp;
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
if (move[j].score > move[i].score) {
temp = move[i];
move[i] = move[j];
move[j] = temp;
}
}
}
}
void Sort(Thread* t, Move* m, s32 mi, u64 n) {
s32 i, j = mi, high = -INF;
Move* mov;
Move temp;
for (i = mi + 1; i < n; i++) {
mov = m + i;
if (mov->score > high) {
high = mov->score;
j = i;
}
}
temp = m[mi];
m[mi] = m[j];
m[j] = temp;
}
s32 Qsort(Thread* t, Move* m, s32 n) {
s32 i = 0, high = -INF;
Move* mov;
for (; n > OO; n--) {
mov = m - n;
if (!mov->status && mov->score > high) {
high = mov->score;
i = n;
}
}
(m - i)->status = true;
return i;
}
u64 GenMoves(Thread* t, Move* m) {
s32 i, type, ot, score = -INF;
u32 fs, ts, sq;
u64 bb, captures = 0;
Move* n = m;
u64 blockers;
u64 pieces = piece[wtm];
u64 aPieces = piece[BLACK] | piece[WHITE];
u64 enemy = aPieces ^ pieces;
u64 empty = 0xffffffffffffffff ^ aPieces;
u64 notme = 0xffffffffffffffff ^ pieces;
do {
_BitScanForward64(&fs, pieces);
pieces ^= one << fs;
ot = type = board[fs];
switch (type) {
case OO:
break;
case WP:
switch (fs >> 3) {
case RANK1: break;
case RANK2:
if (!_BitScanForward64(&sq, wPawnMoves[fs] & aPieces)) {
sq = H8;
}
bb = (wPawnMoves[fs] & below[sq]) | (wPawnCapts[fs] & enemy);
type = Wd;
break;
case RANK3:
case RANK4:
case RANK6:
bb = (wPawnMoves[fs] & empty) | (wPawnCapts[fs] & enemy);
break;
case RANK5:
bb = (wPawnMoves[fs] & empty) | (wPawnCapts[fs] & (enemy | epbb[ply]));
type = We;
break;
case RANK7:
bb = (wPawnMoves[fs] & empty) | (wPawnCapts[fs] & enemy);
if (bb & king[1 - wtm]) return OO;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
for (i = Q; i >= B; i--) {
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = Wb + i;
m->score = (value[board[m->ts]] << 4) + value[m->type];
m->status = false;
m++;
}
}
continue;
}
break;
case WN:
case BN:
bb = knightMoves[fs] & notme;
break;
case WB:
case BB:
blockers = aPieces & bob[fs];
bb = bss[fs][(blockers >> 9) & 63][0]
& bss[fs][(blockers >> 17) & 63][1]
& bss[fs][(blockers >> 25) & 63][2]
& bss[fs][(blockers >> 33) & 63][3]
& bss[fs][(blockers >> 41) & 63][4]
& bss[fs][(blockers >> 49) & 63][5]
& notme;
break;
case WR:
case WRC:
case BR:
case BRC:
blockers = aPieces & rob[fs];
bb = qss[fs][(blockers >> (fs & 56)) & 127][0]
& qss[fs][(blockers >> 8) & 255][1]
& qss[fs][(blockers >> 16) & 255][2]
& qss[fs][(blockers >> 24) & 255][3]
& qss[fs][(blockers >> 32) & 255][4]
& qss[fs][(blockers >> 40) & 255][5]
& qss[fs][(blockers >> 48) & 255][6]
& rob[fs]
& notme;
break;
case WQ:
case BQ:
blockers = aPieces & (bob[fs] | rob[fs]);
bb = qss[fs][(blockers >> (fs & 56)) & 127][0]
& qss[fs][(blockers >> 8) & 255][1]
& qss[fs][(blockers >> 16) & 255][2]
& qss[fs][(blockers >> 24) & 255][3]
& qss[fs][(blockers >> 32) & 255][4]
& qss[fs][(blockers >> 40) & 255][5]
& qss[fs][(blockers >> 48) & 255][6]
& notme;
break;
case WK:
case BK:
bb = kingMoves[fs] & notme;
break;
case WC:
bb = kingMoves[fs] & notme;
if (board[H1] == WRC && !(WOCCS & aPieces) && !AtkByBlack(t, WATKS)) {
m->fs = E1;
m->ts = G1;
m->type = WS;
m->score = 1000;
m->status = false;
m++;
}
if (board[A1] == WRC && !(WOCCL & aPieces) && !AtkByBlack(t, WATKL)) {
m->fs = E1;
m->ts = C1;
m->type = WL;
m->score = 1000;
m->status = false;
m++;
}
break;
case BP:
switch (fs >> 3) {
case RANK1:
break;
case RANK2:
bb = (bPawnMoves[fs] & empty) | (bPawnCapts[fs] & enemy);
if (bb & king[1 - wtm]) return OO;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
for (i = Q; i >= B; i--) {
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = Bb + i;
m->score = (value[board[m->ts]] << 4) + value[m->type];
m->status = false;
m++;
}
}
continue;
case RANK3:
case RANK5:
case RANK6:
bb = (bPawnMoves[fs] & empty) | (bPawnCapts[fs] & enemy);
break;
case RANK4:
bb = (bPawnMoves[fs] & empty) | (bPawnCapts[fs] & (enemy | epbb[ply]));
type = Be;
break;
case RANK7:
if (!_BitScanReverse64(&sq, bPawnMoves[fs] & aPieces)) {
sq = A1;
}
bb = (bPawnMoves[fs] & above[sq]) | (bPawnCapts[fs] & enemy);
type = Bd;
break;
}
break;
case BC:
bb = kingMoves[fs] & notme;
if (board[H8] == BRC && !(BOCCS & aPieces) && !AtkByWhite(t, BATKS)) {
m->fs = E8;
m->ts = G8;
m->type = BS;
m->score = 1000;
m->status = false;
m++;
}
if (board[A8] == BRC && !(BOCCL & aPieces) && !AtkByWhite(t, BATKL)) {
m->fs = E8;
m->ts = C8;
m->type = BL;
m->score = 1000;
m->status = false;
m++;
}
break;
}
captures |= bb;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = type;
m->score = (value[board[m->ts]] << 4) - value[board[m->fs]];
m->score -= pcePST[ot][m->fs];
m->score += pcePST[ot][m->ts];
m->score -=
m->status = false;
m++;
}
} while (pieces);
if (captures & king[1 - wtm]) return OO;
return m - n;
}
