question about implementing resigning

[Uri Blass]

Geschrieben von:/Posted by: Uri Blass at 26 August 2004 04:57:41:

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

[Lance Perkins]

Geschrieben von:/Posted by: Lance Perkins at 26 August 2004 05:43:03:
Als Antwort auf:/In reply to: question about implementing resigning geschrieben von:/posted by: Uri Blass at 26 August 2004 04:57:41:

Hi Uri,
My suggestion is for you to output the resign whenever you determine that you need to resign. When you output a resign, it does not mean that you program will now stop playing. You just go on as if nothing happened. This is because your opponent may choose to reject your resignation and wants to go on with the game. Certainly, I can immagine humans wanting this because they really want to see if they can mate the engine (sometimes also, they can't see why the engine is resigning).
Cheers...

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

[Will Singleton]

Geschrieben von:/Posted by: Will Singleton at 26 August 2004 05:51:09:
Als Antwort auf:/In reply to: question about implementing resigning geschrieben von:/posted by: Uri Blass at 26 August 2004 04:57:41:

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

Uri,
I am frequently perplexed by your questions. I will leave it at that.
Will

[Peter Fendrich]

Geschrieben von:/Posted by: Peter Fendrich at 26 August 2004 11:00:16:
Als Antwort auf:/In reply to: question about implementing resigning geschrieben von:/posted by: Uri Blass at 26 August 2004 04:57:41:

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

IMO resign is a function of it's own well separated from gamefinished.
You will need a call before makeandprintmove() to the resign-function.
I do it after but that's because I make the move when resigning because the game
might continue even if I resign.
Here is my resign logic:
(resign=0/1 is an option.)
Resign only if (resign=1 and ...):
The evaluation is below -450 (1 bishop+pawn) during 4 consecutive moves.
The material balance is bad enough (-350)
Opponent isn't short of time (< Xs for each coming move)
The opponent has no forced mate to execute
The opponent isn't in check after my computed move
The opponent has improved the evaluation with more than 75 (3/4 pawn) during the last 4 moves
If any of these rules are not fulfilled Terra will not resign
/Peter

[Odd Gunnar Malin]

Geschrieben von:/Posted by: Odd Gunnar Malin at 26 August 2004 12:37:11:
Als Antwort auf:/In reply to: Re: question about implementing resigning geschrieben von:/posted by: Peter Fendrich at 26 August 2004 11:00:16:

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

IMO resign is a function of it's own well separated from gamefinished.
You will need a call before makeandprintmove() to the resign-function.
I do it after but that's because I make the move when resigning because the game
might continue even if I resign.
Here is my resign logic:
(resign=0/1 is an option.)
Resign only if (resign=1 and ...):
The evaluation is below -450 (1 bishop+pawn) during 4 consecutive moves.
The material balance is bad enough (-350)
Opponent isn't short of time (< Xs for each coming move)
The opponent has no forced mate to execute
The opponent isn't in check after my computed move
The opponent has improved the evaluation with more than 75 (3/4 pawn) during the last 4 moves
If any of these rules are not fulfilled Terra will not resign
/Peter

What if you have resigned before in the game and the user wanted to continue, do you bother him med the resign question more times in the game?
Odd Gunnar

[Peter Fendrich]

Geschrieben von:/Posted by: Peter Fendrich at 26 August 2004 12:58:10:
Als Antwort auf:/In reply to: Re: question about implementing resigning geschrieben von:/posted by: Odd Gunnar Malin at 26 August 2004 12:37:11:

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

IMO resign is a function of it's own well separated from gamefinished.
You will need a call before makeandprintmove() to the resign-function.
I do it after but that's because I make the move when resigning because the game
might continue even if I resign.
Here is my resign logic:
(resign=0/1 is an option.)
Resign only if (resign=1 and ...):
The evaluation is below -450 (1 bishop+pawn) during 4 consecutive moves.
The material balance is bad enough (-350)
Opponent isn't short of time (< Xs for each coming move)
The opponent has no forced mate to execute
The opponent isn't in check after my computed move
The opponent has improved the evaluation with more than 75 (3/4 pawn) during the last 4 moves
If any of these rules are not fulfilled Terra will not resign
/Peter

What if you have resigned before in the game and the user wanted to continue, do you bother him med the resign question more times in the game?
Odd Gunnar

Good question!
Resign just once.
The rules above was from my web site. I took a look in my code and found the following comment, somewhat different from the rules above:
//------------------------------------------------------------
// Check if it's time to resign.
// Terra will resign if and only if:
//- Rule 1: If one resign is sent. Don't do it again.
//- Rule 2: Never resign if material is not bad enough
//- Rule 3: Never resign if opponent time is very short
//- Rule 4: Never resign if opponent has a forced mate
//- Rule 5: Don't resign if the last move was a check
//- Rule 6: Don't resign if opponent hasn't improved his eval
// at least Resign_Delta during the previous Resign_MoveCnt moves
//- Rule 7: Don't resign if opponent has been below Resign_Limit
// at least one time during the previous Resign_MoveCnt moves.
//------------------------------------------------------------
/Peter

[Uri Blass]

Geschrieben von:/Posted by: Uri Blass at 26 August 2004 13:30:14:
Als Antwort auf:/In reply to: Re: question about implementing resigning geschrieben von:/posted by: Peter Fendrich at 26 August 2004 12:58:10:

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

IMO resign is a function of it's own well separated from gamefinished.
You will need a call before makeandprintmove() to the resign-function.
I do it after but that's because I make the move when resigning because the game
might continue even if I resign.
Here is my resign logic:
(resign=0/1 is an option.)
Resign only if (resign=1 and ...):
The evaluation is below -450 (1 bishop+pawn) during 4 consecutive moves.
The material balance is bad enough (-350)
Opponent isn't short of time (< Xs for each coming move)
The opponent has no forced mate to execute
The opponent isn't in check after my computed move
The opponent has improved the evaluation with more than 75 (3/4 pawn) during the last 4 moves
If any of these rules are not fulfilled Terra will not resign
/Peter

What if you have resigned before in the game and the user wanted to continue, do you bother him med the resign question more times in the game?
Odd Gunnar

Good question!
Resign just once.
The rules above was from my web site. I took a look in my code and found the following comment, somewhat different from the rules above:
//------------------------------------------------------------
// Check if it's time to resign.
// Terra will resign if and only if:
//- Rule 1: If one resign is sent. Don't do it again.
//- Rule 2: Never resign if material is not bad enough
//- Rule 3: Never resign if opponent time is very short
//- Rule 4: Never resign if opponent has a forced mate
//- Rule 5: Don't resign if the last move was a check
//- Rule 6: Don't resign if opponent hasn't improved his eval
// at least Resign_Delta during the previous Resign_MoveCnt moves
//- Rule 7: Don't resign if opponent has been below Resign_Limit
// at least one time during the previous Resign_MoveCnt moves.
//------------------------------------------------------------
/Peter

When I think about resigning I think only about computer opponents and not about humans for the following reasons.
1)Humans are in most cases too stupid to play chess against computers so I do not care much about them
2)If humans do not like the engine to resign they can disable resign in the beginning of the game and if they do not like to win won position they can adjudicate the game in every moment.
I do not like resigning in the opponent move because the computer opponent may be something that does not ponder and does not listen to winboard command when it is his move(except maybe ? that is move now) so if I play a move and resign after it the opponent may ignore all winboard commands and play a move a minute later and only notice the resign a minute later so I spended a lot of computer time when if I resign before playing the move the oponent may get the information and understand that the game is finished immediatly so it may be ready for new game.
Uri

