int32_t leave_map(struct map *m,struct aoi_object *o)
{
struct map_block *block = get_block_by_point(m,&o->current_pos);
if(!block)
return -1;
double_link_remove(&o->block_node);
uint32_t radius = STAND_RADIUS;
if(o->view_radius > STAND_RADIUS)
{
radius = o->view_radius;
double_link_remove(&o->super_node);
}
uint32_t x1,y1,x2,y2;
cal_blocks(m,&o->current_pos,radius,&x1,&y1,&x2,&y2);
uint32_t y = y1;
uint32_t x;
for( ; y <= y2; ++y)
{
for( x=x1; x <= x2; ++x)
{
block_process_leave(m,get_block(m,y,x),o,1);
}
}
o->is_leave_map = 1;
if(--o->watch_me_count == 0)
m->all_aoi_objects[o->aoi_object_id] = NULL;
}
int cavan_alarm_insert_node2(struct cavan_alarm_thread *thread, struct cavan_alarm_node *node, int year, int mon, int day, int hour, int min, int sec)
{
struct tm time =
{
.tm_sec = sec,
.tm_min = min,
.tm_hour = hour,
.tm_mday = day,
.tm_mon = mon - 1,
.tm_year = year - 1900,
.tm_wday = 0,
.tm_yday = 0,
.tm_isdst = 0
};
return cavan_alarm_insert_node(thread, node, &time);
}
void cavan_alarm_delete_node(struct cavan_alarm_thread *thread, struct cavan_alarm_node *node)
{
pthread_mutex_lock(&thread->lock);
double_link_remove(&thread->link, &node->node);
if (node->destroy)
{
node->destroy(node, node->private_data);
}
pthread_mutex_unlock(&thread->lock);
}
static inline void coro_destroy(coro_t *co)
{
double_link_remove(&(*co)->dblink);
if((*co)->stack);
free((*co)->stack);
uthread_destroy(&((*co)->ut));
free(*co);
*co = NULL;
}
inline int32_t epoll_unregister(engine_t e,socket_t s)
{
assert(e);assert(s);
struct epoll_event ev;int32_t ret;
TEMP_FAILURE_RETRY(ret = epoll_ctl(e->poller_fd,EPOLL_CTL_DEL,s->fd,&ev));
s->readable = s->writeable = 0;
double_link_remove((struct double_link_node*)s);
s->engine = NULL;
return ret;
}
static int cavan_alarm_thread_handler(struct cavan_thread *thread, void *data)
{
struct cavan_alarm_thread *alarm_thread = data;
struct double_link_node *node;
pthread_mutex_lock(&alarm_thread->lock);
node = double_link_get_first_node(&alarm_thread->link);
if (node == NULL)
{
alarm(0);
cavan_thread_suspend(thread);
}
else
{
struct cavan_alarm_node *alarm_node = double_link_get_container(&alarm_thread->link, node);
time_t curr_time;
curr_time = time(NULL);
if (curr_time < 0)
{
pr_error_info("get current time");
pthread_mutex_unlock(&thread->lock);
return curr_time;
}
cavan_show_date2(curr_time, "curr_time = ");
cavan_show_date2(alarm_node->time, "alarm_time = ");
if (curr_time < alarm_node->time)
{
alarm(alarm_node->time - curr_time);
cavan_thread_suspend(thread);
}
else
{
double_link_remove(&alarm_thread->link, node);
alarm_node->handler(alarm_node, alarm_thread, alarm_node->private_data);
if (alarm_node->repeat)
{
alarm_node->time += alarm_node->repeat;
cavan_alarm_insert_node_base(alarm_thread, alarm_node);
}
else if (alarm_node->destroy)
{
alarm_node->destroy(alarm_node, alarm_node->private_data);
}
}
}
pthread_mutex_unlock(&alarm_thread->lock);
return 0;
}
static inline mq_sync_pop(mq_t m,struct per_thread_struct *pts,uint32_t timeout)
{
mutex_lock(m->mtx);
if(link_list_is_empty(m->share_list))
{
if(timeout)
{
while(link_list_is_empty(m->share_list))
{
double_link_push(&m->blocks,&pts->block);
if(0 != condition_timedwait(pts->cond,m->mtx,timeout))
{
double_link_remove(&pts->block);
break;
}
}
}
}
link_list_swap(pts->local_pop_q,m->share_list);
mutex_unlock(m->mtx);
}
int cavan_alarm_insert_node(struct cavan_alarm_thread *thread, struct cavan_alarm_node *node, struct tm *date)
{
time_t curr_time;
if (node->handler == NULL)
{
pr_red_info("node->handler == NULL");
return -EINVAL;
}
if (date)
{
node->time = mktime(date);
}
curr_time = time(NULL);
if (node->time < curr_time)
{
node->time += TIME_DAY(1);
if (node->time < curr_time)
{
pr_red_info("Date too old");
return -EINVAL;
}
}
cavan_show_date2(node->time, "date = ");
pthread_mutex_lock(&thread->lock);
double_link_remove(&thread->link, &node->node);
cavan_alarm_insert_node_base(thread, node);
cavan_thread_resume(&thread->thread);
pthread_mutex_unlock(&thread->lock);
return 0;
}
//将o移动到new_pos,并计算视野变化
void move_to(struct map *m,struct aoi_object *o,struct point2D *new_pos)
{
struct point2D old_pos = o->current_pos;
o->current_pos = *new_pos;
struct map_block *old_block = get_block_by_point(m,&old_pos);
struct map_block *new_block = get_block_by_point(m,new_pos);
if(old_block != new_block)
double_link_remove(&o->block_node);
uint32_t radius = STAND_RADIUS;
if(o->view_radius > STAND_RADIUS)
radius = o->view_radius;
//计算新旧管理区域
uint32_t n_x1,n_y1,n_x2,n_y2;
uint32_t o_x1,o_y1,o_x2,o_y2;
cal_blocks(m,&old_pos,radius,&o_x1,&o_y1,&o_x2,&o_y2);
cal_blocks(m,new_pos,radius,&n_x1,&n_y1,&n_x2,&n_y2);
uint32_t y = n_y1;
uint32_t x;
for( ; y <= n_y2; ++y)
{
for( x = n_x1; x <= n_x2; ++x)
{
if(x >= o_x1 && x <= o_x2 && y >= o_y1 && y <= o_y2)
{
//无变化区域
struct map_block *bl = get_block(m,y,x);
struct aoi_object *cur = (struct aoi_object*)bl->aoi_objs.head.next;
while(cur != (struct aoi_object*)&bl->aoi_objs.tail)
{
uint64_t distance = cal_distance_2D(new_pos,&cur->current_pos);
if(o != cur)
{
if(o->view_radius >= distance && !is_set(&o->self_view_objs,cur->aoi_object_id))
enter_me(m,o,cur);
if(o->view_radius < distance && is_set(&o->self_view_objs,cur->aoi_object_id))
leave_me(m,o,cur);
if(cur->view_radius >= distance && !is_set(&cur->self_view_objs,o->aoi_object_id))
enter_me(m,cur,o);
if(cur->view_radius < distance && is_set(&cur->self_view_objs,o->aoi_object_id))
leave_me(m,cur,o);
}
cur = (struct aoi_object *)cur->block_node.next;
}
}
else
{
//新进入的区域
block_process_enter(m,get_block(m,y,x),o);
}
}
}
if(old_block != new_block)
double_link_push(&new_block->aoi_objs,&o->block_node);
y = o_y1;
for( ; y <= o_y2; ++y)
{
for(x = o_x1; x <= o_x2; ++x)
{
if(x >= n_x1 && x <= n_x2 && y >= n_y1 && y <= n_y2)
continue;//这里不处理无变化区域
block_process_leave(m,get_block(m,y,x),o,0);
}
}
o->last_update_tick = GetCurrentMs();
}
