static void check_quadrant(map_t *m,int startX,int startY,int dx, int dy, int extentX,int extentY, bool light_walls) {
TCOD_list_t active_views=TCOD_list_new();
line_t shallow_line= {offset,limit,extentX*STEP_SIZE,0};
line_t steep_line= {limit,offset,0,extentY*STEP_SIZE};
int maxI=extentX+extentY,i=1;
view_t *view= &views[startX+startY*m->width];
view->shallow_line=shallow_line;
view->steep_line=steep_line;
view->shallow_bump=NULL;
view->steep_bump=NULL;
TCOD_list_push(active_views,view);
current_view=(view_t **)TCOD_list_begin(active_views);
while ( i != maxI+1 && ! TCOD_list_is_empty(active_views) ) {
int startJ=MAX(i-extentX,0);
int maxJ=MIN(i,extentY);
int j=startJ;
while ( j != maxJ+1 && ! TCOD_list_is_empty(active_views) && current_view != (view_t **)TCOD_list_end(active_views) ) {
int x=(i - j)*STEP_SIZE;
int y=j*STEP_SIZE;
visit_coords(m,startX,startY,x,y,dx,dy,active_views, light_walls);
j++;
}
i++;
current_view=(view_t **)TCOD_list_begin(active_views);
}
TCOD_list_delete(active_views);
}
/* walk the path */
bool TCOD_dijkstra_path_walk (TCOD_dijkstra_t dijkstra, int *x, int *y) {
dijkstra_t * data = (dijkstra_t*)dijkstra;
TCOD_IFNOT(data != NULL) return false;
if (TCOD_list_is_empty(data->path)) return false;
else {
unsigned int node = (unsigned int)(uintptr)TCOD_list_pop(data->path);
if ( x ) *x = (int)(node % data->width);
if ( y ) *y = (int)(node / data->width);
}
return true;
}
/* fill the grid, starting from the origin until we reach the destination */
static void TCOD_path_set_cells(TCOD_path_data_t *path, int cutoff) {
int stepstaken = 0;
while ( path->grid[path->dx + path->dy * path->w ] == 0 && ! TCOD_list_is_empty(path->heap) ) {
stepstaken++;
if (stepstaken > cutoff)
break;
int x,y,i,imax;
float distance;
TCOD_path_get_cell(path,&x,&y,&distance);
imax= ( path->diagonalCost == 0.0f ? 4 : 8) ;
for (i=0; i < imax; i++ ) {
/* convert i to dx,dy */
static int idirx[]={0,-1,1,0,-1,1,-1,1};
static int idiry[]={-1,0,0,1,-1,-1,1,1};
/* convert i to direction */
static dir_t prevdirs[] = {
NORTH, WEST, EAST, SOUTH, NORTH_WEST, NORTH_EAST,SOUTH_WEST,SOUTH_EAST
};
/* coordinate of the adjacent cell */
int cx=x+idirx[i];
int cy=y+idiry[i];
if ( cx >= 0 && cy >= 0 && cx < path->w && cy < path->h ) {
float walk_cost = TCOD_path_walk_cost(path,x,y,cx,cy);
if ( walk_cost > 0.0f ) {
/* in of the map and walkable */
float covered=distance + walk_cost * (i>=4 ? path->diagonalCost : 1.0f);
float previousCovered = path->grid[cx + cy * path->w ];
if ( previousCovered == 0 ) {
/* put a new cell in the heap */
int offset=cx + cy * path->w;
/* A* heuristic : remaining distance */
float remaining=(float)sqrt((cx-path->dx)*(cx-path->dx)+(cy-path->dy)*(cy-path->dy));
path->grid[ offset ] = covered;
path->heur[ offset ] = covered + remaining;
path->prev[ offset ] = prevdirs[i];
TCOD_path_push_cell(path,cx,cy);
} else if ( previousCovered > covered ) {
/* we found a better path to a cell already in the heap */
int offset=cx + cy * path->w;
path->grid[ offset ] = covered;
path->heur[ offset ] -= (previousCovered - covered); /* fix the A* score */
path->prev[ offset ] = prevdirs[i];
/* reorder the heap */
heap_reorder(path,offset);
}
}
}
}
}
}
bool TCOD_bsp_traverse_inverted_level_order(TCOD_bsp_t *node, TCOD_bsp_callback_t listener, void *userData) {
TCOD_list_t stack1=TCOD_list_new();
TCOD_list_t stack2=TCOD_list_new();
TCOD_list_push(stack1,node);
while ( ! TCOD_list_is_empty(stack1) ) {
TCOD_bsp_t *node=(TCOD_bsp_t *)TCOD_list_get(stack1,0);
TCOD_list_push(stack2,node);
TCOD_list_remove(stack1,node);
if ( TCOD_bsp_left(node) ) TCOD_list_push(stack1,TCOD_bsp_left(node));
if ( TCOD_bsp_right(node) ) TCOD_list_push(stack1,TCOD_bsp_right(node));
}
while ( ! TCOD_list_is_empty(stack2) ) {
TCOD_bsp_t *node=(TCOD_bsp_t *)TCOD_list_pop(stack2);
if (!listener(node,userData)) {
TCOD_list_delete(stack1);
TCOD_list_delete(stack2);
return false;
}
}
TCOD_list_delete(stack1);
TCOD_list_delete(stack2);
return true;
}
bool TCOD_dijkstra_is_empty(TCOD_dijkstra_t p) {
dijkstra_t * data = (dijkstra_t*)p;
TCOD_IFNOT(data != NULL) return true;
return TCOD_list_is_empty(data->path);
}
bool TCOD_path_is_empty(TCOD_path_t p) {
TCOD_path_data_t *path=(TCOD_path_data_t *)p;
TCOD_IFNOT(p != NULL) return true;
return TCOD_list_is_empty(path->path);
}
