Chess

[+Al_Nafuur]

it works on Stella 6.0.2:

 

but not in 6.2.1:

 

and not 6.3_pre:

 

[zbyti]

For quick (post-mortem) game check

 

https://lichess.org/analysis

 

 

https://www.chess.com/analysis

 

Edited August 31, 2020 by zbyti
post-mortem ;)

[zbyti]

Clash of the Titans!

 

Commodore Chessmate on Lv. 8 (average time per move 1 min, from few seconds up to ~2 min). Opponent picket from this roster https://www.schach-computer.info/wiki/index.php?title=1978

 

xboard -fcp "mame -w -plugin chessengine chmate"

 

BitChess was running in Turbo Mode :]

 

I stopped the game in the end because it's a waste of life

 

[Event "Computer Chess Game"]
[Site "X201"]
[Date "2020.08.31"]
[Round "-"]
[White "Chessmate (mame 0.221)"]
[Black "BitChess Atari2600 (chess20200819_4PQ4)"]
[Result "1/2-1/2"]
[TimeControl "Level 8"]

1. e4 e5 2. Nf3 Bb4 3. Nxe5 Qg5 4. Nf3 Qf4 5. Nc3 Nf6 6. d3 Qg4 7. Ne5
Qxd1+ 8. Kxd1 d6 9. Nc4 Bg4+ 10. Be2 Bxe2+ 11. Nxe2 Nc6 12. Bg5 O-O-O 13.
a3 b5 14. axb4 bxc4 15. dxc4 Nxe4 16. Bxd8 Nxf2+ 17. Kd2 Nxh1 18. Bxc7 Kxc7
19. Rxh1 Kc8 20. b5 Ne5 21. b3 Rd8 22. Ra1 Kb7 23. Ra6 f6 24. h3 d5 25.
cxd5 Rxd5+ 26. Kc3 Rc5+ 27. Kd4 Rxc2 28. Nf4 Rf2 29. Ke3 Rc2 30. Re6 Rc3+
31. Kd4 Rxb3 32. Re7+ Kb8 33. Re8+ Kb7 34. Re7+ Kb8 35. Re8+ Kb7 36. Kc5
Rc3+ 37. Kd6 Rc2 38. Re7+ Kb6 39. Rxg7 Rd2+ 40. Nd5+ Kxb5 41. Rb7+ Ka6 42.
Rg7 h5 43. Ke6 h4 44. Nxf6 Nc6 45. Ne4 Rb2 46. Nc5+ Ka5 47. Nb7+ Kb6 48.
Nd6 Re2+ 49. Kd7 Nd4 50. Nc8+ Kb7 51. Nd6+ Kb6 52. Nc4+ Kb7 53. Na5+ Kb6
54. Nc4+ {game claimed a draw by zbyti} 1/2-1/2

 

 

 

Edited August 31, 2020 by zbyti
info about turbo mode

[zbyti]

Chafitz Boris diplomat no opening, 1 min fixed per move.

 

 

[Event "Computer Chess Game"]
[Site "X201"]
[Date "2020.08.31"]
[Round "-"]
[White "Boris (rev. 01) (mame 0.221)"]
[Black "BitChess (Atari2600) (chess20200819_4PQ4)"]
[Result "*"]
[TimeControl "Boris 1 min fixed"]

1. Nc3 e5 2. Nf3 Nc6 3. d4 Nxd4 4. Nxe5 c5 5. e3 d6 6. exd4 dxe5 7. Bb5+
Bd7 8. dxe5 Bxb5 9. Qxd8+ Rxd8 10. Nxb5 Be7 11. Nxa7 c4 12. Be3 Rd5 13. f4
f5 14. Rc1 Ra5 15. Ra1 Bh4+ 16. Ke2 c3 17. bxc3 Nh6 18. Rhb1 Ng4 19. Rxb7
Nxe3 20. Kxe3 Ra3 21. Nb5 Ra5 22. Nd6+ Kf8 23. Rb8+ Ke7 24. Nxf5+ Ke6 25.
Nxg7+ Kf7 26. Rxh8 Kxg7 27. Rc8 Ra6 28. a4 Be7 29. g4 Rb6 30. Rd1 Rb7 31.
e6 Rb6 32. f5 Bg5+ 33. Ke2 Rb7 34. Kf3 Bf6 35. Kf4 h6 36. Kf3 Kh7 37. Rd2
Be5 38. Rc5 Bf6 39. Rd1 Be7 40. Rc8 Bf6 41. Rd2
{bored to death waiting for Rd7...}

 

Edited August 31, 2020 by zbyti
mame screenshot

[+Andrew Davie]

13 minutes ago, zbyti said:

Chafitz Boris diplomat no opening, 1 min fixed per move.

Interesting - from all these games its' clear that the evaluation routine is favouring mobility far too much - and in any case the quiescence search is also way too small.  Here's an update with those two issues fixed.  It will be interesting to see if you consider the gameplay any different.  But in any case, it's totally a work-in-progress at the moment. The game has no concept of endgame, or any idea of chess strategy. I'll get there, but my schedule has always been "a couple of years"... it's just a baby at the moment.

Also, I'm chasing that bug why it doesn't work on 5PQ8 and it appears I have a serious issue somewhere. I have no idea if this one runs on hardware at the moment - that's obviously got to be my top priority.

 

As an aside, Stella has a "developer mode" which randomises stuff at startup. My game fails in developer mode, so I have some missing initalisation and/or assumptions made. Whoops.

 

chess20200901_4PQ6.bin
 

 

 

[zbyti]

[Date "2020.08.31"]
[White "zbyti"]
[Black "chess20200901_4PQ6"]

1. e4 e5
2. Bc4 Bc5      ; better then previous Bb4
3. Nf3 Qf6      ; premature Queen move
4. d3 Bb4+      ; useless check
5. c3 d5        ; useless pawn sacrifice
6. Bxd5 c6      ; tacticall error
7. Bxf7+ Kxf7   
8. Qb3+ Be6
9. Qxb4 Nd7     ; further material lose
10. Qxb7 Rb8
11. Qxa7 h6
12. Nbd2 Kg6    ; King on the run? ;)
13. Qe3 Qf7
14. b3 Ngf6
15. h3 Rbc8
16. Ba3

 

Edited August 31, 2020 by zbyti
add comment to game score

[zbyti]

[Date "2020.08.31"]
[White "zbyti"]
[Black "chess20200901_4PQ6"]
[Result "1-0"]

1. e4 e5
2. f4 exf4      {it's new}
3. Nf3 Nf6
4. e5 Bc5       {knight for nothing}
5. exf6 Qxf6
6. d4 Bb4+      {helped me develop}
7. c3 Bd6       {he blocked his own pieces, bad protection}
8. Bc4 O-O
9. O-O Nc6
10. Nbd2 Re8
11. Re1 Re3
12. Ne4 Rxe1+
13. Qxe1 Qf5    {missed the checkmate on the first line}
14. Nxd6 Qe6
15. Bxe6 dxe6
16. Nxc8 Rxc8
17. Bxf4 Ne7
18. Qg3 Nf5
19. Qg4 c6
20. Nh4 Nxh4    {don't exchange if you lose, especially if it's not a mating piece}
21. Qxh4 f6
22. Re1 e5
23. dxe5 Re8
24. exf6 Rxe1+  {don't exchange if you lose, especially if it's not a mating piece}
25. Qxe1 gxf6
26. Qe7 a5
27. Bh6 f5
28. Qf8#
{White mates} 1-0

 

[zbyti]

@Andrew Davie could you be so kind and recap your work on chess engine (without UI)?

 

About a year I have a dream to write chess engine on 6502 too, I gather materials, played with historical engines etc. to keep my motivation

 

If you recap in short how to start to develop 8-bit engine I will be grateful :]

 

Thanks in advance  

[zbyti]

To cheer you up - Boris Diplomat drop pieces too

[Event "Computer Chess Game"]
[Site "X201"]
[Date "2020.08.31"]
[Round "-"]
[White "zbyti"]
[Black "Boris (rev. 01) (mame 0.221)"]
[Result "1-0"]
[TimeControl "Boris 1:20 min per move"]

1. e4 d5 2. exd5 e6 3. dxe6 Bxe6 4. d4 Nc6 5. Nf3 Be7 6. Bb5 Bb4+ 7. c3 Bd6
8. d5 a6 9. dxe6 axb5 10. exf7+ Kxf7 11. Ng5+ Ke8 12. O-O Qe7 13. Re1 Ne5
14. f4 h6 15. Ne4 Bc5+ 16. Nxc5 Qxc5+ 17. Be3 Qc4 18. fxe5 Qa4 19. Qh5+ Ke7
20. Bc5+ Kd8 21. Qf7 Qc2 22. Na3 Qxb2 23. Rad1+ Qd2 24. Rxd2+ Kc8 25. Qe8#
{Xboard adjudication: Checkmate} 1-0

 

Visible counters count down from 60 minutes to 0. I used ~15 min.

 

Edited August 31, 2020 by zbyti
info about counters

[zbyti]

 

[+Andrew Davie]

2 hours ago, zbyti said:

@Andrew Davie could you be so kind and recap your work on chess engine (without UI)?

 

About a year I have a dream to write chess engine on 6502 too, I gather materials, played with historical engines etc. to keep my motivation

 

If you recap in short how to start to develop 8-bit engine I will be grateful :]

 

Thanks in advance  

 

Probably the first thing to do is figure out how to represent the pieces on the board.

I settled on an array (not 8x8, but actually 10 across x 12 high). Why?  Because of the knight movement.

The reason for that will become clear when I discuss generation of valid moves.

Once you have the board representation settled, you actually have to put pieces on the board. There are black pieces, white pieces, and of course each of these is either pawn, knight, bishop, rook, queen or king. So at the moment, my implementation has the pieces all on the same board, one piece per square, or the square is empty. I just used numbers for the pieces, and I happen to use a different number for black pawns and white pawns but this is not a normal implementation. Doesn't really matter.

So, with a board format settled, and pieces on the board, now you have to generate the moves for either white or black.

Here's one of the areas where I will improve things. Currently I just scan the board (not all squares, just the valid 8x8 squares). When I find a piece of the right colour (we're either generating moves for white, or for black)... then I use the piece type to vector to a subroutine that calculates moves for that piece on the given square.

Now, pawns can move "forward" (up the board if they're white, down if they're black). If they reach the final rank, then they can promote (to either knight, rook, bishop, or queen). If they are on their initial square, they can move +2 rows. If there is an opponent on a diagonal, they can take that piece and move to the square it occupied. If they are on a square which is adjacent to an opponent's pawn that has just moved +2, then they can capture that opponent pawn and occupy the +1 square. So, surprisingly, the pawns are actually the most complex pieces to actually generate moves for.  And what is "generating a move"?  Well, it's calculating a valid square to move to, and then putting a description of that move in a "move list".  So, the move list needs to contain enough information so that we can make that move at some later point. So for me it contains the "from" square, the "to" square, the new piece type, and the "capture" square.  

