Debian Codegraph @

old-sample/legacy-checkmate/lib/oracleProverLight.cc

raw
1 /* oracleProverLight.cc
2 */
3 #include "oracleProverLight.h"
4 #include "osl/checkmate/immediateCheckmate.h"
5 #include "osl/checkmate/oracleAdjust.h"
6 #include "osl/effect_util/effectUtil.h"
7 #include "osl/container/moveVector.h"
8 #include "osl/move_generator/escape_.h"
9 #include "osl/move_action/store.h"
10 #include "osl/apply_move/applyMove.h"
11
12 namespace osl
13 {
14 namespace checkmate
15 {
16 /**
17 * OracleProverLight::defense を呼ぶhelper
18 */
19 template <Player Attacker>
20 struct OracleProverLightDefense
21 {
22 OracleProverLight<Attacker> *prover;
23 ProofOracleDefense<Attacker> oracle;
24 ProofDisproof result;
25 void operator()(Square)
26 {
27 result = prover->defense(oracle);
28 }
29 };
30
31 /**
32 * OracleProverLight::attack を呼ぶhelper
33 */
34 template <Player Attacker>
35 struct OracleProverLightAttack
36 {
37 OracleProverLight<Attacker> *prover;
38 ProofOracleAttack<Attacker> oracle;
39 ProofDisproof result;
40 void operator()(Square)
41 {
42 result = prover->attack(oracle);
43 }
44 };
45
46 } // namespace checkmate
47 } // namespace osl
48
49 template <osl::Player Attacker>
50 bool osl::checkmate::OracleProverLight<Attacker>::
51 proofWin(state_t& state, ProofOracleAttack<Attacker> oracle, Move& best_move)
52 {
53 check_assert(oracle.isValid());
54 check_assert(state.turn() == Attacker);
55 this->state = &state;
56 fixed_searcher.setState(state);
57 if ((! state.inCheck())
58 && ImmediateCheckmate::hasCheckmateMove<Attacker>(state, best_move)) {
59 assert(state.isValidMove(best_move));
60 return true;
61 }
62 if (oracle.guide->getBestMove()
63 && oracle.guide->getBestMove()->flags.isSet(MoveFlags::ImmediateCheckmate))
64 return fixed_searcher.hasCheckmateMove<Attacker>(2, best_move).isCheckmateSuccess();
65 const ProofDisproof result = attack(oracle);
66 if (! result.isCheckmateSuccess())
67 return false;
68 best_move = this->best_move;
69 assert(state.isValidMove(best_move));
70 return true;
71 }
72
73 template <osl::Player Attacker>
74 bool osl::checkmate::OracleProverLight<Attacker>::
75 proofLose(state_t& state, ProofOracleDefense<Attacker> oracle, Move last_move)
76 {
77 check_assert(oracle.isValid());
78 check_assert(state.turn() == alt(Attacker));
79 this->state = &state;
80 fixed_searcher.setState(state);
81
82 const ProofDisproof result = defense(oracle);
83 if (result.isPawnDropFoul(last_move))
84 return false;
85 return result.isCheckmateSuccess();
86 }
87
88 template <osl::Player Attacker>
89 const osl::checkmate::ProofDisproof
90 osl::checkmate::OracleProverLight<Attacker>::
91 attack(ProofOracleAttack<Attacker> oracle)
92 {
93 ++node_count;
94 check_assert(oracle.isValid());
95 check_assert(state->turn() == Attacker);
96 #if 0
97 if ((! EffectUtil::isKingInCheck(Attacker, *state))
98 && ImmediateCheckmate::hasCheckmateMove<Attacker>(*state, best_move))
99 return ProofDisproof::Checkmate();
100 if (oracle.guide->getBestMove()
101 && oracle.guide->getBestMove()->flags.isSet(MoveFlags::ImmediateCheckmate))
102 return fixed_searcher.hasCheckmateMove<Attacker>(2, best_move);
103 #endif
104 if (fixed_searcher.hasCheckmateMove<Attacker>(2, best_move).isCheckmateSuccess()) {
105 state->isValidMove(best_move);
106 return ProofDisproof::Checkmate();
107 }
108
109 ProofOracleDefense<Attacker> new_oracle = oracle.expandOracle();
110 if (! new_oracle.isValid())
111 return ProofDisproof::Unknown();
112 check_assert(oracle.oracle().player() == Attacker);
113 Move check_move = OracleAdjust::attack(*state, oracle.oracle());
114 if (! check_move.isNormal())
115 return ProofDisproof::Unknown();
116
117 OracleProverLightDefense<Attacker> oracle_prover = {this, new_oracle,
118 ProofDisproof::Unknown()};
119 ApplyMove<Attacker>::doUndoMove(*state, check_move, oracle_prover);
120 if (oracle_prover.result.isPawnDropFoul(check_move))
121 return ProofDisproof::Unknown();
122
123 best_move = check_move;
124 return oracle_prover.result;
125 }
126
127 template <osl::Player Attacker>
128 const osl::checkmate::ProofDisproof
129 osl::checkmate::OracleProverLight<Attacker>::
130 defense(ProofOracleDefense<Attacker> oracle)
131 {
132 ++node_count;
133 check_assert(oracle.isValid());
134 const Player Defense = PlayerTraits<Attacker>::opponent;
135
136 const bool illegal = state->inCheck(Attacker);
137 if (illegal)
138 return ProofDisproof::NoCheckmate();
139 const bool check = state->inCheck();
140 if (! check)
141 return ProofDisproof::NoCheckmate();
142
143 MoveVector moves;
144 move_generator::GenerateEscape<Defense>::
145 generateKingEscape(*state,moves);
146
147 if (moves.empty())
148 return ProofDisproof::NoEscape();
149 for (MoveVector::const_iterator p=moves.begin(); p!=moves.end(); ++p)
150 {
151 ProofOracleAttack<Attacker> new_oracle = oracle.expandOracle(*p);
152 if (! new_oracle.isValid()) {
153 const ProofDisproof pdp = fixed_searcher.hasEscapeMove<Attacker>(*p, 2);
154 if (pdp.isCheckmateSuccess())
155 return pdp;
156 return ProofDisproof::Unknown();
157 }
158 OracleProverLightAttack<Attacker> oracle_prover = {this, new_oracle,
159 ProofDisproof::Unknown()};
160 ApplyMove<Defense>::doUndoMove(*state, *p, oracle_prover);
161
162 if (! oracle_prover.result.isCheckmateSuccess())
163 return oracle_prover.result;
164 }
165 return ProofDisproof::Checkmate();
166 }
167 namespace osl
168 {
169 namespace checkmate
170 {
171 template class OracleProverLight<BLACK>;
172 template class OracleProverLight<WHITE>;
173 }
174 }
175 // ;;; Local Variables:
176 // ;;; mode:c++
177 // ;;; c-basic-offset:2
178 // ;;; End: