user20203: 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

user9179: 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).

20203: <p>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?</p>

<p>[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). </p>

<p>[edit 4.10.2019] I found that on <a href="https://lichess.org" rel="nofollow noreferrer">https://lichess.org</a> 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</p>
 9179: <p>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?</p>

<p>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.</p>

<p>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.</p>

<p>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).</p>
