Chess Programming Tutorial

[romichess]

The search routine is recursive. Some people understand recursion without much trouble. Others find it a difficult idea to master. As this is a chess programming tutorial and not a programming tutorial it would be best for the confused reader to research recursion on their own. The search routine in this example is the nega_max variant. It is really difficult to wrap one's brain around. And yet it is quite simple. We are recursively calling Search in a way that we change sides and look at the situation from the other sides point of view. Alpha is the lower bound and beta is the higher bound. So if we are currently with white to move then as we find better moves alpha increases because alpha is the best we have found so far. However, beta represents the best that the other side has found so far. So when we call Search -beta becomes the other sides alpha and our -alpha becomes the other sides beta. And since alpha and beta are negated so is the score returned negated to flip it back to our point of view.

The search control function searches the root moves and in a more developed state does time management and plays book moves, etc. It starts out with alpha and beta set to -INFINITY and INFINITY which is -/+ 10000 in this case. Even though we might set the search depth to say 8 ply we search using iterative deepening. That is to develop a principle variation so as to order the moves better that then will greatly speed up the nega_max algorithm. This is the most basic search code possible. It is good enough to get a working engine.  And it is all I can do right now because it is way past my bedtime, again. gn

NOTE: I have modified the move stack definition to include a score and a stats integer. It is a little wasteful to include a score and a stats with every single move in the move stack but it makes the coding more simple.

Code: QB64: [Select]

1. FUNCTION Search (alpha AS INTEGER, beta AS INTEGER, depth AS INTEGER)
2.     ' IF depth < 1 then Search = Qsearch(alpha, beta)
3.     IF NOT Move_Generator THEN Search = 10000
4.     FOR i = move_stack_index(ply) TO move_stack_index(ply - 1) + 1 STEP -1
5.         Make_Move (i)
6.         move_stack(i).score = -Search(-beta, -alpha, depth - 1)
7.         Take_Back
8.         IF move_stack(i).score > alpha THEN
9.             IF move_stack(i).score >= beta THEN Search = beta
10.             alpha = move_stack(i).score
11.         END IF
12.     NEXT
13.     Search = alpha
14. END FUNCTION
15.  
16. SUB Search_control
17.     legal = Move_Generator
18.     FOR depth = 1 TO max_depth
19.         FOR i = move_stack_index(ply) TO move_stack_index(ply - 1) + 1 STEP -1
20.             Make_Move (i)
21.             move_stack(i).score = Search(-10000, 10000, depth - 1)
22.             Take_Back
23.             IF move_stack(i).score > best THEN
24.                 best = score
25.                 move = move_stack(i)
26.             END IF
27.         NEXT
28.         ' Sort_Root_Moves
29.     NEXT
30. END SUB

[anttiylikoski]

Ref: the signature---

You say

"Russia looks world from future. big data is peace data i never
recommend anything to anyone and always write only about myself"

Russia -- First

adversary

The Satan-2 has some ~5 MIRV warheads, about 500kt thermonuclear.

And:

Dr A. J. Y.
Finland

[romichess]

I have opted for a simple way. This way is new and even simpler than the traditional simple way. The traditional way uses bit flags and logical operator test called castling rights. This new way uses more memory but is really much more simple. Since the simple ways always take clock cycles even if castling is no longer possible this new way will not be any slower and might be faster as the mechanism is more simple.

We keep a count array the size of the board.

DIM count(120) AS INTEGER 'initialized to -1

In Make_Move and Takeback we increment and decrement respectively the from square and to square count of all moves. That way the test for the king's right to castle is as simple as, IF count(E1). That is more simple than IF (castle AND 1) and what is needed to maintain the flag bits in the first place. :) Here is the king move code with castling.

Code: QB64: [Select]

1.             CASE 5 ' white king that can still castle
2.                 FOR i = 0 TO 7
3.                     to_square = from_square + royal_offsets(i)
4.                     target = board(to_square)
5.                     ' off board check
6.                     IF NOT target THEN
7.                         action = white_target(target)
8.                         SELECT CASE action
9.                             CASE 0 ' empty square
10.                                 Record_Move from_square, to_square
11.                             CASE 1 ' black piece
12.                                 Record_Capture from_square, to_square, target
13.                             CASE 2 ' illegal move detected
14.                                 Move_Generator = 0
15.                             CASE 3 ' white piece
16.                         END SELECT
17.                     END IF
18.                 NEXT
19.                 IF count(E1) THEN
20.                     IF count(H1) THEN
21.                         IF chess_board(F1) = 0 AND chess_board(G1) = 0 THEN
22.                             IF Not_Attacked_By(BLACK, E1) AND Not_Attacked_By(BLACK, F1) AND Not_Attacked_By(BLACK, G1) THEN
23.                                 Record_Castle(E1, G1)
24.                             END IF
25.                         END IF
26.                     END IF
27.                     IF count(A1) THEN
28.  
29.                     END IF
30.                 END IF
31.  

[romichess]

The above 6 lessons form the basis for our chess engine. Going forward I'm going to finish each routine and post the code. The very next goal is also something new, AFAIK. Instead of the traditional search we are going to write a very useful new search function called something like Gen_One_Move_Then_Q. Q stands for quiescent which means a quiet space. At the leaf node of every search a qsearch is done to resolve capture sequences that remain on the board. It is impossible to have a strong chess engine without resolving captures. We could get away with a static exchange analysing function for a simple chess engine but I much prefer a full capture search.

This new function will have several benefits. First of all, all the moves generated will be legal as the illegal moves from the pseudo legal move generator will be caught by the qsearch. The second advantage will be that the moves will be evaluated and have a score. That will mean a good move ordering which is so important for how fast the alpha/beta algorithm will run. Yes, I have already mentioned the importance of move ordering. I'm repeating it because it is one of the most important things in achieving a deep searching chess engine. It is magnitudes better to have slow code and excellent move ordering than to have fast code and poor move ordering!

[SMcNeill]

Do you guys know what I’d love to see, and what I thought about working on sometime?

A custom chess engine!!

Everyone always tries to build a chess game that follows all the rules of chess, and that’s fine an all — but it’s so LIMITING!!

Pass a chess set to a group of four year olds, spend a few hours teaching them the rules, and then leave them alone.  When you go back into the room and check on them three hours later, you’ll find they have the car from Monopoly, Mr Potato Head’s ear, two marbles, and a Barbie inserted into the game!!  And they’re having a blast!!

I’d love to see this flexibility inserted into a computerized chess game sometime!  My concept would be:

1) Load icons to form the pieces on each side — name them and number them as you do.
2) Create the game board, of X by Y size, in whatever shades/colors are desired, with any agreed upon obstacles.  Add a black hole, a swamp, a tower — whatever!  It’s basically just a set of choosing icons, setting them on the board, and naming them.
3) Each player places their pieces on the board.
4) You then choose the rules for your pieces and how they interact with the board.

“Pawns” move “1 step forward.”
“Pawns” attack “1 step diagional.”
“Cars” move “6 steps forward” and “run over everything.”

5) You then save the game and ruleset for quick loading and replayability.

Then you play against your opponent(s)!

[romichess]

Now it is time to start writing the official code starting with the heart of the chess engine which is the one move generator plus quiescent search.

Code: QB64: [Select]

1. TYPE moves
2.     from_square AS _UNSIGNED _BYTE
3.     to_square AS _UNSIGNED _BYTE
4.     target AS _UNSIGNED _BYTE
5.     special AS _UNSIGNED _BYTE
6.     score AS INTEGER
7. END TYPE
8.  
9. CONST TERMINATE = 0
10.  
11. DIM SHARED ply AS INTEGER
12. DIM SHARED move_stack(8000) AS moves
13.  
14. SUB Search_One_Q (alpha AS INTEGER, beta AS INTEGER)
15.     Generate_Moves
16.     i = move_stack_index(ply)
17.     while move_stack(i).special <> TERMINATE
18.         Make_Move i
19.         move_stack(i).score = Qsearch(alpha, beta)
20.         Take_Back
21.         i = i - 1
22.     WEND
23. END SUB
24.  

[romichess]

Do you guys know what I’d love to see, and what I thought about working on sometime?

A custom chess engine!!

Everyone always tries to build a chess game that follows all the rules of chess, and that’s fine an all — but it’s so LIMITING!!

Pass a chess set to a group of four year olds, spend a few hours teaching them the rules, and then leave them alone.  When you go back into the room and check on them three hours later, you’ll find they have the car from Monopoly, Mr Potato Head’s ear, two marbles, and a Barbie inserted into the game!!  And they’re having a blast!!

I’d love to see this flexibility inserted into a computerized chess game sometime!  My concept would be:

1) Load icons to form the pieces on each side — name them and number them as you do.
2) Create the game board, of X by Y size, in whatever shades/colors are desired, with any agreed upon obstacles.  Add a black hole, a swamp, a tower — whatever!  It’s basically just a set of choosing icons, setting them on the board, and naming them.
3) Each player places their pieces on the board.
4) You then choose the rules for your pieces and how they interact with the board.

“Pawns” move “1 step forward.”
“Pawns” attack “1 step diagional.”
“Cars” move “6 steps forward” and “run over everything.”

5) You then save the game and ruleset for quick loading and replayability.

Then you play against your opponent(s)!

There is something like that that already exist. It was from a couple decades ago. It is called something like the "Incredible Game Machine". The user defined the board type, squares or hexes, size and the pieces with their rules. Also what the board looked like and the pieces looked like. More than that I do not remember. 

[STxAxTIC]

I love the question of an abstracted game engine. Not for games, you all know me - but for the sake of creating a Turing complete world within a world. Indeed the chess engine can be, ahem, in the right language - very easily generalized for any kind of topology (a Cartesian board is very last millennium), abstract "pieces", which in this sense don't even need to be discrete - entities are more generally fields, waves, blobs of density - stuff along those lines. Turn-based moves become asynchronous events, etc. etc.

