void MapDrawingArea::on_size_allocate(Gtk::Allocation& alloc)
{
    DrawingArea::on_size_allocate(alloc);
    setup_surfaces();
    setup_bounds();
    after_change();
}
MapDrawingArea::MapDrawingArea(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>&):
    Gtk::DrawingArea(cobject),
    pressed(false),
    zoom(1),
    tran_x(0),
    tran_y(0),
    topleft(-1, -1),
    bottomright(1, 1),
    lat(0),
    lon(0)
{
    add_events(Gdk::SCROLL_MASK | Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK | Gdk::POINTER_MOTION_MASK);
    setup_projection();
    setup_surfaces();
    setup_bounds();
}
Beispiel #3
0
static void
negamax(struct node *node)
{
	assert(node->alpha < node->beta);

	node_init(node);

	if (check_trivial_draw(node) == is_trivial_draw)
		return;

	ht_prefetch(node->tt, node->pos->zhash[0]);

	if (adjust_depth(node) == too_deep)
		return;

	if (handle_mate_search(node) == mate_search_handled)
		return;

	if (setup_bounds(node) == stand_pat_cutoff)
		return;

	if (setup_moves(node) == no_legal_moves)
		return;

	if (node->forced_pv == 0) {
		if (fetch_hash_value(node) == hash_cutoff)
			return;
	}
	else {
		int r = move_order_add_hint(node->mo, node->forced_pv, 0);
		(void) r;
		assert(r == 0);
	}

	if (try_null_move_prune(node) == prune_successfull)
		return;

	if (recheck_bounds(node) == alpha_beta_range_too_small)
		return;

	assert(node->beta > -max_value + 2);
	assert(node->alpha < max_value - 2);

	do {
		move_order_pick_next(node->mo);

		if (can_prune_moves(node))
			break;

		move m = mo_current_move(node->mo);

		int LMR_factor;

		setup_child_node(node, m, &LMR_factor);

		int value = negamax_child(node);

		if (LMR_factor != 0) {
			if (value > node->alpha) {
				reset_child_after_lmr(node);
				value = negamax_child(node);
			}
			else {
				debug_trace_tree_pop_move(node);
				continue;
			}
		}

		value = handle_beta_extension(node, m, value);

		if (value > node->value) {
			node->value = value;
			if (value > node->alpha) {
				node->alpha = value;
				new_best_move(node, m);

				if (node->alpha >= node->beta)
					fail_high(node);
				else
					node->expected_type = PV_node;
			}
		}
		debug_trace_tree_pop_move(node);
	} while (search_more_moves(node));

	ht_entry entry = hash_current_node_value(node);
	setup_best_move(node);

	assert(node->repetition_affected_any == 0 || !node->is_GHI_barrier);
	assert(node->repetition_affected_best == 0 || !node->is_GHI_barrier);

	if (node->depth > 0) {
		if (node->best_move != 0)
			entry = ht_set_move(entry, node->best_move);
		if (node->null_move_search_failed)
			entry = ht_set_no_null(entry);
		if (ht_value_type(entry) != 0 || node->best_move != 0)
			ht_pos_insert(node->tt, node->pos, entry);
	}
	if (node->value < node->lower_bound)
		node->value = node->lower_bound;
	node->forced_pv = 0;
}