By default, engines return the strongest variation(s) they calculate. I was wondering if there is a way to tweak an open source chess engine to show a move from their MultiPV which is slightly better than or equal to your moves. Let's say the evaluation stays only +2 consistently through the game. Instead of the strongest move in a position, the engine is retuning back the move with +2. Is there a way to do this?

[edit 3.10.2019] in case of a blunder (e.g. +3 jump in the engine evaluation, the engine can keep the difference and continue the game with +5 instead of +2).

[edit 4.10.2019] I found that on https://lichess.org there are levels for SF. Right now, level 5 corresponds to ca. 1700 elo, level 6 is 1900, level 7 is 2200. This satisfies my needs and closes my question. Thank you

  • 3
    May I ask what the purpose of this is? Do not get me wrong but this sounds a bit like cheating advice as I currently do not see any other use case. Oct 1 '19 at 19:43
  • 2
    @FabianFichter The obvious use case is to tune the engine to be slightly better than the player so that he always gets a challenging game but one where he still has a chance and doesn't just get crushed.
    – Brian Towers
    Oct 1 '19 at 21:47
  • 1
    @BrianTowers As it is described above, it however maintains the same advantage no matter the playing strength of the opponent (if I understand correctly), so playing well or not does not have impact on the result, which does not sound like a suitable opponent for training. Would be good to get a clarification from Amir. Oct 2 '19 at 7:09
  • 1
    If you'd like to tweak the SF just to play against it than I would highly reccomend the good old Chessmaster 9000 - a desktop chess software that has about 100 human-like levels. That way you can play against a certain opponent until you can beat him easily and then move on to the next one. Works great even on Windows 10.
    – ThinkTank
    Oct 2 '19 at 15:55
  • I don't think this would work as you're intending; see the answer below and my comment. Oct 2 '19 at 19:13

Ok, so say the engine plays a move with white and values the position as +0.50 (slightly better for white). So now the human plays as black, and blunders a bishop. The engine now values the position as +3.50, but you want to play a move as close as possible to +0.50, v. g. +0.60. Is it what you're looking for?

In that case it seems the way to go is (from the POV of the engine); "the position after my last move was +0.50, so in the current position, if a move that improves that eval exists, I must play the one closest to +0.50. Otherwise (there isn't a move that improves my eval after my last move), play the best move available." If this is your idea, I guess this is doable, and for someone who develops their own chess engine probably shouldn't be hard to code.

Maybe the idea can be improved. For example, if you blunder a bishop, probably it's a good idea the engine to grab the bishop than to play something really stupid.

In any case, I think it's definitely doable, probably with some refinement. (For example, it's not the same blundering a bishop in one than losing a bishop after a 10 moves combination; in the first case, IMO, the engine should take the bishop, but in the second one it should chose a sub-optimal move).

  • This highlights the flaw in the proposal from OP - playing against such a computer, you could ram your queen into the pawn on A2, and the rook couldn't capture back, since +8 [winning the queen for a pawn] is further away from +0.5 than -6 [losing the rook and pawn for no compensation]. Oct 2 '19 at 19:13
  • Thanks for the valid points and for improving the idea
    – Amir
    Oct 2 '19 at 23:22

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.