And if you've done it right, all you have to do is set some initial parameters to have chess, checkers, Chinese checkers, stratego, backgammon, whatever. Poker. It's endless.

Hell of a big job. You may as well design an OOP sublanguage for QB64 first, it'll make things way easier.

I like the mission though.

[romichess]

At the end of any day in which I have written a substantial amount of code I will post the code. Please do not try to compile the code, yet. The code that is posted is for tutorial purposes so one can follow the thought process. As stated earlier my first goal is to complete the Search_One_Q subroutine and all of its subroutines. That in itself will make for a nice one move search engine!

Code: QB64: [Select]

1. TYPE PIECES
2.     typ AS _BYTE
3.     squ AS _BYTE
4.     nxt AS _BYTE
5.     prv AS _BYTE
6. END TYPE
7.  
8. TYPE MOVES
9.     from_square AS _UNSIGNED _BYTE
10.     to_square AS _UNSIGNED _BYTE
11.     target AS _UNSIGNED _BYTE
12.     special AS _UNSIGNED _BYTE
13.     score AS INTEGER
14. END TYPE
15.  
16. CONST FALSE = 0
17. CONST TRUE = 1
18.  
19. CONST ILLEGAL = -1
20.  
21. CONST BLACK = 0
22. CONST WHITE = 1
23.  
24. CONST EMPTY = 0
25. CONST FP = 1
26. CONST EP = 2
27. CONST EK = 3
28.  
29. CONST NA = -1
30. CONST NON = -1
31. CONST TERMINATE = 0
32. CONST WP = 1
33. CONST WN = 2
34. CONST WB = 3
35. CONST WR = 4
36. CONST WQ = 5
37. CONST WC = 6
38. CONST WK = 7
39. CONST BP = 8
40. CONST BN = 9
41. CONST BB = 10
42. CONST BR = 11
43. CONST BQ = 12
44. CONST BK = 13
45.  
46. CONST A1 = 21
47. CONST B1 = 22
48. CONST C1 = 23
49. CONST D1 = 24
50. CONST E1 = 25
51. CONST F1 = 26
52. CONST G1 = 27
53. CONST H1 = 28
54. CONST A2 = 31
55. CONST B2 = 32
56. CONST C2 = 33
57. CONST D2 = 34
58. CONST E2 = 35
59. CONST F2 = 36
60. CONST G2 = 37
61. CONST H2 = 38
62. CONST A7 = 81
63. CONST B7 = 82
64. CONST C7 = 83
65. CONST D7 = 84
66. CONST E7 = 85
67. CONST F7 = 86
68. CONST G7 = 87
69. CONST H7 = 88
70. CONST A8 = 91
71. CONST B8 = 92
72. CONST C8 = 93
73. CONST D8 = 94
74. CONST E8 = 95
75. CONST f8 = 96
76. CONST G8 = 97
77. CONST H8 = 98
78.  
79. CONST X2R = 0
80. CONST L2R = 1
81. CONST L2X = 2
82. CONST X1R = 3
83. CONST L1R = 4
84. CONST L1X = 5
85. CONST XER = 6
86. CONST LER = 7
87. CONST LEX = 8
88. CONST XPR = 9
89. CONST LPR = 10
90. CONST LPX = 11
91.  
92. DIM SHARED ply AS INTEGER
93. DIM SHARED wtm AS _BYTE
94. DIM SHARED move_stack(8000) AS MOVES
95. DIM SHARED start_index(2) AS _BYTE
96.  
97. DIM SHARED chess_board(120) AS _BYTE
98.  
99. DATA -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
100. DATA -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
101. DATA -1,14,10,12,15,16,11,+9,13,-1
102. DATA -1,+5,+4,+3,+2,+1,+8,+7,+6,-1
103. DATA -1,00,00,00,00,00,00,00,00,-1
104. DATA -1,00,00,00,00,00,00,00,00,-1
105. DATA -1,00,00,00,00,00,00,00,00,-1
106. DATA -1,00,00,00,00,00,00,00,00,-1
107. DATA -1,25,24,23,22,21,28,27,26,-1
108. DATA -1,34,30,32,35,36,31,29,33,-1
109. DATA -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
110. DATA -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
111.  
112. FOR i = 0 TO 119: READ chess_board(i): NEXT
113.  
114.  
115. DIM SHARED white_pawns(120) AS _BYTE
116.  
117. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
118. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
119. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
120. DATA NON,X2R,L2R,L2R,L2R,L2R,L2R,L2R,R2X,NON
121. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
122. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
123. DATA NON,XER,LER,LER,LER,LER,LER,LER,LEX,NON
124. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
125. DATA NON,XPR,LPR,LPR,LPR,LPR,LPR,LPR,LPX,NON
126. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
127. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
128. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
129.  
130. FOR i = 0 TO 119: READ white_pawns(i): NEXT
131.  
132.  
133. DIM SHARED black_pawns(120) AS _BYTE
134.  
135. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
136. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
137. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
138. DATA NON,XPR,LPR,LPR,LPR,LPR,LPR,LPR,LPX,NON
139. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
140. DATA NON,XER,LER,LER,LER,LER,LER,LER,LEX,NON
141. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
142. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
143. DATA NON,X2R,L2R,L2R,L2R,L2R,L2R,L2R,R2X,NON
144. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
145. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
146. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
147.  
148. FOR i = 0 TO 119: READ black_pawns(i): NEXT
149.  
150.  
151. DIM SHARED piece(40) AS PIECES
152.  
153. DATA NA,NA,+1,NA
154. DATA WP,E2,+2,NA
155. DATA WP,D2,+3,+1
156. DATA WP,C2,+4,+2
157. DATA WP,B2,+5,+3
158. DATA WP,A2,+6,+4
159. DATA WP,H2,+7,+5
160. DATA WP,G2,+8,+6
161. DATA WP,F2,+9,+7
162. DATA WN,G1,10,+8
163. DATA WN,B1,11,+9
164. DATA WB,F1,12,10
165. DATA WB,C1,13,11
166. DATA WR,H1,14,12
167. DATA WR,A1,15,13
168. DATA WQ,D1,16,14
169. DATA WK,NA,NA,NA
170. DATA WC,E1,39,16
171. DATA NA,NA,NA,NA
172. DATA NA,NA,NA,NA
173. DATA NA,NA,21,NA
174. DATA BP,E7,22,NA
175. DATA BP,D7,23,21
176. DATA BP,C7,24,22
177. DATA BP,B7,25,23
178. DATA BP,A7,26,24
179. DATA BP,H7,27,25
180. DATA BP,G7,28,26
181. DATA BP,F7,29,27
182. DATA BN,G8,30,28
183. DATA BN,B8,31,29
184. DATA BB,F8,32,30
185. DATA BB,C8,33,31
186. DATA BR,H8,34,32
187. DATA BR,A8,35,33
188. DATA BQ,D8,36,34
189. DATA BK,NA,NA,NA
190. DATA BC,E8,39,36
191. DATA NA,NA,NA,NA
192. DATA NA,NA,NA,NA
193. DATA TERMINATE,NA,NA,NA
194.  
195. FOR i = 0 TO 39: READ piece(i).typ: READ piece(i).squ: READ piece(i).nxt: READ piece(i).prv: NEXT
196.  
197. DIM SHARED white_target(40) AS _BYTE
198.  
199. DATA EMPTY,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,0,0
200. DATA EMPTY,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EK,EK,0,0
201.  
202. FOR i = 0 TO 99: READ white_target(i): NEXT
203.  
204.  
205. DIM SHARED black_target(40) AS _BYTE
206.  
207. DATA EMPTY,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EK,EK,0,0
208. DATA EMPTY,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,0,0
209.  
210. FOR i = 0 TO 99: READ black_target(i): NEXT
211.  
212.  
213. DIM SHARED bishop_offsets(4) AS _BYTE
214.  
215. DATA 9,11,-9,-11
216.  
217. FOR i = 0 TO 3: READ bishop_offsets(i): NEXT
218.  
219.  
220. DIM SHARED rook_offsets(4) AS _BYTE
221.  
222. DATA 1,10,-1,-10
223.  
224. FOR i = 0 TO 3: READ rook_offsets(i): NEXT
225.  
226.  
227. DIM SHARED royal_offsets AS _BYTE
228.  
229. DATA 1,9,10,11,-1,-9,-10,-11
230.  
231. FOR i = 0 TO 7: READ royal_offsets(i): NEXT
232.  
233.  
234. DIM SHARED knight_offsets AS _BYTE
235.  
236. DATA 8,12,19,21,-8,-12,-19,-21
237.  
238. FOR i = 0 TO 7: READ knight_offsets(i): NEXT
239.  
240. SUB Record_Move (from_square AS _BYTE, to_square AS _BYTE)
241.  
242. END SUB
243.  
244. SUB Record_Capture (from_square AS _BYTE, to_square AS _BYTE, target AS _BYTE)
245.  
246. END SUB
247.  
248. SUB Record_Move_Mark_ep (from_square AS _BYTE, to_square AS _BYTE)
249.  
250. END SUB
251.  
252. SUB Record_ep (from_square AS _BYTE, to_square AS _BYTE)
253.  
254. END SUB
255.  
256. SUB Record_Move_Promotion (from_square AS _BYTE, to_square AS _BYTE)
257.  
258. END SUB
259.  
260. SUB Record_capture_Promotion (from_square AS _BYTE, to_square AS _BYTE, target AS _BYTE)
261.  
262. END SUB
263.  
264. SUB Generate_Moves
265.     piece_index = next_piece(start_index(wtm))
266.     DO
267.         from_square = piece(piece_index).squ
268.         SELECT CASE piece(piece_index).typ
269.             CASE TERMINATE
270.                 EXIT SUB
271.             CASE WP
272.                 SELECT CASE white_pawns(from_square)
273.                     CASE X2R
274.                         to_square = from_square + 10
275.                         target = chess_board(to_square)
276.                         IF target = EMPTY THEN
277.                             Record_Move from_square, to_square
278.                             to_square = from_square + 20
279.                             target = chess_board(to_square)
280.                             IF target = EMPTY THEN
281.                                 Record_Move_Mark_ep from_square, to_square
282.                             END IF
283.                         END IF
284.                         to_square = from_square + 11
285.                         target = chess_board(to_square)
286.                         action = white_target(target)
287.                         SELECT CASE action
288.                             CASE 0
289.                             CASE 1
290.                             CASE 2
291.                                 Record_Capture from_square, to_square, target
292.                         END SELECT
293.  
294.                     CASE L2R
295.                         to_square = from_square + 9
296.                         target = chess_board(to_square)
297.                         action = white_target(target)
298.                         SELECT CASE action
299.                             CASE 0
300.                             CASE 1
301.                             CASE 2
302.                                 Record_Capture from_square, to_square, target
303.                         END SELECT
304.                         to_square = from_square + 10
305.                         target = chess_board(to_square)
306.                         IF target = EMPTY THEN
307.                             Record_Move from_square, to_square
308.                             to_square = from_square + 20
309.                             target = chess_board(to_square)
310.                             IF target = EMPTY THEN
311.                                 Record_Move_Mark_ep from_square, to_square
312.                             END IF
313.                         END IF
314.                         to_square = from_square + 11
315.                         target = chess_board(to_square)
316.                         action = white_target(target)
317.                         SELECT CASE action
318.                             CASE 0
319.                             CASE 1
320.                             CASE 2
321.                                 Record_Capture from_square, to_square, target
322.                         END SELECT
323.  
324.                     CASE L2X
325.                         to_square = from_square + 9
326.                         target = chess_board(to_square)
327.                         action = white_target(target)
328.                         SELECT CASE action
329.                             CASE 0
330.                             CASE 1
331.                             CASE 2
332.                                 Record_Capture from_square, to_square, target
333.                         END SELECT
334.                         to_square = from_square + 10
335.                         target = chess_board(to_square)
336.                         IF target = EMPTY THEN
337.                             Record_Move from_square, to_square
338.                             to_square = from_square + 20
339.                             target = chess_board(to_square)
340.                             IF target = EMPTY THEN
341.                                 Record_Move_Mark_ep from_square, to_square
342.                             END IF
343.                         END IF
344.  
345.                     CASE X1R
346.                         to_square = from_square + 10
347.                         target = chess_board(to_square)
348.                         IF target = EMPTY THEN
349.                             Record_Move from_square, to_square
350.                         END IF
351.                         to_square = from_square + 11
352.                         target = chess_board(to_square)
353.                         action = white_target(target)
354.                         SELECT CASE action
355.                             CASE 0
356.                             CASE 1
357.                             CASE 2
358.                                 Record_Capture from_square, to_square, target
359.                         END SELECT
360.  
361.                     CASE L1R
362.                         to_square = from_square + 9
363.                         target = chess_board(to_square)
364.                         action = white_target(target)
365.                         SELECT CASE action
366.                             CASE 0
367.                             CASE 1
368.                             CASE 2
369.                                 Record_Capture from_square, to_square, target
370.                         END SELECT
371.                         to_square = from_square + 10
372.                         target = chess_board(to_square)
373.                         IF target = EMPTY THEN
374.                             Record_Move from_square, to_square
375.                         END IF
376.                         to_square = from_square + 11
377.                         target = chess_board(to_square)
378.                         action = white_target(target)
379.                         SELECT CASE action
380.                             CASE 0
381.                             CASE 1
382.                             CASE 2
383.                                 Record_Capture from_square, to_square, target
384.                         END SELECT
385.  
386.                     CASE L1X
387.                         to_square = from_square + 9
388.                         target = chess_board(to_square)
389.                         action = white_target(target)
390.                         SELECT CASE action
391.                             CASE 0
392.                             CASE 1
393.                             CASE 2
394.                                 Record_Capture from_square, to_square, target
395.                         END SELECT
396.                         to_square = from_square + 10
397.                         target = chess_board(to_square)
398.                         IF target = EMPTY THEN
399.                             Record_Move from_square, to_square
400.                         END IF
401.  
402.                     CASE XER
403.                         to_square = from_square + 10
404.                         target = chess_board(to_square)
405.                         IF target = EMPTY THEN
406.                             Record_Move from_square, to_square
407.                         END IF
408.                         to_square = from_square + 11
409.                         target = chess_board(to_square)
410.                         action = white_target(target)
411.                         SELECT CASE action
412.                             CASE 0
413.                                 IF to_square = ep_square(ply) THEN Record_ep from_square, to_square
414.                             CASE 1
415.                             CASE 2
416.                                 Record_Capture from_square, to_square, target
417.                         END SELECT
418.  
419.                     CASE LER
420.                         to_square = from_square + 9
421.                         target = chess_board(to_square)
422.                         action = white_target(target)
423.                         SELECT CASE action
424.                             CASE 0
425.                                 IF to_square = ep_square(ply) THEN Record_ep from_square, to_square
426.                             CASE 1
427.                             CASE 2
428.                                 Record_Capture from_square, to_square, target
429.                         END SELECT
430.                         to_square = from_square + 10
431.                         target = chess_board(to_square)
432.                         IF target = EMPTY THEN
433.                             Record_Move from_square, to_square
434.                         END IF
435.                         to_square = from_square + 11
436.                         target = chess_board(to_square)
437.                         action = white_target(target)
438.                         SELECT CASE action
439.                             CASE 0
440.                                 IF to_square = ep_square(ply) THEN Record_ep from_square, to_square
441.                             CASE 1
442.                             CASE 2
443.                                 Record_Capture from_square, to_square, target
444.                         END SELECT
445.  
446.                     CASE LEX
447.                         to_square = from_square + 9
448.                         target = chess_board(to_square)
449.                         action = white_target(target)
450.                         SELECT CASE action
451.                             CASE 0
452.                                 IF to_square = ep_square(ply) THEN Record_ep from_square, to_square
453.                             CASE 1
454.                             CASE 2
455.                                 Record_Capture from_square, to_square, target
456.                         END SELECT
457.                         to_square = from_square + 10
458.                         target = chess_board(to_square)
459.                         IF target = EMPTY THEN
460.                             Record_Move from_square, to_square
461.                         END IF
462.  
463.                     CASE XPR
464.                         to_square = from_square + 10
465.                         target = chess_board(to_square)
466.                         IF target = EMPTY THEN
467.                             Record_Move_Promotion from_square, to_square
468.                         END IF
469.                         to_square = from_square + 11
470.                         target = chess_board(to_square)
471.                         action = white_target(target)
472.                         SELECT CASE action
473.                             CASE 0
474.                             CASE 1
475.                             CASE 2
476.                                 Record_capture_Promotion from_square, to_square, target
477.                         END SELECT
478.  
479.                     CASE LPR
480.                         to_square = from_square + 9
481.                         target = chess_board(to_square)
482.                         action = white_target(target)
483.                         SELECT CASE action
484.                             CASE 0
485.                             CASE 1
486.                             CASE 2
487.                                 Record_capture_Promotion from_square, to_square, target
488.                         END SELECT
489.                         to_square = from_square + 10
490.                         target = chess_board(to_square)
491.                         IF target = EMPTY THEN
492.                             Record_Move_Promotion from_square, to_square
493.                         END IF
494.                         to_square = from_square + 11
495.                         target = chess_board(to_square)
496.                         action = white_target(target)
497.                         SELECT CASE action
498.                             CASE 0
499.                             CASE 1
500.                             CASE 2
501.                                 Record_capture_Promotion from_square, to_square, target
502.                         END SELECT
503.  
504.                     CASE LPX
505.                         to_square = from_square + 9
506.                         target = chess_board(to_square)
507.                         action = white_target(target)
508.                         SELECT CASE action
509.                             CASE 0
510.                             CASE 1
511.                             CASE 2
512.                                 Record_capture_Promotion from_square, to_square, target
513.                         END SELECT
514.                         to_square = from_square + 10
515.                         target = chess_board(to_square)
516.                         IF target = EMPTY THEN
517.                             Record_Move_Promotion from_square, to_square
518.                         END IF
519.  
520.                 END SELECT
521.             CASE WN
522.  
523.             CASE WB
524.  
525.             CASE WR
526.  
527.             CASE WQ
528.  
529.             CASE WK
530.  
531.             CASE WC
532.  
533.             CASE BP
534.  
535.             CASE BN
536.  
537.             CASE BB
538.  
539.             CASE BR
540.  
541.             CASE BQ
542.  
543.             CASE BK
544.  
545.             CASE BC
546.  
547.         END SELECT
548.     LOOP
549. END SUB
550.  
551. SUB Make_Move (i AS INTEGER)
552.  
553. END SUB
554.  
555. SUB Take_Back
556.  
557. END SUB
558.  
559. SUB Search_One_Q (alpha AS INTEGER, beta AS INTEGER)
560.     Generate_Moves
561.     i = move_stack_index(ply)
562.     WHILE move_stack(i).special <> TERMINATE
563.         Make_Move i
564.         move_stack(i).score = Qsearch(alpha, beta)
565.         Take_Back
566.         i = i - 1
567.     WEND
568. END SUB
569.  

