/**
* Initiate storage module
* Called from map.c::do_init()
*/
void do_init_storage(void)
{
guild_storage_db = idb_alloc(DB_OPT_RELEASE_DATA);
}
/*==========================================
* 初期化とか
*------------------------------------------*/
int do_init_storage(void) // map.c::do_init()から呼ばれる
{
guild_storage_db=idb_alloc(DB_OPT_RELEASE_DATA);
return 1;
}
/**
* Initialize PC Groups: allocate DBMaps and read config.
* @public
*/
void do_init_pc_groups(void)
{
pc_group_db = idb_alloc(DB_OPT_RELEASE_DATA);
pc_groupname_db = stridb_alloc(DB_OPT_DUP_KEY, 0);
read_config();
}
/**
* Initializes the quest interface.
*/
void do_init_quest(void) {
questdb = idb_alloc(DB_OPT_BASE);
quest_read_db();
}
void do_init_battleground(void)
{
bg_team_db = idb_alloc(DB_OPT_RELEASE_DATA);
add_timer_func_list(bg_send_xy_timer, "bg_send_xy_timer");
add_timer_interval(gettick() + battle_config.bg_update_interval, bg_send_xy_timer, 0, 0, battle_config.bg_update_interval);
}
// ギルドデータの読み込み
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 = idb_alloc(DB_OPT_RELEASE_DATA);
castle_db = idb_alloc(DB_OPT_RELEASE_DATA);
if ((fp = fopen(guild_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 && 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(EXIT_FAILURE);
}
// 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);
c = 0;//カウンタ初期化
if ((fp = fopen(castle_txt, "r")) == NULL) {
return 1;
}
while(fgets(line, sizeof(line), fp))
{
gc = (struct guild_castle *) aCalloc(sizeof(struct guild_castle), 1);
if(gc == NULL){
ShowFatalError("int_guild: out of memory!\n");
exit(EXIT_FAILURE);
}
// 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++;
}
fclose(fp);
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(EXIT_FAILURE);
}
gc->castle_id = i;
idb_put(castle_db, gc->castle_id, gc);
}
ShowStatus(" %s - making done\n",castle_txt);
return 0;
}
return 0;
}
/*==========================================
* Init/Terminate
*------------------------------------------*/
int do_init_storage(void) // Called from map.c::do_init()
{
guild_storage_db=idb_alloc(DB_OPT_RELEASE_DATA);
return 1;
}
/**
* Destory the vending module
* called in map::do_final
*/
void do_init_vending(void) {
vending_db = idb_alloc(DB_OPT_BASE);
vending_nextid = 0;
}
/// opens accounts file, loads it, and starts a periodic saving timer
static bool account_db_txt_init(AccountDB* self)
{
AccountDB_TXT* db = (AccountDB_TXT*)self;
DBMap* accounts;
FILE* fp;
char line[2048];
unsigned int version = 0;
// create accounts database
db->accounts = idb_alloc(DB_OPT_RELEASE_DATA);
accounts = db->accounts;
// open data file
fp = fopen(db->account_db, "r");
if( fp == NULL )
{
// no account file -> no account -> no login, including char-server (ERROR)
ShowError(CL_RED"account_db_txt_init: Accounts file [%s] not found."CL_RESET"\n", db->account_db);
return false;
}
// load data file
while( fgets(line, sizeof(line), fp) != NULL )
{
int account_id, n;
unsigned int v;
struct mmo_account acc;
struct mmo_account* tmp;
struct DBIterator* iter;
int (*compare)(const char* str1, const char* str2) = ( db->case_sensitive ) ? strcmp : stricmp;
if( line[0] == '/' && line[1] == '/' )
continue;
n = 0;
if( sscanf(line, "%d%n", &v, &n) == 1 && (line[n] == '\n' || line[n] == '\r') )
{// format version definition
version = v;
continue;
}
n = 0;
if( sscanf(line, "%d\t%%newid%%%n", &account_id, &n) == 1 && (line[n] == '\n' || line[n] == '\r') )
{// auto-increment
if( account_id > db->next_account_id )
db->next_account_id = account_id;
continue;
}
if( !mmo_auth_fromstr(&acc, line, version) )
{
ShowError("account_db_txt_init: skipping invalid data: %s", line);
continue;
}
// apply constraints & checks here
if( acc.sex != 'S' && (acc.account_id < START_ACCOUNT_NUM || acc.account_id > END_ACCOUNT_NUM) )
ShowWarning("account_db_txt_init: account %d:'%s' has ID outside of the defined range for accounts (min:%d max:%d)!\n", acc.account_id, acc.userid, START_ACCOUNT_NUM, END_ACCOUNT_NUM);
iter = accounts->iterator(accounts);
for( tmp = (struct mmo_account*)iter->first(iter,NULL); iter->exists(iter); tmp = (struct mmo_account*)iter->next(iter,NULL) )
if( compare(acc.userid, tmp->userid) == 0 )
break;
iter->destroy(iter);
if( tmp != NULL )
{// entry with identical username
ShowWarning("account_db_txt_init: account %d:'%s' has same username as account %d. The account will be inaccessible!\n", acc.account_id, acc.userid, tmp->account_id);
}
if( idb_get(accounts, acc.account_id) != NULL )
{// account id already occupied
ShowError("account_db_txt_init: ID collision for account id %d! Discarding data for account '%s'...\n", acc.account_id, acc.userid);
continue;
}
// record entry in db
tmp = (struct mmo_account*)aMalloc(sizeof(struct mmo_account));
memcpy(tmp, &acc, sizeof(struct mmo_account));
idb_put(accounts, acc.account_id, tmp);
if( db->next_account_id < acc.account_id)
db->next_account_id = acc.account_id + 1;
}
// close data file
fclose(fp);
// initialize data saving timer
add_timer_func_list(mmo_auth_sync_timer, "mmo_auth_sync_timer");
db->save_timer = add_timer_interval(gettick() + AUTH_SAVING_INTERVAL, mmo_auth_sync_timer, 0, (int)db, AUTH_SAVING_INTERVAL);
return true;
}
/*--------------------------------------
* name : instance name
* Return value could be
* -4 = already exists | -3 = no free instances | -2 = owner not found | -1 = invalid type
* On success return instance_id
*--------------------------------------*/
int instance_create(int owner_id, const char *name, enum instance_owner_type type) {
struct map_session_data *sd = NULL;
unsigned short *icptr = NULL;
struct party_data *p = NULL;
struct guild *g = NULL;
short *iptr = NULL;
int i, j;
switch ( type ) {
case IOT_NONE:
break;
case IOT_CHAR:
if( ( sd = map->id2sd(owner_id) ) == NULL ) {
ShowError("instance_create: character %d not found for instance '%s'.\n", owner_id, name);
return -2;
}
iptr = sd->instance;
icptr = &sd->instances;
break;
case IOT_PARTY:
if( ( p = party->search(owner_id) ) == NULL ) {
ShowError("instance_create: party %d not found for instance '%s'.\n", owner_id, name);
return -2;
}
iptr = p->instance;
icptr = &p->instances;
break;
case IOT_GUILD:
if( ( g = guild->search(owner_id) ) == NULL ) {
ShowError("instance_create: guild %d not found for instance '%s'.\n", owner_id, name);
return -2;
}
iptr = g->instance;
icptr = &g->instances;
break;
default:
ShowError("instance_create: unknown type %d for owner_id %d and name %s.\n", type,owner_id,name);
return -1;
}
if( type != IOT_NONE && *icptr ) {
ARR_FIND(0, *icptr, i, strcmp(instances[iptr[i]].name,name) == 0 );
if( i != *icptr )
return -4;/* already got this instance */
}
ARR_FIND(0, instance->instances, i, instances[i].state == INSTANCE_FREE);
if( i == instance->instances )
RECREATE(instances, struct instance_data, ++instance->instances);
instances[i].state = INSTANCE_IDLE;
instances[i].id = i;
instances[i].idle_timer = INVALID_TIMER;
instances[i].idle_timeout = instances[i].idle_timeoutval = 0;
instances[i].progress_timer = INVALID_TIMER;
instances[i].progress_timeout = 0;
instances[i].users = 0;
instances[i].map = NULL;
instances[i].num_map = 0;
instances[i].owner_id = owner_id;
instances[i].owner_type = type;
instances[i].vars = idb_alloc(DB_OPT_RELEASE_DATA);
safestrncpy( instances[i].name, name, sizeof(instances[i].name) );
if( type != IOT_NONE ) {
ARR_FIND(0, *icptr, j, iptr[j] == -1);
if( j == *icptr ) {
switch( type ) {
case IOT_CHAR:
RECREATE(sd->instance, short, ++*icptr);
sd->instance[sd->instances-1] = i;
break;
case IOT_PARTY:
RECREATE(p->instance, short, ++*icptr);
p->instance[p->instances-1] = i;
break;
case IOT_GUILD:
RECREATE(g->instance, short, ++*icptr);
g->instance[g->instances-1] = i;
break;
}
} else
//---------------------------------------------------------
// 倉庫データを読み込む
int inter_storage_init()
{
char line[65536];
int c = 0;
FILE *fp;
storage_db = idb_alloc(DB_OPT_RELEASE_DATA);
fp=fopen(storage_txt,"r");
if(fp==NULL){
ShowError("can't read : %s\n",storage_txt);
return 1;
}
while( fgets(line, sizeof(line), fp) )
{
int account_id;
struct storage_data *s;
s = (struct storage_data*)aCalloc(sizeof(struct storage_data), 1);
if( s == NULL )
{
ShowFatalError("int_storage: out of memory!\n");
exit(EXIT_FAILURE);
}
if( storage_fromstr(line,&account_id,s) )
{
idb_put(storage_db,account_id,s);
}
else{
ShowError("int_storage: broken data in [%s] line %d\n",storage_txt,c);
aFree(s);
}
c++;
}
fclose(fp);
c = 0;
guild_storage_db = idb_alloc(DB_OPT_RELEASE_DATA);
fp=fopen(guild_storage_txt,"r");
if(fp==NULL){
ShowError("can't read : %s\n",guild_storage_txt);
return 1;
}
while(fgets(line, sizeof(line), fp))
{
int tmp_int;
struct guild_storage *gs;
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(EXIT_FAILURE);
}
// 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_clan(){
clan_db = idb_alloc(DB_OPT_RELEASE_DATA);
}
/*==========================================
* Initializes db.
*------------------------------------------*/
void status_init()
{
scdata_db = idb_alloc(DB_OPT_BASE);
status_load_scdata(scdata_txt);
}
/**
* Initiate storage module
* Called from map.c::do_init()
*/
void do_init_storage(void)
{
guild_storage_db = idb_alloc(DB_OPT_RELEASE_DATA);
storage_db = NULL;
storage_count = 0;
}
/**
* Initiate storage module
* Called from map.c::do_init()
* @return 1
*/
int do_init_storage(void) //
{
guild_storage_db=idb_alloc(DB_OPT_RELEASE_DATA);
return 1;
}
/*==========================================
* アイテムデータベースの読み込み
*------------------------------------------*/
static int itemdb_readdb(void)
{
const char* filename[] = {
DBPATH"item_db.txt",
"item_db2.txt" };
int fi;
DBMap* item_combo_db = idb_alloc(DB_OPT_RELEASE_DATA);
itemdb_read_combos(item_combo_db);
for( fi = 0; fi < ARRAYLENGTH(filename); ++fi ) {
uint32 lines = 0, count = 0;
char line[1024];
char path[256];
FILE* fp;
sprintf(path, "%s/%s", db_path, filename[fi]);
fp = fopen(path, "r");
if( fp == NULL ) {
ShowWarning("itemdb_readdb: File not found \"%s\", skipping.\n", path);
continue;
}
// process rows one by one
while(fgets(line, sizeof(line), fp))
{
char *str[32], *p;
int i;
struct item_combo *ic = NULL;
char *script2 = NULL;
lines++;
if(line[0] == '/' && line[1] == '/')
continue;
memset(str, 0, sizeof(str));
p = line;
while( ISSPACE(*p) )
++p;
if( *p == '\0' )
continue;// empty line
for( i = 0; i < 19; ++i )
{
str[i] = p;
p = strchr(p,',');
if( p == NULL )
break;// comma not found
*p = '\0';
++p;
}
if( p == NULL )
{
ShowError("itemdb_readdb: Insufficient columns in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
// Script
if( *p != '{' )
{
ShowError("itemdb_readdb: Invalid format (Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
str[19] = p;
p = strstr(p+1,"},");
if( p == NULL )
{
ShowError("itemdb_readdb: Invalid format (Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
p[1] = '\0';
p += 2;
// OnEquip_Script
if( *p != '{' )
{
ShowError("itemdb_readdb: Invalid format (OnEquip_Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
str[20] = p;
p = strstr(p+1,"},");
if( p == NULL )
{
ShowError("itemdb_readdb: Invalid format (OnEquip_Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
p[1] = '\0';
p += 2;
// OnUnequip_Script (last column)
if( *p != '{' )
{
ShowError("itemdb_readdb: Invalid format (OnUnequip_Script column) in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
str[21] = p;
p = strstr(p+1,"}");
if ( strchr(p,',') != NULL )
{
ShowError("itemdb_readdb: Extra columns in line %d of \"%s\" (item with id %d), skipping.\n", lines, path, atoi(str[0]));
continue;
}
if ((ic = idb_get(item_combo_db, atoi(str[0])))) {
script2 = ic->script;
}
if (!itemdb_parse_dbrow(str, path, lines, 0, script2))
continue;
if( script2 != NULL )
idb_remove(item_combo_db,atoi(str[0]));
count++;
}
fclose(fp);
ShowStatus("Done reading '"CL_WHITE"%lu"CL_RESET"' entries in '"CL_WHITE"%s"CL_RESET"'.\n", count, filename[fi]);
}
if( db_size(item_combo_db) ) {
DBIterator * iter = db_iterator(item_combo_db);
struct item_combo * ic = NULL;
int icount = 1;
/* non-processed entries */
ShowWarning("item_combo_db: There are %d unused entries in the file (combo(s) with non-available item IDs)\n",db_size(item_combo_db));
for( ic = dbi_first(iter); dbi_exists(iter); ic = dbi_next(iter) ) {
ShowWarning("item_combo_db(%d): (ID:%d) \"%s\" combo unused\n",icount++,ic->nameid,ic->script);
}
dbi_destroy(iter);
}
db_destroy(item_combo_db);
return 0;
}
