/// MaterialTable::material_info() takes a position object as input, /// computes or looks up a MaterialInfo object, and returns a pointer to it. /// If the material configuration is not already present in the table, it /// is stored there, so we don't have to recompute everything when the /// same material configuration occurs again. internal void probe(Position pos, out MaterialEntry e) { var key = pos.material_key(); e = this.entries[((uint)key) & Constants.MaterialTableMask]; // If mi->key matches the position's material hash key, it means that we // have analysed this material configuration before, and we can simply // return the information we found the last time instead of recomputing it. if (e.key == key) { return; } // Initialize MaterialInfo entry var npm = pos.non_pawn_material(ColorC.WHITE) + pos.non_pawn_material(ColorC.BLACK); e.value = 0; e.scalingFunctionWHITE = null; e.scalingFunctionBLACK = null; e.spaceWeight = 0; e.key = key; e.factorWHITE = e.factorBLACK = ScaleFactorC.SCALE_FACTOR_NORMAL; e.gamePhase = npm >= MidgameLimit ? PhaseC.PHASE_MIDGAME : npm <= EndgameLimit ? PhaseC.PHASE_ENDGAME : (((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit)); // Let's look if we have a specialized evaluation function for this // particular material configuration. First we look for a fixed // configuration one, then a generic one if previous search failed. if ((e.evaluationFunction = Endgame.probeValue(key, out e.evaluationFunctionColor)) != null) { return; } if (is_KXK(ColorC.WHITE, pos)) { e.evaluationFunction = Endgame.Endgame_KXK; e.evaluationFunctionColor = ColorC.WHITE; return; } if (is_KXK(ColorC.BLACK, pos)) { e.evaluationFunction = Endgame.Endgame_KXK; e.evaluationFunctionColor = ColorC.BLACK; return; } if ((pos.pieces_PT(PieceTypeC.PAWN) == 0) && (pos.pieces_PT(PieceTypeC.ROOK) == 0) && (pos.pieces_PT(PieceTypeC.QUEEN) == 0)) { // Minor piece endgame with at least one minor piece per side and // no pawns. Note that the case KmmK is already handled by KXK. Debug.Assert( (pos.pieces_PTC(PieceTypeC.KNIGHT, ColorC.WHITE) | pos.pieces_PTC(PieceTypeC.BISHOP, ColorC.WHITE)) != 0); Debug.Assert( (pos.pieces_PTC(PieceTypeC.KNIGHT, ColorC.BLACK) | pos.pieces_PTC(PieceTypeC.BISHOP, ColorC.BLACK)) != 0); if (pos.piece_count(ColorC.WHITE, PieceTypeC.BISHOP) + pos.piece_count(ColorC.WHITE, PieceTypeC.KNIGHT) <= 2 && pos.piece_count(ColorC.BLACK, PieceTypeC.BISHOP) + pos.piece_count(ColorC.BLACK, PieceTypeC.KNIGHT) <= 2) { e.evaluationFunction = Endgame.Endgame_KmmKm; e.evaluationFunctionColor = pos.sideToMove; return; } } // OK, we didn't find any special evaluation function for the current // material configuration. Is there a suitable scaling function? // // We face problems when there are several conflicting applicable // scaling functions and we need to decide which one to use. EndgameScaleFactor sf; int c; if ((sf = Endgame.probeScaleFactor(key, out c)) != null) { if (c == ColorC.WHITE) { e.scalingFunctionWHITE = sf; } else { e.scalingFunctionBLACK = sf; } return; } // Generic scaling functions that refer to more then one material // distribution. Should be probed after the specialized ones. // Note that these ones don't return after setting the function. if (is_KBPsKs(ColorC.WHITE, pos)) { e.scalingFunctionWHITE = Endgame.Endgame_KBPsK; } if (is_KBPsKs(ColorC.BLACK, pos)) { e.scalingFunctionBLACK = Endgame.Endgame_KBPsK; } if (is_KQKRPs(ColorC.WHITE, pos)) { e.scalingFunctionWHITE = Endgame.Endgame_KQKRPs; } else if (is_KQKRPs(ColorC.BLACK, pos)) { e.scalingFunctionBLACK = Endgame.Endgame_KQKRPs; } var npm_w = pos.non_pawn_material(ColorC.WHITE); var npm_b = pos.non_pawn_material(ColorC.BLACK); if (npm_w + npm_b == ValueC.VALUE_ZERO) { if (pos.piece_count(ColorC.BLACK, PieceTypeC.PAWN) == 0) { Debug.Assert(pos.piece_count(ColorC.WHITE, PieceTypeC.PAWN) >= 2); e.scalingFunctionWHITE = Endgame.Endgame_KPsK; } else if (pos.piece_count(ColorC.WHITE, PieceTypeC.PAWN) == 0) { Debug.Assert(pos.piece_count(ColorC.BLACK, PieceTypeC.PAWN) >= 2); e.scalingFunctionBLACK = Endgame.Endgame_KPsK; } else if (pos.piece_count(ColorC.WHITE, PieceTypeC.PAWN) == 1 && pos.piece_count(ColorC.BLACK, PieceTypeC.PAWN) == 1) { // This is a special case because we set scaling functions // for both colors instead of only one. e.scalingFunctionWHITE = Endgame.Endgame_KPKP; e.scalingFunctionBLACK = Endgame.Endgame_KPKP; } } // No pawns makes it difficult to win, even with a material advantage if (pos.piece_count(ColorC.WHITE, PieceTypeC.PAWN) == 0 && npm_w - npm_b <= Constants.BishopValueMidgame) { e.factorWHITE = (byte) (npm_w == npm_b || npm_w < Constants.RookValueMidgame ? 0 : NoPawnsSF[Math.Min(pos.piece_count(ColorC.WHITE, PieceTypeC.BISHOP), 2)]); } if (pos.piece_count(ColorC.BLACK, PieceTypeC.PAWN) == 0 && npm_b - npm_w <= Constants.BishopValueMidgame) { e.factorBLACK = (byte) (npm_w == npm_b || npm_b < Constants.RookValueMidgame ? 0 : NoPawnsSF[Math.Min(pos.piece_count(ColorC.BLACK, PieceTypeC.BISHOP), 2)]); } // Compute the space weight if (npm_w + npm_b >= 2 * Constants.QueenValueMidgame + 4 * Constants.RookValueMidgame + 2 * Constants.KnightValueMidgame) { var minorPieceCount = pos.piece_count(ColorC.WHITE, PieceTypeC.KNIGHT) + pos.piece_count(ColorC.WHITE, PieceTypeC.BISHOP) + pos.piece_count(ColorC.BLACK, PieceTypeC.KNIGHT) + pos.piece_count(ColorC.BLACK, PieceTypeC.BISHOP); e.spaceWeight = minorPieceCount * minorPieceCount; } // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // for the bishop pair "extended piece", this allow us to be more flexible // in defining bishop pair bonuses. this.pieceCount[0][0] = pos.piece_count(ColorC.WHITE, PieceTypeC.BISHOP) > 1 ? 1 : 0; this.pieceCount[0][1] = pos.piece_count(ColorC.WHITE, PieceTypeC.PAWN); this.pieceCount[0][2] = pos.piece_count(ColorC.WHITE, PieceTypeC.KNIGHT); this.pieceCount[0][3] = pos.piece_count(ColorC.WHITE, PieceTypeC.BISHOP); this.pieceCount[0][4] = pos.piece_count(ColorC.WHITE, PieceTypeC.ROOK); this.pieceCount[0][5] = pos.piece_count(ColorC.WHITE, PieceTypeC.QUEEN); this.pieceCount[1][0] = pos.piece_count(ColorC.BLACK, PieceTypeC.BISHOP) > 1 ? 1 : 0; this.pieceCount[1][1] = pos.piece_count(ColorC.BLACK, PieceTypeC.PAWN); this.pieceCount[1][2] = pos.piece_count(ColorC.BLACK, PieceTypeC.KNIGHT); this.pieceCount[1][3] = pos.piece_count(ColorC.BLACK, PieceTypeC.BISHOP); this.pieceCount[1][4] = pos.piece_count(ColorC.BLACK, PieceTypeC.ROOK); this.pieceCount[1][5] = pos.piece_count(ColorC.BLACK, PieceTypeC.QUEEN); e.value = (short)((this.imbalance(ColorC.WHITE) - this.imbalance(ColorC.BLACK)) / 16); }
/// Wait for a command from the user, parse this text string as an UCI command, /// and call the appropriate functions. Also intercepts EOF from stdin to ensure /// that we exit gracefully if the GUI dies unexpectedly. In addition to the UCI /// commands, the function also supports a few debug commands. internal static void uci_loop(string args) { for (int i = 0; i < 102; i++) { StateRingBuf[i] = new StateInfo(); } Position pos = new Position(StartFEN, false, Threads.main_thread()); // The root position string cmd, token = string.Empty; while (token != "quit") { if (args.Length > 0) { cmd = args; } else if (String.IsNullOrEmpty(cmd = Plug.ReadLine())) // Block here waiting for input { cmd = "quit"; } Stack<string> stack = Utils.CreateStack(cmd); token = stack.Pop(); if (token == "quit" || token == "stop") { Search.SignalsStop = true; Threads.wait_for_search_finished(); // Cannot quit while threads are running } else if (token == "ponderhit") { // The opponent has played the expected move. GUI sends "ponderhit" if // we were told to ponder on the same move the opponent has played. We // should continue searching but switching from pondering to normal search. Search.Limits.ponder = false; if (Search.SignalsStopOnPonderhit) { Search.SignalsStop = true; Threads.main_thread().wake_up(); // Could be sleeping } } else if (token == "go") { go(pos, stack); } else if (token == "ucinewgame") { /* Avoid returning "Unknown command" */ } else if (token == "isready") { Plug.Write("readyok"); Plug.Write(Constants.endl); } else if (token == "position") { set_position(pos, stack); } else if (token == "setoption") { set_option(stack); } else if (token == "validmoves") { Search.validmoves(pos, stack); } else if (token == "d") { pos.print(0); } else if (token == "flip") { pos.flip(); } else if (token == "eval") { Plug.Write(Evaluate.trace(pos)); Plug.Write(Constants.endl); } else if (token == "bench") { Benchmark.benchmark(pos, stack); } else if (token == "key") { Plug.Write("key: "); Plug.Write(String.Format("{0:X}", pos.key())); Plug.Write("\nmaterial key: "); Plug.Write(pos.material_key().ToString()); Plug.Write("\npawn key: "); Plug.Write(pos.pawn_key().ToString()); Plug.Write(Constants.endl); } else if (token == "uci") { Plug.Write("id name "); Plug.Write(Utils.engine_info(true)); Plug.Write("\n"); Plug.Write(OptionMap.Instance.ToString()); Plug.Write("\nuciok"); Plug.Write(Constants.endl); } else if (token == "perft") { token = stack.Pop(); // Read depth Stack<string> ss = Utils.CreateStack( string.Format("{0} {1} {2} current perft", OptionMap.Instance["Hash"].v, OptionMap.Instance["Threads"].v, token) ); Benchmark.benchmark(pos, ss); } else { Plug.Write("Unknown command: "); Plug.Write(cmd); Plug.Write(Constants.endl); } if (args.Length > 0) // Command line arguments have one-shot behaviour { Threads.wait_for_search_finished(); break; } } }
/// Wait for a command from the user, parse this text string as an UCI command, /// and call the appropriate functions. Also intercepts EOF from stdin to ensure /// that we exit gracefully if the GUI dies unexpectedly. In addition to the UCI /// commands, the function also supports a few debug commands. internal static void loop(string args) { for (var i = 0; i < 102; i++) { StateRingBuf[i] = new StateInfo(); } var pos = new Position(StartFEN, false, Threads.main_thread()); // The root position string cmd, token = string.Empty; while (token != "quit") { if (args.Length > 0) { cmd = args; } else if (string.IsNullOrEmpty(cmd = Plug.ReadLine())) // Block here waiting for input { cmd = "quit"; } var stack = Utils.CreateStack(cmd); token = stack.Pop(); if (token == "quit" || token == "stop" || token == "ponderhit") { // GUI sends 'ponderhit' to tell us to ponder on the same move the // opponent has played. In case Signals.stopOnPonderhit is set we are // waiting for 'ponderhit' to stop the search (for instance because we // already ran out of time), otherwise we should continue searching but // switching from pondering to normal search. if (token != "ponderhit" || Search.SignalsStopOnPonderhit) { Search.SignalsStop = true; Threads.main_thread().notify_one(); // Could be sleeping } else { Search.Limits.ponder = false; } } else if (token == "go") { go(pos, stack); } else if (token == "ucinewgame") { TT.clear(); } else if (token == "isready") { Plug.Write("readyok"); Plug.Write(Constants.endl); } else if (token == "position") { set_position(pos, stack); } else if (token == "setoption") { set_option(stack); } else if (token == "validmoves") { Search.validmoves(pos, stack); } else if (token == "d") { pos.print(0); } else if (token == "flip") { pos.flip(); } else if (token == "eval") { Plug.Write(Evaluate.trace(pos)); Plug.Write(Constants.endl); } else if (token == "bench") { Benchmark.benchmark(pos, stack); } else if (token == "key") { Plug.Write("key: "); Plug.Write(string.Format("{0:X}", pos.key())); Plug.Write("\nmaterial key: "); Plug.Write(pos.material_key().ToString()); Plug.Write("\npawn key: "); Plug.Write(pos.pawn_key().ToString()); Plug.Write(Constants.endl); } else if (token == "uci") { Plug.Write("id name "); Plug.Write(Utils.engine_info(true)); Plug.Write("\n"); Plug.Write(OptionMap.Instance.ToString()); Plug.Write("\nuciok"); Plug.Write(Constants.endl); } else if (token == "perft") { token = stack.Pop(); // Read depth var ss = Utils.CreateStack( string.Format( "{0} {1} {2} current perft", OptionMap.Instance["Hash"].v, OptionMap.Instance["Threads"].v, token)); Benchmark.benchmark(pos, ss); } else { Plug.Write("Unknown command: "); Plug.Write(cmd); Plug.Write(Constants.endl); } if (args.Length > 0) // Command line arguments have one-shot behaviour { Threads.wait_for_think_finished(); break; } } }