If we encounter a knight, then it moves to squares +12, +21, +19, +8, -12, -21, -19, -8.  Now, some of those squares may be "off the board", and here's where/why I use a 10x12 implementation of the board. If I take the current square of the knight, and add one of those offsets, I get the new square for the knight. Let's say we have the knight on b1. That's square #23 in my board layout (bottom left square is 22, then moving up the rows along column a, we have squares 32, 42, 52, 62, 72, 82, 92).  So, squares 22 - 29 inclusive are valid squares, as are 32-39, 42-49 etc.  Back to our knight on #23,  We add offset +12, to get square #35.  That's valid, so we check that the square is valid and either empty, or contains an opponent piece. If those conditions are met, we add the move into the move list. Now what do I mean by "the square is valid"?  Well, it must be in the range 22-29, 32-39 .... 92-99.  And to make that quick, I have a "valid square" array and I just use the new square number as an index into that, to get if the move is valid.  The valid array is also a 10x12 array and it's purely to make things quick when determining if squares are valid. It stops knights moving off board. It prevents queens, bishops, rooks, from extending their moves infinitely. In short, it's a bounding box of sorts. Only the 64 chessboard squares in that 10x12 array are marked as "valid" and so when each piece calculates a square to move to, it checks via the array to see if the new square is valid.

So, bishops, rooks, queens... these just loop with indexes  +1, -1, +10, -10 (for rooks, queens) and +11, +9, -11, -9 (for bishops, queens) to extend "rays" from the current square.  Each new square we check for valid (if not, end the ray projection). If valid, check for an opponent piece. Add the move to the move list. If there was an opponent piece, end the ray.

And the king of course just checks squares +1, -1, +10, -10, +9, +11, -9, -11.

Finally check is handled by actually getting into a situation where you are generating moves and you find you can capture the opponent's king. If that happens, then it sets a flag and aborts the move generation immediately, because capturing an opponent's king is actually "illegal" in terms of the PREVIOUS move made by the opponent left himself in check, and that mean the previous move was illegal. So in the search we're basically making a move, swapping black/white turn, listing all moves. If the check flag is set, return and indicate last move was illegal. Otherwise, pretty much repeat the previous process.

Now, once you have a board representation, and you have the ability to list moves. And we also have the ability to detect check...

Now we need to actually choose a move. And that's the tree search.

I'm sure you've read up on various algorithms - but in summary the simplest form of search is "minimax", a recursive best of the worst of the best of the worst....  the basic premise being that each side will choose the best possible move for that side, so when I choose my best move, it's based on the move where the opponent has chosen a move that's best for him (i.e., worst for me). And he did the same.  So at the very "bottom" of the search tree we have some "evaluation" of the board position at that point, and the "which move do I choose" at that bottom level is based on maximising the evaluation score. Literally, choose the "best" move is just choose the move with the highest score.  And at that point we are moving back up the tree. We choose move "x" because its value is (say) 54.  Back one level up, the other side knows that if it makes move "y" (the one just made before this), then his opponent can score (at best) 54.  Is 54 a better move for me than the best move found so far?  If yes, then we have a new move to prefer. If not, we shouldn't make the move just tested, because we know the opponent can (at best) get to a position worth 54, and that's worse than our current option. That may not be explained too well, but in short, each player at every move is assumed to make the best move possible. And the best move for that player is to minimise the score for the opponent.

So, minimax checks every possible move and every possible reply and every reply to that reply, etc. That's why searching can be so slow/tedious.

Then along came "alpha beta pruning". And it goes something like this -- If I already know that I can get to some position worth (say) 100 -- and remember I'm trying to maximise this value.  Well, when the opponent is looking at his best options, if he gets to a position where he can guarantee a score of 80 (better for him) while checking his moves -- well at that point I already know I wouldn't choose that particular move I made -- because I can get 100 already, and that's better than the (so far) best of 80 that the opponent can achieve. I'm just going to say "no thanks" and move on to my next move. So the prune at this stage aborts checking the opponent moves. The opponent can make things worse for me than if I chose the move I already have as my best.... so I'm not going to make that worse move. Prune.

This pruning goes along all the way down the tree -- and it can be effective. Particularly effective if the moves are sorted, and we're more likely to have "good/best" moves early on - because these lead to more pruning of the search nodes, and thus a quicker search. Minimax branching factor (average moves per player) is about 30+.  If you use alpha-beta pruning and decent searching, this can be reduced to something small (say 5 moves/player).  So in a 5 ply search, instead of visiting 30^5 positions, you only visit 3^5 positions.

