|
|
//gcc -o aoi aoi.c utils.c
|
|
|
#include <stdio.h>
|
|
|
#include <stdlib.h>
|
|
|
#include <string.h>
|
|
|
#include <time.h>
|
|
|
|
|
|
#include <lua.h>
|
|
|
#include <lualib.h>
|
|
|
#include <lauxlib.h>
|
|
|
|
|
|
#include "utils.h"
|
|
|
#include "aoi.h"
|
|
|
|
|
|
static int NEARBY_CEIL_OFFSETS[9][2] = {
|
|
|
{0, 0}, // center
|
|
|
{-1, 1}, // TL
|
|
|
{0, 1}, // T
|
|
|
{1, 1}, // TR
|
|
|
|
|
|
{-1, 0}, // L
|
|
|
{1, 0}, // R
|
|
|
|
|
|
{-1, -1}, // BL
|
|
|
{0, -1}, // B
|
|
|
{1, -1}, // BR
|
|
|
};
|
|
|
|
|
|
static double cost_time_in_lua = 0.0;
|
|
|
static double cost_time_in_cal = 0.0;
|
|
|
static double cost_time_in_get_event = 0.0;
|
|
|
|
|
|
static int get_grid_idx(World *w, int x, int y)
|
|
|
{
|
|
|
return (x - 1) * (w->col) + y - 1;
|
|
|
};
|
|
|
|
|
|
static void get_xy_by_grididx(World *w, int grid_idx, int *x, int *y)
|
|
|
{
|
|
|
*x = (grid_idx / w->col) + 1;
|
|
|
*y = grid_idx - ((*x) - 1) * w->col + 1;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
static int out_of_range(World *w, int grid_idx, int idx)
|
|
|
{
|
|
|
int x1, y1;
|
|
|
get_xy_by_grididx(w, grid_idx, &x1, &y1);
|
|
|
int x2, y2;
|
|
|
get_xy_by_grididx(w, idx, &x2, &y2);
|
|
|
if ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) > 2)
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
static HashTable *get_nearby_grids(World *w, Grid *grid)
|
|
|
{
|
|
|
int grid_num = w->row * w->col;
|
|
|
HashTable *ret = hashtbl_create();
|
|
|
|
|
|
int x, y;
|
|
|
get_xy_by_grididx(w, grid->idx, &x, &y);
|
|
|
int i, _x, _y;
|
|
|
for (i = 0; i < 9; i++)
|
|
|
{
|
|
|
_x = x + NEARBY_CEIL_OFFSETS[i][0];
|
|
|
_y = y + NEARBY_CEIL_OFFSETS[i][1];
|
|
|
if (_x >= 1 && _x <= w->row && _y >= 1 && _y <= w->col)
|
|
|
{
|
|
|
int tmp_idx = get_grid_idx(w, _x, _y);
|
|
|
Grid *grid = w->grids[tmp_idx];
|
|
|
hashtbl_upsert(ret, tmp_idx, grid);
|
|
|
//printf("get_nearby_grids %d %d\n",grid->idx,tmp_idx);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// for (int i = -1; i<=1; i++){
|
|
|
// for (int j= -1; j<=1; j++){
|
|
|
// int index = i*w->col + grid->idx + j;
|
|
|
// if(index >= 0 && index < grid_num){
|
|
|
// Grid* grid = w->grids[index];
|
|
|
// hashtbl_upsert(ret, index, grid);
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// local k = i*col + cur_grididx + j
|
|
|
// local grid = grids[k]
|
|
|
// if grid and not ret[k] then
|
|
|
// ret[k] = grid
|
|
|
// end
|
|
|
// end
|
|
|
// end
|
|
|
// return ret
|
|
|
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
static void print_event(int grid_idx, char flag, HashTable *events)
|
|
|
{
|
|
|
HashTableIter iter;
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
while (hashtbl_iter(events, &iter))
|
|
|
{
|
|
|
Event *e = (Event *)(iter.node->value);
|
|
|
printf("flag:%c grid_idx:%d event:%c,id:%d,x:%d,y:%d\n", flag, grid_idx, e->e, e->id, e->x, e->y);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static void get_grid_add_event(Grid *grid, lua_State *L)
|
|
|
{ //你进入某个格子，要知道该格子的事情
|
|
|
int idx_grid_info = lua_gettop(L); //2
|
|
|
lua_rawgeti(L, idx_grid_info, grid->idx);
|
|
|
if (lua_isnil(L, -1))
|
|
|
{
|
|
|
lua_pop(L, 1);
|
|
|
lua_newtable(L);
|
|
|
lua_pushvalue(L, -1);
|
|
|
lua_rawseti(L, idx_grid_info, grid->idx);
|
|
|
}
|
|
|
int idx_grid_detail = lua_gettop(L); //3
|
|
|
lua_rawgeti(L, idx_grid_detail, 1); //key_idx==1
|
|
|
if (lua_isnil(L, -1))
|
|
|
{
|
|
|
lua_pop(L, 1);
|
|
|
lua_newtable(L);
|
|
|
lua_pushvalue(L, -1);
|
|
|
lua_rawseti(L, idx_grid_detail, 1);
|
|
|
}
|
|
|
int idx_grid_add_del_update = lua_gettop(L); //4
|
|
|
size_t tbl_len = lua_rawlen(L, idx_grid_add_del_update);
|
|
|
if (tbl_len == 0)
|
|
|
{
|
|
|
int len = 1;
|
|
|
|
|
|
HashTableIter iter;
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
while (hashtbl_iter(grid->caches, &iter))
|
|
|
{
|
|
|
Cache *cache = (Cache *)(iter.node->value);
|
|
|
if (cache->e == 'A' || cache->e == 'U')
|
|
|
{
|
|
|
lua_newtable(L);
|
|
|
lua_pushinteger(L, 1); //'A'
|
|
|
lua_rawseti(L, -2, 1);
|
|
|
lua_pushinteger(L, cache->id);
|
|
|
lua_rawseti(L, -2, 2);
|
|
|
lua_pushinteger(L, cache->x);
|
|
|
lua_rawseti(L, -2, 3);
|
|
|
lua_pushinteger(L, cache->y);
|
|
|
lua_rawseti(L, -2, 4);
|
|
|
|
|
|
lua_rawseti(L, idx_grid_add_del_update, len);
|
|
|
len = len + 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
while (hashtbl_iter(grid->makers, &iter))
|
|
|
{
|
|
|
Obj *obj = (Obj *)(iter.node->value);
|
|
|
if (!hashtbl_get(grid->caches, obj->id))
|
|
|
{ //如果在cache中且没进入event_adds，说明e是D
|
|
|
lua_newtable(L);
|
|
|
lua_pushinteger(L, 1); //'A'
|
|
|
lua_rawseti(L, -2, 1);
|
|
|
lua_pushinteger(L, obj->id);
|
|
|
lua_rawseti(L, -2, 2);
|
|
|
lua_pushinteger(L, obj->x);
|
|
|
lua_rawseti(L, -2, 3);
|
|
|
lua_pushinteger(L, obj->y);
|
|
|
lua_rawseti(L, -2, 4);
|
|
|
|
|
|
lua_rawseti(L, idx_grid_add_del_update, len);
|
|
|
len = len + 1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static void get_grid_del_event(Grid *grid, lua_State *L)
|
|
|
{ //你离开某个格子，要知道该格子的事情
|
|
|
int idx_grid_info = lua_gettop(L); //2
|
|
|
lua_rawgeti(L, idx_grid_info, grid->idx);
|
|
|
if (lua_isnil(L, -1))
|
|
|
{
|
|
|
lua_pop(L, 1);
|
|
|
lua_newtable(L);
|
|
|
lua_pushvalue(L, -1);
|
|
|
lua_rawseti(L, idx_grid_info, grid->idx);
|
|
|
}
|
|
|
int idx_grid_detail = lua_gettop(L); //3
|
|
|
lua_rawgeti(L, idx_grid_detail, 2); //key_idx==2
|
|
|
if (lua_isnil(L, -1))
|
|
|
{
|
|
|
lua_pop(L, 1);
|
|
|
lua_newtable(L);
|
|
|
lua_pushvalue(L, -1);
|
|
|
lua_rawseti(L, idx_grid_detail, 2);
|
|
|
}
|
|
|
int idx_grid_add_del_update = lua_gettop(L); //4
|
|
|
size_t tbl_len = lua_rawlen(L, idx_grid_add_del_update);
|
|
|
if (tbl_len == 0)
|
|
|
{
|
|
|
int len = 1;
|
|
|
|
|
|
HashTableIter iter;
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
//cache中还没加进makers的就不管了
|
|
|
while (hashtbl_iter(grid->makers, &iter))
|
|
|
{
|
|
|
Obj *obj = (Obj *)(iter.node->value);
|
|
|
lua_newtable(L);
|
|
|
|
|
|
lua_pushinteger(L, 2); //'D'
|
|
|
lua_rawseti(L, -2, 1);
|
|
|
lua_pushinteger(L, obj->id);
|
|
|
lua_rawseti(L, -2, 2);
|
|
|
lua_pushinteger(L, obj->x);
|
|
|
lua_rawseti(L, -2, 3);
|
|
|
lua_pushinteger(L, obj->y);
|
|
|
lua_rawseti(L, -2, 4);
|
|
|
|
|
|
lua_rawseti(L, idx_grid_add_del_update, len);
|
|
|
len = len + 1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static void get_grid_update_event(Grid *grid, lua_State *L)
|
|
|
{ //你在某个格子附近晃，要知道该格子的事情
|
|
|
int idx_grid_info = lua_gettop(L); //2
|
|
|
lua_rawgeti(L, idx_grid_info, grid->idx);
|
|
|
if (lua_isnil(L, -1))
|
|
|
{
|
|
|
lua_pop(L, 1);
|
|
|
lua_newtable(L);
|
|
|
lua_pushvalue(L, -1);
|
|
|
lua_rawseti(L, idx_grid_info, grid->idx);
|
|
|
}
|
|
|
int idx_grid_detail = lua_gettop(L); //3
|
|
|
lua_rawgeti(L, idx_grid_detail, 3); //key_idx==3
|
|
|
if (lua_isnil(L, -1))
|
|
|
{
|
|
|
lua_pop(L, 1);
|
|
|
lua_newtable(L);
|
|
|
lua_pushvalue(L, -1);
|
|
|
lua_rawseti(L, idx_grid_detail, 3);
|
|
|
}
|
|
|
int idx_grid_add_del_update = lua_gettop(L); //4
|
|
|
size_t tbl_len = lua_rawlen(L, idx_grid_add_del_update);
|
|
|
if (tbl_len == 0)
|
|
|
{
|
|
|
int len = 1;
|
|
|
|
|
|
HashTableIter iter;
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
while (hashtbl_iter(grid->caches, &iter))
|
|
|
{
|
|
|
Cache *cache = (Cache *)(iter.node->value);
|
|
|
lua_newtable(L);
|
|
|
if (cache->e == 'A')
|
|
|
{
|
|
|
lua_pushinteger(L, 1); //'A'
|
|
|
}
|
|
|
else if (cache->e == 'D')
|
|
|
{
|
|
|
lua_pushinteger(L, 2);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
lua_pushinteger(L, 3);
|
|
|
}
|
|
|
lua_rawseti(L, -2, 1);
|
|
|
lua_pushinteger(L, cache->id);
|
|
|
lua_rawseti(L, -2, 2);
|
|
|
lua_pushinteger(L, cache->x);
|
|
|
lua_rawseti(L, -2, 3);
|
|
|
lua_pushinteger(L, cache->y);
|
|
|
lua_rawseti(L, -2, 4);
|
|
|
|
|
|
lua_rawseti(L, idx_grid_add_del_update, len);
|
|
|
len = len + 1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//结果处理
|
|
|
static void add_grid_events_to_watchers(Grid *grid, char e, int id, lua_State *L)
|
|
|
{
|
|
|
//printf("add_grid_events_to_watchers %d %c %d\n", grid->idx, e, id);
|
|
|
//clock_t t1 = clock();
|
|
|
//HashTable* events;
|
|
|
int key_idx;
|
|
|
if (e == 'U')
|
|
|
{ //3
|
|
|
get_grid_update_event(grid, L);
|
|
|
key_idx = 3;
|
|
|
}
|
|
|
else if (e == 'A')
|
|
|
{ //1
|
|
|
get_grid_add_event(grid, L);
|
|
|
key_idx = 1;
|
|
|
}
|
|
|
else if (e == 'D')
|
|
|
{ //2
|
|
|
get_grid_del_event(grid, L);
|
|
|
key_idx = 2;
|
|
|
}
|
|
|
//clock_t t2 = clock();
|
|
|
//double t3 = (double)(t2-t1)/CLOCKS_PER_SEC;
|
|
|
//cost_time_in_get_event += t3;
|
|
|
|
|
|
//clock_t time_begin = clock();
|
|
|
//不copy，直接用引用
|
|
|
int idx_ret = 1;
|
|
|
//将events upsert进L
|
|
|
//printf("upsert events succ %d\n",idx_grid_add_del_update);
|
|
|
|
|
|
lua_rawgeti(L, idx_ret, id);
|
|
|
if (lua_isnil(L, -1))
|
|
|
{
|
|
|
lua_pop(L, 1);
|
|
|
lua_newtable(L);
|
|
|
lua_pushvalue(L, -1);
|
|
|
lua_rawseti(L, idx_ret, id);
|
|
|
}
|
|
|
int idx_watcher_ret = lua_gettop(L); //5
|
|
|
size_t tbl_len = lua_rawlen(L, idx_watcher_ret);
|
|
|
lua_pushvalue(L, 4);
|
|
|
lua_rawseti(L, idx_watcher_ret, tbl_len + 1);
|
|
|
lua_pop(L, 3);
|
|
|
|
|
|
// lua_rawgeti(L, idx_watcher_ret, grid->idx);
|
|
|
// if(lua_isnil(L,-1)){
|
|
|
// lua_pop(L,1);
|
|
|
// lua_newtable(L);
|
|
|
// lua_pushvalue(L,-1);
|
|
|
// lua_rawseti(L, idx_watcher_ret, grid->idx);
|
|
|
// }
|
|
|
// int idx_watcher_grid_ret = lua_gettop(L);//6
|
|
|
// lua_pushvalue(L, 4);//引用,idx_grid_add_del_update==4
|
|
|
// lua_rawseti(L, idx_watcher_grid_ret, key_idx);
|
|
|
// lua_pop(L,4);
|
|
|
//clock_t time_end = clock();
|
|
|
//double time_cost = (double)(time_end-time_begin)/CLOCKS_PER_SEC;
|
|
|
//cost_time_in_lua += time_cost;
|
|
|
//printf("===cost_time_in_lua:%f====\n", cost_time_in_lua);
|
|
|
}
|
|
|
|
|
|
//watcher到了grid
|
|
|
static void resolve_change_watcher(World *w, Grid *grid, HashTable *right_grid_map, int pre_idx, int id, lua_State *L)
|
|
|
{
|
|
|
//printf("resolve_change_watcher id:%d grid_idx:%d pre_idx:%d\n",id, grid->idx, pre_idx);
|
|
|
HashTableIter iter;
|
|
|
HashTable *left_grid_map;
|
|
|
if (pre_idx != -1)
|
|
|
{
|
|
|
// int x,y;
|
|
|
// get_xy_by_grididx(w,pre_idx,&x,&y);
|
|
|
// int i, _x, _y;
|
|
|
// for(i=0; i<9; i++) {
|
|
|
// _x = x + NEARBY_CEIL_OFFSETS[i][0];
|
|
|
// _y = y + NEARBY_CEIL_OFFSETS[i][1];
|
|
|
// if (!(_x>=1&&_x<=w->row&&_y>=1&&_y<=w->col)){
|
|
|
// continue;
|
|
|
// }
|
|
|
// int tmp_idx = get_grid_idx(w, _x, _y);
|
|
|
// Grid* tmp_grid = w->grids[tmp_idx];
|
|
|
|
|
|
// if(out_of_range(w, grid->idx, tmp_idx)){
|
|
|
// add_grid_events_to_watchers(tmp_grid, 'D', id, L);
|
|
|
// }
|
|
|
// else{
|
|
|
// add_grid_events_to_watchers(tmp_grid, 'U', id, L);
|
|
|
// }
|
|
|
// }
|
|
|
Grid *old_grid = w->grids[pre_idx];
|
|
|
left_grid_map = get_nearby_grids(w, old_grid);
|
|
|
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
while (hashtbl_iter(left_grid_map, &iter))
|
|
|
{
|
|
|
Grid *tmp_grid = (Grid *)(iter.node->value);
|
|
|
if (hashtbl_get(right_grid_map, tmp_grid->idx))
|
|
|
{
|
|
|
add_grid_events_to_watchers(tmp_grid, 'U', id, L);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
add_grid_events_to_watchers(tmp_grid, 'D', id, L);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
while (hashtbl_iter(right_grid_map, &iter))
|
|
|
{
|
|
|
Grid *tmp_grid = (Grid *)(iter.node->value);
|
|
|
if (pre_idx == -1 || !hashtbl_get(left_grid_map, tmp_grid->idx))
|
|
|
{
|
|
|
add_grid_events_to_watchers(tmp_grid, 'A', id, L);
|
|
|
}
|
|
|
}
|
|
|
if (pre_idx != -1)
|
|
|
{
|
|
|
hashtbl_destroy(left_grid_map);
|
|
|
}
|
|
|
// for (int i = 0; i<9;i++){
|
|
|
// Grid* tmp_grid = grid_list[i];
|
|
|
// if(!tmp_grid){
|
|
|
// continue;
|
|
|
// }
|
|
|
// if(pre_idx!=-1 && !out_of_range(w, pre_idx, tmp_grid->idx)){
|
|
|
// continue;//之前已经get 'U'过了
|
|
|
// }
|
|
|
// add_grid_events_to_watchers(tmp_grid, 'A', id, L);
|
|
|
// }
|
|
|
}
|
|
|
static int grid_add_obj(World *w, Grid *grid, int id, int x, int y, int is_maker, int is_watcher)
|
|
|
{
|
|
|
if (is_maker)
|
|
|
{
|
|
|
if (hashtbl_get(grid->caches, id))
|
|
|
{
|
|
|
//之前可能有D 在里面
|
|
|
Cache *old_cache = (Cache *)hashtbl_get(grid->caches, id);
|
|
|
skynet_free(old_cache);
|
|
|
hashtbl_remove(grid->caches, id);
|
|
|
old_cache = NULL;
|
|
|
//printf("old cache id:%d e:%c x:%d y:%d \n", old_cache->id, old_cache->e, old_cache->x, old_cache->y);
|
|
|
}
|
|
|
Cache *cache = (Cache *)skynet_malloc(sizeof(Cache));
|
|
|
cache->id = id;
|
|
|
cache->x = x;
|
|
|
cache->y = y;
|
|
|
cache->e = 'A';
|
|
|
hashtbl_insert(grid->caches, id, cache);
|
|
|
}
|
|
|
if (is_watcher)
|
|
|
{
|
|
|
Obj *obj = (Obj *)skynet_malloc(sizeof(Obj));
|
|
|
obj->id = id;
|
|
|
obj->x = x;
|
|
|
obj->y = y;
|
|
|
obj->is_maker = is_maker;
|
|
|
obj->is_watcher = is_watcher;
|
|
|
hashtbl_insert(grid->watchers, obj->id, obj);
|
|
|
hashtbl_upsert(w->watcher_grids, grid->idx, NULL);
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
static int grid_del_obj(World *w, Grid *grid, int id)
|
|
|
{
|
|
|
if (hashtbl_get(grid->makers, id))
|
|
|
{ //已经落地了
|
|
|
//旧的cache清除
|
|
|
if (hashtbl_get(grid->caches, id))
|
|
|
{
|
|
|
Cache *old_cache = (Cache *)hashtbl_get(grid->caches, id);
|
|
|
skynet_free(old_cache);
|
|
|
hashtbl_remove(grid->caches, id);
|
|
|
old_cache = NULL;
|
|
|
}
|
|
|
//添加新的
|
|
|
Obj *obj = (Obj *)hashtbl_get(grid->makers, id);
|
|
|
Cache *cache = (Cache *)skynet_malloc(sizeof(Cache));
|
|
|
cache->id = obj->id;
|
|
|
cache->x = obj->x;
|
|
|
cache->y = obj->y;
|
|
|
cache->e = 'D';
|
|
|
hashtbl_insert(grid->caches, obj->id, cache);
|
|
|
}
|
|
|
else if (hashtbl_get(grid->caches, id))
|
|
|
{ //只是存在cache中
|
|
|
//当你从来没有出现过
|
|
|
//printf("grid_del_obj remove_caches %d\n", id);
|
|
|
Cache *cache = (Cache *)hashtbl_get(grid->caches, id);
|
|
|
skynet_free(cache);
|
|
|
hashtbl_remove(grid->caches, id);
|
|
|
cache = NULL;
|
|
|
}
|
|
|
|
|
|
if (hashtbl_get(grid->watchers, id))
|
|
|
{
|
|
|
//printf("grid_del_obj remove_watchers %d\n", id);
|
|
|
Obj *obj = (Obj *)hashtbl_get(grid->watchers, id);
|
|
|
hashtbl_remove(grid->watchers, id);
|
|
|
if (!obj->is_maker)
|
|
|
{
|
|
|
//如果只是watcher的话，释放对象
|
|
|
skynet_free(obj);
|
|
|
obj = NULL;
|
|
|
}
|
|
|
if (grid->watchers->count == 0)
|
|
|
{
|
|
|
hashtbl_remove(w->watcher_grids, grid->idx);
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
static void grid_update_obj(Grid *grid, int id)
|
|
|
{
|
|
|
//watcher不需要update
|
|
|
if (hashtbl_get(grid->makers, id) && !hashtbl_get(grid->caches, id))
|
|
|
{
|
|
|
//之前已经在的且没有caches的才需要添加cache
|
|
|
Obj *obj = (Obj *)hashtbl_get(grid->makers, id);
|
|
|
Cache *cache = (Cache *)skynet_malloc(sizeof(Cache));
|
|
|
cache->id = obj->id;
|
|
|
cache->x = obj->x;
|
|
|
cache->y = obj->y;
|
|
|
cache->e = 'U';
|
|
|
hashtbl_insert(grid->caches, obj->id, cache);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static void handle_cache(Grid *grid)
|
|
|
{
|
|
|
HashTableIter iter;
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
while (hashtbl_iter(grid->caches, &iter))
|
|
|
{
|
|
|
Cache *cache = (Cache *)(iter.node->value);
|
|
|
iter.node->value = NULL;
|
|
|
if (cache->e == 'A' && !hashtbl_get(grid->makers, cache->id))
|
|
|
{ //之前在makers，D了再A，就会重复，无须处理
|
|
|
//先D了去了其他格子，再回来，就不需要add_makers了
|
|
|
Obj *obj;
|
|
|
if (hashtbl_get(grid->watchers, cache->id))
|
|
|
{
|
|
|
obj = (Obj *)hashtbl_get(grid->watchers, cache->id);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
obj = (Obj *)skynet_malloc(sizeof(Obj));
|
|
|
obj->id = cache->id;
|
|
|
obj->x = cache->x;
|
|
|
obj->y = cache->y;
|
|
|
obj->is_maker = 1;
|
|
|
obj->is_watcher = 0;
|
|
|
}
|
|
|
hashtbl_insert(grid->makers, obj->id, obj);
|
|
|
}
|
|
|
else if (cache->e == 'D')
|
|
|
{
|
|
|
Obj *obj = (Obj *)hashtbl_get(grid->makers, cache->id);
|
|
|
hashtbl_remove(grid->makers, cache->id);
|
|
|
skynet_free(obj);
|
|
|
obj = NULL;
|
|
|
}
|
|
|
skynet_free(cache);
|
|
|
cache = NULL;
|
|
|
}
|
|
|
hashtbl_destroy(grid->caches);
|
|
|
grid->caches = hashtbl_create();
|
|
|
}
|
|
|
|
|
|
static void handle_aoi(World *w, Grid *grid, lua_State *L)
|
|
|
{
|
|
|
|
|
|
HashTable *grid_map = get_nearby_grids(w, grid);
|
|
|
HashTableIter iter2;
|
|
|
|
|
|
HashTableIter iter;
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
//Grid** grid_list = get_nearby_grids(w, grid);
|
|
|
while (hashtbl_iter(grid->watchers, &iter))
|
|
|
{
|
|
|
Obj *watcher = (Obj *)(iter.node->value);
|
|
|
int pre_idx = -1;
|
|
|
int id = watcher->id;
|
|
|
//printf("handle_aoi %d %d\n",grid->idx, id);
|
|
|
if (hashtbl_get(w->pre_where_is, id))
|
|
|
{
|
|
|
int *p_idx = (int *)hashtbl_get(w->pre_where_is, id);
|
|
|
pre_idx = *p_idx;
|
|
|
}
|
|
|
if (pre_idx == grid->idx)
|
|
|
{
|
|
|
|
|
|
hashtbl_iter_reset(&iter2);
|
|
|
while (hashtbl_iter(grid_map, &iter2))
|
|
|
{
|
|
|
Grid *tmp_grid = (Grid *)(iter2.node->value);
|
|
|
// if(id==6) {
|
|
|
// printf("tmp_grid %d\n",tmp_grid->idx);
|
|
|
// }
|
|
|
add_grid_events_to_watchers(tmp_grid, 'U', id, L);
|
|
|
}
|
|
|
// for (int i = 0; i<9;i++){
|
|
|
// Grid* tmp_grid = grid_list[i];
|
|
|
// if(!tmp_grid){
|
|
|
// continue;
|
|
|
// }
|
|
|
// add_grid_events_to_watchers(tmp_grid, 'U', id, L);
|
|
|
// }
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
resolve_change_watcher(w, grid, grid_map, pre_idx, id, L);
|
|
|
if (hashtbl_get(w->pre_where_is, id))
|
|
|
{
|
|
|
int *p_idx = (int *)hashtbl_get(w->pre_where_is, id);
|
|
|
*p_idx = grid->idx;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
int *p_idx = (int *)skynet_malloc(sizeof(int));
|
|
|
*p_idx = grid->idx;
|
|
|
hashtbl_insert(w->pre_where_is, id, p_idx);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
hashtbl_destroy(grid_map);
|
|
|
}
|
|
|
|
|
|
World *aoi_create_world(int row, int col)
|
|
|
{
|
|
|
//printf("aoi_create_world %d %d\n",row, col);
|
|
|
World *w = (World *)skynet_malloc(sizeof(World));
|
|
|
w->row = row;
|
|
|
w->col = col;
|
|
|
|
|
|
int grid_num = w->row * w->col;
|
|
|
w->grids = (Grid **)skynet_malloc(grid_num * sizeof(Grid *));
|
|
|
for (int i = 0; i < grid_num; i++)
|
|
|
{
|
|
|
Grid *grid = (Grid *)skynet_malloc(sizeof(Grid));
|
|
|
grid->idx = i;
|
|
|
grid->watchers = hashtbl_create();
|
|
|
grid->makers = hashtbl_create();
|
|
|
grid->caches = hashtbl_create();
|
|
|
|
|
|
w->grids[i] = grid;
|
|
|
}
|
|
|
w->where_is = hashtbl_create();
|
|
|
w->pre_where_is = hashtbl_create();
|
|
|
w->watcher_grids = hashtbl_create();
|
|
|
return w;
|
|
|
}
|
|
|
|
|
|
void aoi_get_cost_time(void *l)
|
|
|
{
|
|
|
lua_State *L = (lua_State *)l;
|
|
|
lua_pushnumber(L, cost_time_in_get_event);
|
|
|
lua_pushnumber(L, cost_time_in_lua);
|
|
|
lua_pushnumber(L, cost_time_in_cal);
|
|
|
cost_time_in_get_event = 0.0;
|
|
|
cost_time_in_lua = 0.0;
|
|
|
cost_time_in_cal = 0.0;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
void aoi_update_aoi(World *w, void *l)
|
|
|
{
|
|
|
//clock_t time_begin = clock();
|
|
|
lua_State *L = (lua_State *)l;
|
|
|
//printf("=========start update_aoi=========\n");
|
|
|
int grid_num = w->row * w->col;
|
|
|
//抛出事件
|
|
|
|
|
|
//for(int i=0;i<grid_num;i++){
|
|
|
// Grid* grid = w->grids[i];
|
|
|
// handle_aoi(w, grid, L);
|
|
|
//}
|
|
|
HashTableIter iter;
|
|
|
hashtbl_iter_reset(&iter);
|
|
|
while (hashtbl_iter(w->watcher_grids, &iter))
|
|
|
{
|
|
|
int grid_idx = (iter.node->key);
|
|
|
//printf("handle_aoi grid_idx %d\n", grid_idx);
|
|
|
Grid *grid = w->grids[grid_idx];
|
|
|
handle_aoi(w, grid, L);
|
|
|
}
|
|
|
//clock_t time_end = clock();
|
|
|
//处理cache
|
|
|
//printf("handle_cache\n");
|
|
|
for (int i = 0; i < grid_num; i++)
|
|
|
{
|
|
|
Grid *grid = w->grids[i];
|
|
|
handle_cache(grid);
|
|
|
}
|
|
|
|
|
|
//清空每个格子的events 通过lua_state自己清
|
|
|
//printf("clean all grids events\n");
|
|
|
|
|
|
//printf("=========end update_aoi=========\n");
|
|
|
//clock_t time_end = clock();
|
|
|
//double time_cost = (double)(time_end-time_begin)/CLOCKS_PER_SEC;
|
|
|
//cost_time_in_cal += time_cost;
|
|
|
//printf("===time_cost:%f====\n",cost_time_in_cal);
|
|
|
}
|
|
|
|
|
|
int aoi_add_obj(World *w, int id, int x, int y, int is_maker, int is_watcher)
|
|
|
{
|
|
|
int idx = get_grid_idx(w, x, y); //函数结束会释放idx的，不能hashtbl_insert(&idx)
|
|
|
Grid *grid = w->grids[idx];
|
|
|
|
|
|
if (hashtbl_get(w->where_is, id) || hashtbl_get(grid->caches, id) || hashtbl_get(grid->watchers, id) || hashtbl_get(grid->makers, id))
|
|
|
{
|
|
|
printf("add_obj duplicated %d\n", id);
|
|
|
return 1;
|
|
|
}
|
|
|
if (!is_maker && !is_watcher)
|
|
|
{
|
|
|
printf("add_obj no watcher_and_maker %d\n", id);
|
|
|
return 2;
|
|
|
}
|
|
|
int *p_idx = (int *)skynet_malloc(sizeof(int));
|
|
|
*p_idx = idx; //不同于p_idx=&idx
|
|
|
hashtbl_insert(w->where_is, id, p_idx);
|
|
|
grid_add_obj(w, grid, id, x, y, is_maker, is_watcher);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int aoi_del_obj(World *w, int id)
|
|
|
{
|
|
|
int *p_idx = (int *)hashtbl_get(w->where_is, id);
|
|
|
if (!p_idx)
|
|
|
{
|
|
|
printf("del_obj not_exist %d\n", id);
|
|
|
return 1;
|
|
|
}
|
|
|
Grid *grid = w->grids[*p_idx];
|
|
|
grid_del_obj(w, grid, id);
|
|
|
|
|
|
hashtbl_remove(w->where_is, id);
|
|
|
skynet_free(p_idx);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int aoi_set_obj(World *w, int id, int x, int y)
|
|
|
{
|
|
|
int *p_idx = (int *)hashtbl_get(w->where_is, id);
|
|
|
if (!p_idx)
|
|
|
{
|
|
|
printf("set_obj not_exist %d\n", id);
|
|
|
return 1;
|
|
|
}
|
|
|
int idx = get_grid_idx(w, x, y);
|
|
|
if (idx == *p_idx)
|
|
|
{
|
|
|
Grid *grid = w->grids[idx];
|
|
|
grid_update_obj(grid, id);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Grid *old_grid = w->grids[*p_idx];
|
|
|
Grid *new_grid = w->grids[idx];
|
|
|
int is_maker = 0;
|
|
|
int is_watcher = 0;
|
|
|
if (hashtbl_get(old_grid->makers, id) || hashtbl_get(old_grid->caches, id))
|
|
|
{
|
|
|
is_maker = 1;
|
|
|
}
|
|
|
if (hashtbl_get(old_grid->watchers, id))
|
|
|
{
|
|
|
is_watcher = 1;
|
|
|
}
|
|
|
grid_del_obj(w, old_grid, id);
|
|
|
grid_add_obj(w, new_grid, id, x, y, is_maker, is_watcher);
|
|
|
|
|
|
*p_idx = idx;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// int main() {
|
|
|
// // World* w = aoi_create_world(3,3);
|
|
|
// // aoi_add_obj(w,7,2,2,1,1);
|
|
|
// // aoi_add_obj(w,1,2,2,1,1);
|
|
|
// // aoi_add_obj(w,6,3,3,1,1);
|
|
|
// // //aoi_update_aoi(w);
|
|
|
// // //aoi_update_aoi(w);
|
|
|
// // aoi_set_obj(w,7,2,3);
|
|
|
// // //aoi_update_aoi(w);
|
|
|
// // aoi_add_obj(w,2,1,1,1,1);
|
|
|
// // aoi_set_obj(w,2,1,2);
|
|
|
// // //aoi_update_aoi(w);
|
|
|
// // //先加再删，等于从来没出现过
|
|
|
// // aoi_add_obj(w,3,2,2,1,1);
|
|
|
// // aoi_del_obj(w,3);
|
|
|
// // //aoi_update_aoi(w);
|
|
|
|
|
|
// // aoi_set_obj(w,2,3,3);
|
|
|
// // aoi_set_obj(w,7,1,1);
|
|
|
// //aoi_update_aoi(w);
|
|
|
// // update_aoi(w);
|
|
|
// // printf("======\n");
|
|
|
// // del_obj(w,7);
|
|
|
// // update_aoi(w);
|
|
|
// // printf("=======\n");
|
|
|
// // int grid_idx = get_grid_idx(w,1,2);
|
|
|
// // int x,y;
|
|
|
// // get_xy_by_grididx(w,grid_idx,&x,&y);
|
|
|
// // printf("x:%d y:%d\n", x, y);
|
|
|
// // add_obj(w,2,5,5,1,1);
|
|
|
// // show_world(w);
|
|
|
// // set_obj(w,1,6,6);
|
|
|
// // show_world(w);
|
|
|
// // del_obj(w,1);
|
|
|
// // show_world(w);
|
|
|
|
|
|
// // World* w = aoi_create_world(3,3);
|
|
|
// // for(int i=1;i<=10000;i++)
|
|
|
// // {
|
|
|
// // aoi_add_obj(w,i,1,1,1,1);
|
|
|
// // }
|
|
|
// // HashTable* aoi_results = hashtbl_create();
|
|
|
// // aoi_update_aoi(w, aoi_results);
|
|
|
// // //打印aoi_results
|
|
|
// // HashTableIter iter;
|
|
|
// // hashtbl_iter_reset(&iter);
|
|
|
// // int i = 0;
|
|
|
// // while(hashtbl_iter(aoi_results, &iter)){
|
|
|
// // Result* re=(Result*)(iter.node->value);
|
|
|
|
|
|
// // printf("watcher:%ld\n", iter.node->key);
|
|
|
// // int watcher_id = (int)iter.node->key;
|
|
|
// // HashTableIter tmp_iter;
|
|
|
// // hashtbl_iter_reset(&tmp_iter);
|
|
|
// // while(hashtbl_iter(re->add_results, &tmp_iter)){
|
|
|
// // Event* e=(Event*)(tmp_iter.node->value);
|
|
|
// // //printf("event:%c,id:%d,x:%d,y:%d\n",e->e,e->id,e->x,e->y);
|
|
|
// // i=i+1;
|
|
|
// // printf("i is %d\n",i);
|
|
|
// // }
|
|
|
// // // hashtbl_iter_reset(&tmp_iter);
|
|
|
// // // while(hashtbl_iter(re->del_results, &tmp_iter)){
|
|
|
// // // Event* e=(Event*)(tmp_iter.node->value);
|
|
|
// // // //printf("event:%c,id:%d,x:%d,y:%d\n",e->e,e->id,e->x,e->y);
|
|
|
// // // }
|
|
|
// // // hashtbl_iter_reset(&tmp_iter);
|
|
|
// // // while(hashtbl_iter(re->update_results, &tmp_iter)){
|
|
|
// // // Event* e=(Event*)(tmp_iter.node->value);
|
|
|
// // // //printf("event:%c,id:%d,x:%d,y:%d\n",e->e,e->id,e->x,e->y);
|
|
|
// // // }
|
|
|
|
|
|
// // hashtbl_destroy(re->add_results);
|
|
|
// // hashtbl_destroy(re->del_results);
|
|
|
// // hashtbl_destroy(re->update_results);
|
|
|
// // }
|
|
|
// // printf("clean aoi_results\n");
|
|
|
// // //todo清空aoi_results
|
|
|
// // hashtbl_destroy(aoi_results);
|
|
|
// return 0;
|
|
|
// }
|