[Odd Gunnar Malin]

Geschrieben von:/Posted by: Odd Gunnar Malin at 26 August 2004 13:37:49:
Als Antwort auf:/In reply to: Re: question about implementing resigning geschrieben von:/posted by: Uri Blass at 26 August 2004 13:30:14:

1)Humans are in most cases too stupid to play chess against computers so I do not care much about them

Thanks for your input, I will save it.
I'm almost exclusive play human-engine games, even against my own engine, so I must be realy stupid.
By the way I have had many interesting games againt Terra and it doesn't win all the time, but haven't tried your engine yet.
Odd Gunnar

[Peter Fendrich]

Geschrieben von:/Posted by: Peter Fendrich at 26 August 2004 14:32:56:
Als Antwort auf:/In reply to: Re: question about implementing resigning geschrieben von:/posted by: Uri Blass at 26 August 2004 13:30:14:

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

IMO resign is a function of it's own well separated from gamefinished.
You will need a call before makeandprintmove() to the resign-function.
I do it after but that's because I make the move when resigning because the game
might continue even if I resign.
Here is my resign logic:
(resign=0/1 is an option.)
Resign only if (resign=1 and ...):
The evaluation is below -450 (1 bishop+pawn) during 4 consecutive moves.
The material balance is bad enough (-350)
Opponent isn't short of time (< Xs for each coming move)
The opponent has no forced mate to execute
The opponent isn't in check after my computed move
The opponent has improved the evaluation with more than 75 (3/4 pawn) during the last 4 moves
If any of these rules are not fulfilled Terra will not resign
/Peter