So, sorting is very important. How do you do that?  Well, I've played around with several things -- for example putting captures first in the move list. Generating moves for non-pawns first, then pawns. These all work, but not hugely different. The next option (currently being implemented) is to do a mini-search (2 ply) first. That is, before searching to depth n, we do a search to depth 2. At that point we have an evaluation for each move of the best position for me, but two moves later.  Sort according to those evaluations, and we have a relatively good sorted move list.  Hopefully with good moves early on we will gain great benefits from the alpha-beta pruning.  Now alpha-beta has a slight variant called "negamax". This is mostly an implementation detail which greatly simplifies the code. Rather than handling white/black and increasing score or decreasing score on alternate levels, negamax fiddles with the evaluations/scores so that the same subroutines can be used and always try to maximise score, etc. It's just a cleaner bit of coding but operates the same as alpha-beta.

Back to the sort - well, isn't it expensive to do a 2-ply search on every move?  Well, yes. But it's less expensive than doing a search with a poorly sorted move list at each level. In other words we gain back the speed penatly and much more by doing that 2-ply search (which might examine 30x30 = about 1000 positions). 

The final piece of the implementation is the "evaluation".  This is what determines at the "leaf" nodes of the search tree (i.e., the very bottom of the search depth) the actual value of a board position. Now in my current implementation this evaluation consists of....  1. the material value of the pieces on the board (+for white, - for black).  Each piece has some numerical value indicating its relative worth to the other pieces. Currently I use P=100, N=325, B=350, R=525, Q=900, K=10000.  This basically controls piece exchanges - the relative value of each piece and if it's worth losing it for another piece. Another factor added to the value of a board position is the square each piece sits on. Pawns are more valuable if they are further up the board, but also in the center columns. Rooks are valuable on the 7th row.  In this way, some rudimentary knowledge about position is given. It is these position value tables that help to drive the opening moves/strucutre. Another factor in the evaluation is "mobility". If I have 20 moves available on the final board position, then I consider this more valuable than having 10. The # moves is therefore added to the evaluation. And finally I add a small (and reducing) random factor to encourage variations in openings for moves that would otherwise be fairly equal. Balancing the relative weight of all these is what makes the evaluation tricky, and ultimately it is the evaluation algorithm that controls the whole personality of the game.

Now I have a working implementation, but its playing skills are rudimentary. It has no innate "chess knowledge" - and it should be clear now that to achieve that, I put bonuses and penalties into the evaluation routine. I've been avoiding that as long as possible, because it's the evaluation routine that is called an umpteen gazillion times, so packing it with knowlege can be expensive time-wise. It slows the move selection. But on the other hand, a good evaluation routine can significantly improve the alpha-beta pruning, so there's a balance there.

All these current testing/games are interesting/fun - but given the extremely simple and completely-devoid-of-strategy evaluation routine I'm currently using, the game is doing OK.

So I have a clear pathway on how to improve things.

1) strategy into the evaluation routine

2) sorting the move list, leading to better alpa-beta pruning

3) more efficient move generation

SO on that last point, the idea is that instead of scanning 10x12 board to find the pieces I can move, instead we have a list of my pieces and we just scan that list. At most I have 16 pieces, so if we have a list of them then that's just 16 to scan, rather than (potentially) 100 squares to look at. Given the move generation happens on every level of the search, it can be pretty significant.

 

Well, hopefully that's.going to give you a reasonable idea of how the program is working at the moment.

 

 

 

 

 

[zbyti]

34 minutes ago, Andrew Davie said:

Well, hopefully that's.going to give you a reasonable idea of how the program is working at the moment.

Thank you very much! I will try my hand (using what you wrote) in Mad Pascal on Atari 800XL :]

[Keatah]

Love the insight into how this is being developed. Only understand about half of it. But I like to keep it that way, too. Always something to learn later on. Replay value, you know?

[zbyti]

7 hours ago, Andrew Davie said:

SO on that last point, the idea is that instead of scanning 10x12 board to find the pieces I can move, instead we have a list of my pieces and we just scan that list. At most I have 16 pieces, so if we have a list of them then that's just 16 to scan, rather than (potentially) 100 squares to look at. Given the move generation happens on every level of the search, it can be pretty significant.

https://www.chessprogramming.org/Piece-Lists ?

[+Andrew Davie]

Well, here's where it all happens. My workspace. Kind of cramped, and not terribly pretty. It is what it is.

That's a 3D printer on the right side, and on the left I'm running a PlusCart in an NTSC '2600 on top of a "found" TV.
The '2600 was very kindly sent by @McCallister and I use it every day - much appreciated.

The PlusCart is by @Al_Nafuur, of course - and I'm really impressed by the work he has done on this and the backend. Amazing.

 

It's a pretty amazing device, and it takes a bit of getting used to how it all works. But basically it connects to the local wifi network, and from there it has internet access. it then connects to the "Plus Store" which isn't really just a store -- it's a repository of ROMs. Lots of them. Basically I have access to pretty much the complete '2600 library through menus on the PlusCart. I see something interesting, and I can select it from the menu and a few seconds later I'm actually playing it.

 

The pluscart menus are dynamic (an amazing/astounding number of characters/line - pretty much a full text screen on the '2600 - I believe the magic was by @Thomas Jentzsch which shouldn't surprise anyone. But it's super cool and makes the machine with menus just super-handy).  So anyway, the meus... they retreive their stuff from the plus store on-the-fly. New ROMs are added every day.... a new homebrew release (including mine!) are on the store within the day. I don't have to go hunting for stuff - it's all there. I want to check out a ROM... just go to the menu, a few seconds work, choose the ROM... it's playing on my machine after a few seconds of download.

 

And to "upload" to it, well I don't really do that. I have a "live" folder on my machine (via Nextcloud). The plusstore provides Nextcloud storage/acts as a server. So when I put stuff in that folder, it's automatically uploaded to my personal folder on the PlusStore, and from there the PlusCart sees it. Pretty weird, but that's all i do -- assemble, copy the file to the local folder, and it's on my '2600 to test if I want. Automatically. Magic.

 

I really really like the PlusCart - it's so different/original/unique.  I totally highly recommend this device - it's a total game changer as to what you can do with your '2600. I hope to get some functionality into the chess program to take advantage of this - like automatically downloading moves of games to play/review/check. Correspondence chess where you can play with someone offline, and just turn on your pluscart chess and you get notifications if any of your games have had your opponent move, and then download all the moves for that game and you're ready to make a move. Lots of really cool stuff.

 

So, that's my workspace, as noted. And the magical Pluscart.

 

Now to something less magical; my chess program...

 

 

On the TV you can see the game I just played. Now, seeing @zbyti making such oddball moves in the sample games, I thought I'd do something different, and concentrated on opening things up for my bishop. Well all of 4 moves later, the program checkmated me. This must be the fastest mate ever... a source of great embarrasment and pride at the same time. Oh well, I'm not the greatest of chess players, that much is certain. Still, I think this is almost my fastest loss ever

 

[zbyti]

@Andrew Davie shame on you  you missed mate in one  

 

But seriously, you can see an advantage in developing a Bishop on c5 (and the importance of the f2 square), previously your program preferred Bb4.

Edited September 1, 2020 by zbyti
mate in one

[+Al_Nafuur]

42 minutes ago, Andrew Davie said:

Well, here's where it all happens. My workspace. Kind of cramped, and not terribly pretty. It is what it is.

That's a 3D printer on the right side, and on the left I'm running a PlusCart in an NTSC '2600 on top of a "found" TV.
The '2600 was very kindly sent by @McCallister and I use it every day - much appreciated.

The PlusCart is by @Al_Nafuur, of course - and I'm really impressed by the work he has done on this and the backend. Amazing.

TY, and a nice workspace

 

44 minutes ago, Andrew Davie said:

The pluscart menus are dynamic (an amazing/astounding number of characters/line - pretty much a full text screen on the '2600 - I believe the magic was by @Thomas Jentzsch which shouldn't surprise anyone. But it's super cool and makes the machine with menus just super-handy).

Yes it was done by @Thomas Jentzsch, and it is really magic.

 

20 minutes ago, Andrew Davie said:

So anyway, the meus... they retreive their stuff from the plus store on-the-fly. New ROMs are added every day.... a new homebrew release (including mine!) are on the store within the day. I don't have to go hunting for stuff - it's all there. I want to check out a ROM... just go to the menu, a few seconds work, choose the ROM... it's playing on my machine after a few seconds of download.

The ROMs in the public area are mainly added, organized and updated by @Prizrak and he is really fast. Mostly when I want to add a ROM I have to find out that it has already been added by him.

 

32 minutes ago, Andrew Davie said:

And to "upload" to it, well I don't really do that. I have a "live" folder on my machine (via Nextcloud). The plusstore provides Nextcloud storage/acts as a server. So when I put stuff in that folder, it's automatically uploaded to my personal folder on the PlusStore, and from there the PlusCart sees it. Pretty weird, but that's all i do -- assemble, copy the file to the local folder, and it's on my '2600 to test if I want. Automatically. Magic.

nextcloud is a file sharing tool, so you could share your test ROMs with your tester. But currently users can not share ROMs with each other, because I am not sure about the legal implications. Maybe we can add a new group of (trusted) users, that can share files with other users.

[zbyti]

For fun.

 

Year ago I found weakness in Colossus 4.0 on Atari 800XL with overprotecting f2, f7 square. It must be so hardcoded that I could afford to play without a Rook, on tournament time (2h for 60 moves and 2h for next 60 moves) and still win the game

 

[+Andrew Davie]

33 minutes ago, zbyti said:

@Andrew Davie shame on you  you missed mate in one  

 

But seriously, you can see an advantage in developing a Bishop on c5 (and the importance of the f2 square), previously your program preferred Bb4.

The game was something like (with my thinking in each row just after my move)...

 

1. e4 e5
2. P-b3 Q-h4.   "let's try getting a bishop out a different way"
3. N-c3 b-C5.   "ok Q attacking the e4 pawn, gotta defend it with the N"

4. N-F3 Qxp++ "righto, now I can attack the queen with my other N"

5...  .... "... wait....what....?"

 

[zbyti]

[+Al_Nafuur]

39 minutes ago, zbyti said:

one principle for every square ?

[+Al_Nafuur]

I only have 2 principles

1. get out of your opponents opening book
2. use your brain (especially before touching a piece)

that is all I can afford to remember, while being busy with the second principle

 

[+Andrew Davie]

Just now, Al_Nafuur said:

I only have 2 principles

1. get out of your opponents opening book
2. use your brain (especially before touching a piece)

that is all I can afford to remember, while being busy with the second principle

 

 

My single rule appears to be "mmh, that looks good, let's do that"

[+Al_Nafuur]

5 minutes ago, Andrew Davie said:

 

My single rule appears to be "mmh, that looks good, let's do that"

You should try to changed that to:

"spontaneity needs to be carefully considered"

[Prizrak]

nextcloud is a file sharing tool, so you could share your test ROMs with your tester. But currently users can not share ROMs with each other, because I am not sure about the legal implications. Maybe we can add a new group of (trusted) users, that can share files with other users.

@Al_Nafuur I try to stay on top of it and sometimes like with this Chess game we can have 3 binaries released in a day or so. I just check the forums a few times a day to ensure there's nothing I missed and the project/users benefit by having the latest games to play without the fuss of loading them on a cart themselves.

Sent from my SM-N960U using Tapatalk