All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
ntesukiMove.cc
Go to the documentation of this file.
1 /* ntesukiMove.cc
2  */
5 #include <iostream>
6 
7 
8 /* Constructors and destructors
9  */
12  : move(Move::INVALID()), flags(0), order(-1) {};
13 
16  : move(m), flags(0), order(-1),
17  h_a_proof(1), h_a_disproof(1),
18  h_d_proof(1), h_d_disproof(1)
19 {};
20 
23  : move(m), flags(f), order(-1),
24  h_a_proof(1), h_a_disproof(1),
25  h_d_proof(1), h_d_disproof(1)
26 {};
27 
30  : move(m.move), flags(m.flags), order(m.order),
31  h_a_proof(1), h_a_disproof(1),
32  h_d_proof(1), h_d_disproof(1)
33 {};
34 
38 {
39  if (this == &m) return *this;
40 
41  move = m.move;
42  flags = m.flags;
43  order = m.order;
44  h_a_proof = m.h_a_proof;
45  h_a_disproof = m.h_a_disproof;
46  h_d_proof = m.h_d_proof;
47  h_d_disproof = m.h_d_disproof;
48 
49  return *this;
50 };
51 
54 {
55 }
56 
57 /* static methods */
60 
61 /* about the state of the node */
64 {
65  ntesuki_assert(!(flags & CHECK_FLAG));
66  flags |= CHECK_FLAG;
67 };
68 
70 isCheck() const
71 {
72  return flags & CHECK_FLAG;
73 }
74 
76 setOrder(int o)
77 {
78  ntesuki_assert(order == -1);
79  order = o;
80 };
81 
83 getOrder() const
84 {
85  //ntesuki_assert(order != -1);
86  return order;
87 }
88 
91 {
92  ntesuki_assert(!(flags & NOPROMOTE));
93  flags |= NOPROMOTE;
94 };
95 
97 isNoPromote() const
98 {
99  return flags & NOPROMOTE;
100 }
101 
104 {
105  ntesuki_assert(!(flags & INTERPOSE));
106  flags |= INTERPOSE;
107 };
108 
110 isInterpose() const
111 {
112  return flags & INTERPOSE;
113 }
114 
117 {
118  ntesuki_assert(!(flags & LAME_LONG));
119  flags |= LAME_LONG;
120 }
121 
123 isLameLong() const
124 {
125  return flags & LAME_LONG;
126 }
127 
130 {
131  flags |= TO_OLDER_CHILD;
132 };
133 
135 isToOld() const
136 {
137  return flags & TO_OLDER_CHILD;
138 }
139 
140 /* setImmediateCheckmate is defiend in .tcc
141  */
142 
145 {
146  return flags & IMMEDIATE_CHECKMATE;
147 };
148 
151 {
152  flags |= BY_SIMULATION;
153 };
154 
157 {
158  return flags & BY_SIMULATION;
159 }
160 
161 /* Pawn drop checkmates
162  */
165 {
166  flags |= PAWN_DROP_CHECKMATE_FLAG;
167 };
168 
171 {
172  return (flags & PAWN_DROP_CHECKMATE_FLAG) == PAWN_DROP_CHECKMATE_FLAG;
173 }
174 
176 setHEstimates(unsigned short p_a, unsigned short d_a,
177  unsigned short p_d, unsigned short d_d)
178 {
179  h_a_proof = p_a;
180  h_a_disproof = d_a;
181  h_d_proof = p_d;
182  h_d_disproof = d_d;
183 }
184 
186 isCheckmateSuccessSlow(Player P, int pass_left) const
187 {
188  if (P == BLACK)
189  return isCheckmateSuccess<BLACK>(pass_left);
190  else
191  return isCheckmateSuccess<WHITE>(pass_left);
192 }
193 
195 isCheckmateFailSlow(Player P, int pass_left) const
196 {
197  if (P == BLACK)
198  return isCheckmateFail<BLACK>(pass_left);
199  else
200  return isCheckmateFail<WHITE>(pass_left);
201 }
202 
203 /* about the move */
205 isValid() const { return move.isValid(); }
207 isInvalid() const { return move.isInvalid(); }
209 isNormal() const { return move.isNormal(); }
211 isPass() const { return move.isPass(); }
213 isDrop() const { return move.isDrop(); }
215 to() const { return move.to(); }
217 ptype() const { return move.ptype(); }
219 getMove() const { return move; }
220 
221 /* for moves */
223 operator==(const NtesukiMove& rhs) const
224 {
225  return move == rhs.move;
226 };
228 operator!=(const NtesukiMove& rhs) const
229 {
230  return move != rhs.move;
231 };
232 /* output to stream
233  */
235 flagsToStream(std::ostream& os) const
236 {
237  int tmp = flags;
238  for (int i = 0; i < 32; ++i)
239  {
240  if (1 == (tmp % 2))
241  os << " " << NtesukiMove::FlagsStr[i];
242  tmp = tmp >> 1;
243  }
244 }
245 
246 std::ostream& osl::ntesuki::
247 operator<<(std::ostream& os, const osl::ntesuki::NtesukiMove& move)
248 {
249  os << "(" << move.getMove();
250  os << "o=" << move.getOrder() << " ";
251  move.flagsToStream(os);
252  return os << ")";
253 }
254 
255 namespace osl
256 {
257  namespace ntesuki
258  {
259  template void NtesukiMove::setCheckmateSuccess<BLACK>(int pass_left);
260  template void NtesukiMove::setCheckmateSuccess<WHITE>(int pass_left);
261  template void NtesukiMove::setCheckmateFail<BLACK>(int pass_left);
262  template void NtesukiMove::setCheckmateFail<WHITE>(int pass_left);
263  template void NtesukiMove::setImmediateCheckmate<BLACK>();
264  template void NtesukiMove::setImmediateCheckmate<WHITE>();
265  }
266 }
267 
268 std::string
270  {
271  /* 2^0 CHECK_FLAG*/
272  "CHECK",
273  /* 2^1 PAWN_DROP_CHECKMATE_FLAG = 2 */
274  "PAWN_CHECKMATE",
275  /* 2^2 */
276  "(BUG)",
277  /* 2^3 IMMEDIATE_CHECKMATE */
278  "IMMEDIATE",
279  /* 2^4 TO_OLDER_CHILD */
280  "OLD_CHILD",
281  /* 2^5 NOPROMOTE */
282  "NOPROMOTE",
283  /* 2^6 INTERPOSE */
284  "INTERPOSE",
285  /* 2^7 */
286  "ATTACK",
287  /* 2^8 */
288  "BY_SIMULATION",
289  /* 2^9 */
290  "LAME_LONG",
291  /* 2^10 */
292  "(BUG)",
293  /* 2^11 */
294  "(BUG)",
295  /* 2^12 */
296  "(BUG)",
297  /* 2^13 */
298  "(BUG)",
299  /* 2^14 */
300  "(BUG)",
301  /* 2^15 */
302  "(BUG)",
303  /* 16-19 BLACK SUCCESS */
304  "BLACK_SUCC_1",
305  "BLACK_SUCC_2",
306  "BLACK_SUCC_3",
307  "BLACK_SUCC_4",
308  /* 20-23 WHITE SUCCESS */
309  "WHITE_SUCC_1",
310  "WHITE_SUCC_2",
311  "WHITE_SUCC_3",
312  "WHITE_SUCC_4",
313  /* 24-27 BLACK FAIL */
314  "BLACK_FAIL_1",
315  "BLACK_FAIL_2",
316  "BLACK_FAIL_3",
317  "BLACK_FAIL_4",
318  /* 28-31 WHITE FAIL */
319  "WHITE_FAIL_1",
320  "WHITE_FAIL_2",
321  "WHITE_FAIL_3",
322  "WHITE_FAIL_4",
323  };