/**
* map_control -- draw a cursor on the screen and accept control from FSM
* @ch: the input word from the FSM
*/
int map_control(int ch)
{
bool dozoom = false;
struct map_t *tmp;
if (!nav_win)
map_cursor_init();
top_panel(nav_pan);
switch (ch)
{
case MODE_STARTED:
map_controls_active = true;
cursor->Show(cursor);
show_panel(nav_pan);
break;
/* Scroll the map in a direction */
case 'w': case 'a': case 's': case 'd':
case 'W': case 'A': case 'S': case 'D':
map_scroll(MAPBOOK->active, ch);
break;
/* Move the zoom frame in a direction */
case 'h': case 'j': case 'k': case 'l':
case 'H': case 'J': case 'K': case 'L':
cursor->Move(cursor, ch);
break;
/* Select the current zoom frame */
case '\n':
dozoom = true;
break;
case KEY_ESC:
case 'm':
map_controls_active = false;
show_dock();
cursor->Hide(cursor);
hide_panel(nav_pan);
return MODE_RELEASE;
}
/* Adjust for changing y0 or x0 of the map pad */
y_map = pos_y(cursor->pos) + pos_y(ACTIVE->pos);
x_map = pos_x(cursor->pos) + pos_x(ACTIVE->pos);
zoomlevel = MAPBOOK->page;
print_map_control(y_map, x_map);
draw_zoom_box(ACTIVE, y_map, x_map);
if (dozoom)
set_zoom(MAPBOOK, y_map, x_map);
return MODE_PERSIST;
}
void UIContext::set_beacon_position(const Point2i& pos)
{
if( this->valid() ) {
Rocket::Core::ElementDocument* target =
this->context()->GetDocument("rkt-debug-log-beacon");
NOM_ASSERT( target != nullptr );
if( target ) {
// NOM_DUMP( target->GetSourceURL().CString() );
Rocket::Core::Element* body_tag =
target->GetParentNode();
NOM_ASSERT( body_tag != nullptr );
if( body_tag ) {
Rocket::Core::Element* debug_info =
body_tag->GetElementById("rkt-debug-log-beacon");
NOM_ASSERT( debug_info != nullptr );
if( debug_info ) {
Rocket::Core::Property pos_x( pos.x, Rocket::Core::Property::PX);
Rocket::Core::Property pos_y( pos.y, Rocket::Core::Property::PX);
debug_info->SetProperty("left", pos_x);
debug_info->SetProperty("top", pos_y);
} // end if debug_info
} // end if body_tag
} // end if target
} // end if valid context
}
void chk_walls(unsigned int c_pos, unsigned char m_dir)
{
unsigned int i;
unsigned char cnt_L0,cnt_R0,cnt_L45,cnt_R45;
// Initiate.
cnt_L0 = cnt_R0 = cnt_L45 = cnt_R45 = 0;
// Count.
for(i=0;i<SS_HISTORY_SIZE;i++) {
if (ss_history[SS_L45][i] > threshold_L45 ) cnt_L45++;
if (ss_history[SS_R45][i] > threshold_R45 ) cnt_R45++;
if (ss_history[SS_L0 ][i] > threshold_L0 ) cnt_L0++;
if (ss_history[SS_R0 ][i] > threshold_R0 ) cnt_R0++;
}
// Decide the existance of walls.
if ( cnt_L45 > 2 ) maze[c_pos] |= wall_bit(get_absolute_dir(L,m_dir));
if ( cnt_R45 > 2 ) maze[c_pos] |= wall_bit(get_absolute_dir(R,m_dir));
//if ( cnt_L0 > 2 && cnt_R0 > 2 ) maze[c_pos] |= wall_bit(get_absolute_dir(F,m_dir));
if ( cnt_L0 > 1 && cnt_R0 > 1 ) maze[c_pos] |= wall_bit(get_absolute_dir(F,m_dir));
// Process walls of blocks around.
unsigned char x,y;
x = pos_x( c_pos ); y = pos_y( c_pos );
if ( (maze[c_pos] & NORTH) && y < 15 ) maze[ c_pos + dxy[N] ] |= SOUTH;
if ( (maze[c_pos] & EAST ) && x < 15 ) maze[ c_pos + dxy[E] ] |= WEST;
if ( (maze[c_pos] & SOUTH) && y > 0 ) maze[ c_pos + dxy[S] ] |= NORTH;
if ( (maze[c_pos] & WEST ) && x > 0 ) maze[ c_pos + dxy[W] ] |= EAST;
// Check the block read.
maze_info[ c_pos ] |= VALID_BLK;
}
void print_map_control(int y, int x)
{
werase(nav_win);
mvwpumpw(nav_win, 0, 2, L"y:%03d, x:%03d", pos_y(ACTIVE->pos), pos_x(ACTIVE->pos));
mvwpumpw(nav_win, 0, 16, L"▏ ymax:%d xmax:%d", ACTIVE->pos->ymax, ACTIVE->pos->xmax);
mvwpumpw(nav_win, 0, COLS-17, L"▕ %s", page[zoomlevel]);
}
void tri_basic(t_content *axx)
{
TMP_A(4) = LIST_A(3);
LIST_I(NB_LIST + 4, 0);
norm(axx);
while (check_list(axx, 0) != 0)
{
TMP_A(3) = LIST_A(0);
LIST_I(NB_LIST + 3, 1);
TMP_A(8) = LIST_A(0);
LIST_I(NB_LIST + 8, 0);
LIST_I(NB_LIST + 8, 0);
if (VALUE_IN(0, 0) < VALUE_IN(0, 1))
{
op(axx, 5);
}
else if (TMP_IN(3, 1) < VALUE_IN(0, 1))
{
op(axx, 0);
}
else
{
push_b(axx, pos_x(axx, TMP_I(4, 0)));
LIST_I(NB_LIST + 4, 0);
}
}
}
/* wall bits are filled by absolute direction.
* index : current mouse location to save the wall information.
*/
void save_wallinfo_to_maze(unsigned char index, unsigned char wall)
{
int x, y;
print_dbg(DEBUG_SEARCH, "%02X, %02X\n", index, wall&0xf);
/* trying to save know wall to maze_search? */
if ((maze_search[index]&0xF0) == 0xF0)
print_exit("%s: %d,%d is already known block!\n",
__func__, pos_x(index), pos_y(index));
/* save wall info to current index */
maze_search[index] |= (wall&0xf);
maze_search[index] |= 0xF0;
/* save wall information the wall of other blocks */
x = pos_x(index);
y = pos_y(index);
/* north (it's south wall of next block) */
if (y+1 < MAX_Y) {
maze_search[get_index(x, y+1)] |= KNOWN_SOUTH;
if (wall & NORTH)
maze_search[get_index(x, y+1)] |= SOUTH;
}
/* east (it's west wall of next block) */
if (x+1 < MAX_X) {
maze_search[get_index(x+1, y)] |= KNOWN_WEST;
if (wall & EAST)
maze_search[get_index(x+1, y)] |= WEST;
}
/* south (it's north wall of next block) */
if (y > 0) {
maze_search[get_index(x, y-1)] |= KNOWN_NORTH;
if (wall & SOUTH)
maze_search[get_index(x, y-1)] |= NORTH;
}
/* west (it's east wall of next block) */
if (x > 0) {
maze_search[get_index(x-1, y)] |= KNOWN_EAST;
if (wall & WEST)
maze_search[get_index(x-1, y)] |= EAST;
}
print_dbg(DEBUG_SEARCH, "%s: index:%02X maze_search[index]=%02X\n",
__func__, index, (unsigned char)maze_search[index]);
}
/* Find fastest path from known maze information
* and return the FRBL turn array to the caller.
* if first turn is one of RBL, it means that the
* mouse has to make back turn or smooth L/R turn.
* In that case, no diagonal turns.
*
* fast_path_type: 0 find all possible pathes
* 1 find from only known blocks
*/
unsigned char *find_maze_fastest_path(
unsigned char cur_mouse_pos, char cur_mouse_dir,
unsigned int search_type, struct s_link *f_node,
int fast_path_type)
{
unsigned char *path;
struct s_link *mouse_path;
struct s_link *sl_fast_path;
#ifdef DEBUG
int i;
#endif
if (!f_node)
print_exit("f_node NULL\n");
print_dbg(DEBUG_SEARCH, "mouse pos:%d,%d mouse_dir:%d "
"search_type:%d\n", pos_x(cur_mouse_pos),
pos_y(cur_mouse_pos), cur_mouse_dir,
search_type);
/* draw contour map from the goal */
draw_contour(maze_search, contour_map,
search_type, cur_mouse_pos);
/* generate full binary tree with all pathes */
mouse_path = gen_bin_tree(maze_search,
contour_map, cur_mouse_pos, cur_mouse_dir);
/* find the fastest path and get the node */
sl_fast_path = find_fastest_path(mouse_path, fast_path_type);
if (sl_fast_path) {
memcpy(f_node, sl_fast_path, sizeof(struct s_link));
/* Free sl_nodes after searching the fastest path */
sl_node_free(mouse_path);
} else {
sl_node_free(mouse_path);
return NULL;
}
/* generate FRBL array for the fastest path */
path = gen_frbl_from_node(f_node);
#ifdef DEBUG
printf("%s\n", __func__);
for (i = 0; path[i] != 0xff; i++)
printf("%C",
(path[i] == FD) ? 'F' : \
((path[i] == RD) ? 'R' : \
((path[i] == BD) ? 'B' : \
((path[i] == LD) ? 'L' : 'X'))));
printf("\n");
#endif
return path;
}
void drawmouse()
{
int x,y,xx,yy;
char temp[]="**";
x=pos_x(mouse_pos);
y=pos_y(mouse_pos);
xx=x*28+2;
yy=28*(15-y)+2;
// showweight(); getch();
setcolor(WHITE);
outtextxy(xx+2,yy+10,temp);
}
void UIContext::set_debugger_position(const Point2i& pos)
{
if( this->valid() ) {
Rocket::Core::ElementDocument* target =
this->context()->GetDocument("rkt-debug-hook");
NOM_ASSERT( target != nullptr );
if( target ) {
// NOM_DUMP( target->GetSourceURL().CString() );
Rocket::Core::Element* body_tag =
target->GetParentNode();
NOM_ASSERT( body_tag != nullptr );
if( body_tag ) {
Rocket::Core::Element* debug_info =
body_tag->GetElementById("rkt-debug-info");
NOM_ASSERT( debug_info != nullptr );
if( debug_info ) {
Rocket::Core::Property pos_x( pos.x, Rocket::Core::Property::PX);
Rocket::Core::Property pos_y( pos.y, Rocket::Core::Property::PX);
debug_info->SetProperty("left", pos_x);
debug_info->SetProperty("top", pos_y);
} // end if debug_info
} // end if body_tag
} // end if target
} // end if valid context
// for( auto itr = tags.begin(); itr != tags.end(); ++itr ) {
// if( (*itr)->GetId() == "rkt-debug-info" ) {
// NOM_DUMP( (*itr)->GetTagName().CString() );
// NOM_DUMP( (*itr)->GetId().CString() );
// }
// } // end for tags loop
}
static int gen_bin_tree_tail(unsigned char *maze, unsigned char *map,
struct s_link **head)
{
struct btree_node *bt_new_node, *bt_node;
struct s_link *sl_node;
struct s_link *sl_new_node, *tail_new_list = NULL;
unsigned char i, index, abs_dir;
struct btree_node bt_node_backup;
char dir, is_goal = 0, found_node;
#ifdef CONFIG_PATH_LIMIT
int path_limit = 0;
#endif
if (!maze || !map || !head || !*head) {
print_error("NULL pointer error! %X %X %X %X\n",
(unsigned int)maze, (unsigned int)map,
(unsigned int)head, (unsigned int)*head);
}
print_dbg(DEBUG_S_LINK, "Check input linked list: %08X\n",
(unsigned int)*head);
debug_sl_node(*head);
print_dbg(DEBUG_S_LINK, "Find next lower contour level\n");
/* Find next lower contour cube arond current location */
for (sl_node = *head; sl_node; sl_node = sl_node->node) {
index = sl_node->bt_node->pos;
abs_dir = sl_node->bt_node->abs_dir;
bt_node = sl_node->bt_node;
/* when it's set, found turn. on the unkonwn blocks,
* there may be too many pathes to calculate.
**/
found_node = 0;
bt_node_backup.time = 0; /* use to check FD detection */
for (i = NI; i <= WI; i++) {
if (!(maze[index] & wall_bit(i)) &&
(map[index] == map[index + maze_dxy[i]] + 1)) {
dir = relative_direction(abs_dir, i);
/* if block is unknown, then take turn prior
* to straight path. It's to save memory
* and calculation time.
*/
if (dir == FD && ((maze[index]&0xF0) != 0xF0)) {
bt_node_backup.pos = index+maze_dxy[i];
bt_node_backup.dir = dir;
bt_node_backup.abs_dir = i;
/* to mark block has meaningful data */
bt_node_backup.time = 1;
continue;
}
found_node = 1;
/* create new bt_node and save next mouse index
* and absolute direction of mouse at next block
*/
bt_new_node =
bt_node_alloc(index+maze_dxy[i], i);
/* Next bt_node->dir is to save how mouse made
* a turn to come the block.
*/
bt_new_node->dir = dir;
/* there can be 3rd child, only take 2 child at
* a time
*/
if (!add_bt_node(bt_node, bt_new_node)) {
sl_new_node = s_link_alloc(bt_new_node);
add_sl_node(&tail_new_list, sl_new_node);
#ifdef CONFIG_PATH_LIMIT
path_limit++;
#endif
} else {
bt_node_free(bt_new_node);
}
/*
* debug_sl_node(tail_new_list);
*/
}
}
/* if forward is the only one in known block,
* then use it
*/
if (!found_node && bt_node_backup.time) {
bt_new_node =
bt_node_alloc(bt_node_backup.pos,
bt_node_backup.abs_dir);
bt_new_node->dir = bt_node_backup.dir;
add_bt_node(bt_node, bt_new_node);
sl_new_node = s_link_alloc(bt_new_node);
add_sl_node(&tail_new_list, sl_new_node);
#ifdef CONFIG_PATH_LIMIT
path_limit++;
#endif
}
if (map[index] == 1 && !is_goal)
is_goal = 1;
/* Remove bt_node if there is no child, it'll search
* parent node and remove the node if it had no child
*/
if (!is_goal)
clean_bin_tree(bt_node, 80);
#ifdef CONFIG_PATH_LIMIT
/* 10 pathes : max 20KB
* 20 pathes : max 30 KB
* 40 pathes : max 57 KB
*/
if (path_limit >= 20)
break;
#endif
}
if (tail_new_list)
debug_sl_node(tail_new_list);
#ifdef DEBUG
if (is_goal) {
i = 0;
print_dbg(DEBUG_BINTREE,
"Found maze goal!!!\n");
print_dbg(DEBUG_BINTREE,
"tail_new_list for tail: 0x%08X\n",
(unsigned int)tail_new_list);
print_dbg(DEBUG_BINTREE,
"*head pointer: %08X\n",
(unsigned int)*head);
if (tail_new_list)
print_error("tail_new_list must be NULL!\n");
for (sl_node = *head; sl_node; sl_node = sl_node->node) {
index = sl_node->bt_node->pos;
bt_node = sl_node->bt_node;
i++;
}
print_dbg(DEBUG_BINTREE, "Total path: %d\n", i);
}
#endif
/* critical error to find next contour maps */
if (!is_goal && tail_new_list == NULL) {
printf("contour map\n");
print_full(map);
printf("maze map\n");
print_map(maze);
for (sl_node = *head; sl_node; sl_node = sl_node->node) {
index = sl_node->bt_node->pos;
abs_dir = sl_node->bt_node->abs_dir;
bt_node = sl_node->bt_node;
printf("mouse:(%d,%d),abs_dir:%d\n", pos_x(index),
pos_y(index), abs_dir);
}
}
/* free s_link nodes */
if (!is_goal) {
sl_node_free(*head);
*head = tail_new_list;
}
return is_goal;
}
