Sanny writes:

1. Nc3 d5 2. d4 Nf6 3. Bf4 e6 4. g3 Bb4 5. Bg2 Ne4 6. Bxe4 dxe4 7. e3 g5 8. Be5
O-O 9. g4 Nc6 10. Bg3 e5 11. d5 Ne7 12. Bxe5 Nxd5 13. Qe2 Re8 14. f4 exf3
15. Nxf3 Bxc3+ 16. bxc3 Bxg4 17. Bd4 c5 18. Bxc5 Nf4 19. Qf1 Qd5 20. Nxg5 Ng2+
21. Kf2 Qxc5 22. Kxg2 Qxg5 23. h4 Bf3+ 24. Kf2 Qxe3+ 25. Kg3 Bc6+ 26. Kh2 Qe5+
27. Kh3 Qe6+ 28. Kg3 Qd6+ 0-1

I guess that beginner level isn't intentionally making bad moves,
therefore my guess is a broken quiescence search.

When dis you played this game. I could not find any game against
Beginner Level. Have you not yet completed the game. Or may be you
played a month/ week ago when it was having bugs.

I played that game yesterday, but since I have already played 30
games, I'm only allowed to play the beginner level, and the games are
apparently not logged.

--
Peter Osterlund -
http://web.telia.com/~u89404340

Patrick Volk wrote:
On Fri, 9 May 2008 09:57:41 -0700 (PDT), Sanny
wrote:
Yes, I will see if that can be corrected. It is very difficult to
modify the code as changing one line of code brings new Bugs and then
a week is wasted in correcting the Bugs.

That statement tells me quite at least 2 things:

1) There's a lot of copy and paste in your code (parts tend to look
alike, with minor modifications... some question as to whether making
a change is the right one).

It would make sense to split the code into clean separate modules (even
if there was initially a slight performance penalty).

It is probably well worth profiling it to see exactly where it spends
all its time. Getting the thing to run faster would help a lot. You will
probably find that it spends all its time in the terminal node eval.

2) You're probably not using the benefits of Java. Your display might
be OO, but I doubt that your chess analysis part did. What I know
about some contemporary chess engines (the company I work for built
the boards for Deep Blue) is that they evaluate each space.

That is a hardware accelerator tactic which can consider all the squares
using a local sub processor per square. I don't think it works so well
on a PC.

You can score the piece count, but you also can score position...
Simplistically by how many squares are controlled. You only have 3
different kind of squares.

I get the impression it is already a bit better than that, but that
there is something horribly wrong with its quiessence search. Perhaps
because it thinks that pinned pieces can move or something... see the
game with the mobile phone.

Also I have to agree with what someone else said. For testing
purposes, you really should work on handling position notation. One of
the beauties of chess is the state of the game can store in so few
bytes (64 and be comfortable). If you have a position that is, say, a
mate in 5, you can try that position against different versions (and
load it against different opponents as well).

Regression testing at least means that you can be sure the program still
gets right all the test cases you have tested and fixed so far as well
as any new ones.

Checks and draws should be some sort of function... I forget whether
you play a particular sound when the person is in check, but you can
use it for that, and also to put a '+' in the notation (or '#' for
checkmate).

Human readable output needs a couple more tweaks and it would be OK.
Like for example putting the players and dates in the right sort of
brackets and format for standard engines to read.

Its like when we fly Kites. When the threads messup how difficult it
is to correct the jumbeled threads.

This Program is so large that if I have to read whole program line by
line, it will take me full day. So its very difficult to go through
all the codes and correct them.

Bulk spagetti code is not a viable programming model. It is time to
restructure the code and separate the evaluation, move generation and
alpha-beta search into clearly separate modules. Ultimately the majority
of the changes should be in eval once the other components are stable.

200K isn't that large, even for a one-person project.

It is large if there is no well defined overall structure.

Regards,
Martin Brown
** Posted from http://www.teranews.com **

Peter Osterlund wrote:
Martin Brown writes:

Sanny wrote:

That game was played by EASY level. Heres a game by Advance Level
where Zebediah gave lots of sacrifices and win the game in just 34
moves.

In this game Zebediah was a knight ahead but later sacrificed its
knight to bring a quick end.

You mean that Getclub gifted him a knight and then played like a
patzer. This play is basically insane. There is something wrong with
either the evaluation function or the search algorithm.

