size_t src_bit_width(IROpcode op, int i) {
// move-* opcodes can always be encoded as move-*/16
if (is_move(op)) {
return 16;
}
return dex_opcode::src_bit_width(opcode::to_dex_opcode(op), i);
}
/**
*末尾へ移動
*/
void Notation::Last()
{
int pos;
pos = this->number() - (*this->current_moves_)[0].number();
ASSERT_MSG(pos >= 0, "内部状態が変?");
while (pos < (int)this->current_moves_->size())
{
if (this->move_current_->getCurrentBranchNumber() == -1)
{
pos++;
if (pos >= (int)this->current_moves_->size())
{
break;
}
}
else
{
this->current_moves_ = this->move_current_->getCurrentBranch();
pos = 0;
}
this->move_current_ = &(*this->current_moves_)[pos];
if (is_move(this->move_current_->move_type()))
{
// 指し手の場合局面をすすめる
this->position_.DoMove(*this->move_current_);
}
}
}
/**
*指定指し手へ移動
*/
void Notation::Jump(int num)
{
this->position_ = this->initial_position_;
this->current_moves_ = &this->moves_;
Moves::iterator ite = this->current_moves_->begin();
while (ite != this->current_moves_->end())
{
MoveKif& move = *ite++;
this->move_current_ = &move;
if (is_move(move.move_type()))
{
// 指し手の場合局面をすすめる
this->position_.DoMove(move);
}
if (move.number() == num)
{
// 所定の位置まできたので終了
break;
}
if (move.getCurrentBranchNumber() >= 0)
{
// 分岐側
this->current_moves_ = move.getCurrentBranch();
ite = this->current_moves_->begin();
}
}
}
void curr_exe() {
if (is_alive(CURR_POKEMON) && is_alive(OTHR_POKEMON)) {
if (is_move(CURR_ACTION)) {
curr_attack();
} else {
curr_switchto();
}
}
}
boost::optional<ParamIndex> find_return_param_index(
cfg::ControlFlowGraph& cfg) {
for (auto& mie : InstructionIterable(cfg)) {
TRACE(RP, 2, " %s\n", SHOW(mie.insn));
}
// find register that is being returned (if any)
cfg.calculate_exit_block();
auto exit_block = cfg.exit_block();
auto it = exit_block->rbegin();
if (it == exit_block->rend() || !is_return_value(it->insn->opcode()))
return boost::none;
auto return_reg = it->insn->src(0);
TRACE(RP, 2, " returns v%d\n", return_reg);
++it;
if (it == exit_block->rend() || !is_move(it->insn->opcode()))
return boost::none;
auto src_reg = it->insn->src(0);
TRACE(RP, 2, " move v%d, v%d\n", it->insn->dest(), src_reg);
if (it->insn->dest() != return_reg) return boost::none;
// let's see if it came from a unique load-param
IRInstruction* load_param = nullptr;
for (auto& mie : InstructionIterable(cfg)) {
if (mie.insn->dests_size()) {
if (mie.insn->dest() == src_reg) {
if (opcode::is_load_param(mie.insn->opcode())) {
load_param = mie.insn;
} else {
TRACE(RP, 2, " move_reg clobbered\n");
return boost::none;
}
}
}
}
if (load_param != nullptr) {
ParamIndex param_index = get_load_param_map(cfg).at(load_param);
TRACE(RP, 2, " found matching load-param %d\n", param_index);
return param_index;
} else {
TRACE(RP, 2, " did not find matching load-param\n");
return boost::none;
}
}
/**
*指定した手数戻る
*/
bool Notation::Prev(int num)
{
int pos;
bool ret = false;
pos = this->number() - (*this->current_moves_)[0].number();
ASSERT_MSG(pos >= 0, "内部状態が変?");
for (int i = 0; i < num; i++)
{
MoveKif& move = (*this->current_moves_)[pos];
if (pos <= 0)
{
if (this->current_moves_->parent() == nullptr)
{
break;
}
// 親の分岐を取得
this->current_moves_ = this->current_moves_->parent();
pos = move.getParentNumber() - (*this->current_moves_)[0].number();
}
else
{
pos--;
}
if (is_move(move.move_type()))
{
// 指し手の場合局面をすすめる
this->position_.UndoMove(move);
}
this->move_current_ = &(*this->current_moves_)[pos];
ret = true; // 指し手の移動があったのでtrue;
}
return ret;
}
size_t dest_bit_width(IRList::iterator it) {
auto insn = it->insn;
auto op = insn->opcode();
if (opcode::is_move_result_pseudo(op)) {
auto primary_op =
ir_list::primary_instruction_of_move_result_pseudo(it)->opcode();
if (primary_op == OPCODE_CHECK_CAST) {
return 4;
} else {
return dex_opcode::dest_bit_width(opcode::to_dex_opcode(primary_op));
}
} else if (opcode::is_internal(op) || is_move(op)) {
// move-* opcodes can always be encoded as move-*/16
return 16;
} else if (is_literal_const(op)) {
// const opcodes can always be encoded in a form that addresses 8-bit regs
return 8;
} else {
return dex_opcode::dest_bit_width(opcode::to_dex_opcode(op));
}
}
// [TestMethod, Description("")]
TEST_F(MoveCheckTest, testCanPromota)
{
Position pos;
Sfen::LoadPosition(pos, sfen2);
int i = 0;
for (auto str : moves)
{
Move movedata = Sfen::ParseMove(pos, str);
ASSERT_EQ(MoveCheck::CanPromota(movedata), promotions[i]);
if (is_move(movedata.move_type()))
{
pos.DoMove(movedata);
}
i++;
}
}
/*-----------------------------------------------------------------------------*/
bool Notation::Next(int num)
{
int pos;
bool ret = false;
pos = this->number() - (*this->current_moves_)[0].number();
ASSERT_MSG(pos >= 0, "内部状態が変?");
for (int i = 0; i < num && pos < (int)this->current_moves_->size(); i++)
{
if (this->move_current_->getCurrentBranchNumber() == -1)
{
pos++;
if (pos >= (int)this->current_moves_->size())
{
break;
}
}
else
{
this->current_moves_ = this->move_current_->getCurrentBranch();
pos = 0;
}
ret = true;
this->move_current_ = &(*this->current_moves_)[pos];
if (is_move(this->move_current_->move_type()))
{
// 指し手の場合局面をすすめる
this->position_.DoMove(*this->move_current_);
}
}
return ret;
}
/*
* Build the interference graph by adding edges between nodes that are
* simultaneously live.
*
* check-cast instructions have to be handled specially. They are represented
* with both a dest (via a move-result-pseudo) and a src in our IR. However, in
* actual Dex bytecode, it only takes a single operand which acts as both src
* and dest. So when converting IR to Dex bytecode, we need to insert a move
* instruction if the src and dest operands differ. We must insert the move
* before, not after, the check-cast. Suppose we did not:
*
* IR | Dex
* sget-object v0 LFoo; | sget-object v0 LFoo;
* check-cast v0 LBar; | check-cast v0 LBar;
* move-result-pseudo v1 | move-object v1 v0
* invoke-static v0 LFoo.a; | invoke-static v0 LFoo.a; // v0 is of type Bar!
*
* However, inserting before the check-cast is tricky to get right. If the
* check-cast is in a try region, we must be careful to not clobber other
* live registers. For example, if we had some IRCode like
*
* B0:
* load-param v1 Ljava/lang/Object;
* TRY_START
* const v0 123
* check-cast v1 LFoo;
* B1:
* move-result-pseudo v0
* return v0
* TRY_END
* B2:
* CATCH
* // handle failure of check-cast
* // Note that v0 has the value of 123 here because the check-cast failed
* add-int v0, v0, v0
*
* Inserting the move before the check-cast would cause v0 to have an object
* (instead of integer) type inside the exception handler.
*
* The solution is to have the interference graph make check-cast's dest
* register interfere with the live registers in both B0 and B1, so that when
* the move gets inserted, it does not clobber any live registers.
*/
Graph GraphBuilder::build(const LivenessFixpointIterator& fixpoint_iter,
IRCode* code,
reg_t initial_regs,
const RangeSet& range_set) {
Graph graph;
auto ii = InstructionIterable(code);
for (auto it = ii.begin(); it != ii.end(); ++it) {
GraphBuilder::update_node_constraints(it.unwrap(), range_set, &graph);
}
auto& cfg = code->cfg();
for (cfg::Block* block : cfg.blocks()) {
LivenessDomain live_out = fixpoint_iter.get_live_out_vars_at(block);
for (auto it = block->rbegin(); it != block->rend(); ++it) {
if (it->type != MFLOW_OPCODE) {
continue;
}
auto insn = it->insn;
auto op = insn->opcode();
if (opcode::has_range_form(op)) {
graph.m_range_liveness.emplace(insn, live_out);
}
if (insn->dests_size()) {
for (auto reg : live_out.elements()) {
if (is_move(op) && reg == insn->src(0)) {
continue;
}
graph.add_edge(insn->dest(), reg);
}
// We add interference edges between the wide src and dest operands of
// an instruction even if the srcs are not live-out. This avoids
// allocations like `xor-long v1, v0, v9`, where v1 and v0 overlap --
// even though this is not a verification error, we have observed bugs
// in the ART interpreter when handling these sorts of instructions.
// However, we still want to be able to coalesce these symregs if they
// don't actually interfere based on liveness information, so that we
// can remove move-wide opcodes and/or use /2addr encodings. As such,
// we insert a specially marked edge that coalescing ignores but
// coloring respects.
if (insn->dest_is_wide()) {
for (size_t i = 0; i < insn->srcs_size(); ++i) {
if (insn->src_is_wide(i)) {
graph.add_coalesceable_edge(insn->dest(), insn->src(i));
}
}
}
}
if (op == OPCODE_CHECK_CAST) {
auto move_result_pseudo = std::prev(it)->insn;
for (auto reg : live_out.elements()) {
graph.add_edge(move_result_pseudo->dest(), reg);
}
}
// adding containment edge between liverange defined in insn and elements
// in live-out set of insn
if (insn->dests_size()) {
for (auto reg : live_out.elements()) {
graph.add_containment_edge(insn->dest(), reg);
}
}
fixpoint_iter.analyze_instruction(it->insn, &live_out);
// adding containment edge between liverange used in insn and elements
// in live-in set of insn
for (size_t i = 0; i < insn->srcs_size(); ++i) {
for (auto reg : live_out.elements()) {
graph.add_containment_edge(insn->src(i), reg);
}
}
}
}
for (auto& pair : graph.nodes()) {
auto reg = pair.first;
auto& node = pair.second;
if (reg >= initial_regs) {
node.m_props.set(Node::SPILL);
}
assert_log(!node.m_type_domain.is_bottom(),
"Type violation of v%u in code:\n%s\n",
reg,
SHOW(code));
}
return graph;
}
void loop(char *input, render_callback render_board){
/* case where it's the computer's turn to move: */
if (!is_edit_mode && (comp_color == white_to_move || automode)
&& !force_mode && !must_sit && !result) {
/* whatever happens, never allow pondering in normal search */
is_pondering = FALSE_C;
cpu_start = clock ();
comp_move = think ();
cpu_end = clock();
ply = 0;
/* must_sit can be changed by search */
if (!must_sit || must_go != 0)
{
/* check for a game end: */
if ((
((Variant == Losers || Variant == Suicide)
&&
((result != white_is_mated) && (result != black_is_mated)))
||
((Variant == Normal || Variant == Crazyhouse || Variant == Bughouse)
&& ((comp_color == 1 && result != white_is_mated)
||
(comp_color == 0 && result != black_is_mated)
)))
&& result != stalemate
&& result != draw_by_fifty
&& result != draw_by_rep)
{
comp_to_coord (comp_move, output);
hash_history[move_number] = hash;
game_history[move_number] = comp_move;
make (&comp_move, 0);
/* saves state info */
game_history_x[move_number++] = path_x[0];
userealholdings = 0;
must_go--;
/* check to see if we draw by rep/fifty after our move: */
if (is_draw ()) {
result = draw_by_rep;
}
else if (fifty > 100) {
result = draw_by_fifty;
}
root_to_move ^= 1;
reset_piece_square ();
if (book_ply < 40) {
if (!book_ply) {
strcpy(opening_history, output);
}
else {
strcat(opening_history, output);
}
}
book_ply++;
printf ("\nNodes: %d (%0.2f%% qnodes)\n", nodes,
(float) ((float) qnodes / (float) nodes * 100.0));
elapsed = (cpu_end-cpu_start)/(double) CLOCKS_PER_SEC;
nps = (float) nodes/(float) elapsed;
if (!elapsed)
printf ("NPS: N/A\n");
else
printf ("NPS: %d\n", (int32_t) nps);
printf("ECacheProbes : %d ECacheHits : %d HitRate : %f%%\n",
ECacheProbes, ECacheHits,
((float)ECacheHits/((float)ECacheProbes+1)) * 100);
printf("TTStores : %d TTProbes : %d TTHits : %d HitRate : %f%%\n",
TTStores, TTProbes, TTHits,
((float)TTHits/((float)TTProbes+1)) * 100);
printf("NTries : %d NCuts : %d CutRate : %f%% TExt: %d\n",
NTries, NCuts, (((float)NCuts*100)/((float)NTries+1)), TExt);
printf("Check extensions: %d Razor drops : %d Razor Material : %d\n", ext_check, razor_drop, razor_material);
printf("EGTB Hits: %d EGTB Probes: %d Efficiency: %3.1f%%\n", EGTBHits, EGTBProbes,
(((float)EGTBHits*100)/(float)(EGTBProbes+1)));
printf("Move ordering : %f%%\n", (((float)FHF*100)/(float)(FH+1)));
printf("Material score: %d Eval : %d White hand: %d Black hand : %d\n",
Material, (int)eval(), white_hand_eval, black_hand_eval);
printf("Hash : %X HoldHash : %X\n", (unsigned)hash, (unsigned)hold_hash);
/* check to see if we mate our opponent with our current move: */
if (!result) {
if (xb_mode) {
/* safety in place here */
if (comp_move.from != dummy.from || comp_move.target != dummy.target)
printf ("move %s\n", output);
if (Variant == Bughouse)
{
CheckBadFlow(FALSE_C);
}
}
else {
if (comp_move.from != dummy.from || comp_move.target != dummy.target)
printf ("\n%s\n", output);
}
}
else {
if (xb_mode) {
if (comp_move.from != dummy.from || comp_move.target != dummy.target)
printf ("move %s\n", output);
}
else {
if (comp_move.from != dummy.from || comp_move.target != dummy.target)
printf ("\n%s\n", output);
}
if (result == white_is_mated) {
printf ("0-1 {Black Mates}\n");
}
else if (result == black_is_mated) {
printf ("1-0 {White Mates}\n");
}
else if (result == draw_by_fifty) {
printf ("1/2-1/2 {Fifty move rule}\n");
}
else if (result == draw_by_rep) {
printf ("1/2-1/2 {3 fold repetition}\n");
}
else {
printf ("1/2-1/2 {Draw}\n");
}
automode = 0;
}
}
/* we have been mated or stalemated: */
else {
if (result == white_is_mated) {
printf ("0-1 {Black Mates}\n");
}
else if (result == black_is_mated) {
printf ("1-0 {White Mates}\n");
}
else if (result == draw_by_fifty) {
printf ("1/2-1/2 {Fifty move rule}\n");
}
else if (result == draw_by_rep) {
printf ("1/2-1/2 {3 fold repetition}\n");
}
else {
printf ("1/2-1/2 {Draw}\n");
}
automode = 0;
}
}
}
/* get our input: */
if (!xb_mode) {
if (show_board) {
printf ("\n");
display_board (stdout, 1-comp_color);
render_board(1-comp_color);
}
if (!automode)
{
printf ("Sjeng: ");
//readStr(input, STR_BUFF);
// rinput (input, STR_BUFF, stdin);
}
}
else {
/* start pondering */
if ((must_sit || (allow_pondering && !is_edit_mode && !force_mode &&
move_number != 0) || is_analyzing) && !result && !automode)
{
is_pondering = TRUE_C;
think();
is_pondering = FALSE_C;
ply = 0;
}
if (!automode)
{
//rinput (input, STR_BUFF, stdin);
}
}
/* check to see if we have a move. If it's legal, play it. */
if (!is_edit_mode && is_move (&input[0])) {
if (verify_coord (input, &human_move)) {
if (confirm_moves) printf ("Legal move: %s\n", input);
game_history[move_number] = human_move;
hash_history[move_number] = hash;
make (&human_move, 0);
game_history_x[move_number++] = path_x[0];
reset_piece_square ();
root_to_move ^= 1;
if (book_ply < 40) {
if (!book_ply) {
strcpy(opening_history, input);
}
else {
strcat(opening_history, input);
}
}
book_ply++;
if (show_board) {
printf ("\n");
display_board (stdout, 1-comp_color);
render_board(1-comp_color);
}
}
else {
printf ("Illegal move: %s\n", input);
}
}
else {
/* make everything lower case for convenience: */
/* GCP: except for setboard, which is case sensitive */
if (!strstr(input, "setboard")){
for (p = input; *p; p++) {
*p = tolower (*p);
}
}
/* command parsing: */
if (!strcmp (input, "quit") || (!input[0] && feof(stdin))) {
safe_fclose(lrn_standard);
safe_fclose(lrn_zh);
safe_fclose(lrn_suicide);
safe_fclose(lrn_losers);
free_hash();
free_ecache();
exit (EXIT_SUCCESS);
}
else if (!strcmp (input, "exit"))
{
if (is_analyzing)
{
is_analyzing = FALSE_C;
is_pondering = FALSE_C;
time_for_move = 0;
}
else
{
safe_fclose(lrn_standard);
safe_fclose(lrn_zh);
safe_fclose(lrn_suicide);
safe_fclose(lrn_losers);
free_hash();
free_ecache();
exit (EXIT_SUCCESS);
}
}
else if (!strcmp (input, "diagram") || !strcmp (input, "d")) {
toggle_bool_c (&show_board);
}
else if (!strncmp (input, "perft", 5)) {
sscanf (input+6, "%d", &depth);
raw_nodes = 0;
xstart_time = rtime();
perft (depth);
printf ("Raw nodes for depth %d: %d\n", depth, raw_nodes);
printf("Time : %.2f\n", (float)rdifftime(rtime(), xstart_time)/100.);
}
else if (!strcmp (input, "confirm_moves")) {
confirm_moves = TRUE_C;
printf("Will now confirm moves.\n");
}
else if (!strcmp (input, "new")) {
if (xb_mode)
{
printf("tellics set 1 Sjeng " VERSION " (2001-9-28/%s)\n", setcode);
}
if (!is_analyzing)
{
memcpy(material, std_material, sizeof(std_material));
Variant = Normal;
// memcpy(material, zh_material, sizeof(zh_material));
//Variant = Crazyhouse;
init_game ();
initialize_hash();
if (!braindeadinterface)
{
clear_tt();
init_book();
reset_ecache();
}
force_mode = FALSE_C;
must_sit = FALSE_C;
go_fast = FALSE_C;
piecedead = FALSE_C;
partnerdead = FALSE_C;
kibitzed = FALSE_C;
fixed_time = FALSE_C;
root_to_move = WHITE;
comp_color = 0;
move_number = 0;
hash_history[move_number] = 0;
bookidx = 0;
my_rating = opp_rating = 2000;
must_go = 0;
tradefreely = 1;
automode = 0;
CheckBadFlow(TRUE_C);
ResetHandValue();
}
else
{
init_game ();
move_number = 0;
}
}
else if (!strcmp (input, "xboard")) {
xb_mode = TRUE_C;
toggle_bool_c (&show_board);
signal (SIGINT, SIG_IGN);
printf ("\n");
/* Reset f5 in case we left with partner */
printf("tellics set f5 1=1\n");
BegForPartner();
}
else if (!strcmp (input, "nodes")) {
printf ("Number of nodes: %d (%0.2f%% qnodes)\n", nodes,
(float) ((float) qnodes / (float) nodes * 100.0));
}
else if (!strcmp (input, "nps")) {
elapsed = (cpu_end-cpu_start)/(double) CLOCKS_PER_SEC;
nps = (float) nodes/(float) elapsed;
if (!elapsed)
printf ("NPS: N/A\n");
else
printf ("NPS: %d\n", (int32_t) nps);
}
else if (!strcmp (input, "post")) {
toggle_bool_c (&post);
if (xb_mode)
post = TRUE_C;
}
else if (!strcmp (input, "nopost")) {
post = FALSE_C;
}
else if (!strcmp (input, "random")) {
return;
}
else if (!strcmp (input, "hard")) {
allow_pondering = TRUE_C;
return;
}
else if (!strcmp (input, "easy")) {
allow_pondering = FALSE_C;
return;
}
else if (!strcmp (input, "?")) {
return;
}
else if (!strcmp (input, "white")) {
white_to_move = 1;
root_to_move = WHITE;
comp_color = 0;
}
else if (!strcmp (input, "black")) {
white_to_move = 0;
root_to_move = BLACK;
comp_color = 1;
}
else if (!strcmp (input, "force")) {
force_mode = TRUE_C;
}
else if (!strcmp (input, "eval")) {
check_phase();
printf("Eval: %d\n", (int)eval());
}
else if (!strcmp (input, "go")) {
comp_color = white_to_move;
force_mode = FALSE_C;
}
else if (!strncmp (input, "time", 4)) {
sscanf (input+5, "%d", &time_left);
}
else if (!strncmp (input, "otim", 4)) {
sscanf (input+5, "%d", &opp_time);
}
else if (!strncmp (input, "level", 5)) {
if (strstr(input+6, ":"))
{
/* time command with seconds */
sscanf (input+6, "%d %d:%d %d", &moves_to_tc, &min_per_game,
&sec_per_game, &inc);
time_left = (min_per_game*6000) + (sec_per_game * 100);
opp_time = time_left;
}
else
{
/* extract the time controls: */
sscanf (input+6, "%d %d %d", &moves_to_tc, &min_per_game, &inc);
time_left = min_per_game*6000;
opp_time = time_left;
}
fixed_time = FALSE_C;
time_cushion = 0;
}
else if (!strncmp (input, "rating", 6)) {
sscanf (input+7, "%d %d", &my_rating, &opp_rating);
if (my_rating == 0) my_rating = 2000;
if (opp_rating == 0) opp_rating = 2000;
}
else if (!strncmp (input, "holding", 7)) {
ProcessHoldings(input);
}
else if (!strncmp (input, "variant", 7)) {
if (strstr(input, "normal"))
{
Variant = Normal;
memcpy(material, std_material, sizeof(std_material));
init_book();
}
else if (strstr(input, "crazyhouse"))
{
Variant = Crazyhouse;
memcpy(material, zh_material, sizeof(zh_material));
init_book();
}
else if (strstr(input, "bughouse"))
{
Variant = Bughouse;
memcpy(material, zh_material, sizeof(zh_material));
init_book();
}
else if (strstr(input, "suicide"))
{
Variant = Suicide;
Giveaway = FALSE_C;
memcpy(material, suicide_material, sizeof(suicide_material));
init_book();
}
else if (strstr(input, "giveaway"))
{
Variant = Suicide;
Giveaway = TRUE_C;
memcpy(material, suicide_material, sizeof(suicide_material));
init_book();
}
else if (strstr(input, "losers"))
{
Variant = Losers;
memcpy(material, losers_material, sizeof(losers_material));
init_book();
}
initialize_hash();
clear_tt();
reset_ecache();
}
else if (!strncmp (input, "analyze", 7)) {
is_analyzing = TRUE_C;
is_pondering = TRUE_C;
think();
ply = 0;
}
else if (!strncmp (input, "undo", 4)) {
printf("Move number : %d\n", move_number);
if (move_number > 0)
{
path_x[0] = game_history_x[--move_number];
unmake(&game_history[move_number], 0);
reset_piece_square();
root_to_move ^= 1;
}
result = 0;
}
else if (!strncmp (input, "remove", 5)) {
if (move_number > 1)
{
path_x[0] = game_history_x[--move_number];
unmake(&game_history[move_number], 0);
reset_piece_square();
path_x[0] = game_history_x[--move_number];
unmake(&game_history[move_number], 0);
reset_piece_square();
}
result = 0;
}
else if (!strncmp (input, "edit", 4)) {
is_edit_mode = TRUE_C;
edit_color = WHITE;
}
else if (!strncmp (input, ".", 1) && is_edit_mode) {
is_edit_mode = FALSE_C;
if (wking_loc == 30) white_castled = no_castle;
if (bking_loc == 114) black_castled = no_castle;
book_ply = 50;
ep_square = 0;
move_number = 0;
memset(opening_history, 0, sizeof(opening_history));
clear_tt();
initialize_hash();
reset_piece_square();
}
else if (is_edit_mode && !strncmp (input, "c", 1)) {
if (edit_color == WHITE) edit_color = BLACK; else edit_color = WHITE;
}
else if (is_edit_mode && !strncmp (input, "#", 1)) {
reset_board();
move_number = 0;
}
else if (is_edit_mode
&& isalpha(input[0])
&& isalpha(input[1])
&& isdigit(input[2])) {
PutPiece(edit_color, input[0], input[1], input[2]);
}
else if (!strncmp (input, "partner", 7)) {
HandlePartner(input+7);
}
else if (!strncmp (input, "$partner", 8)) {
HandlePartner(input+8);
}
else if (!strncmp (input, "ptell", 5)) {
HandlePtell(input);
}
else if (!strncmp (input, "test", 4)) {
run_epd_testsuite();
}
else if (!strncmp (input, "st", 2)) {
sscanf(input+3, "%d", &fixed_time);
fixed_time = fixed_time * 100;
}
else if (!strncmp (input, "book", 4)) {
build_book();
}
else if (!strncmp (input, "speed", 5)) {
speed_test();
}
else if (!strncmp (input, "result", 6)) {
if (cfg_booklearn)
{
if (strstr (input+7, "1-0"))
{
if (comp_color == 1)
book_learning(WIN);
else
book_learning(LOSS);
}
else if (strstr(input+7, "0-1"))
{
if (comp_color == 1)
book_learning(LOSS);
else
book_learning(WIN);
}
else if (strstr(input+7, "1/2-1/2"))
{
book_learning(DRAW);
};
}
}
else if (!strncmp (input, "prove", 5)) {
printf("\nMax time to search (s): ");
start_time = rtime();
rinput(readbuff, STR_BUFF, stdin);
pn_time = atoi(readbuff) * 100;
printf("\n");
proofnumbersearch();
}
else if (!strncmp (input, "ping", 4)) {
sscanf (input+5, "%d", &pingnum);
printf("pong %d\n", pingnum);
}
else if (!strncmp (input, "fritz", 5)) {
braindeadinterface = TRUE_C;
}
else if (!strncmp (input, "reset", 5)) {
memcpy(material, std_material, sizeof(std_material));
Variant = Normal;
init_game ();
initialize_hash();
clear_tt();
init_book();
reset_ecache();
force_mode = FALSE_C;
fixed_time = FALSE_C;
root_to_move = WHITE;
comp_color = 0;
move_number = 0;
bookidx = 0;
my_rating = opp_rating = 2000;
}
else if (!strncmp (input, "setboard", 8)) {
setup_epd_line(input+9);
}
else if (!strncmp (input, "buildegtb", 9)) {
Variant = Suicide;
gen_all_tables();
}
else if (!strncmp (input, "lookup", 6)) {
Variant = Suicide;
printf("Value : %d\n", egtb(white_to_move));
}
else if (!strncmp (input, ".", 1)) {
/* periodic updating and were not searching */
/* most likely due to proven mate */
return;
}
else if (!strncmp (input, "sd", 2)) {
sscanf(input+3, "%d", &maxdepth);
printf("New max depth set to: %d\n", maxdepth);
return;
}
else if (!strncmp (input, "auto", 4)) {
automode = 1;
return;
}
else if (!strncmp (input, "protover", 8)) {
printf("feature ping=1 setboard=1 playother=0 san=0 usermove=0 time=1\n");
printf("feature draw=0 sigint=0 sigterm=0 reuse=1 analyze=1\n");
printf("feature myname=\"Sjeng " VERSION "\"\n");
printf("feature variants=\"normal,bughouse,crazyhouse,suicide,giveaway,losers\"\n");
printf("feature colors=1 ics=0 name=0 pause=0 done=1\n");
xb_mode = 2;
}
else if (!strncmp (input, "accepted", 8)) {
/* do nothing as of yet */
}
else if (!strncmp (input, "rejected", 8)) {
printf("Interface does not support a required feature...expect trouble.\n");
}
else if (!strncmp (input, "warranty", 8)) {
printf("\n BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n"
"FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\n"
"OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n"
"PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n"
"OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n"
"MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\n"
"TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\n"
"PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n"
"REPAIR OR CORRECTION.\n"
"\n");
printf(" IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n"
"WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n"
"REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n"
"INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n"
"OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n"
"TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n"
"YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n"
"PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n"
"POSSIBILITY OF SUCH DAMAGES.\n\n");
}
else if (!strncmp (input, "distribution", 12)) {
printf("\n You may copy and distribute verbatim copies of the Program's\n"
"source code as you receive it, in any medium, provided that you\n"
"conspicuously and appropriately publish on each copy an appropriate\n"
"copyright notice and disclaimer of warranty; keep intact all the\n"
"notices that refer to this License and to the absence of any warranty;\n"
"and give any other recipients of the Program a copy of this License\n"
"along with the Program.\n"
"\n"
"You may charge a fee for the physical act of transferring a copy, and\n"
"you may at your option offer warranty protection in exchange for a fee.\n\n");
}
else if (!strcmp (input, "help")) {
printf ("\n%s\n\n", divider);
printf ("diagram/d: toggle diagram display\n");
printf ("exit/quit: terminate Sjeng\n");
printf ("go: make Sjeng play the side to move\n");
printf ("new: start a new game\n");
printf ("level <x>: the xboard style command to set time\n");
printf (" <x> should be in the form: <a> <b> <c> where:\n");
printf (" a -> moves to TC (0 if using an ICS style TC)\n");
printf (" b -> minutes per game\n");
printf (" c -> increment in seconds\n");
printf ("nodes: outputs the number of nodes searched\n");
printf ("nps: outputs Sjeng's NPS in search\n");
printf ("perft <x>: compute raw nodes to depth x\n");
printf ("post: toggles thinking output\n");
printf ("xboard: put Sjeng into xboard mode\n");
printf ("test: run an EPD testsuite\n");
printf ("speed: test movegen and evaluation speed\n");
printf ("warranty: show warranty details\n");
printf ("distribution: show distribution details\n");
printf( "proof: try to prove or disprove the current pos\n");
printf( "sd <x>: limit thinking to depth x\n");
printf( "st <x>: limit thinking to x centiseconds\n");
printf( "setboard <FEN>: set board to a specified FEN string\n");
printf( "undo: back up a half move\n");
printf( "remove: back up a full move\n");
printf( "force: disable computer moving\n");
printf( "auto: computer plays both sides\n");
printf ("\n%s\n\n", divider);
show_board = 0;
}
else if (!xb_mode) {
printf ("Illegal move: %s\n", input);
}
}
}
int main (int argc, char *argv[]) {
char input[STR_BUFF], *p, output[STR_BUFF];
move_s move, comp_move;
int depth = 4, comp_color;
bool force_mode, show_board;
double nps, elapsed;
clock_t cpu_start = 0, cpu_end = 0;
parse_cmdline (argc, argv);
start_up ();
init_hash_values ();
init_hash_tables ();
init_game ();
init_book ();
xb_mode = FALSE;
force_mode = FALSE;
comp_color = 0;
show_board = TRUE;
setbuf (stdout, NULL);
setbuf (stdin, NULL);
/* keep looping for input, and responding to it: */
while (TRUE) {
/* case where it's the computer's turn to move: */
if (comp_color == white_to_move && !force_mode) {
nodes = 0;
qnodes = 0;
ply = 0;
start_time = rtime ();
cpu_start = clock ();
comp_move = think ();
cpu_end = clock ();
/* check for a game end: */
if (((comp_color == 1 && result != white_is_mated) ||
(comp_color == 0 && result != black_is_mated)) &&
result != stalemate && result != draw_by_fifty &&
result != draw_by_rep) {
comp_to_coord (comp_move, output);
make (&comp_move, 0);
/* check to see if we draw by rep/fifty after our move: */
if (is_draw ()) {
result = draw_by_rep;
}
else if (fifty > 100) {
result = draw_by_fifty;
}
reset_piece_square ();
/* check to see if we mate our opponent with our current move: */
if (!result) {
if (xb_mode) {
printf ("move %s\n", output);
}
else {
printf ("\n%s\n", output);
}
}
else {
if (xb_mode) {
printf ("move %s\n", output);
}
else {
printf ("\n%s\n", output);
}
if (result == white_is_mated) {
printf ("0-1 {Black Mates}\n");
}
else if (result == black_is_mated) {
printf ("1-0 {White Mates}\n");
}
else if (result == draw_by_fifty) {
printf ("1/2-1/2 {Fifty move rule}\n");
}
else if (result == draw_by_rep) {
printf ("1/2-1/2 {3 fold repetition}\n");
}
else {
printf ("1/2-1/2 {Draw}\n");
}
}
}
/* we have been mated or there is a draw: */
else {
if (result == white_is_mated) {
printf ("0-1 {Black Mates}\n");
}
else if (result == black_is_mated) {
printf ("1-0 {White Mates}\n");
}
else if (result == stalemate) {
printf ("1/2-1/2 {Stalemate}\n");
}
else if (result == draw_by_fifty) {
printf ("1/2-1/2 {Fifty move rule}\n");
}
else if (result == draw_by_rep) {
printf ("1/2-1/2 {3 fold repetition}\n");
}
else {
printf ("1/2-1/2 {Draw}\n");
}
}
}
/* get our input: */
if (!xb_mode) {
if (show_board && strcmp (input, "help")) {
printf ("\n");
display_board (stdout, 1-comp_color);
}
printf ("Faile> ");
rinput (input, STR_BUFF, stdin);
}
else {
rinput (input, STR_BUFF, stdin);
}
/* check to see if we have a move. If it's legal, play it. */
if (is_valid_comp (pgn_to_comp (input))) {
/* good SAN input style move */
move = pgn_to_comp (input);
make (&move, 0);
reset_piece_square ();
if (show_board) {
printf ("\n");
display_board (stdout, 1-comp_color);
}
}
else if (is_move (&input[0])) {
/* good coordinate style input move */
if (verify_coord (input, &move)) {
make (&move, 0);
reset_piece_square ();
if (show_board) {
printf ("\n");
display_board (stdout, 1-comp_color);
}
}
else {
printf ("Illegal move: %s\n", input);
}
}
else {
/* make everything lower case for convenience: */
for (p = input; *p; p++) *p = tolower (*p);
/* command parsing: */
if (!strcmp (input, "quit") || !strcmp (input, "exit")) {
shut_down (EXIT_SUCCESS);
}
else if (!strcmp (input, "diagram") || !strcmp (input, "d")) {
toggle_bool (&show_board);
}
else if (!strncmp (input, "perft", 5)) {
sscanf (input+6, "%d", &depth);
raw_nodes = 0;
perft (depth);
printf ("Raw nodes for depth %d: %ld\n", depth, raw_nodes);
}
else if (!strcmp (input, "new")) {
init_game ();
/* refresh our hash tables: */
refresh_hash ();
force_mode = FALSE;
comp_color = 0;
}
else if (!strcmp (input, "xboard")) {
xb_mode = TRUE;
toggle_bool (&show_board);
signal (SIGINT, SIG_IGN);
printf ("\n");
}
else if (!strcmp (input, "nodes")) {
printf ("Number of nodes: %li (%0.2f%% qnodes)\n", nodes,
(float) ((float) qnodes / (float) nodes * 100.0));
}
else if (!strcmp (input, "nps")) {
elapsed = (cpu_end-cpu_start)/(double) CLOCKS_PER_SEC;
nps = (float) nodes/(float) elapsed;
if (!elapsed)
printf ("NPS: N/A\n");
else
printf ("NPS: %ld\n", (long int) nps);
}
else if (!strcmp (input, "post")) {
toggle_bool (&post);
if (xb_mode)
post = TRUE;
}
else if (!strcmp (input, "nopost")) {
post = FALSE;
}
else if (!strcmp (input, "random")) {
continue;
}
else if (!strcmp (input, "hard")) {
continue;
}
else if (!strcmp (input, "easy")) {
continue;
}
else if (!strcmp (input, "?")) {
continue;
}
else if (!strcmp (input, "white")) {
white_to_move = 1;
comp_color = 0;
}
else if (!strcmp (input, "black")) {
white_to_move = 0;
comp_color = 1;
}
else if (!strcmp (input, "force")) {
force_mode = TRUE;
}
else if (!strcmp (input, "go")) {
comp_color = white_to_move;
force_mode = FALSE;
}
else if (!strncmp (input, "time", 4)) {
sscanf (input+5, "%ld", &time_left);
}
else if (!strncmp (input, "otim", 4)) {
sscanf (input+5, "%ld", &opp_time);
}
else if (!strncmp (input, "level", 5)) {
/* extract the time controls: */
sscanf (input+6, "%ld %ld %ld", &moves_to_tc, &min_per_game, &inc);
time_left = min_per_game*6000;
opp_time = time_left;
inc *= 100;
}
else if (!strncmp (input, "result", 6)) {
ics_game_end ();
init_game ();
force_mode = FALSE;
comp_color = 0;
}
else if (!strcmp (input, "help")) {
printf ("\n%s\n\n", divider);
printf ("diagram/d: toggle diagram display\n");
printf ("exit/quit: terminate Faile\n");
printf ("go: make Faile play the side to move\n");
printf ("new: start a new game\n");
printf ("level <x>: the xboard style command to set time\n");
printf (" <x> should be in the form: <a> <b> <c> where:\n");
printf (" a -> moves to TC (0 if using an ICS style TC)\n");
printf (" b -> minutes per game\n");
printf (" c -> increment in seconds\n");
printf ("nodes: outputs the number of nodes searched\n");
printf ("nps: outputs Faile's NPS in search\n");
printf ("perft <x>: compute raw nodes to depth x\n");
printf ("post: toggles thinking output\n");
printf ("xboard: put Faile into xboard mode\n");
printf ("\n%s\n\n", divider);
}
else if (!xb_mode) {
printf ("Illegal move: %s\n", input);
}
}
}
return 0;
}
/*-----------------------------------------------------------------------------*/
bool Notation::AddMove(const MoveKif& move)
{
const MoveKif* prev_move = this->getPrevMove();
const MoveKif& move_current = this->current_moves_->back();
if (move.number() != 0 && move.number() != (this->move_current_->number() + 1))
{
// 番号が違う
return false;
}
if (move_current.number() != this->number())
{
// 指し手の末尾と番号が違う場合 ブランチとして作成する
this->current_moves_ = this->move_current_->MakeBranch(this->current_moves_);
}
int number = this->move_current_->number();
// 要素追加
this->current_moves_->emplace_back(move);
this->move_current_ = &this->current_moves_->back();
MoveKif& move_kif = this->current_moves_->back();
if (move_kif.number() == 0)
{
move_kif.set_number(number + 1);
}
move_kif.set_side(this->position_.side_to_move());
if ((move_kif.move_type() & MOVE_FLAG))
{
if (move_kif.to() == move_current.to())
{
// 同ほげをたてる
move_kif.set_move_type(MoveType(move_kif.move_type() | MoveType::SAME_FLAG));
}
Piece capture_piece = position_.GetPiece(move_kif.to());
if (capture_piece != NO_PIECE)
{
// 捕獲する場合 captureフラグを建てる
move_kif.set_capture_piece(capture_piece);
move_kif.set_move_type(MoveType(move_kif.move_type() | MoveType::CAPTURE_FLAG));
}
}
else if (is_result(move_kif.move_type()))
{
this->result_ = move_kif.move_type();
this->winner_ = this->getWinPlayer(move_kif);
}
if (move_kif.totalTime == 0)
{
// トータル時間の計算
move_kif.totalTime = ((prev_move != nullptr) ? prev_move->totalTime : 0) + move_kif.time;
}
if (is_move(move_kif.move_type()))
{
// 盤面をすすめる
this->position_.DoMove(move_kif);
}
return true;
}
int get_priority(trainer_s *trainer) {
action_t action = trainer->action;
return (is_move(action) ? get_move(trainer, action)->priority : 6); // if isn't move it is switch
}
// [TestMethod, Description("IsValidのテスト")]
TEST_F(MoveCheckTest, testIsValid)
{
Position pos;
Sfen::LoadPosition(pos, sfen2);
int i = 0;
for (auto& str: moves)
{
Move movedata2 = Sfen::ParseMove(pos, str);
if (is_move(movedata2.move_type()))
{
ASSERT_EQ(MoveCheck::IsValid(pos, movedata2), true);
pos.DoMove(movedata2);
}
i++;
}
Sfen::LoadPosition(pos, sfen2);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::PASS)), true);
Move movedata(MoveType::NORMAL);
ASSERT_EQ(MoveCheck::IsValid(pos, movedata), false);
movedata.set_to(Square::SQ_68);
ASSERT_EQ(MoveCheck::IsValid(pos, movedata), false);
movedata.set_piece(Piece::W_SILVER);
movedata.set_side(WHITE);
ASSERT_EQ(MoveCheck::IsValid(pos, movedata), false);
movedata.set_move_type(MoveType::DROP);
ASSERT_EQ(MoveCheck::IsValid(pos, movedata), true);
movedata.set_piece(Piece::B_SILVER);
ASSERT_EQ(MoveCheck::IsValid(pos, movedata), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_36, Piece::W_GOLD, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_37, Piece::W_SILVER, Piece::NO_PIECE)), true);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::NORMAL, Square::SQ_81, Square::SQ_73, Piece::W_KNIGHT, Piece::NO_PIECE)), false);
// Drop可否判定
Sfen::LoadPosition(pos, sfen3);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_99, Piece::W_PAWN, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_28, Piece::W_PAWN, Piece::NO_PIECE)), true);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_69, Piece::W_LANCE, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_38, Piece::W_LANCE, Piece::NO_PIECE)), true);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_89, Piece::W_KNIGHT, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_48, Piece::W_KNIGHT, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_77, Piece::W_KNIGHT, Piece::NO_PIECE)), true);
// 打ち歩詰め判定
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_77, Piece::W_PAWN, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_77, Piece::W_LANCE, Piece::NO_PIECE)), true);
// Drop可否判定
Sfen::LoadPosition(pos, sfen4);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_11, Piece::B_PAWN, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_82, Piece::B_PAWN, Piece::NO_PIECE)), true);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_41, Piece::B_LANCE, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_72, Piece::B_LANCE, Piece::NO_PIECE)), true);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_21, Piece::B_KNIGHT, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_62, Piece::B_KNIGHT, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_33, Piece::B_KNIGHT, Piece::NO_PIECE)), true);
// 打ち歩詰め判定
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_33, Piece::B_PAWN, Piece::NO_PIECE)), false);
ASSERT_EQ(MoveCheck::IsValid(pos, Move(MoveType::DROP, SQ_NONE, Square::SQ_33, Piece::B_LANCE, Piece::NO_PIECE)), true);
}