int main(int argc, char ** argv){
db_t i;
db_t first;
if(argc>1) {
i = atoi(argv[1]);
dbase = malloc_file(sizeof(struct ITEM)*DBSIZE,FMODE_RO,"dbase24");
printf("%08X %X %X\n",dbase[i].db,dbase[i].dw,dbase[i].dd);
return 0;
}
dbase = malloc_file(sizeof(struct ITEM)*DBSIZE,FMODE_CR,"dbase24");
lastp = dbsize;
first = db_alloc();
dbase[first].db = 0xfff00fff;
dbase[first].dw = 0x00000fff;
dbase[first].dd = 0;
rootp[dbase[first].dw] = first;
time(&started);
for(level=0;;level++){
tprintf("level=%d tail=%d dbsize=%u\n",level,dbsize-lastp,dbsize);
db_t newp = dbsize;
for(;lastp!=newp;lastp++){
uint32_t w,b,d;
Unpack(dbase[lastp].db,dbase[lastp].dw,dbase[lastp].dd,&w,&b,&d);
MoveWhite(w,b,d);
}
if(dbsize==newp) break;
}
return 0;
}
int do_init_itemdb(void)
{
item_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_BASE,sizeof(int));
create_dummy_data(); //Dummy data item.
itemdb_read();
return 0;
}
// 初期化
void do_init_guild(void)
{
guild_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
castle_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
guild_expcache_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_BASE,sizeof(int));
guild_infoevent_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_BASE,sizeof(int));
expcache_ers = ers_new((uint32)sizeof(struct guild_expcache));
guild_castleinfoevent_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_BASE,sizeof(int));
guild_read_castledb();
guild_read_guildskill_tree_db(); //guild skill tree [Komurka]
add_timer_func_list(guild_gvg_eliminate_timer,"guild_gvg_eliminate_timer");
add_timer_func_list(guild_payexp_timer,"guild_payexp_timer");
add_timer_func_list(guild_save_sub, "guild_save_sub");
add_timer_func_list(guild_send_xy_timer, "guild_send_xy_timer");
add_timer_interval(gettick()+GUILD_PAYEXP_INVERVAL,guild_payexp_timer,0,0,GUILD_PAYEXP_INVERVAL);
add_timer_interval(gettick()+GUILD_SEND_XY_INVERVAL,guild_send_xy_timer,0,0,GUILD_SEND_XY_INVERVAL);
}
int MoveBlack(uint32_t w, uint32_t b, uint32_t d){
if(_popc(w|b) != 24 ) return -1;
uint32_t busy,iwhite,idamka;
Pack(&busy,&iwhite,&idamka,_brev(w),_brev(b),_brev(d));
db_t x = db_alloc();
dbase[x].db = busy;
dbase[x].dw = iwhite;
dbase[x].dd = idamka;
if(tsearch(x,rootp+iwhite)!=x)
db_free();
return 0;
}
OPERATION
create_operation()
{
register OPERATION op;
GDB_INIT_CHECK
op = (OPERATION)db_alloc(sizeof(OPERATION_DATA));
op->status = OP_NOT_STARTED; /* things like */
/* reset_operation */
/* want valid status */
/* at all times*/
op->id = GDB_OP_ID; /* eye-catcher */
return op;
}
// パ?ティデ?タのロ?ド
int inter_party_init() {
char line[8192];
struct party_data *p;
FILE *fp;
int c = 0;
int i, j;
party_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
if ((fp = fopen(party_txt, "r")) == NULL)
return 1;
while(fgets(line, sizeof(line), fp))
{
j = 0;
if (sscanf(line, "%d\t%%newid%%\n%n", &i, &j) == 1 && j > 0 && party_newid <= i) {
party_newid = i;
continue;
}
p = (struct party_data*)aCalloc(sizeof(struct party_data), 1);
if (p == NULL){
ShowFatalError("int_party: out of memory!\n");
exit(0);
}
memset(p, 0, sizeof(struct party_data));
if (inter_party_fromstr(line, &p->party) == 0 && p->party.party_id > 0) {
int_party_calc_state(p);
if (p->party.party_id >= party_newid)
party_newid = p->party.party_id + 1;
idb_put(party_db, p->party.party_id, p);
party_check_empty(&p->party);
} else {
ShowError("int_party: broken data [%s] line %d\n", party_txt, c + 1);
aFree(p);
}
c++;
}
fclose(fp);
return 0;
}
void kernel_init(void) {
static int init;
pmap_start = 1;
if(init) {
Bit_clear(free_map, 0, XN_NBLOCKS-1);
return;
}
init = 1;
pages = (void *)malloc(XN_BLOCK_SIZE * (PHYS_MEM+1));
assert(pages);
pages = (void *)roundup((unsigned)pages, XN_BLOCK_SIZE);
demand((unsigned) pages % XN_BLOCK_SIZE == 0, Bogus alignment);
pmap = Bit_new(PHYS_MEM);
free_map = Bit_new(XN_NBLOCKS);
demand(db_isfree(0, 1), should have allocated);
db_alloc(0, 1);
demand(!db_isfree(0, 1), should have allocated);
}
/*==========================================
*
*------------------------------------------*/
int do_init_chrif(void)
{
add_timer_func_list(check_connect_char_server, "check_connect_char_server");
add_timer_func_list(send_usercount_tochar, "send_usercount_tochar");
add_timer_func_list(send_users_tochar, "send_users_tochar");
add_timer_func_list(auth_db_cleanup, "auth_db_cleanup");
add_timer_interval(gettick() + 1000, check_connect_char_server, 0, 0, 10 * 1000);
#ifdef TXT_ONLY
//Txt needs this more frequently because it is used for the online.html file.
add_timer_interval(gettick() + 1000, send_users_tochar, 0, 0, UPDATE_INTERVAL);
#else
add_timer_interval(gettick() + 1000, send_users_tochar, 0, 0, CHECK_INTERVAL);
add_timer_interval(gettick() + 1000, send_usercount_tochar, 0, 0, UPDATE_INTERVAL);
#endif
add_timer_interval(gettick() + 1000, auth_db_cleanup, 0, 0, 30 * 1000);
auth_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
return 0;
}
int read_gm_account()
{
char line[8192];
struct gm_account *p;
FILE *fp;
int c=0;
gm_account_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_BASE,sizeof(int));
printf("Starting reading gm_account\n");
if( (fp=fopen("conf/GM_account.txt","r"))==NULL )
return 1;
while(fgets(line,sizeof(line),fp)){
if(line[0] == '/' || line[1] == '/' || line[2] == '/')
continue;
p = (struct gm_account*)malloc(sizeof(struct gm_account));
if(p==NULL){
printf("gm_account: out of memory!\n");
exit(0);
}
if(sscanf(line,"%d %d",&p->account_id,&p->level) != 2 || p->level <= 0) {
printf("gm_account: broken data [conf/GM_account.txt] line %d\n",c);
continue;
}
else {
if(p->level > 99)
p->level = 99;
idb_put(gm_account_db,p->account_id,p);
c++;
printf("GM ID: %d Level: %d\n",p->account_id,p->level);
}
}
fclose(fp);
printf("%d ID of gm_accounts read.\n",c);
return 0;
}
/**
* Used to create a database record and get it written out to a granule.
* In some cases, storage will need to be allocated.
*/
void
color_putrec(struct ged *gedp, struct mater *mp)
{
struct directory dir;
union record rec;
/* we get here only if database is NOT read-only */
rec.md.md_id = ID_MATERIAL;
rec.md.md_low = mp->mt_low;
rec.md.md_hi = mp->mt_high;
rec.md.md_r = mp->mt_r;
rec.md.md_g = mp->mt_g;
rec.md.md_b = mp->mt_b;
/* Fake up a directory entry for db_* routines */
RT_DIR_SET_NAMEP(&dir, "color_putrec");
dir.d_magic = RT_DIR_MAGIC;
dir.d_flags = 0;
if (mp->mt_daddr == MATER_NO_ADDR) {
/* Need to allocate new database space */
if (db_alloc(gedp->ged_wdbp->dbip, &dir, 1)) {
bu_vls_printf(gedp->ged_result_str, "Database alloc error, aborting");
return;
}
mp->mt_daddr = dir.d_addr;
} else {
dir.d_addr = mp->mt_daddr;
dir.d_len = 1;
}
if (db_put(gedp->ged_wdbp->dbip, &dir, &rec, 0, 1)) {
bu_vls_printf(gedp->ged_result_str, "Database write error, aborting");
return;
}
}
/*==========================================
* 初期化とか
*------------------------------------------
*/
int do_init_storage(void) // map.c::do_init()から呼ばれる
{
storage_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
guild_storage_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
return 1;
}
/*
* Initialize a disk. In real life we will have to deal with
* bootstrapping both the template file and root file.
*/
xn_err_t sys_xn_init(void) {
int new_p;
#ifndef EXOPC
char block[XN_BLOCK_SIZE];
#endif
size_t f_blocks, nbytes;
void *fm;
si->si_xn_entries = 0;
XN_DEV = 0;
if (XN_DEV >= si->si_ndisks) {
printf ("No XN is being configured (XN_DEV %d, si_ndisks %d)\n",
XN_DEV, si->si_ndisks);
return -E_NO_XN;
} else {
printf ("Giving XN permissions to disk %d\n", XN_DEV);
}
init();
/* Allocate blocks for the catalogues. */
fm = db_get_freemap(&nbytes);
super_block.f_nbytes = nbytes;
f_blocks = bytes_to_blocks(nbytes);
printf("free map takes up %d f_blocks %d\n", nbytes, f_blocks);
f_db = SUPER_BLOCK_DB + 1;
r_db = f_db + f_blocks;
t_db = r_db + R_NBLOCKS;
if(db_alloc(SUPER_BLOCK_DB, 1) != SUPER_BLOCK_DB)
fatal(Could not allocate);
// bc_check("checking super", SUPER_BLOCK_DB);
if(db_alloc(f_db, f_blocks) != f_db)
fatal(Could not allocate);
// bc_check("checking freemap", f_db);
if(db_alloc(r_db, R_NBLOCKS) != r_db)
fatal(Could not allocate);
// bc_check("checking root catalogue", r_db);
if(db_alloc(t_db, T_NBLOCKS) != t_db)
fatal(Could not allocate);
// bc_check("checking type catalogue", t_db);
#ifdef EXOPC
/* Always redo disk. */
new_p = 1;
#else
/* See if we are booting on a new disk. */
sync_read(block, SUPER_BLOCK_DB, 1);
memcpy(&super_block, block, sizeof super_block);
new_p = (super_block.cookie != compute_cookie(&super_block));
if(!new_p) {
printf("old disk\n");
assert(super_block.r_db == r_db);
assert(super_block.t_db == t_db);
assert(super_block.f_db == f_db);
/* tells us if we have to reconstruct. */
if(super_block.clean)
printf("clean shutdown\n");
else {
printf("unclean shutdown\n");
/* xn_reconstruct_disk(); */
}
/* read in free map. */
fm = malloc(f_blocks * XN_BLOCK_SIZE);
assert(fm);
sync_read(fm, super_block.f_db, f_blocks);
db_put_freemap(fm, nbytes);
free(fm);
root_init(new_p);
} else
#endif
{
printf("new disk\n");
super_block.r_db = r_db;
super_block.t_db = t_db;
super_block.f_db = f_db;
super_block.f_nbytes = nbytes;
super_block.clean = 1;
super_block.cookie = compute_cookie(&super_block);
/* Create new entry. */
root_init(new_p);
}
super_block.clean = 0;
super_block.cookie = compute_cookie(&super_block);
#ifndef EXOPC
sync_write(SUPER_BLOCK_DB, &super_block, 1);
sync_read(block, SUPER_BLOCK_DB, 1);
assert(compute_cookie(block) == super_block.cookie);
#endif
return XN_SUCCESS;
}
/**
* make n copies of a v4 combination.
*/
static struct directory *
copy_v4_comb(struct db_i *_dbip, struct directory *proto, struct clone_state *state, int idx)
{
struct directory *dp = (struct directory *)NULL;
union record *rp = (union record *)NULL;
size_t i;
size_t j;
/* make n copies */
for (i = 0; i < state->n_copies; i++) {
/* get a v4 in-memory reference to the object being copied */
if ((rp = db_getmrec(_dbip, proto)) == (union record *)0) {
TCL_READ_ERR;
return NULL;
}
if (proto->d_flags & RT_DIR_REGION) {
if (!is_in_list(obj_list, rp[1].M.m_instname)) {
bu_log("ERROR: clone internal error looking up %s\n", rp[1].M.m_instname);
return NULL;
}
bu_vls_strcpy(&obj_list.names[idx].dest[i], bu_vls_addr(&obj_list.names[index_in_list(obj_list, rp[1].M.m_instname)].dest[i]));
/* bleh, odd convention going on here.. prefix regions with an 'r' */
*bu_vls_addr(&obj_list.names[idx].dest[i]) = 'r';
} else {
struct bu_vls *name;
if (i==0)
name = get_name(_dbip, proto, state, i);
else {
dp = db_lookup(_dbip, bu_vls_addr(&obj_list.names[idx].dest[i-1]), LOOKUP_QUIET);
if (!dp) {
continue;
}
name = get_name(_dbip, dp, state, i);
}
bu_vls_strcpy(&obj_list.names[idx].dest[i], bu_vls_addr(name));
bu_vls_free(name);
}
bu_strlcpy(rp[0].c.c_name, bu_vls_addr(&obj_list.names[idx].dest[i]), NAMESIZE);
/* add the object to the directory */
dp = db_diradd(_dbip, rp->c.c_name, RT_DIR_PHONY_ADDR, proto->d_len, proto->d_flags, &proto->d_minor_type);
if ((dp == NULL) || (db_alloc(_dbip, dp, proto->d_len) < 0)) {
TCL_ALLOC_ERR;
return NULL;
}
for (j = 1; j < proto->d_len; j++) {
if (!is_in_list(obj_list, rp[j].M.m_instname)) {
bu_log("ERROR: clone internal error looking up %s\n", rp[j].M.m_instname);
return NULL;
}
snprintf(rp[j].M.m_instname, NAMESIZE, "%s", bu_vls_addr(&obj_list.names[index_in_list(obj_list, rp[j].M.m_instname)].dest[i]));
}
/* write the object to disk */
if (db_put(_dbip, dp, rp, 0, dp->d_len) < 0) {
bu_log("ERROR: clone internal error writing to the database\n");
return NULL;
}
/* our responsibility to free the record */
bu_free((char *)rp, "deallocate copy_v4_comb() db_getmrec() record");
}
return dp;
}
// ギルドデータの読み込み
int inter_guild_init() {
char line[16384];
struct guild *g;
struct guild_castle *gc;
FILE *fp;
int i, j, c = 0;
inter_guild_readdb();
guild_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
castle_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
if ((fp = fopen(guild_txt,"r")) == NULL)
return 1;
while(fgets(line, sizeof(line)-1, fp)) {
j = 0;
if (sscanf(line, "%d\t%%newid%%\n%n", &i, &j) == 1 && j > 0 && guild_newid <= i) {
guild_newid = i;
continue;
}
g = (struct guild *) aCalloc(sizeof(struct guild), 1);
if(g == NULL){
ShowFatalError("int_guild: out of memory!\n");
exit(0);
}
// memset(g, 0, sizeof(struct guild)); not needed...
if (inter_guild_fromstr(line, g) == 0 && g->guild_id > 0) {
if (g->guild_id >= guild_newid)
guild_newid = g->guild_id + 1;
idb_put(guild_db, g->guild_id, g);
guild_check_empty(g);
guild_calcinfo(g);
} else {
ShowError("int_guild: broken data [%s] line %d\n", guild_txt, c);
aFree(g);
}
c++;
}
fclose(fp);
// printf("int_guild: %s read done (%d guilds)\n", guild_txt, c);
c = 0;//カウンタ初期化
if ((fp = fopen(castle_txt, "r")) == NULL) {
return 1;
}
while(fgets(line, sizeof(line)-1, fp)) {
gc = (struct guild_castle *) aCalloc(sizeof(struct guild_castle), 1);
if(gc == NULL){
ShowFatalError("int_guild: out of memory!\n");
exit(0);
}
// memset(gc, 0, sizeof(struct guild_castle)); No need...
if (inter_guildcastle_fromstr(line, gc) == 0) {
idb_put(castle_db, gc->castle_id, gc);
} else {
ShowError("int_guild: broken data [%s] line %d\n", castle_txt, c);
aFree(gc);
}
c++;
}
if (!c) {
ShowStatus(" %s - making Default Data...\n", castle_txt);
//デフォルトデータを作成
for(i = 0; i < MAX_GUILDCASTLE; i++) {
gc = (struct guild_castle *) aCalloc(sizeof(struct guild_castle), 1);
if (gc == NULL) {
ShowFatalError("int_guild: out of memory!\n");
exit(0);
}
gc->castle_id = i;
idb_put(castle_db, gc->castle_id, gc);
}
ShowStatus(" %s - making done\n",castle_txt);
return 0;
}
fclose(fp);
return 0;
}
// initialize
int inter_init(const char *file)
{
//int i;
ShowInfo ("interserver initialize...\n");
inter_config_read(file);
//DB connection initialized
mysql_init(&mysql_handle);
ShowInfo("Connect Character DB server.... (Character Server)\n");
if(!mysql_real_connect(&mysql_handle, char_server_ip, char_server_id, char_server_pw,
char_server_db ,char_server_port, (char *)NULL, 0)) {
//pointer check
ShowFatalError("%s\n",mysql_error(&mysql_handle));
exit(1);
}
else if (inter_sql_test()) {
ShowStatus("Connect Success! (Character Server)\n");
}
if(char_gm_read) {
mysql_init(&lmysql_handle);
ShowInfo("Connect Character DB server.... (login server)\n");
if(!mysql_real_connect(&lmysql_handle, login_server_ip, login_server_id, login_server_pw,
login_server_db ,login_server_port, (char *)NULL, 0)) {
//pointer check
ShowFatalError("%s\n",mysql_error(&lmysql_handle));
exit(1);
} else {
ShowStatus ("Connect Success! (Login Server)\n");
}
}
if(strlen(default_codepage) > 0 ) {
sprintf( tmp_sql, "SET NAMES %s", default_codepage );
if (mysql_query(&mysql_handle, tmp_sql)) {
ShowSQL("DB error - %s\n",mysql_error(&mysql_handle));
ShowDebug("at %s:%d - %s\n", __FILE__,__LINE__,tmp_sql);
}
if(char_gm_read)
if (mysql_query(&lmysql_handle, tmp_sql)) {
ShowSQL("DB error - %s\n",mysql_error(&lmysql_handle));
ShowDebug("at %s:%d - %s\n", __FILE__,__LINE__,tmp_sql);
}
}
wis_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
inter_guild_sql_init();
inter_storage_sql_init();
inter_party_sql_init();
inter_pet_sql_init();
inter_accreg_sql_init();
//printf ("interserver timer initializing : %d sec...\n",autosave_interval);
//i=add_timer_interval(gettick()+autosave_interval,inter_save_timer,0,0,autosave_interval);
if (connection_ping_interval) {
add_timer_func_list(inter_sql_ping, "inter_sql_ping");
add_timer_interval(gettick()+connection_ping_interval*60*60*1000,
inter_sql_ping, 0, 0, connection_ping_interval*60*60*1000);
}
return 0;
}
//---------------------------------------------------------
// 倉庫データを読み込む
int inter_storage_init()
{
char line[65536];
int c=0,tmp_int;
struct storage *s;
struct guild_storage *gs;
FILE *fp;
storage_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
fp=fopen(storage_txt,"r");
if(fp==NULL){
ShowError("can't read : %s\n",storage_txt);
return 1;
}
while(fgets(line,65535,fp)){
sscanf(line,"%d",&tmp_int);
s = (struct storage*)aCalloc(sizeof(struct storage), 1);
if(s==NULL){
ShowFatalError("int_storage: out of memory!\n");
exit(0);
}
// memset(s,0,sizeof(struct storage)); aCalloc does this...
s->account_id=tmp_int;
if(s->account_id > 0 && storage_fromstr(line,s) == 0) {
idb_put(storage_db,s->account_id,s);
}
else{
ShowError("int_storage: broken data [%s] line %d\n",storage_txt,c);
aFree(s);
}
c++;
}
fclose(fp);
c = 0;
guild_storage_db = db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
fp=fopen(guild_storage_txt,"r");
if(fp==NULL){
ShowError("can't read : %s\n",guild_storage_txt);
return 1;
}
while(fgets(line,65535,fp)){
sscanf(line,"%d",&tmp_int);
gs = (struct guild_storage*)aCalloc(sizeof(struct guild_storage), 1);
if(gs==NULL){
ShowFatalError("int_storage: out of memory!\n");
exit(0);
}
// memset(gs,0,sizeof(struct guild_storage)); aCalloc...
gs->guild_id=tmp_int;
if(gs->guild_id > 0 && guild_storage_fromstr(line,gs) == 0) {
idb_put(guild_storage_db,gs->guild_id,gs);
}
else{
ShowError("int_storage: broken data [%s] line %d\n",guild_storage_txt,c);
aFree(gs);
}
c++;
}
fclose(fp);
return 0;
}
// 初期化
void do_init_party(void)
{
party_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
add_timer_func_list(party_send_xy_timer,"party_send_xy_timer");
add_timer_interval(gettick()+PARTY_SEND_XY_INVERVAL,party_send_xy_timer,0,0,PARTY_SEND_XY_INVERVAL);
}
/**
* make a copy of a v4 solid by adding it to our book-keeping list,
* adding it to the db directory, and writing it out to disk.
*/
static void
copy_v4_solid(struct db_i *_dbip, struct directory *proto, struct clone_state *state, int idx)
{
struct directory *dp = (struct directory *)NULL;
union record *rp = (union record *)NULL;
size_t i, j;
/* make n copies */
for (i = 0; i < state->n_copies; i++) {
struct bu_vls *name;
if (i==0)
name = get_name(_dbip, proto, state, i);
else {
dp = db_lookup(_dbip, bu_vls_addr(&obj_list.names[idx].dest[i-1]), LOOKUP_QUIET);
if (!dp) {
continue;
}
name = get_name(_dbip, dp, state, i);
}
/* XXX: this can probably be optimized. */
bu_vls_strcpy(&obj_list.names[idx].dest[i], bu_vls_addr(name));
bu_vls_free(name);
/* add the object to the directory */
dp = db_diradd(_dbip, bu_vls_addr(&obj_list.names[idx].dest[i]), RT_DIR_PHONY_ADDR, proto->d_len, proto->d_flags, &proto->d_minor_type);
if ((dp == RT_DIR_NULL) || (db_alloc(_dbip, dp, proto->d_len) < 0)) {
TCL_ALLOC_ERR;
return;
}
/* get an in-memory reference to the object being copied */
if ((rp = db_getmrec(_dbip, proto)) == (union record *)0) {
TCL_READ_ERR;
return;
}
if (rp->u_id == ID_SOLID) {
bu_strlcpy(rp->s.s_name, dp->d_namep, NAMESIZE);
/* mirror */
if (state->miraxis != W) {
/* XXX er, this seems rather wrong .. but it's v4 so punt */
rp->s.s_values[state->miraxis] += 2 * (state->mirpos - rp->s.s_values[state->miraxis]);
for (j = 3+state->miraxis; j < 24; j++)
rp->s.s_values[j] = -rp->s.s_values[j];
}
/* translate */
if (state->trans[W] > SMALL_FASTF)
/* assumes primitive's first parameter is its position */
VADD2(rp->s.s_values, rp->s.s_values, state->trans);
/* rotate */
if (state->rot[W] > SMALL_FASTF) {
mat_t r;
vect_t vec, ovec;
if (state->rpnt[W] > SMALL_FASTF)
VSUB2(rp->s.s_values, rp->s.s_values, state->rpnt);
MAT_IDN(r);
bn_mat_angles(r, state->rot[X], state->rot[Y], state->rot[Z]);
for (j = 0; j < 24; j+=3) {
VMOVE(vec, rp->s.s_values+j);
MAT4X3VEC(ovec, r, vec);
VMOVE(rp->s.s_values+j, ovec);
}
if (state->rpnt[W] > SMALL_FASTF)
VADD2(rp->s.s_values, rp->s.s_values, state->rpnt);
}
} else
bu_log("mods not available on %s\n", proto->d_namep);
/* write the object to disk */
if (db_put(_dbip, dp, rp, 0, dp->d_len) < 0) {
bu_log("ERROR: clone internal error writing to the database\n");
return;
}
}
if (rp)
bu_free((char *)rp, "copy_solid record[]");
return;
}
// 初期化
void do_init_party(void)
{
party_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
add_timer_func_list(party_send_xy_timer, "party_send_xy_timer");
add_timer_interval(gettick()+battle_config.party_update_interval, party_send_xy_timer, 0, 0, battle_config.party_update_interval);
}
