/** * Lookup (and possibly create) a new set of patterns by the set id */ static struct pcrematch_set* lookup_pcreset(struct npc_data* nd, int setid) { struct pcrematch_set *pcreset; struct npc_parse *npcParse = (struct npc_parse *) nd->chatdb; if (npcParse == NULL) nd->chatdb = npcParse = (struct npc_parse *) aCalloc(sizeof(struct npc_parse), 1); pcreset = npcParse->active; while (pcreset != NULL) { if (pcreset->setid == setid) break; pcreset = pcreset->next; } if (pcreset == NULL) pcreset = npcParse->inactive; while (pcreset != NULL) { if (pcreset->setid == setid) break; pcreset = pcreset->next; } if (pcreset == NULL) { pcreset = (struct pcrematch_set *) aCalloc(sizeof(struct pcrematch_set), 1); pcreset->next = npcParse->inactive; if (pcreset->next != NULL) pcreset->next->prev = pcreset; pcreset->prev = 0; npcParse->inactive = pcreset; pcreset->setid = setid; } return pcreset; }
//--------------------------------------------------------- // storage data initialize int inter_storage_sql_init(void) { //memory alloc ShowDebug("interserver storage memory initialize....(%d byte)\n",sizeof(struct storage)); storage_pt = (struct storage*)aCalloc(sizeof(struct storage), 1); guild_storage_pt = (struct guild_storage*)aCalloc(sizeof(struct guild_storage), 1); return 1; }
//--------------------------------------------------------- // storage data initialize int inter_storage_sql_init(void) { //memory alloc ShowDebug("interserver storage memory initialize....(%d byte)\n",sizeof(struct storage)); storage_pt = (struct storage*)aCalloc(sizeof(struct storage), 1); guild_storage_pt = (struct guild_storage*)aCalloc(sizeof(struct guild_storage), 1); // memset(storage_pt,0,sizeof(struct storage)); //Calloc sets stuff to 0 already. [Skotlex] // memset(guild_storage_pt,0,sizeof(struct guild_storage)); return 1; }
//character selected, insert into auth db void chrif_authok(int fd) { struct auth_node *auth_data; TBL_PC* sd; //Check if we don't already have player data in our server //(prevents data that is to be saved from being overwritten by //this received status data if this auth is later successful) [Skotlex] if ((sd = map_id2sd(RFIFOL(fd, 4))) != NULL) { struct mmo_charstatus *status = (struct mmo_charstatus *)RFIFOP(fd, 20); //Auth check is because this could be the very same sd that is waiting char-server authorization. if (sd->state.auth && sd->status.char_id == status->char_id) return; } if ((auth_data =uidb_get(auth_db, RFIFOL(fd, 4))) != NULL) { //Is the character already awaiting authorization? if (auth_data->sd) { //First, check to see if the session data still exists (avoid dangling pointers) if(session[auth_data->fd] && session[auth_data->fd]->session_data == auth_data->sd) { if (auth_data->char_dat == NULL && auth_data->account_id == RFIFOL(fd, 4) && auth_data->login_id1 == RFIFOL(fd, 8)) { //Auth Ok pc_authok(auth_data->sd, RFIFOL(fd, 16), RFIFOL(fd, 12), (struct mmo_charstatus*)RFIFOP(fd, 20)); } else { //Auth Failed pc_authfail(auth_data->sd); chrif_char_offline(auth_data->sd); //Set him offline, the char server likely has it set as online already. } } //else: Character no longer exists, just go through. } //Delete the data of this node... if (auth_data->char_dat) aFree (auth_data->char_dat); uidb_remove(auth_db, RFIFOL(fd, 4)); return; } // Awaiting for client to connect. auth_data = (struct auth_node *)aCalloc(1,sizeof(struct auth_node)); auth_data->char_dat = (struct mmo_charstatus *) aCalloc(1,sizeof(struct mmo_charstatus)); auth_data->account_id=RFIFOL(fd, 4); auth_data->login_id1=RFIFOL(fd, 8); auth_data->connect_until_time=RFIFOL(fd, 12); auth_data->login_id2=RFIFOL(fd, 16); memcpy(auth_data->char_dat,RFIFOP(fd, 20),sizeof(struct mmo_charstatus)); auth_data->node_created=gettick(); uidb_put(auth_db, RFIFOL(fd, 4), auth_data); }
/** * Load achievements for a character. * @param char_id: Character ID * @param count: Pointer to return the number of found entries. * @return Array of found entries. It has *count entries, and it is care of the caller to aFree() it afterwards. */ struct achievement *mapif_achievements_fromsql(uint32 char_id, int *count) { struct achievement *achievelog = NULL; struct achievement tmp_achieve; SqlStmt *stmt; StringBuf buf; int i; if (!count) return NULL; memset(&tmp_achieve, 0, sizeof(tmp_achieve)); StringBuf_Init(&buf); StringBuf_AppendStr(&buf, "SELECT `id`, COALESCE(UNIX_TIMESTAMP(`completed`),0), COALESCE(UNIX_TIMESTAMP(`rewarded`),0)"); for (i = 0; i < MAX_ACHIEVEMENT_OBJECTIVES; ++i) StringBuf_Printf(&buf, ", `count%d`", i + 1); StringBuf_Printf(&buf, " FROM `%s` WHERE `char_id` = '%u'", schema_config.achievement_table, char_id); stmt = SqlStmt_Malloc(sql_handle); if( SQL_ERROR == SqlStmt_PrepareStr(stmt, StringBuf_Value(&buf)) || SQL_ERROR == SqlStmt_Execute(stmt) ) { SqlStmt_ShowDebug(stmt); SqlStmt_Free(stmt); StringBuf_Destroy(&buf); *count = 0; return NULL; } SqlStmt_BindColumn(stmt, 0, SQLDT_INT, &tmp_achieve.achievement_id, 0, NULL, NULL); SqlStmt_BindColumn(stmt, 1, SQLDT_INT, &tmp_achieve.completed, 0, NULL, NULL); SqlStmt_BindColumn(stmt, 2, SQLDT_INT, &tmp_achieve.rewarded, 0, NULL, NULL); for (i = 0; i < MAX_ACHIEVEMENT_OBJECTIVES; ++i) SqlStmt_BindColumn(stmt, 3 + i, SQLDT_INT, &tmp_achieve.count[i], 0, NULL, NULL); *count = (int)SqlStmt_NumRows(stmt); if (*count > 0) { i = 0; achievelog = (struct achievement *)aCalloc(*count, sizeof(struct achievement)); while (SQL_SUCCESS == SqlStmt_NextRow(stmt)) { if (i >= *count) // Sanity check, should never happen break; memcpy(&achievelog[i++], &tmp_achieve, sizeof(tmp_achieve)); } if (i < *count) { // Should never happen. Compact array *count = i; achievelog = (struct achievement *)aRealloc(achievelog, sizeof(struct achievement) * i); } } SqlStmt_Free(stmt); StringBuf_Destroy(&buf); ShowInfo("achievement load complete from DB - id: %d (total: %d)\n", char_id, *count); return achievelog; }
/*========================================== * Loads all scdata from the given filename. *------------------------------------------ */ void status_load_scdata(const char* filename) { FILE *fp; int sd_count=0, sc_count=0; char line[8192]; struct scdata *sc; if ((fp = fopen(filename, "r")) == NULL) { ShowError("status_load_scdata: Nao se pode abrir o arquivo %s!\n", filename); return; } while(fgets(line, sizeof(line) - 1, fp)) { sc = (struct scdata*)aCalloc(1, sizeof(struct scdata)); if (inter_scdata_fromstr(line, sc)) { numdb_insert(scdata_db, sc->char_id, sc); sd_count++; sc_count+= sc->count; } else { ShowError("status_load_scdata: Arquivo de linha quebrada: %s\n", line); aFree(sc); } } fclose(fp); ShowStatus("Carregado %d salvo mudança de status %d personagem.\n", sc_count, sd_count); }
// 作成可否 int party_created(int account_id,int char_id,int fail,int party_id,char *name) { struct map_session_data *sd; sd=map_id2sd(account_id); nullpo_retr(0, sd); if (sd->status.char_id != char_id) return 0; //unlikely failure... if(fail==0){ struct party *p; sd->status.party_id=party_id; if(idb_get(party_db,party_id)!=NULL){ ShowFatalError("party: id already exists!\n"); exit(1); } p=(struct party *)aCalloc(1,sizeof(struct party)); p->party_id=party_id; memcpy(p->name, name, NAME_LENGTH); idb_put(party_db,party_id,p); clif_party_created(sd,0); //Success message clif_charnameupdate(sd); //Update other people's display. [Skotlex] }else{ clif_party_created(sd,1); } return 0; }
int inter_homun_init() { char line[8192]; struct s_homunculus *p; FILE *fp; int c=0; homun_db= idb_alloc(DB_OPT_RELEASE_DATA); if( (fp=fopen(homun_txt,"r"))==NULL ) return 1; while(fgets(line, sizeof(line), fp)) { p = (struct s_homunculus*)aCalloc(sizeof(struct s_homunculus), 1); if(p==NULL){ ShowFatalError("int_homun: out of memory!\n"); exit(EXIT_FAILURE); } if(inter_homun_fromstr(line,p)==0 && p->hom_id>0){ if( p->hom_id >= homun_newid) homun_newid=p->hom_id+1; idb_put(homun_db,p->hom_id,p); }else{ ShowError("int_homun: broken data [%s] line %d\n",homun_txt,c); aFree(p); } c++; } fclose(fp); return 0; }
/*========================================== * new auth system [Kevin] *------------------------------------------*/ void chrif_authreq(struct map_session_data *sd) { struct auth_node *auth_data; auth_data=idb_get(auth_db, sd->bl.id); if(auth_data) { if(auth_data->char_dat && auth_data->account_id== sd->bl.id && auth_data->login_id1 == sd->login_id1) { //auth ok pc_authok(sd, auth_data->login_id2, auth_data->connect_until_time, auth_data->char_dat); } else { //auth failed pc_authfail(sd); chrif_char_offline(sd); //Set him offline, the char server likely has it set as online already. } if (auth_data->char_dat) aFree(auth_data->char_dat); idb_remove(auth_db, sd->bl.id); } else { //data from char server has not arrived yet. auth_data = aCalloc(1,sizeof(struct auth_node)); auth_data->sd = sd; auth_data->fd = sd->fd; auth_data->account_id = sd->bl.id; auth_data->login_id1 = sd->login_id1; auth_data->node_created = gettick(); uidb_put(auth_db, sd->bl.id, auth_data); } return; }
int inter_pet_init() { char line[8192]; struct s_pet *p; FILE *fp; int c=0; pet_db= idb_alloc(DB_OPT_RELEASE_DATA); if( (fp=fopen(pet_txt,"r"))==NULL ) return 1; while(fgets(line, sizeof(line), fp)) { p = (struct s_pet*)aCalloc(sizeof(struct s_pet), 1); if(p==NULL){ ShowFatalError("int_pet: out of memory!\n"); exit(EXIT_FAILURE); } memset(p,0,sizeof(struct s_pet)); if(inter_pet_fromstr(line,p)==0 && p->pet_id>0){ if( p->pet_id >= pet_newid) pet_newid=p->pet_id+1; idb_put(pet_db,p->pet_id,p); }else{ ShowError("int_pet: broken data [%s] line %d\n",pet_txt,c); aFree(p); } c++; } fclose(fp); return 0; }
// パーティデータのロード int inter_party_init() { char line[8192]; struct party *p; FILE *fp; int c=0; party_db=numdb_init(); if( (fp=fopen(party_txt,"r"))==NULL ) return 1; while(fgets(line,sizeof(line),fp)){ int i,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 *)aCalloc(1,sizeof(struct party)); if(inter_party_fromstr(line,p)==0 && p->party_id>0){ if( p->party_id >= party_newid) party_newid=p->party_id+1; numdb_insert(party_db,p->party_id,p); party_check_empty(p); } else{ printf("int_party: broken data [%s] line %d\n",party_txt,c+1); free(p); } c++; } fclose(fp); // printf("int_party: %s read done (%d parties)\n",party_txt,c); return 0; }
int acquire_timer (void) { int i; if (free_timer_list_pos) { do { i = free_timer_list[--free_timer_list_pos]; } while(i >= timer_data_num && free_timer_list_pos > 0); } else i = timer_data_num; if (i >= timer_data_num) for (i = timer_data_num; i < timer_data_max && timer_data[i].type; i++); if (i >= timer_data_num && i >= timer_data_max) { if (timer_data_max == 0) { timer_data_max = 256; timer_data = (struct TimerData*) aCalloc( sizeof(struct TimerData) , timer_data_max); } else { timer_data_max += 256; timer_data = (struct TimerData *) aRealloc( timer_data, sizeof(struct TimerData) * timer_data_max); memset(timer_data + (timer_data_max - 256), 0, sizeof(struct TimerData) * 256); } } return i; }
/*====================================== * CORE : Timer Heap *-------------------------------------- */ static void push_timer_heap(int index) { int i, j; int min, max, pivot; // for sorting // check number of element if (timer_heap_num >= timer_heap_max) { if (timer_heap_max == 0) { timer_heap_max = 256; timer_heap = (int *) aCalloc( sizeof(int) , 256); } else { timer_heap_max += 256; timer_heap = (int *) aRealloc( timer_heap, sizeof(int) * timer_heap_max); memset(timer_heap + (timer_heap_max - 256), 0, sizeof(int) * 256); } } // do a sorting from higher to lower j = timer_data[index].tick; // speed up // with less than 4 values, it's speeder to use simple loop if (timer_heap_num < 4) { for(i = timer_heap_num; i > 0; i--) // if (j < timer_data[timer_heap[i - 1]].tick) //Plain comparisons break on bound looping timers. [Skotlex] if (DIFF_TICK(j, timer_data[timer_heap[i - 1]].tick) < 0) break; else timer_heap[i] = timer_heap[i - 1]; timer_heap[i] = index; // searching by dichotomie } else { // if lower actual item is higher than new // if (j < timer_data[timer_heap[timer_heap_num - 1]].tick) //Plain comparisons break on bound looping timers. [Skotlex] if (DIFF_TICK(j, timer_data[timer_heap[timer_heap_num - 1]].tick) < 0) timer_heap[timer_heap_num] = index; else { // searching position min = 0; max = timer_heap_num - 1; while (min < max) { pivot = (min + max) / 2; // if (j < timer_data[timer_heap[pivot]].tick) //Plain comparisons break on bound looping timers. [Skotlex] if (DIFF_TICK(j, timer_data[timer_heap[pivot]].tick) < 0) min = pivot + 1; else max = pivot; } // move elements - do loop if there are a little number of elements to move if (timer_heap_num - min < 5) { for(i = timer_heap_num; i > min; i--) timer_heap[i] = timer_heap[i - 1]; // move elements - else use memmove (speeder for a lot of elements) } else memmove(&timer_heap[min + 1], &timer_heap[min], sizeof(int) * (timer_heap_num - min)); // save new element timer_heap[min] = index; } } timer_heap_num++; }
static void* create_guildstorage(DBKey key, va_list args) { struct guild_storage *gs = NULL; gs = (struct guild_storage *) aCalloc(sizeof(struct guild_storage), 1); gs->guild_id=key.i; return gs; }
/** * @see DBCreateData */ static DBData create_guildstorage(DBKey key, va_list args) { struct guild_storage *gs = NULL; gs = (struct guild_storage *) aCalloc(sizeof(struct guild_storage), 1); gs->guild_id=key.i; return db_ptr2data(gs); }
/** * Inter-serv has sent us the elemental data from sql, fill it in map-serv memory * @param ele : The elemental data received from char-serv * @param flag : 0:not created, 1:was saved/loaded * @return 0:failed, 1:sucess */ int elemental_data_received(struct s_elemental *ele, bool flag) { struct map_session_data *sd; struct elemental_data *ed; struct s_elemental_db *db; int i = elemental_search_index(ele->class_); if( (sd = map_charid2sd(ele->char_id)) == NULL ) return 0; if( !flag || i < 0 ) { // Not created - loaded - DB info sd->status.ele_id = 0; return 0; } db = &elemental_db[i]; if( !sd->ed ) { // Initialize it after first summon. sd->ed = ed = (struct elemental_data*)aCalloc(1,sizeof(struct elemental_data)); ed->bl.type = BL_ELEM; ed->bl.id = npc_get_new_npc_id(); ed->master = sd; ed->db = db; memcpy(&ed->elemental, ele, sizeof(struct s_elemental)); status_set_viewdata(&ed->bl, ed->elemental.class_); ed->vd->head_mid = 10; // Why? status_change_init(&ed->bl); unit_dataset(&ed->bl); ed->ud.dir = sd->ud.dir; ed->bl.m = sd->bl.m; ed->bl.x = sd->bl.x; ed->bl.y = sd->bl.y; unit_calc_pos(&ed->bl, sd->bl.x, sd->bl.y, sd->ud.dir); ed->bl.x = ed->ud.to_x; ed->bl.y = ed->ud.to_y; map_addiddb(&ed->bl); status_calc_elemental(ed,SCO_FIRST); ed->last_spdrain_time = ed->last_thinktime = gettick(); ed->summon_timer = INVALID_TIMER; ed->masterteleport_timer = INVALID_TIMER; elemental_summon_init(ed); } else { memcpy(&sd->ed->elemental, ele, sizeof(struct s_elemental)); ed = sd->ed; } sd->status.ele_id = ele->elemental_id; if( ed->bl.prev == NULL && sd->bl.prev != NULL ) { if(map_addblock(&ed->bl)) return 0; clif_spawn(&ed->bl); clif_elemental_info(sd); clif_elemental_updatestatus(sd,SP_HP); clif_hpmeter_single(sd->fd,ed->bl.id,ed->battle_status.hp,ed->battle_status.max_hp); clif_elemental_updatestatus(sd,SP_SP); } return 1; }
// ========================================== // アカウント変数のジャーナルのロールフォワード用コールバック関数 // ------------------------------------------ int accregdb_journal_rollforward( int key, void* buf, int flag ) { struct accreg* reg = (struct accreg *)numdb_search( accreg_db, key ); // 念のためチェック if( flag == JOURNAL_FLAG_WRITE && key != ((struct accreg*)buf)->account_id ) { printf("inter: accreg_journal: key != account_id !\n"); return 0; } // データの置き換え if( reg ) { if( flag == JOURNAL_FLAG_DELETE ) { numdb_erase( accreg_db, key ); aFree( reg ); } else { memcpy( reg, buf, sizeof(struct accreg) ); } return 1; } // 追加 if( flag != JOURNAL_FLAG_DELETE ) { reg = (struct accreg*) aCalloc( 1, sizeof( struct accreg ) ); memcpy( reg, buf, sizeof(struct accreg) ); numdb_insert( accreg_db, key, reg ); return 1; } return 0; }
/// public constructor AccountDB* account_db_txt(void) { AccountDB_TXT* db = (AccountDB_TXT*)aCalloc(1, sizeof(AccountDB_TXT)); // set up the vtable db->vtable.init = &account_db_txt_init; db->vtable.destroy = &account_db_txt_destroy; db->vtable.get_property = &account_db_txt_get_property; db->vtable.set_property = &account_db_txt_set_property; db->vtable.save = &account_db_txt_save; db->vtable.create = &account_db_txt_create; db->vtable.remove = &account_db_txt_remove; db->vtable.load_num = &account_db_txt_load_num; db->vtable.load_str = &account_db_txt_load_str; db->vtable.iterator = &account_db_txt_iterator; // initialize to default values db->accounts = NULL; db->next_account_id = START_ACCOUNT_NUM; db->auths_before_save = AUTHS_BEFORE_SAVE; db->save_timer = INVALID_TIMER; safestrncpy(db->account_db, "save/account.txt", sizeof(db->account_db)); db->case_sensitive = false; return &db->vtable; }
/*========================================== * Loads all scdata from the given filename. *------------------------------------------*/ void status_load_scdata(const char* filename) { FILE *fp; int sd_count=0, sc_count=0; char line[8192]; struct scdata *sc; if ((fp = fopen(filename, "r")) == NULL) { ShowError("status_load_scdata: Cannot open file %s!\n", filename); return; } while(fgets(line, sizeof(line), fp)) { sc = (struct scdata*)aCalloc(1, sizeof(struct scdata)); if (inter_scdata_fromstr(line, sc)) { sd_count++; sc_count+= sc->count; sc = idb_put(scdata_db, sc->char_id, sc); if (sc) { ShowError("Duplicate entry in %s for character %d\n", filename, sc->char_id); if (sc->data) aFree(sc->data); aFree(sc); } } else { ShowError("status_load_scdata: Broken line data: %s\n", line); aFree(sc); } } fclose(fp); ShowStatus("Loaded %d saved status changes for %d characters.\n", sc_count, sd_count); }
/// public constructor AccountDB* account_db_sql(void) { AccountDB_SQL* db = (AccountDB_SQL*)aCalloc(1, sizeof(AccountDB_SQL)); // set up the vtable db->vtable.init = &account_db_sql_init; db->vtable.destroy = &account_db_sql_destroy; db->vtable.get_property = &account_db_sql_get_property; db->vtable.set_property = &account_db_sql_set_property; db->vtable.save = &account_db_sql_save; db->vtable.create = &account_db_sql_create; db->vtable.remove = &account_db_sql_remove; db->vtable.load_num = &account_db_sql_load_num; db->vtable.load_str = &account_db_sql_load_str; db->vtable.iterator = &account_db_sql_iterator; // initialize to default values db->accounts = NULL; // local sql settings safestrncpy(db->db_hostname, "127.0.0.1", sizeof(db->db_hostname)); db->db_port = 3306; safestrncpy(db->db_username, "ragnarok", sizeof(db->db_username)); safestrncpy(db->db_password, "ragnarok", sizeof(db->db_password)); safestrncpy(db->db_database, "ragnarok", sizeof(db->db_database)); safestrncpy(db->codepage, "", sizeof(db->codepage)); // other settings db->case_sensitive = false; safestrncpy(db->account_db, "login", sizeof(db->account_db)); safestrncpy(db->accreg_db, "global_reg_value", sizeof(db->accreg_db)); return &db->vtable; }
// 作成可否 int party_created(int account_id,int fail,int party_id,char *name) { struct map_session_data *sd; sd=map_id2sd(account_id); nullpo_retr(0, sd); if(fail==0){ struct party *p; sd->status.party_id=party_id; if((p=(struct party *) numdb_search(party_db,party_id))!=NULL){ ShowFatalError("party: id already exists!\n"); exit(1); } p=(struct party *)aCalloc(1,sizeof(struct party)); p->party_id=party_id; memcpy(p->name, name, NAME_LENGTH-1); numdb_insert(party_db,party_id,p); clif_party_created(sd,0); clif_charnameupdate(sd); //Update other people's display. [Skotlex] }else{ clif_party_created(sd,1); } return 0; }
static void* create_scdata(DBKey key, va_list args) { struct scdata *data; data = aCalloc(1, sizeof(struct scdata)); data->account_id = va_arg(args, int); data->char_id = key.i; return data; }
/** * create a new pattern entry */ static struct pcrematch_entry* create_pcrematch_entry(struct pcrematch_set* set) { struct pcrematch_entry * e = (struct pcrematch_entry *) aCalloc(sizeof(struct pcrematch_entry), 1); struct pcrematch_entry * last = set->head; // Normally we would have just stuck it at the end of the list but // this doesn't sink up with peoples usage pattern. They wanted // the items defined first to have a higher priority then the // items defined later. as a result, we have to do some work up front. /* if we are the first pattern, stick us at the end */ if (last == NULL) { set->head = e; return e; } /* Look for the last entry */ while (last->next != NULL) last = last->next; last->next = e; e->next = NULL; return e; }
// アカウント変数の読み込み int inter_accreg_init(void) { char line[8192]; FILE *fp; int c = 0; struct accreg *reg; accreg_db = idb_alloc(DB_OPT_RELEASE_DATA); if( (fp = fopen(accreg_txt, "r")) == NULL) return 1; while(fgets(line, sizeof(line), fp)) { reg = (struct accreg*)aCalloc(sizeof(struct accreg), 1); if (reg == NULL) { ShowFatalError("inter: accreg: out of memory!\n"); exit(EXIT_FAILURE); } if (inter_accreg_fromstr(line, reg) == 0 && reg->account_id > 0) { idb_put(accreg_db, reg->account_id, reg); } else { ShowError("inter: accreg: broken data [%s] line %d\n", accreg_txt, c); aFree(reg); } c++; } fclose(fp); return 0; }
/** * Received mercenary data from char-serv * @param merc : mercenary datas * @param flag : if inter-serv request was sucessfull * @return false:failure, true:sucess */ bool mercenary_recv_data(struct s_mercenary *merc, bool flag) { struct map_session_data *sd; struct mercenary_data *md; struct s_mercenary_db *db; int i = mercenary_search_index(merc->class_); if( (sd = map_charid2sd(merc->char_id)) == NULL ) return false; if( !flag || i < 0 ) { // Not created - loaded - DB info sd->status.mer_id = 0; return false; } db = &mercenary_db[i]; if( !sd->md ) { sd->md = md = (struct mercenary_data*)aCalloc(1,sizeof(struct mercenary_data)); md->bl.type = BL_MER; md->bl.id = npc_get_new_npc_id(); md->devotion_flag = 0; md->master = sd; md->db = db; memcpy(&md->mercenary, merc, sizeof(struct s_mercenary)); status_set_viewdata(&md->bl, md->mercenary.class_); status_change_init(&md->bl); unit_dataset(&md->bl); md->ud.dir = sd->ud.dir; md->bl.m = sd->bl.m; md->bl.x = sd->bl.x; md->bl.y = sd->bl.y; unit_calc_pos(&md->bl, sd->bl.x, sd->bl.y, sd->ud.dir); md->bl.x = md->ud.to_x; md->bl.y = md->ud.to_y; map_addiddb(&md->bl); status_calc_mercenary(md, SCO_FIRST); md->contract_timer = INVALID_TIMER; md->masterteleport_timer = INVALID_TIMER; merc_contract_init(md); } else { memcpy(&sd->md->mercenary, merc, sizeof(struct s_mercenary)); md = sd->md; } if( sd->status.mer_id == 0 ) mercenary_set_calls(md, 1); sd->status.mer_id = merc->mercenary_id; if( md && md->bl.prev == NULL && sd->bl.prev != NULL ) { if(map_addblock(&md->bl)) return false; clif_spawn(&md->bl); clif_mercenary_info(sd); clif_mercenary_skillblock(sd); } return true; }
static void* create_item_data(DBKey key, va_list args) { struct item_data *id; id=(struct item_data *)aCalloc(1,sizeof(struct item_data)); id->nameid = key.i; id->weight=1; id->type=IT_ETC; return id; }
// Create Party int mapif_parse_CreateParty (int fd, char *name, int item, int item2, struct party_member *leader) { struct party_data *p; int i; if ( (p = search_partyname (name)) != NULL) { mapif_party_created (fd, leader->account_id, leader->char_id, NULL); return 0; } // Check Authorised letters/symbols in the name of the character if (char_name_option == 1) // only letters/symbols in char_name_letters are authorised { for (i = 0; i < NAME_LENGTH && name[i]; i++) if (strchr (char_name_letters, name[i]) == NULL) { mapif_party_created (fd, leader->account_id, leader->char_id, NULL); return 0; } } else if (char_name_option == 2) // letters/symbols in char_name_letters are forbidden { for (i = 0; i < NAME_LENGTH && name[i]; i++) if (strchr (char_name_letters, name[i]) != NULL) { mapif_party_created (fd, leader->account_id, leader->char_id, NULL); return 0; } } p = (struct party_data *) aCalloc (1, sizeof (struct party_data)); memcpy (p->party.name, name, NAME_LENGTH); p->party.exp = 0; p->party.item = (item ? 1 : 0) | (item2 ? 2 : 0); memcpy (&p->party.member[0], leader, sizeof (struct party_member)); p->party.member[0].leader = 1; p->party.member[0].online = 1; p->party.party_id = -1; //New party. if (inter_party_tosql (&p->party, PS_CREATE | PS_ADDMEMBER, 0)) { //Add party to db int_party_calc_state (p); idb_put (party_db_, p->party.party_id, p); mapif_party_info (fd, &p->party, 0); mapif_party_created (fd, leader->account_id, leader->char_id, &p->party); } else //Failed to create party. { aFree (p); mapif_party_created (fd, leader->account_id, leader->char_id, NULL); } return 0; }
/** * Create a guild_storage stucture and add it into the db * @see DBCreateData * @param key * @param args * @return */ static DBData create_guildstorage(DBKey key, va_list args) { struct s_storage *gs = NULL; gs = (struct s_storage *) aCalloc(sizeof(struct s_storage), 1); gs->type = TABLE_GUILD_STORAGE; gs->id = key.i; return db_ptr2data(gs); }
int mapif_account_reg(int fd,unsigned char *src) { // unsigned char buf[WBUFW(src,2)]; <- Hey, can this really be done? [Skotlex] unsigned char *buf = aCalloc(1,WBUFW(src,2)); // [Lance] - Skot... Dynamic allocation is better :D memcpy(WBUFP(buf,0),src,WBUFW(src,2)); WBUFW(buf, 0)=0x3804; mapif_sendallwos(fd, buf, WBUFW(buf,2)); aFree(buf); return 0; }
/*========================================== * npcチャットルーム作成 *------------------------------------------ */ int chat_createnpcchat( struct npc_data *nd,int limit,int pub,int trigger,const char* title,int titlelen,const char *ev, int zeny,int lowlv,int highlv,unsigned int job,int upper) { int change_flag = 0; struct chat_data *cd; nullpo_retr(1, nd); // 既にチャットを持っているなら状態変更するだけ if( nd->chat_id && (cd = map_id2cd(nd->chat_id)) ) { change_flag = 1; memset(cd->npc_event, 0, sizeof(cd->npc_event)); } else { cd = (struct chat_data *)aCalloc(1,sizeof(struct chat_data)); cd->pass[0] = 0; cd->users = 0; cd->bl.type = BL_CHAT; cd->owner_ = &nd->bl; cd->owner = &cd->owner_; cd->bl.id = map_addobject(&cd->bl); if(cd->bl.id == 0) { aFree(cd); return 0; } nd->chat_id = cd->bl.id; } cd->limit = (unsigned char)limit; cd->trigger = (trigger > 0)? trigger: limit; cd->pub = pub; if(titlelen >= (int)(sizeof(cd->title) - 1)) { titlelen = (int)(sizeof(cd->title) - 1); } memcpy(cd->title,title,titlelen); cd->title[titlelen] = 0; cd->bl.m = nd->bl.m; cd->bl.x = nd->bl.x; cd->bl.y = nd->bl.y; cd->zeny = zeny; cd->lowlv = lowlv; cd->highlv = highlv; cd->job = job; cd->upper = upper; memcpy(cd->npc_event,ev,sizeof(cd->npc_event)); cd->npc_event[sizeof(cd->npc_event)-1] = '\0'; if(change_flag) clif_changechatstatus(cd); clif_dispchat(cd,-1); return 0; }