[TempodiBasic]

Bump
:-)

[romichess]

Bump
:-)

I thought it would go quietly into the night. My apologies! I'll start devoting some time to the project.

[romichess]

The move generator is almost done. There have been minor changes to the data to allow the code to be more efficient. Edge squares now have a value of 39. So target = white_target(chess_board(to_square)) yields 4 which is the case  4 EXIT DO. Therefore no separate test needed for an off board test. In the old eight bit days move generation was done in one looping structure with lots of if statements. On today's cpus with megabytes of instruction cache code proliferation like loop unrolling is desirable for speed of execution.

If anyone sees any errors please let me know. Or if anyone has any suggestions for faster code. Or any questions. To be honest I quit posting because I was feeling rather lonely. And I can do that all by myself very well by not posting, LOL!

EDIT: I flubbed up. In the slider code I forgot why there needs to be a target and an action. I'm just going to edit the first bishop direction. It will be fully corrected in my next post.

Code: QB64: [Select]

1. TYPE PIECES
2.     typ AS _BYTE
3.     squ AS _BYTE
4.     nxt AS _BYTE
5.     prv AS _BYTE
6. END TYPE
7.  
8. TYPE MOVES
9.     from_square AS _UNSIGNED _BYTE
10.     to_square AS _UNSIGNED _BYTE
11.     target AS _UNSIGNED _BYTE
12.     special AS _UNSIGNED _BYTE
13.     score AS INTEGER
14. END TYPE
15.  
16. CONST FALSE = 0
17. CONST TRUE = 1
18.  
19. CONST ILLEGAL = -1
20.  
21. CONST BLACK = 0
22. CONST WHITE = 1
23.  
24. CONST EMPTY_SQUARE = 0
25. CONST FRIENDLY_PIECE = 1
26. CONST ENEMY_PIECE = 2
27. CONST OFF_BOARD = 3
28. CONST ENEMY_KING = 4
29.  
30. CONST ES = 0
31. CONST FP = 1
32. CONST EP = 2
33. CONST OB = 3
34. CONST EK = 4
35.  
36. CONST NA = -1
37. CONST NON = -1
38. CONST TERMINATE = 0
39. CONST WP = 1
40. CONST WN = 2
41. CONST WB = 3
42. CONST WR = 4
43. CONST WQ = 5
44. CONST WC = 6
45. CONST WK = 7
46. CONST BP = 8
47. CONST BN = 9
48. CONST BB = 10
49. CONST BR = 11
50. CONST BQ = 12
51. CONST BK = 13
52.  
53. CONST A1 = 21
54. CONST B1 = 22
55. CONST C1 = 23
56. CONST D1 = 24
57. CONST E1 = 25
58. CONST F1 = 26
59. CONST G1 = 27
60. CONST H1 = 28
61. CONST A2 = 31
62. CONST B2 = 32
63. CONST C2 = 33
64. CONST D2 = 34
65. CONST E2 = 35
66. CONST F2 = 36
67. CONST G2 = 37
68. CONST H2 = 38
69. CONST A7 = 81
70. CONST B7 = 82
71. CONST C7 = 83
72. CONST D7 = 84
73. CONST E7 = 85
74. CONST F7 = 86
75. CONST G7 = 87
76. CONST H7 = 88
77. CONST A8 = 91
78. CONST B8 = 92
79. CONST C8 = 93
80. CONST D8 = 94
81. CONST E8 = 95
82. CONST f8 = 96
83. CONST G8 = 97
84. CONST H8 = 98
85.  
86. CONST X2R = 0
87. CONST L2R = 1
88. CONST L2X = 2
89. CONST X1R = 3
90. CONST L1R = 4
91. CONST L1X = 5
92. CONST XER = 6
93. CONST LER = 7
94. CONST LEX = 8
95. CONST XPR = 9
96. CONST LPR = 10
97. CONST LPX = 11
98.  
99. DIM SHARED ply AS INTEGER
100. DIM SHARED wtm AS _BYTE
101. DIM SHARED move_stack(8000) AS MOVES
102. DIM SHARED start_index(2) AS _BYTE
103.  
104. DIM SHARED chess_board(120) AS _BYTE
105.  
106. DATA 39,39,39,39,39,39,39,39,39,39
107. DATA 39,39,39,39,39,39,39,39,39,39
108. DATA 39,14,10,12,15,16,11,09,13,39
109. DATA 39,05,04,03,02,01,08,07,06,39
110. DATA 39,00,00,00,00,00,00,00,00,39
111. DATA 39,00,00,00,00,00,00,00,00,39
112. DATA 39,00,00,00,00,00,00,00,00,39
113. DATA 39,00,00,00,00,00,00,00,00,39
114. DATA 39,25,24,23,22,21,28,27,26,39
115. DATA 39,34,30,32,35,36,31,29,33,39
116. DATA 39,39,39,39,39,39,39,39,39,39
117. DATA 39,39,39,39,39,39,39,39,39,39
118.  
119. FOR i = 0 TO 119: READ chess_board(i): NEXT
120.  
121.  
122. DIM SHARED white_pawns(120) AS _BYTE
123.  
124. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
125. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
126. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
127. DATA NON,X2R,L2R,L2R,L2R,L2R,L2R,L2R,R2X,NON
128. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
129. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
130. DATA NON,XER,LER,LER,LER,LER,LER,LER,LEX,NON
131. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
132. DATA NON,XPR,LPR,LPR,LPR,LPR,LPR,LPR,LPX,NON
133. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
134. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
135. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
136.  
137. FOR i = 0 TO 119: READ white_pawns(i): NEXT
138.  
139.  
140. DIM SHARED black_pawns(120) AS _BYTE
141.  
142. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
143. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
144. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
145. DATA NON,XPR,LPR,LPR,LPR,LPR,LPR,LPR,LPX,NON
146. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
147. DATA NON,XER,LER,LER,LER,LER,LER,LER,LEX,NON
148. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
149. DATA NON,X1R,L1R,L1R,L1R,L1R,L1R,L1R,L1X,NON
150. DATA NON,X2R,L2R,L2R,L2R,L2R,L2R,L2R,R2X,NON
151. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
152. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
153. DATA NON,NON,NON,NON,NON,NON,NON,NON,NON,NON
154.  
155. FOR i = 0 TO 119: READ black_pawns(i): NEXT
156.  
157.  
158. DIM SHARED piece(40) AS PIECES
159.  
160. DATA NA,NA,+1,NA
161. DATA WP,E2,+2,NA
162. DATA WP,D2,+3,+1
163. DATA WP,C2,+4,+2
164. DATA WP,B2,+5,+3
165. DATA WP,A2,+6,+4
166. DATA WP,H2,+7,+5
167. DATA WP,G2,+8,+6
168. DATA WP,F2,+9,+7
169. DATA WN,G1,10,+8
170. DATA WN,B1,11,+9
171. DATA WB,F1,12,10
172. DATA WB,C1,13,11
173. DATA WR,H1,14,12
174. DATA WR,A1,15,13
175. DATA WQ,D1,16,14
176. DATA WK,NA,NA,NA
177. DATA WC,E1,39,16
178. DATA NA,NA,NA,NA
179. DATA NA,NA,NA,NA
180. DATA NA,NA,21,NA
181. DATA BP,E7,22,NA
182. DATA BP,D7,23,21
183. DATA BP,C7,24,22
184. DATA BP,B7,25,23
185. DATA BP,A7,26,24
186. DATA BP,H7,27,25
187. DATA BP,G7,28,26
188. DATA BP,F7,29,27
189. DATA BN,G8,30,28
190. DATA BN,B8,31,29
191. DATA BB,F8,32,30
192. DATA BB,C8,33,31
193. DATA BR,H8,34,32
194. DATA BR,A8,35,33
195. DATA BQ,D8,36,34
196. DATA BK,NA,NA,NA
197. DATA BC,E8,39,36
198. DATA NA,NA,NA,NA
199. DATA NA,NA,NA,NA
200. DATA TERMINATE,NA,NA,NA
201.  
202. FOR i = 0 TO 39: READ piece(i).typ: READ piece(i).squ: READ piece(i).nxt: READ piece(i).prv: NEXT
203.  
204. DIM SHARED white_target(40) AS _BYTE
205.  
206. DATA EMPTY,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,0,0
207. DATA EMPTY,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EK,EK,0,OB
208.  
209. FOR i = 0 TO 99: READ white_target(i): NEXT
210.  
211.  
212. DIM SHARED black_target(40) AS _BYTE
213.  
214. DATA EMPTY,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EK,EK,0,0
215. DATA EMPTY,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,0,OB
216.  
217. FOR i = 0 TO 99: READ black_target(i): NEXT
218.  
219.  
220. DIM SHARED bishop_offsets(4) AS _BYTE
221.  
222. DATA 9,11,-9,-11
223.  
224. FOR i = 0 TO 3: READ bishop_offsets(i): NEXT
225.  
226.  
227. DIM SHARED rook_offsets(4) AS _BYTE
228.  
229. DATA 1,10,-1,-10
230.  
231. FOR i = 0 TO 3: READ rook_offsets(i): NEXT
232.  
233.  
234. DIM SHARED royal_offsets AS _BYTE
235.  
236. DATA 1,9,10,11,-1,-9,-10,-11
237.  
238. FOR i = 0 TO 7: READ royal_offsets(i): NEXT
239.  
240.  
241. DIM SHARED knight_offsets AS _BYTE
242.  
243. DATA 8,12,19,21,-8,-12,-19,-21
244.  
245. FOR i = 0 TO 7: READ knight_offsets(i): NEXT
246.  
247. SUB Record_Move (from_square AS _BYTE, to_square AS _BYTE)
248.  
249. END SUB
250.  
251. SUB Record_Capture (from_square AS _BYTE, to_square AS _BYTE, target AS _BYTE)
252.  
253. END SUB
254.  
255. SUB Record_Move_Mark_ep (from_square AS _BYTE, to_square AS _BYTE)
256.  
257. END SUB
258.  
259. SUB Record_ep (from_square AS _BYTE, to_square AS _BYTE)
260.  
261. END SUB
262.  
263. SUB Record_Move_Promotion (from_square AS _BYTE, to_square AS _BYTE)
264.  
265. END SUB
266.  
267. SUB Record_capture_Promotion (from_square AS _BYTE, to_square AS _BYTE, target AS _BYTE)
268.  
269. END SUB
270.  
271. SUB Generate_Moves
272.     piece_index = next_piece(start_index(wtm))
273.     DO
274.         from_square = piece(piece_index).squ
275.         SELECT CASE piece(piece_index).typ
276.             CASE TERMINATE
277.                 EXIT SUB
278.             CASE WP
279.                 SELECT CASE white_pawns(from_square)
280.                     CASE X2R
281.                         to_square = from_square + 10
282.                         target = chess_board(to_square)
283.                         IF target = EMPTY THEN
284.                             Record_Move from_square, to_square
285.                             to_square = from_square + 20
286.                             target = chess_board(to_square)
287.                             IF target = EMPTY THEN
288.                                 Record_Move_Mark_ep from_square, to_square
289.                             END IF
290.                         END IF
291.                         to_square = from_square + 11
292.                         target = chess_board(to_square)
293.                         action = white_target(target)
294.                         SELECT CASE action
295.                             CASE EMPTY_SQUARE
296.                             CASE FRIENDLY_PIECE
297.                             CASE ENEMY_PIECE
298.                                 Record_Capture from_square, to_square, target
299.                         END SELECT
300.  
301.                     CASE L2R
302.                         to_square = from_square + 9
303.                         target = chess_board(to_square)
304.                         action = white_target(target)
305.                         SELECT CASE action
306.                             CASE EMPTY_SQUARE
307.                             CASE FRIENDLY_PIECE
308.                             CASE ENEMY_PIECE
309.                                 Record_Capture from_square, to_square, target
310.                         END SELECT
311.                         to_square = from_square + 10
312.                         target = chess_board(to_square)
313.                         IF target = EMPTY THEN
314.                             Record_Move from_square, to_square
315.                             to_square = from_square + 20
316.                             target = chess_board(to_square)
317.                             IF target = EMPTY THEN
318.                                 Record_Move_Mark_ep from_square, to_square
319.                             END IF
320.                         END IF
321.                         to_square = from_square + 11
322.                         target = chess_board(to_square)
323.                         action = white_target(target)
324.                         SELECT CASE action
325.                             CASE EMPTY_SQUARE
326.                             CASE FRIENDLY_PIECE
327.                             CASE ENEMY_PIECE
328.                                 Record_Capture from_square, to_square, target
329.                         END SELECT
330.  
331.                     CASE L2X
332.                         to_square = from_square + 9
333.                         target = chess_board(to_square)
334.                         action = white_target(target)
335.                         SELECT CASE action
336.                             CASE EMPTY_SQUARE
337.                             CASE FRIENDLY_PIECE
338.                             CASE ENEMY_PIECE
339.                                 Record_Capture from_square, to_square, target
340.                         END SELECT
341.                         to_square = from_square + 10
342.                         target = chess_board(to_square)
343.                         IF target = EMPTY THEN
344.                             Record_Move from_square, to_square
345.                             to_square = from_square + 20
346.                             target = chess_board(to_square)
347.                             IF target = EMPTY THEN
348.                                 Record_Move_Mark_ep from_square, to_square
349.                             END IF
350.                         END IF
351.  
352.                     CASE X1R
353.                         to_square = from_square + 10
354.                         target = chess_board(to_square)
355.                         IF target = EMPTY THEN
356.                             Record_Move from_square, to_square
357.                         END IF
358.                         to_square = from_square + 11
359.                         target = chess_board(to_square)
360.                         action = white_target(target)
361.                         SELECT CASE action
362.                             CASE EMPTY_SQUARE
363.                             CASE FRIENDLY_PIECE
364.                             CASE ENEMY_PIECE
365.                                 Record_Capture from_square, to_square, target
366.                         END SELECT
367.  
368.                     CASE L1R
369.                         to_square = from_square + 9
370.                         target = chess_board(to_square)
371.                         action = white_target(target)
372.                         SELECT CASE action
373.                             CASE EMPTY_SQUARE
374.                             CASE FRIENDLY_PIECE
375.                             CASE ENEMY_PIECE
376.                                 Record_Capture from_square, to_square, target
377.                         END SELECT
378.                         to_square = from_square + 10
379.                         target = chess_board(to_square)
380.                         IF target = EMPTY THEN
381.                             Record_Move from_square, to_square
382.                         END IF
383.                         to_square = from_square + 11
384.                         target = chess_board(to_square)
385.                         action = white_target(target)
386.                         SELECT CASE action
387.                             CASE EMPTY_SQUARE
388.                             CASE FRIENDLY_PIECE
389.                             CASE ENEMY_PIECE
390.                                 Record_Capture from_square, to_square, target
391.                         END SELECT
392.  
393.                     CASE L1X
394.                         to_square = from_square + 9
395.                         target = chess_board(to_square)
396.                         action = white_target(target)
397.                         SELECT CASE action
398.                             CASE EMPTY_SQUARE
399.                             CASE FRIENDLY_PIECE
400.                             CASE ENEMY_PIECE
401.                                 Record_Capture from_square, to_square, target
402.                         END SELECT
403.                         to_square = from_square + 10
404.                         target = chess_board(to_square)
405.                         IF target = EMPTY THEN
406.                             Record_Move from_square, to_square
407.                         END IF
408.  
409.                     CASE XER
410.                         to_square = from_square + 10
411.                         target = chess_board(to_square)
412.                         IF target = EMPTY THEN
413.                             Record_Move from_square, to_square
414.                         END IF
415.                         to_square = from_square + 11
416.                         target = chess_board(to_square)
417.                         action = white_target(target)
418.                         SELECT CASE action
419.                             CASE EMPTY_SQUARE
420.                                 IF to_square = ep_square(ply) THEN Record_ep from_square, to_square
421.                             CASE FRIENDLY_PIECE1
422.                             CASE ENEMY_PIECE
423.                                 Record_Capture from_square, to_square, target
424.                         END SELECT
425.  
426.                     CASE LER
427.                         to_square = from_square + 9
428.                         target = chess_board(to_square)
429.                         action = white_target(target)
430.                         SELECT CASE action
431.                             CASE EMPTY_SQUARE
432.                                 IF to_square = ep_square(ply) THEN Record_ep from_square, to_square
433.                             CASE FRIENDLY_PIECE
434.                             CASE ENEMY_PIECE
435.                                 Record_Capture from_square, to_square, target
436.                         END SELECT
437.                         to_square = from_square + 10
438.                         target = chess_board(to_square)
439.                         IF target = EMPTY THEN
440.                             Record_Move from_square, to_square
441.                         END IF
442.                         to_square = from_square + 11
443.                         target = chess_board(to_square)
444.                         action = white_target(target)
445.                         SELECT CASE action
446.                             CASE EMPTY_SQUARE
447.                                 IF to_square = ep_square(ply) THEN Record_ep from_square, to_square
448.                             CASE FRIENDLY_PIECE
449.                             CASE ENEMY_PIECE
450.                                 Record_Capture from_square, to_square, target
451.                         END SELECT
452.  
453.                     CASE LEX
454.                         to_square = from_square + 9
455.                         target = chess_board(to_square)
456.                         action = white_target(target)
457.                         SELECT CASE action
458.                             CASE EMPTY_SQUARE
459.                                 IF to_square = ep_square(ply) THEN Record_ep from_square, to_square
460.                             CASE FRIENDLY_PIECE
461.                             CASE ENEMY_PIECE
462.                                 Record_Capture from_square, to_square, target
463.                         END SELECT
464.                         to_square = from_square + 10
465.                         target = chess_board(to_square)
466.                         IF target = EMPTY THEN
467.                             Record_Move from_square, to_square
468.                         END IF
469.  
470.                     CASE XPR
471.                         to_square = from_square + 10
472.                         target = chess_board(to_square)
473.                         IF target = EMPTY THEN
474.                             Record_Move_Promotion from_square, to_square
475.                         END IF
476.                         to_square = from_square + 11
477.                         target = chess_board(to_square)
478.                         action = white_target(target)
479.                         SELECT CASE action
480.                             CASE EMPTY_SQUARE
481.                             CASE FRIENDLY_PIECE
482.                             CASE ENEMY_PIECE
483.                                 Record_capture_Promotion from_square, to_square, target
484.                         END SELECT
485.  
486.                     CASE LPR
487.                         to_square = from_square + 9
488.                         target = chess_board(to_square)
489.                         action = white_target(target)
490.                         SELECT CASE action
491.                             CASE EMPTY_SQUARE
492.                             CASE FRIENDLY_PIECE
493.                             CASE ENEMY_PIECE
494.                                 Record_capture_Promotion from_square, to_square, target
495.                         END SELECT
496.                         to_square = from_square + 10
497.                         target = chess_board(to_square)
498.                         IF target = EMPTY THEN
499.                             Record_Move_Promotion from_square, to_square
500.                         END IF
501.                         to_square = from_square + 11
502.                         target = chess_board(to_square)
503.                         action = white_target(target)
504.                         SELECT CASE action
505.                             CASE EMPTY_SQUARE
506.                             CASE FRIENDLY_PIECE
507.                             CASE ENEMY_PIECE
508.                                 Record_capture_Promotion from_square, to_square, target
509.                         END SELECT
510.  
511.                     CASE LPX
512.                         to_square = from_square + 9
513.                         target = chess_board(to_square)
514.                         action = white_target(target)
515.                         SELECT CASE action
516.                             CASE EMPTY_SQUARE
517.                             CASE FRIENDLY_PIECE
518.                             CASE ENEMY_PIECE
519.                                 Record_capture_Promotion from_square, to_square, target
520.                         END SELECT
521.                         to_square = from_square + 10
522.                         target = chess_board(to_square)
523.                         IF target = EMPTY THEN
524.                             Record_Move_Promotion from_square, to_square
525.                         END IF
526.  
527.                 END SELECT
528.             CASE WN
529.                 to_square = from_square + 8
530.                 target = chess_board(to_square)
531.                 action = white_target(target)
532.                 SELECT CASE action
533.                     CASE EMPTY_SQUARE
534.                         Record_Move from_square, to_square
535.                     CASE FRIENDLY_PIECE
536.                     CASE ENEMY_PIECE
537.                         Record_Capture from_square, to_square, target
538.                     CASE OFF_BOARD
539.                 END SELECT
540.                 to_square = from_square + 19
541.                 target = chess_board(to_square)
542.                 action = white_target(target)
543.                 SELECT CASE action
544.                     CASE EMPTY_SQUARE
545.                         Record_Move from_square, to_square
546.                     CASE FRIENDLY_PIECE
547.                     CASE ENEMY_PIECE
548.                         Record_Capture from_square, to_square, target
549.                     CASE OFF_BOARD
550.                 END SELECT
551.                 to_square = from_square + 21
552.                 target = chess_board(to_square)
553.                 action = white_target(target)
554.                 SELECT CASE action
555.                     CASE EMPTY_SQUARE
556.                         Record_Move from_square, to_square
557.                     CASE FRIENDLY_PIECE
558.                     CASE ENEMY_PIECE
559.                         Record_Capture from_square, to_square, target
560.                     CASE OFF_BOARD
561.                 END SELECT
562.                 to_square = from_square + 12
563.                 target = chess_board(to_square)
564.                 action = white_target(target)
565.                 SELECT CASE action
566.                     CASE EMPTY_SQUARE
567.                         Record_Move from_square, to_square
568.                     CASE FRIENDLY_PIECE
569.                     CASE ENEMY_PIECE
570.                         Record_Capture from_square, to_square, target
571.                     CASE OFF_BOARD
572.                 END SELECT
573.                 to_square = from_square - 8
574.                 target = chess_board(to_square)
575.                 action = white_target(target)
576.                 SELECT CASE action
577.                     CASE EMPTY_SQUARE
578.                         Record_Move from_square, to_square
579.                     CASE FRIENDLY_PIECE
580.                     CASE ENEMY_PIECE
581.                         Record_Capture from_square, to_square, target
582.                     CASE OFF_BOARD
583.                 END SELECT
584.                 to_square = from_square - 19
585.                 target = chess_board(to_square)
586.                 action = white_target(target)
587.                 SELECT CASE action
588.                     CASE EMPTY_SQUARE
589.                         Record_Move from_square, to_square
590.                     CASE FRIENDLY_PIECE
591.                     CASE ENEMY_PIECE
592.                         Record_Capture from_square, to_square, target
593.                     CASE OFF_BOARD
594.                 END SELECT
595.                 to_square = from_square - 21
596.                 target = chess_board(to_square)
597.                 action = white_target(target)
598.                 SELECT CASE action
599.                     CASE EMPTY_SQUARE
600.                         Record_Move from_square, to_square
601.                     CASE FRIENDLY_PIECE
602.                     CASE ENEMY_PIECE
603.                         Record_Capture from_square, to_square, target
604.                     CASE OFF_BOARD
605.                 END SELECT
606.                 to_square = from_square - 12
607.                 target = chess_board(to_square)
608.                 action = white_target(target)
609.                 SELECT CASE action
610.                     CASE EMPTY_SQUARE
611.                         Record_Move from_square, to_square
612.                     CASE FRIENDLY_PIECE
613.                     CASE ENEMY_PIECE
614.                         Record_Capture from_square, to_square, target
615.                     CASE OFF_BOARD
616.                 END SELECT
617.             CASE WB
618.                 to_square = from_square + 9
619.                 DO
620.                     target = chess_board(to_square)
621.                     action = white_targets(target)
622.                     SELECT CASE action
623.                         CASE EMPTY_SQUARE
624.                             Record_Move from_square, to_square
625.                             to_square = to_square + 9
626.                         CASE FRIENDLY_PIECE
627.                             EXIT DO
628.                         CASE ENEMY_PIECE
629.                             Record_Capture from_square, to_square, target
630.                             EXIT DO
631.                         CASE OFF_BOARD
632.                             EXIT DO
633.                     END SELECT
634.                 LOOP
635.                 to_square = from_square + 11
636.                 DO
637.                     target = white_targets(chess_board(to_square))
638.                     SELECT CASE target
639.                         CASE EMPTY_SQUARE
640.                             Record_Move from_square, to_square
641.                             to_square = to_square + 11
642.                         CASE FRIENDLY_PIECE
643.                             EXIT DO
644.                         CASE ENEMY_PIECE
645.                             Record_Capture from_square, to_square, target
646.                             EXIT DO
647.                         CASE OFF_BOARD
648.                             EXIT DO
649.                     END SELECT
650.                 LOOP
651.                 to_square = from_square - 9
652.                 DO
653.                     target = white_targets(chess_board(to_square))
654.                     SELECT CASE target
655.                         CASE EMPTY_SQUARE
656.                             Record_Move from_square, to_square
657.                             to_square = to_square - 9
658.                         CASE FRIENDLY_PIECE
659.                             EXIT DO
660.                         CASE ENEMY_PIECE
661.                             Record_Capture from_square, to_square, target
662.                             EXIT DO
663.                         CASE OFF_BOARD
664.                             EXIT DO
665.                     END SELECT
666.                 LOOP
667.                 to_square = from_square - 11
668.                 DO
669.                     target = white_targets(chess_board(to_square))
670.                     SELECT CASE target
671.                         CASE EMPTY_SQUARE
672.                             Record_Move from_square, to_square
673.                             to_square = to_square - 11
674.                         CASE FRIENDLY_PIECE
675.                             EXIT DO
676.                         CASE ENEMY_PIECE
677.                             Record_Capture from_square, to_square, target
678.                             EXIT DO
679.                         CASE OFF_BOARD
680.                             EXIT DO
681.                     END SELECT
682.                 LOOP
683.             CASE WR
684.                 to_square = from_square + 1
685.                 DO
686.                     target = white_targets(chess_board(to_square))
687.                     SELECT CASE target
688.                         CASE EMPTY_SQUARE
689.                             Record_Move from_square, to_square
690.                             to_square = to_square + 1
691.                         CASE FRIENDLY_PIECE
692.                             EXIT DO
693.                         CASE ENEMY_PIECE
694.                             Record_Capture from_square, to_square, target
695.                             EXIT DO
696.                         CASE OFF_BOARD
697.                             EXIT DO
698.                     END SELECT
699.                 LOOP
700.                 to_square = from_square + 10
701.                 DO
702.                     target = white_targets(chess_board(to_square))
703.                     SELECT CASE target
704.                         CASE EMPTY_SQUARE
705.                             Record_Move from_square, to_square
706.                             to_square = to_square + 10
707.                         CASE FRIENDLY_PIECE
708.                             EXIT DO
709.                         CASE ENEMY_PIECE
710.                             Record_Capture from_square, to_square, target
711.                             EXIT DO
712.                         CASE OFF_BOARD
713.                             EXIT DO
714.                     END SELECT
715.                 LOOP
716.                 to_square = from_square - 1
717.                 DO
718.                     target = white_targets(chess_board(to_square))
719.                     SELECT CASE target
720.                         CASE EMPTY_SQUARE
721.                             Record_Move from_square, to_square
722.                             to_square = to_square - 1
723.                         CASE FRIENDLY_PIECE
724.                             EXIT DO
725.                         CASE ENEMY_PIECE
726.                             Record_Capture from_square, to_square, target
727.                             EXIT DO
728.                         CASE OFF_BOARD
729.                             EXIT DO
730.                     END SELECT
731.                 LOOP
732.                 to_square = from_square - 10
733.                 DO
734.                     target = white_targets(chess_board(to_square))
735.                     SELECT CASE target
736.                         CASE EMPTY_SQUARE
737.                             Record_Move from_square, to_square
738.                             to_square = to_square - 10
739.                         CASE FRIENDLY_PIECE
740.                             EXIT DO
741.                         CASE ENEMY_PIECE
742.                             Record_Capture from_square, to_square, target
743.                             EXIT DO
744.                         CASE OFF_BOARD
745.                             EXIT DO
746.                     END SELECT
747.                 LOOP
748.             CASE WQ
749.                 to_square = from_square + 9
750.                 DO
751.                     target = white_targets(chess_board(to_square))
752.                     SELECT CASE target
753.                         CASE EMPTY_SQUARE
754.                             Record_Move from_square, to_square
755.                             to_square = to_square + 9
756.                         CASE FRIENDLY_PIECE
757.                             EXIT DO
758.                         CASE ENEMY_PIECE
759.                             Record_Capture from_square, to_square, target
760.                             EXIT DO
761.                         CASE OFF_BOARD
762.                             EXIT DO
763.                     END SELECT
764.                 LOOP
765.                 to_square = from_square + 11
766.                 DO
767.                     target = white_targets(chess_board(to_square))
768.                     SELECT CASE target
769.                         CASE EMPTY_SQUARE
770.                             Record_Move from_square, to_square
771.                             to_square = to_square + 11
772.                         CASE FRIENDLY_PIECE
773.                             EXIT DO
774.                         CASE ENEMY_PIECE
775.                             Record_Capture from_square, to_square, target
776.                             EXIT DO
777.                         CASE OFF_BOARD
778.                             EXIT DO
779.                     END SELECT
780.                 LOOP
781.                 to_square = from_square - 9
782.                 DO
783.                     target = white_targets(chess_board(to_square))
784.                     SELECT CASE target
785.                         CASE EMPTY_SQUARE
786.                             Record_Move from_square, to_square
787.                             to_square = to_square - 9
788.                         CASE FRIENDLY_PIECE
789.                             EXIT DO
790.                         CASE ENEMY_PIECE
791.                             Record_Capture from_square, to_square, target
792.                             EXIT DO
793.                         CASE OFF_BOARD
794.                             EXIT DO
795.                     END SELECT
796.                 LOOP
797.                 to_square = from_square - 11
798.                 DO
799.                     target = white_targets(chess_board(to_square))
800.                     SELECT CASE target
801.                         CASE EMPTY_SQUARE
802.                             Record_Move from_square, to_square
803.                             to_square = to_square - 11
804.                         CASE FRIENDLY_PIECE
805.                             EXIT DO
806.                         CASE ENEMY_PIECE
807.                             Record_Capture from_square, to_square, target
808.                             EXIT DO
809.                         CASE OFF_BOARD
810.                             EXIT DO
811.                     END SELECT
812.                 LOOP
813.                 to_square = from_square + 1
814.                 DO
815.                     target = white_targets(chess_board(to_square))
816.                     SELECT CASE target
817.                         CASE EMPTY_SQUARE
818.                             Record_Move from_square, to_square
819.                             to_square = to_square + 1
820.                         CASE FRIENDLY_PIECE
821.                             EXIT DO
822.                         CASE ENEMY_PIECE
823.                             Record_Capture from_square, to_square, target
824.                             EXIT DO
825.                         CASE OFF_BOARD
826.                             EXIT DO
827.                     END SELECT
828.                 LOOP
829.                 to_square = from_square + 10
830.                 DO
831.                     target = white_targets(chess_board(to_square))
832.                     SELECT CASE target
833.                         CASE EMPTY_SQUARE
834.                             Record_Move from_square, to_square
835.                             to_square = to_square + 10
836.                         CASE FRIENDLY_PIECE
837.                             EXIT DO
838.                         CASE ENEMY_PIECE
839.                             Record_Capture from_square, to_square, target
840.                             EXIT DO
841.                         CASE OFF_BOARD
842.                             EXIT DO
843.                     END SELECT
844.                 LOOP
845.                 to_square = from_square - 1
846.                 DO
847.                     target = white_targets(chess_board(to_square))
848.                     SELECT CASE target
849.                         CASE EMPTY_SQUARE
850.                             Record_Move from_square, to_square
851.                             to_square = to_square - 1
852.                         CASE FRIENDLY_PIECE
853.                             EXIT DO
854.                         CASE ENEMY_PIECE
855.                             Record_Capture from_square, to_square, target
856.                             EXIT DO
857.                         CASE OFF_BOARD
858.                             EXIT DO
859.                     END SELECT
860.                 LOOP
861.                 to_square = from_square - 10
862.                 DO
863.                     target = white_targets(chess_board(to_square))
864.                     SELECT CASE target
865.                         CASE EMPTY_SQUARE
866.                             Record_Move from_square, to_square
867.                             to_square = to_square - 10
868.                         CASE FRIENDLY_PIECE
869.                             EXIT DO
870.                         CASE ENEMY_PIECE
871.                             Record_Capture from_square, to_square, target
872.                             EXIT DO
873.                         CASE OFF_BOARD
874.                             EXIT DO
875.                     END SELECT
876.                 LOOP
877.             CASE WK
878.                 to_square = from_square + 9
879.                 target = chess_board(to_square)
880.                 action = white_target(target)
881.                 SELECT CASE action
882.                     CASE EMPTY_SQUARE
883.                         Record_Move from_square, to_square
884.                     CASE FRIENDLY_PIECE
885.                     CASE ENEMY_PIECE
886.                         Record_Capture from_square, to_square, target
887.                     CASE OFF_BOARD
888.                 END SELECT
889.                 to_square = from_square + 10
890.                 target = chess_board(to_square)
891.                 action = white_target(target)
892.                 SELECT CASE action
893.                     CASE EMPTY_SQUARE
894.                         Record_Move from_square, to_square
895.                     CASE FRIENDLY_PIECE
896.                     CASE ENEMY_PIECE
897.                         Record_Capture from_square, to_square, target
898.                     CASE OFF_BOARD
899.                 END SELECT
900.                 to_square = from_square + 11
901.                 target = chess_board(to_square)
902.                 action = white_target(target)
903.                 SELECT CASE action
904.                     CASE EMPTY_SQUARE
905.                         Record_Move from_square, to_square
906.                     CASE FRIENDLY_PIECE
907.                     CASE ENEMY_PIECE
908.                         Record_Capture from_square, to_square, target
909.                     CASE OFF_BOARD
910.                 END SELECT
911.                 to_square = from_square + 1
912.                 target = chess_board(to_square)
913.                 action = white_target(target)
914.                 SELECT CASE action
915.                     CASE EMPTY_SQUARE
916.                         Record_Move from_square, to_square
917.                     CASE FRIENDLY_PIECE
918.                     CASE ENEMY_PIECE
919.                         Record_Capture from_square, to_square, target
920.                     CASE OFF_BOARD
921.                 END SELECT
922.                 to_square = from_square - 9
923.                 target = chess_board(to_square)
924.                 action = white_target(target)
925.                 SELECT CASE action
926.                     CASE EMPTY_SQUARE
927.                         Record_Move from_square, to_square
928.                     CASE FRIENDLY_PIECE
929.                     CASE ENEMY_PIECE
930.                         Record_Capture from_square, to_square, target
931.                     CASE OFF_BOARD
932.                 END SELECT
933.                 to_square = from_square - 10
934.                 target = chess_board(to_square)
935.                 action = white_target(target)
936.                 SELECT CASE action
937.                     CASE EMPTY_SQUARE
938.                         Record_Move from_square, to_square
939.                     CASE FRIENDLY_PIECE
940.                     CASE ENEMY_PIECE
941.                         Record_Capture from_square, to_square, target
942.                     CASE OFF_BOARD
943.                 END SELECT
944.                 to_square = from_square - 11
945.                 target = chess_board(to_square)
946.                 action = white_target(target)
947.                 SELECT CASE action
948.                     CASE EMPTY_SQUARE
949.                         Record_Move from_square, to_square
950.                     CASE FRIENDLY_PIECE
951.                     CASE ENEMY_PIECE
952.                         Record_Capture from_square, to_square, target
953.                     CASE OFF_BOARD
954.                 END SELECT
955.                 to_square = from_square - 1
956.                 target = chess_board(to_square)
957.                 action = white_target(target)
958.                 SELECT CASE action
959.                     CASE EMPTY_SQUARE
960.                         Record_Move from_square, to_square
961.                     CASE FRIENDLY_PIECE
962.                     CASE ENEMY_PIECE
963.                         Record_Capture from_square, to_square, target
964.                     CASE OFF_BOARD
965.                 END SELECT
966.             CASE WC
967.                 to_square = from_square + 9
968.                 target = chess_board(to_square)
969.                 action = white_target(target)
970.                 SELECT CASE action
971.                     CASE EMPTY_SQUARE
972.                         Record_Move from_square, to_square
973.                     CASE FRIENDLY_PIECE
974.                     CASE ENEMY_PIECE
975.                         Record_Capture from_square, to_square, target
976.                     CASE OFF_BOARD
977.                 END SELECT
978.                 to_square = from_square + 10
979.                 target = chess_board(to_square)
980.                 action = white_target(target)
981.                 SELECT CASE action
982.                     CASE EMPTY_SQUARE
983.                         Record_Move from_square, to_square
984.                     CASE FRIENDLY_PIECE
985.                     CASE ENEMY_PIECE
986.                         Record_Capture from_square, to_square, target
987.                     CASE OFF_BOARD
988.                 END SELECT
989.                 to_square = from_square + 11
990.                 target = chess_board(to_square)
991.                 action = white_target(target)
992.                 SELECT CASE action
993.                     CASE EMPTY_SQUARE
994.                         Record_Move from_square, to_square
995.                     CASE FRIENDLY_PIECE
996.                     CASE ENEMY_PIECE
997.                         Record_Capture from_square, to_square, target
998.                     CASE OFF_BOARD
999.                 END SELECT
1000.                 to_square = from_square + 1
1001.                 target = chess_board(to_square)
1002.                 action = white_target(target)
1003.                 SELECT CASE action
1004.                     CASE EMPTY_SQUARE
1005.                         Record_Move from_square, to_square
1006.                     CASE FRIENDLY_PIECE
1007.                     CASE ENEMY_PIECE
1008.                         Record_Capture from_square, to_square, target
1009.                     CASE OFF_BOARD
1010.                 END SELECT
1011.                 to_square = from_square - 9
1012.                 target = chess_board(to_square)
1013.                 action = white_target(target)
1014.                 SELECT CASE action
1015.                     CASE EMPTY_SQUARE
1016.                         Record_Move from_square, to_square
1017.                     CASE FRIENDLY_PIECE
1018.                     CASE ENEMY_PIECE
1019.                         Record_Capture from_square, to_square, target
1020.                     CASE OFF_BOARD
1021.                 END SELECT
1022.                 to_square = from_square - 10
1023.                 target = chess_board(to_square)
1024.                 action = white_target(target)
1025.                 SELECT CASE action
1026.                     CASE EMPTY_SQUARE
1027.                         Record_Move from_square, to_square
1028.                     CASE FRIENDLY_PIECE
1029.                     CASE ENEMY_PIECE
1030.                         Record_Capture from_square, to_square, target
1031.                     CASE OFF_BOARD
1032.                 END SELECT
1033.                 to_square = from_square - 11
1034.                 target = chess_board(to_square)
1035.                 action = white_target(target)
1036.                 SELECT CASE action
1037.                     CASE EMPTY_SQUARE
1038.                         Record_Move from_square, to_square
1039.                     CASE FRIENDLY_PIECE
1040.                     CASE ENEMY_PIECE
1041.                         Record_Capture from_square, to_square, target
1042.                     CASE OFF_BOARD
1043.                 END SELECT
1044.                 to_square = from_square - 1
1045.                 target = chess_board(to_square)
1046.                 action = white_target(target)
1047.                 SELECT CASE action
1048.                     CASE EMPTY_SQUARE
1049.                         Record_Move from_square, to_square
1050.                     CASE FRIENDLY_PIECE
1051.                     CASE ENEMY_PIECE
1052.                         Record_Capture from_square, to_square, target
1053.                     CASE OFF_BOARD
1054.                 END SELECT
1055.             CASE BP
1056.  
1057.             CASE BN
1058.  
1059.             CASE BB
1060.  
1061.             CASE BR
1062.  
1063.             CASE BQ
1064.  
1065.             CASE BK
1066.  
1067.             CASE BC
1068.  
1069.         END SELECT
1070.     LOOP
1071. END SUB
1072.  
1073. SUB Make_Move (i AS INTEGER)
1074.  
1075. END SUB
1076.  
1077. SUB Take_Back
1078.  
1079. END SUB
1080.  
1081. SUB Search_One_Q (alpha AS INTEGER, beta AS INTEGER)
1082.     Generate_Moves
1083.     i = move_stack_index(ply)
1084.     WHILE move_stack(i).special <> TERMINATE
1085.         Make_Move i
1086.         move_stack(i).score = Qsearch(alpha, beta)
1087.         Take_Back
1088.         i = i - 1
1089.     WEND
1090. END SUB
1091.  