What if you have resigned before in the game and the user wanted to continue, do you bother him med the resign question more times in the game?
Odd Gunnar

Good question!
Resign just once.
The rules above was from my web site. I took a look in my code and found the following comment, somewhat different from the rules above:
//------------------------------------------------------------
// Check if it's time to resign.
// Terra will resign if and only if:
//- Rule 1: If one resign is sent. Don't do it again.
//- Rule 2: Never resign if material is not bad enough
//- Rule 3: Never resign if opponent time is very short
//- Rule 4: Never resign if opponent has a forced mate
//- Rule 5: Don't resign if the last move was a check
//- Rule 6: Don't resign if opponent hasn't improved his eval
// at least Resign_Delta during the previous Resign_MoveCnt moves
//- Rule 7: Don't resign if opponent has been below Resign_Limit
// at least one time during the previous Resign_MoveCnt moves.
//------------------------------------------------------------
/Peter

When I think about resigning I think only about computer opponents and not about humans for the following reasons.
1)Humans are in most cases too stupid to play chess against computers so I do not care much about them
2)If humans do not like the engine to resign they can disable resign in the beginning of the game and if they do not like to win won position they can adjudicate the game in every moment.
I do not like resigning in the opponent move because the computer opponent may be something that does not ponder and does not listen to winboard command when it is his move(except maybe ? that is move now) so if I play a move and resign after it the opponent may ignore all winboard commands and play a move a minute later and only notice the resign a minute later so I spended a lot of computer time when if I resign before playing the move the oponent may get the information and understand that the game is finished immediatly so it may be ready for new game.
Uri

I don't understand what ponder has to do with anything here...
If you are talking about a computer opponent that can't swollow the resign result after your move, then it is bad design that your opponent should solve and not your program.
More of a problem is the racing problem that is a defect in the protocol. You send a move and the opponent manage to reply to that move before your resign is coming. His reply could be a resign as well or a draw offer...
The best solution would be to have the possiblility to send a move and resign at the same time. The GUI can then act correctly.
/Peter

[Uri Blass]

Geschrieben von:/Posted by: Uri Blass at 27 August 2004 02:47:01:
Als Antwort auf:/In reply to: Re: question about implementing resigning geschrieben von:/posted by: Peter Fendrich at 26 August 2004 14:32:56:

I think about implementing resigning in movei but things are not so simple
because the code is badly written and inspite of the fact that I probably can implement it the way that I think about is ugly and I look for advice to do thing better.
Here is descreption of what I do and it took me time to figure out exactly what I do with my complicated pondering code that has no threads.

I usually make move when I play it and I want to have a first resign only based on the score.
I do not want to make the move before resiging because I think that it may confuse an opponent that may expect resigning only when it ponders.
The code that I want to change is the following code:
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if ( t.isponder())
ponder();
}