I think the quiescence search is either not implemented at all or
somehow broken.

My instinct too. Some moves are otherwise inexplicable.

Just for fun, I played a game between GetClub (running
on a 2.4GHz Core2 CPU) and my mobile phone (I think it has a 400MHz
ARM CPU). I expected my phone to be tactically outplayed, but the
exact opposite happened. Here is the game:

Looking at Shredders computer analysis it is clear that the mobile phone
always had a deeper effective search than GetClub.
About what nominal rating is Glofiish chess?

[White "GetClub beginner level 10-20s/move"]
[Black "Glofiish X800, 15s/move"]
[Result "0-1"]

Yippee! Header data that will import into a CB chess engine..

1. Nc3 d5 2. d4 Nf6 3. Bf4 e6 4. g3 Bb4 5. Bg2 Ne4 6. Bxe4 dxe4

You have to wonder why it played BxN - cramping your own position is not
usually a good idea. I wonder if it thought 7. Nxe4 was possible (ie did
not see that the N was pinned in calculating the exchange)

Something harmless to continue developing like Bd2 would have been fine.

7. e3 g5 8. Be5
O-O 9. g4 Nc6 10. Bg3 e5

GetClub is steadily outplayed by an engine that sees deeper here.

10. a3 would be a better continuation. The line played helps black.

11. d5 Ne7 12. Bxe5 Nxd5 13. Qe2 Re8

We have to wonder why it thought 13. Qe2 was a good idea. It isn't.
h3,h4,a3,Kf1 would all be better (the position is already lost)

14. f4 exf3

ANother helpmate move. Not quite terminal but it greatly assists black.
I think a3 is obviously best with Bd4 or even O-O-O plausible.

15. Nxf3 Bxc3+ 16. bxc3 Bxg4 17. Bd4 c5

17. c4 looks better to me.

18. Bxc5 Nf4 19. Qf1 Qd5

Qd2 is better

20. Nxg5 Ng2+
21. Kf2 Qxc5 22. Kxg2 Qxg5 23. h4 Bf3+

OK. This position needs careful examination. The only viable move here
is Rg1 and I would expect most engines to find it. Anything else leads
inexorably to a mate. h4 is a mate in 10.

Interestingly this particular position produces one of the widest
spectrums of mate detected cutoffs I have seen from Shredder. Does
anyone know how to interpret them?
namely at 18 ply overnight infinite analysis
Rg1 -11.4
Qg1 -#211
e4 -#201
Qc1, Re1 -#177
h4 -#176
h3,Qd3 -#175
Qf4 -#172
Qe1, Qf2, Qe2 -#150
Qf3 -#149
(all the others are resolved to very quick mates)

NB it is odd that h4 stays at -#176 at 18 ply although after playing
"h4" explicitly the engine quickly finds the mate in 10.

24. Kf2 Qxe3+ 25. Kg3 Bc6+ 26. Kh2 Qe5+
27. Kh3 Qe6+ 28. Kg3 Qd6+ 0-1

I presume here that beginner level resigned when the mate came within
its event horizon (which seems surprisingly shallow).

I guess that beginner level isn't intentionally making bad moves,
therefore my guess is a broken quiescence search.

I am not sure. It is hard to decide what it thinks it is doing.

Sanny writes:

6. e2-e4{104} Nf6-e4{1978}
And now the final coup de grace. Suicide chess anyone ???

No it gives 2 points for killing 2 Center pawns and other 1 point for
white King Comming out unprotected. and Look at White position its
none of the pieces is developed.

Sanny what is the granularity of your evaluation function? You keep
talking about integral numbers of pawns as if that is the finest division.

Why a whole point for the unprotected king? Wouldn't a smaller value,
like 0.25 be better?

That is probably about right. Unless there is a forcing mate sequence -
some tricks for quickly breaking open a castled king rely on rook
sacrifice followed by a forcing sequence of checks to mate.

Regards,
Martin Brown
** Posted from http://www.teranews.com **

Martin Brown writes:

Peter Osterlund wrote:
Martin Brown writes:

Sanny wrote:

That game was played by EASY level. Heres a game by Advance Level
where Zebediah gave lots of sacrifices and win the game in just 34
moves.

In this game Zebediah was a knight ahead but later sacrificed its
knight to bring a quick end.