[TempodiBasic]

Hi Mike
thanks to continue to show your work here.

I'm very interested to see how you build this chess engine, but I'm beginner in this kind of programming in chess engine,
so searching to follow your code has let me understand many things, starting why offset of moves of pieces that goes together a  monodimensional managing of chessboard and  a chessboard of 120 cells.

about your last code I have lost meself in the long SUB Generating_Moves  but with some time it will be clearer at my eyes.

I want to report these 2 stranges part that logically brings me to think that there is an error of typing...

Code: QB64: [Select]

1. DIM SHARED white_target(40) AS _BYTE
2.  
3. DATA EMPTY,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,0,0
4. DATA EMPTY,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EK,EK,0,OB
5.  
6. FOR i = 0 TO 99: READ white_target(i): NEXT
7.  
8.  
9. DIM SHARED black_target(40) AS _BYTE
10.  
11. DATA EMPTY,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EK,EK,0,0
12. DATA EMPTY,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,0,OB
13.  
14. FOR i = 0 TO 99: READ black_target(i): NEXT

Here i runs until 99 but it seems there are only 40 DATA to read and white_data() and balck_data() have 41 items

----------------

Code: QB64: [Select]

1. DIM SHARED royal_offsets AS _BYTE
2.  
3. DATA 1,9,10,11,-1,-9,-10,-11
4.  
5. FOR i = 0 TO 7: READ royal_offsets(i): NEXT
6.  
7.  
8. DIM SHARED knight_offsets AS _BYTE
9.  
10. DATA 8,12,19,21,-8,-12,-19,-21
11.  
12. FOR i = 0 TO 7: READ knight_offsets(i): NEXT
13.  