The function makeandprintpvmove() makes the move and tell winboard to play the move.
I think that in case of resigning it is better to avoid making the move in makeandprintpvmove()
I thought to check resigning also in gamefinished() but the problem is that I call gamefinished also after the user move and I may ponder the wrong move so I do not like to use the score that I have after the user move to decide if to resign(the score may tell me that I lose after the expected move but the important question is if I lose after the opponent move).
I may have gamefinished1() that check if the game is finished after the opponent move and gamefinished2() to check if the game is finished after the computer move but it seems to me an ugly solution.
Note also that the code above is printed in the program twice.

case 1 is inside of the function ponder() and it means that I started the search in pondering mode and during the search got the expected move.
case 2 is not inside the function ponder() and it may mean that I play without pondering or I got unexpected move so I had to finish the function ponder() and make the move in a different function.
Uri

IMO resign is a function of it's own well separated from gamefinished.
You will need a call before makeandprintmove() to the resign-function.
I do it after but that's because I make the move when resigning because the game
might continue even if I resign.
Here is my resign logic:
(resign=0/1 is an option.)
Resign only if (resign=1 and ...):
The evaluation is below -450 (1 bishop+pawn) during 4 consecutive moves.
The material balance is bad enough (-350)
Opponent isn't short of time (< Xs for each coming move)
The opponent has no forced mate to execute
The opponent isn't in check after my computed move
The opponent has improved the evaluation with more than 75 (3/4 pawn) during the last 4 moves
If any of these rules are not fulfilled Terra will not resign
/Peter

What if you have resigned before in the game and the user wanted to continue, do you bother him med the resign question more times in the game?
Odd Gunnar

Good question!
Resign just once.
The rules above was from my web site. I took a look in my code and found the following comment, somewhat different from the rules above:
//------------------------------------------------------------
// Check if it's time to resign.
// Terra will resign if and only if:
//- Rule 1: If one resign is sent. Don't do it again.
//- Rule 2: Never resign if material is not bad enough
//- Rule 3: Never resign if opponent time is very short
//- Rule 4: Never resign if opponent has a forced mate
//- Rule 5: Don't resign if the last move was a check
//- Rule 6: Don't resign if opponent hasn't improved his eval
// at least Resign_Delta during the previous Resign_MoveCnt moves
//- Rule 7: Don't resign if opponent has been below Resign_Limit
// at least one time during the previous Resign_MoveCnt moves.
//------------------------------------------------------------
/Peter

When I think about resigning I think only about computer opponents and not about humans for the following reasons.
1)Humans are in most cases too stupid to play chess against computers so I do not care much about them
2)If humans do not like the engine to resign they can disable resign in the beginning of the game and if they do not like to win won position they can adjudicate the game in every moment.
I do not like resigning in the opponent move because the computer opponent may be something that does not ponder and does not listen to winboard command when it is his move(except maybe ? that is move now) so if I play a move and resign after it the opponent may ignore all winboard commands and play a move a minute later and only notice the resign a minute later so I spended a lot of computer time when if I resign before playing the move the oponent may get the information and understand that the game is finished immediatly so it may be ready for new game.
Uri

I don't understand what ponder has to do with anything here...
If you are talking about a computer opponent that can't swollow the resign result after your move, then it is bad design that your opponent should solve and not your program.
More of a problem is the racing problem that is a defect in the protocol. You send a move and the opponent manage to reply to that move before your resign is coming. His reply could be a resign as well or a draw offer...
The best solution would be to have the possiblility to send a move and resign at the same time. The GUI can then act correctly.
/Peter

I know that I had that bad design in the past so I expect a lot of opponents to have the same bad design.
I see no reason to play a move if I resign.
Note that I hope that I solved the problem in a way that I like that does the code more simpler and not more complicated.
I simply decided to have a function for making move and pondering after it and here is the function:
void make_move_and_ponder(int post)
{
if (resigning()==0)
{
makeandprintpvmove();
if (gamefinished())
print_result();
else
{
if (t.isponder())
ponder(post);
}
}
}
make_move_and ponder(post) is called every time that I want to make move in a game even if I do not ponder)(if I do not ponder then t.isponder()=0)

Uri