void print_move(move_t* m) {
print_piece(b.pieces[m->from_square]);
print_square(m->from_square);
print_square(m->to_square);
if (m->move_type & MOVE_PROMOTION) {
piece_t promo = m->move_type & 0x7;
print_piece(promo);
}
}
int print_piece_next(t_next *next, int j)
{
int x;
x = - 1;
while (++x < next->height)
{
mvprintw(next->y + j, next->x, "|");
mvprintw(next->y + j, next->x + next->width, "|");
j = j + 1;
}
print_piece(next->piece, next->x + 2, next->y + 2, next->piece->col);
return (j);
}
int main(int ac, char **av)
{
unsigned short **tab;
int i;
int piece;
int nb_piece;
srand(time(NULL));
tab = init_tab();
i = 0;
if (ac >= 2)
nb_piece = atoi(av[1]);
else
nb_piece = 3;
while (i < nb_piece)
{
piece = rand() % 19;
print_piece(tab, piece, 1);
if (i < nb_piece - 1)
write(1, "\n", 1);
i++;
}
return (0);
}
bool read_data(char* data, size_type offset, size_type size, size_type& read_size)
{
if (m_abort) return false;
boost::mutex::scoped_lock lock(m_notify_mutex);
const torrent_info& info = m_handle.get_torrent_info();
bool ret = false;
read_size = 0;
#if defined(_DEBUG) && defined(WIN32)
unsigned int time = GetTickCount();
#endif
// 计算偏移所在的片.
int index = offset / info.piece_length();
BOOST_ASSERT(index >= 0 && index < info.num_pieces());
if (index >= info.num_pieces() || index < 0)
return ret;
torrent_status status = m_handle.status(torrent_handle::query_pieces);
bitfield &pieces = status.pieces;
if (!pieces.empty())
{
if (status.state != torrent_status::finished &&
status.state != torrent_status::seeding &&
status.state != torrent_status::downloading)
return ret;
// 查看是否需要计算新的下载位置.
bool set_download_point = true;
int min_piece_position = std::min(index, m_cache_offset);
int max_piece_position = std::max(index, m_cache_offset);
if (min_piece_position != -1)// min_piece_position 为-1, 需要设置下载位置, 也就是首次下载位置.
{
// 不为-1, 先计算下载点位置, 如果相等, 说明上一次已经设置过下载点位置.
if (min_piece_position == max_piece_position)
set_download_point = false;
else
{
// 查看上次请求的位置和当前位置是否连接已经下载的分块区域, 如果下载区域已经连接成块.
// 那么也不需要再设置下载点位置.
for (; min_piece_position < max_piece_position; min_piece_position++)
if (!pieces.get_bit(min_piece_position))
break;
// 表示下载块连接成区域.
if (min_piece_position == max_piece_position)
set_download_point = false;
}
}
// 缓存下载位置.
m_cache_offset = index;
// 计算下载位置, 如果有需要, 则修改下载位置.
if (set_download_point)
{
std::vector<int> new_point(pieces.size(), 1);
new_point[index] = 7;
m_handle.prioritize_pieces(new_point);
}
// 如果有数据, 则进入读取.
if (pieces.get_bit(index))
{
// 保存参数信息.
m_current_buffer = data;
m_read_offset = offset;
m_read_size = &read_size;
m_request_size = size;
// 提交请求.
m_handle.read_piece(index, boost::bind(&extern_read_op::on_read, this, _1, _2, _3));
// 等待请求返回.
m_notify.wait(lock);
// 读取字节数.
if (read_size != 0)
ret = true;
}
}
else
{
// 直接读取文件.
if (m_file_path.string() == "" || !m_file.is_open())
{
boost::filesystem::path path = m_handle.save_path();
const file_storage& stor = info.files();
std::string name = stor.name();
m_file_path = path / name;
name = convert_to_native(m_file_path.string());
// 打开文件, 直接从文件读取数据.
if (!m_file.is_open())
{
m_file.open(name.c_str(), std::ios::in | std::ios::binary);
if (!m_file.is_open())
return ret;
}
}
if (!m_file.is_open())
return ret;
m_file.clear();
m_file.seekg(offset, std::ios::beg);
m_file.read(data, size);
read_size = m_file.gcount();
if (read_size != -1)
ret = true;
}
#if defined(_DEBUG) && defined(WIN32)
static unsigned int cur_time = GetTickCount();
char str_info[8192] = { 0 };
char *ptr = (char*)str_info;
if (GetTickCount() - cur_time >= 5000)
{
cur_time = GetTickCount();
sprintf(str_info, "request: %d, size: %d, request time: %d, peers: %d\n",
index, (int)size, cur_time - time, status.num_peers);
ptr = ptr + strlen(str_info);
for (int i = 0; i < status.pieces.size() / 8; i++)
{
if (i % 32 == 0)
{
sprintf(ptr, "\n");
ptr += 1;
}
sprintf(ptr, "%02X", (unsigned char)status.pieces.bytes()[i]);
ptr += 2;
}
if (status.pieces.size() % 8 != 0)
{
sprintf(ptr, "%02X", (unsigned char)status.pieces.bytes()[status.pieces.size() / 8]);
ptr += 2;
}
sprintf(ptr, "\n\n");
// 显示当前正在下载的分片信息.
std::string out;
char str[500];
std::vector<cached_piece_info> pieces;
torrent_handle &h = m_handle;
std::vector<partial_piece_info> queue;
std::vector<peer_info> peers;
m_ses.get_cache_info(h.info_hash(), pieces);
h.get_download_queue(queue);
h.get_peer_info(peers);
std::sort(queue.begin(), queue.end(), boost::bind(&partial_piece_info::piece_index, _1)
< boost::bind(&partial_piece_info::piece_index, _2));
std::sort(pieces.begin(), pieces.end(), boost::bind(&cached_piece_info::last_use, _1)
> boost::bind(&cached_piece_info::last_use, _2));
for (std::vector<cached_piece_info>::iterator i = pieces.begin();
i != pieces.end(); ++i)
{
partial_piece_info* pp = 0;
partial_piece_info tmp;
tmp.piece_index = i->piece;
std::vector<partial_piece_info>::iterator ppi
= std::lower_bound(queue.begin(), queue.end(), tmp
, boost::bind(&partial_piece_info::piece_index, _1)
< boost::bind(&partial_piece_info::piece_index, _2));
if (ppi != queue.end() && ppi->piece_index == i->piece) pp = &*ppi;
print_piece(pp, &*i, peers, out);
if (pp) queue.erase(ppi);
}
for (std::vector<partial_piece_info>::iterator i = queue.begin()
, end(queue.end()); i != end; ++i)
{
print_piece(&*i, 0, peers, out);
}
snprintf(str, sizeof(str), "%s %s: read cache %s %s: downloading %s %s: cached %s %s: flushed\n"
, esc("34;7"), esc("0") // read cache
, esc("33;7"), esc("0") // downloading
, esc("36;7"), esc("0") // cached
, esc("32;7"), esc("0")); // flushed
out += str;
out += "___________________________________\n";
strcat(str_info, out.c_str());
OutputDebugStringA(str_info);
printf(str_info);
}
#endif
return ret;
}
int main(void) {
int r;
unsigned long grid_cells_n2, pieces_n, pieces_max, column_nodes_n1, column_nodes_n2, row_nodes_n, pieces_r, piece_f, piece_l, nodes_n, i, j, k;
scanf("%lu", &grid_rows);
if (!grid_rows) {
return EXIT_FAILURE;
}
scanf("%lu", &grid_columns1);
if (!grid_columns1) {
return EXIT_FAILURE;
}
grid_cells_n1 = grid_rows*grid_columns1;
grid_columns2 = grid_columns1+1;
grid_cells_n2 = grid_rows*grid_columns2;
grid_cells = malloc(grid_cells_n2+1);
if (!grid_cells) {
free_data(0UL);
return EXIT_FAILURE;
}
for (i = grid_columns1; i < grid_cells_n2; i += grid_columns2) {
grid_cells[i] = '\n';
}
grid_cells[grid_cells_n2] = 0;
scanf("%lu", &pieces_n);
if (!pieces_n) {
return EXIT_FAILURE;
}
pieces_max = pieces_n*8;
pieces = malloc(sizeof(piece_t)*pieces_max);
if (!pieces) {
return EXIT_FAILURE;
}
column_nodes_n1 = grid_cells_n1+pieces_n;
column_nodes_n2 = column_nodes_n1+1;
row_nodes_n = 0;
pieces_r = 0;
for (i = 0; i < pieces_n; i++) {
if (!read_piece(&pieces[pieces_r], i)) {
free_data(pieces_r);
return EXIT_FAILURE;
}
piece_f = pieces_r;
row_nodes_n += pieces[pieces_r].row_nodes_n;
pieces_r++;
j = 1;
do {
if (!rotate_piece(&pieces[pieces_r-1], &pieces[pieces_r])) {
free_data(pieces_r);
return EXIT_FAILURE;
}
r = compare_pieces(&pieces[piece_f], &pieces[pieces_r]);
for (k = piece_f+1; k < pieces_r && !r; k++) {
r = compare_pieces(&pieces[k], &pieces[pieces_r]);
}
if (!r) {
row_nodes_n += pieces[pieces_r].row_nodes_n;
pieces_r++;
j++;
}
else {
free_piece(&pieces[pieces_r]);
}
}
while (j < 4 && !r);
piece_l = pieces_r;
j = piece_f;
do {
if (!flip_piece(&pieces[j], &pieces[pieces_r])) {
free_data(pieces_r);
return EXIT_FAILURE;
}
r = compare_pieces(&pieces[piece_f], &pieces[pieces_r]);
for (k = piece_f+1; k < piece_l && !r; k++) {
r = compare_pieces(&pieces[k], &pieces[pieces_r]);
}
if (!r) {
row_nodes_n += pieces[pieces_r].row_nodes_n;
pieces_r++;
j++;
}
else {
free_piece(&pieces[pieces_r]);
}
}
while (j < piece_l && !r);
}
row_nodes = malloc(sizeof(row_node_t)*row_nodes_n);
if (!row_nodes) {
free_data(pieces_r);
return EXIT_FAILURE;
}
nodes_n = column_nodes_n2+row_nodes_n;
nodes = malloc(sizeof(node_t)*nodes_n);
if (!nodes) {
free_data(pieces_r);
return EXIT_FAILURE;
}
for (i = column_nodes_n2; i < nodes_n; i++) {
nodes[i].row_node = &row_nodes[i-column_nodes_n2];
}
tops = malloc(sizeof(node_t *)*column_nodes_n1);
if (!tops) {
free_data(pieces_r);
return EXIT_FAILURE;
}
header = &nodes[column_nodes_n1];
set_column_node(nodes, header);
for (i = 0; i < column_nodes_n1; i++) {
set_column_node(&nodes[i+1], &nodes[i]);
tops[i] = &nodes[i];
}
row_node = header+1;
for (i = 0; i < pieces_r; i++) {
print_piece(&pieces[i]);
set_piece_row_nodes(&pieces[i]);
}
for (i = 0; i < column_nodes_n1; i++) {
link_top(&nodes[i], tops[i]);
}
dlx_search();
printf("\nCost %lu\nSolutions %lu\n", cost, solutions);
free_data(pieces_r);
return EXIT_SUCCESS;
}