Here instead royal_offsets and knight_offsets are not DIMmed as array...

Thanks to read

[romichess]

Hi Mike
thanks to continue to show your work here.

I'm very interested to see how you build this chess engine, but I'm beginner in this kind of programming in chess engine,
so searching to follow your code has let me understand many things, starting why offset of moves of pieces that goes together a  monodimensional managing of chessboard and  a chessboard of 120 cells.

about your last code I have lost meself in the long SUB Generating_Moves  but with some time it will be clearer at my eyes.

I want to report these 2 stranges part that logically brings me to think that there is an error of typing...

Code: QB64: [Select]

1. DIM SHARED white_target(40) AS _BYTE
2.  
3. DATA EMPTY,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,0,0
4. DATA EMPTY,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EK,EK,0,OB
5.  
6. FOR i = 0 TO 99: READ white_target(i): NEXT
7.  
8.  
9. DIM SHARED black_target(40) AS _BYTE
10.  
11. DATA EMPTY,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EP,EK,EK,0,0
12. DATA EMPTY,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,FP,0,OB
13.  
14. FOR i = 0 TO 99: READ black_target(i): NEXT

Here i runs until 99 but it seems there are only 40 DATA to read and white_data() and balck_data() have 41 items

----------------

Code: QB64: [Select]