You mean that Getclub gifted him a knight and then played like a
patzer. This play is basically insane. There is something wrong with
either the evaluation function or the search algorithm.

I think the quiescence search is either not implemented at all or
somehow broken.

My instinct too. Some moves are otherwise inexplicable.

Just for fun, I played a game between GetClub (running
on a 2.4GHz Core2 CPU) and my mobile phone (I think it has a 400MHz
ARM CPU). I expected my phone to be tactically outplayed, but the
exact opposite happened. Here is the game:

Looking at Shredders computer analysis it is clear that the mobile
phone always had a deeper effective search than GetClub.
About what nominal rating is Glofiish chess?

The phone runs Windows Mobile 6 and I installed CEBoard and a PocketPC
version of crafty. The program analyzes about 15k nodes/s. I don't
know what rating that translates to, but it's about 500 times slower
than crafty running on my desktop PC.

--
Peter Osterlund -
http://web.telia.com/~u89404340

On Mon, 12 May 2008 08:38:04 +0100, Martin Brown
wrote:

Patrick Volk wrote:
On Fri, 9 May 2008 09:57:41 -0700 (PDT), Sanny
wrote:
Yes, I will see if that can be corrected. It is very difficult to
modify the code as changing one line of code brings new Bugs and then
a week is wasted in correcting the Bugs.

That statement tells me quite at least 2 things:

1) There's a lot of copy and paste in your code (parts tend to look
alike, with minor modifications... some question as to whether making
a change is the right one).

It would make sense to split the code into clean separate modules (even
if there was initially a slight performance penalty).

It is probably well worth profiling it to see exactly where it spends
all its time. Getting the thing to run faster would help a lot. You will
probably find that it spends all its time in the terminal node eval.

C&P is a consequence generally of wandering design. You find some code
that could work, and instead of re-factoring it to fulfill all cases,
you copy and modify it for each.

One of the levels of programming hell (hell not only to maintain, but
to test)!


2) You're probably not using the benefits of Java. Your display might
be OO, but I doubt that your chess analysis part did. What I know
about some contemporary chess engines (the company I work for built
the boards for Deep Blue) is that they evaluate each space.

That is a hardware accelerator tactic which can consider all the squares
using a local sub processor per square. I don't think it works so well
on a PC.

It used at least one processor per square. A PC could thread it, yeah,
not as fast, but it lends itself to replication.


You can score the piece count, but you also can score position...
Simplistically by how many squares are controlled. You only have 3
different kind of squares.

I get the impression it is already a bit better than that, but that
there is something horribly wrong with its quiessence search. Perhaps
because it thinks that pinned pieces can move or something... see the
game with the mobile phone.

Where A-B pruning comes in. At the level it's at, I don't think you're
going to find a queen sacrifice 4 plies down. Bail!


Also I have to agree with what someone else said. For testing
purposes, you really should work on handling position notation. One of
the beauties of chess is the state of the game can store in so few
bytes (64 and be comfortable). If you have a position that is, say, a
mate in 5, you can try that position against different versions (and
load it against different opponents as well).

Regression testing at least means that you can be sure the program still
gets right all the test cases you have tested and fixed so far as well
as any new ones.

Sanny's idea of regression testing is release, and saying how it's
improved 200%.


Checks and draws should be some sort of function... I forget whether
you play a particular sound when the person is in check, but you can
use it for that, and also to put a '+' in the notation (or '#' for
checkmate).

Human readable output needs a couple more tweaks and it would be OK.
Like for example putting the players and dates in the right sort of
brackets and format for standard engines to read.

Its like when we fly Kites. When the threads messup how difficult it
is to correct the jumbeled threads.

This Program is so large that if I have to read whole program line by
line, it will take me full day. So its very difficult to go through
all the codes and correct them.

Bulk spagetti code is not a viable programming model. It is time to
restructure the code and separate the evaluation, move generation and
alpha-beta search into clearly separate modules. Ultimately the majority
of the changes should be in eval once the other components are stable.

Exactly my point. His comments indicate he may not have painted
himself into the corner just yet, but there's probably no doorways or
windows around.
A program isn't philosophically a journey - it's more like a tour.
You have a list of sights to see.


200K isn't that large, even for a one-person project.

It is large if there is no well defined overall structure.

Very true.



Regards,
Martin Brown
** Posted from http://www.teranews.com **