1. DIM SHARED royal_offsets AS _BYTE
2.  
3. DATA 1,9,10,11,-1,-9,-10,-11
4.  
5. FOR i = 0 TO 7: READ royal_offsets(i): NEXT
6.  
7.  
8. DIM SHARED knight_offsets AS _BYTE
9.  
10. DATA 8,12,19,21,-8,-12,-19,-21
11.  
12. FOR i = 0 TO 7: READ knight_offsets(i): NEXT
13.  

Here instead royal_offsets and knight_offsets are not DIMmed as array...

Thanks to read

Ah yes, thank you!

[romichess]

Let me try to explain the move generator a little better then. Using lots of IF statements in a chess engine is a performance killer. I avoid IF statements whenever possible. In C there are two choices. A switch (SELECT CASE) statement and an array of function pointers. These days I'd use the function pointers which is called a jump table. C/C++ compilers can make jump tables out of switch statements but it is hit and miss. C/C++ compilers can also substitute IF statement for switch cases if there are not enough cases. That is why I'd use function pointer arrays to take all decisions away from the compiler. As far as I know I do not have that choice in QB64? So all I can do in QB64 is use the theoretically best approach and hope that QB64 and Mingw64 do a good job. With that said let's look at the code.

There is an array of 40 type piece. The piece[0].nxt holds the first white piece and piece[20].nxt holds the first black piece. And start_index(wtm) gives either 0 or 20.
Therefore we get the first piece like so: piece_index = next_piece(start_index(wtm)).
Okay, I see that I changed the data and did not change the code, oops. So make that: 
piece_index = piece(start_index(wtm)).nxt. I'm really sorry about that, too many senior moments. Anyway, now that we have the first piece we can find its from square: from_square = piece(piece_index).squ. When we are done with the piece we get the next piece at the end of the main loop like this: piece_index = piece(piece_index).nxt. And I have not added that yet, another oops. So yes, it would be hard to understand in such an incomplete state, my bad :(. Now that we have the from square, we look up the type of piece it is. Did I mention that on the chessboard are indexes, not piece types. That is why we have to use the piece index to look up its type: SELECT CASE piece(piece_index).typ. The pawns will take more study. Essentially they are treated as 12 different types depending on which square they are on. For example X2R is a white pawn on rank 2 or a black pawn on rank 7 on file 1 and therefore they need not check for a left capture thus the X. A white pawn on rank 2 away from an edge file is L2R. And the 2 means it can move one or two squares. This is all done to avoid a plethora of IF statements. Also, why make checks that can be avoided all at the cost of one SELECT CASE statement. In the pawn cases 2 is double move, 1 is single, E is check for en passant and P is promotion.

The knights are much more simple. The knight moves can be done in a loop executed 8 times. However, it is faster to "unroll the loop" and repeat the code 8 times.

            CASE WN
                to_square = from_square + 8 'one up and two to the left
                target = chess_board(to_square) 'EMPTY, piece_index or off-edge square
                action = white_target(target) 'exactly the action to take
                SELECT CASE action
                    CASE EMPTY_SQUARE
                        Record_Move from_square, to_square
                    CASE FRIENDLY_PIECE
                    CASE ENEMY_PIECE
                        Record_Capture from_square, to_square, target
                    CASE OFF_BOARD
                END SELECT 'on to the next offset

The sliders are more fun! Once again we unroll the outer loop.

            CASE WB
                to_square = from_square + 9 'prime first to square, up and to the left
                DO
                    target = chess_board(to_square) same as for knight
                    action = white_targets(target)
                    SELECT CASE action
                        CASE EMPTY_SQUARE
                            Record_Move from_square, to_square
                            to_square = to_square + 9 'This time we are in a do loop, next t_s
                        CASE FRIENDLY_PIECE
                            EXIT DO 'we exit the loop when we can't go further
                        CASE ENEMY_PIECE
                            Record_Capture from_square, to_square, target
                            EXIT DO
                        CASE OFF_BOARD
                            EXIT DO
                    END SELECT
                LOOP

More will become clear. For example the various record move subs will not return right away. They will call the capture only search to resolve captures and add a score to each move. This must be done at the leafs of the tree anyway and doing it for every move in the tree cost very little and has huge benefits. The first is that in the gen all moves routine there is no ENEMY_KING case because only legal moves are generated as the capture search will catch any illegal move and not record it. And having a score for move ordering is huge because the alpha-beta routine performs more spectacularly the better the move ordering is. The end result is that there will be a legal (as opposed to pseudo legal) list of moves that we can do a one pass sort to find the move with the best score to try first. And if it is the best move a huge amount of the search tree will be beta pruned.

I hope this helps. :))