Merge pull request #601 from 4144/hpmreduce

Reduce map server memory usage for 3 MB with loaded HPM

16 files changed, 873 insertions, 852 deletions

diff --git a/src/map/atcommand.c b/src/map/atcommand.c
index 2be990025..fb0b89381 100644
--- a/src/map/atcommand.c
+++ b/src/map/atcommand.c
@@ -5244,11 +5244,11 @@ ACMD(skillid) {
 
 	for (data = iter->first(iter,&key); iter->exists(iter); data = iter->next(iter,&key)) {
 		int idx = skill->get_index(DB->data2i(data));
-		if (strnicmp(key.str, message, skillen) == 0 || strnicmp(skill->db[idx].desc, message, skillen) == 0) {
-			sprintf(atcmd_output, msg_fd(fd,1164), DB->data2i(data), skill->db[idx].desc, key.str); // skill %d: %s (%s)
+		if (strnicmp(key.str, message, skillen) == 0 || strnicmp(skill->dbs->db[idx].desc, message, skillen) == 0) {
+			sprintf(atcmd_output, msg_fd(fd,1164), DB->data2i(data), skill->dbs->db[idx].desc, key.str); // skill %d: %s (%s)
 			clif->message(fd, atcmd_output);
-		} else if ( found < MAX_SKILLID_PARTIAL_RESULTS && ( stristr(key.str,message) || stristr(skill->db[idx].desc,message) ) ) {
-			snprintf(partials[found], MAX_SKILLID_PARTIAL_RESULTS_LEN, msg_fd(fd,1164), DB->data2i(data), skill->db[idx].desc, key.str);
+		} else if ( found < MAX_SKILLID_PARTIAL_RESULTS && ( stristr(key.str,message) || stristr(skill->dbs->db[idx].desc,message) ) ) {
+			snprintf(partials[found], MAX_SKILLID_PARTIAL_RESULTS_LEN, msg_fd(fd,1164), DB->data2i(data), skill->dbs->db[idx].desc, key.str);
 			found++;
 		}
 	}
@@ -5376,7 +5376,7 @@ ACMD(skilltree) {
 	{
 		if( ent->need[j].id && pc->checkskill(sd,ent->need[j].id) < ent->need[j].lv)
 		{
-			sprintf(atcmd_output, msg_fd(fd,1170), ent->need[j].lv, skill->db[ent->need[j].id].desc); // Player requires level %d of skill %s.
+			sprintf(atcmd_output, msg_fd(fd,1170), ent->need[j].lv, skill->dbs->db[ent->need[j].id].desc); // Player requires level %d of skill %s.
 			clif->message(fd, atcmd_output);
 			meets = 0;
 		}
@@ -9306,7 +9306,7 @@ ACMD(cddebug) {
 				const struct TimerData *td = timer->get(cd->entry[i]->timer);
 				
 				if( !td || td->func != skill->blockpc_end ) {
-					clif->messages(fd,"Found invalid entry in slot %d for skill %s",i,skill->db[cd->entry[i]->skidx].name);
+					clif->messages(fd,"Found invalid entry in slot %d for skill %s",i,skill->dbs->db[cd->entry[i]->skidx].name);
 					sd->blockskill[cd->entry[i]->skidx] = false;
 				}
 			}
@@ -9316,7 +9316,7 @@ ACMD(cddebug) {
 	if( !cd || (message && *message && !strcmpi(message,"reset")) ) {
 		for(i = 0; i < MAX_SKILL; i++) {
 			if( sd->blockskill[i] ) {
-				clif->messages(fd,"Found skill '%s', unblocking...",skill->db[i].name);
+				clif->messages(fd,"Found skill '%s', unblocking...",skill->dbs->db[i].name);
 				sd->blockskill[i] = false;
 			}
 		}
diff --git a/src/map/chrif.c b/src/map/chrif.c
index 41485d222..5bd1e436f 100644
--- a/src/map/chrif.c
+++ b/src/map/chrif.c
@@ -1321,8 +1321,8 @@ void chrif_skillid2idx(int fd) {
 	WFIFOHEAD(fd,4 + (MAX_SKILL * 4));
 	WFIFOW(fd,0) = 0x2b0b;
 	for(i = 0; i < MAX_SKILL; i++) {
-		if( skill->db[i].nameid ) {
-			WFIFOW(fd, 4 + (count*4)) = skill->db[i].nameid;
+		if( skill->dbs->db[i].nameid ) {
+			WFIFOW(fd, 4 + (count*4)) = skill->dbs->db[i].nameid;
 			WFIFOW(fd, 6 + (count*4)) = i;
 			count++;
 		}
diff --git a/src/map/clif.c b/src/map/clif.c
index cc517c24f..cbe22dbb0 100644
--- a/src/map/clif.c
+++ b/src/map/clif.c
@@ -1370,7 +1370,7 @@ bool clif_spawn(struct block_list *bl)
 				if( sd->bg_id && map->list[sd->bl.m].flag.battleground )
 					clif->sendbgemblem_area(sd);
 				for( i = 0; i < sd->sc_display_count; i++ ) {
-					clif->sc_load(&sd->bl, sd->bl.id,AREA,status->IconChangeTable[sd->sc_display[i]->type],sd->sc_display[i]->val1,sd->sc_display[i]->val2,sd->sc_display[i]->val3);
+					clif->sc_load(&sd->bl, sd->bl.id,AREA,status->dbs->IconChangeTable[sd->sc_display[i]->type],sd->sc_display[i]->val1,sd->sc_display[i]->val2,sd->sc_display[i]->val3);
 				}
 				if (sd->charm_type != CHARM_TYPE_NONE && sd->charm_count > 0)
 					clif->spiritcharm(sd);
@@ -3227,14 +3227,14 @@ void clif_arrow_create_list(struct map_session_data *sd)
 
 	for (i = 0, c = 0; i < MAX_SKILL_ARROW_DB; i++) {
 		int j;
-		if (skill->arrow_db[i].nameid > 0
-		 && (j = pc->search_inventory(sd, skill->arrow_db[i].nameid)) != INDEX_NOT_FOUND
+		if (skill->dbs->arrow_db[i].nameid > 0
+		 && (j = pc->search_inventory(sd, skill->dbs->arrow_db[i].nameid)) != INDEX_NOT_FOUND
 		 && !sd->status.inventory[j].equip && sd->status.inventory[j].identify
 		) {
-			if ((j = itemdb_viewid(skill->arrow_db[i].nameid)) > 0)
+			if ((j = itemdb_viewid(skill->dbs->arrow_db[i].nameid)) > 0)
 				WFIFOW(fd,c*2+4) = j;
 			else
-				WFIFOW(fd,c*2+4) = skill->arrow_db[i].nameid;
+				WFIFOW(fd,c*2+4) = skill->dbs->arrow_db[i].nameid;
 			c++;
 		}
 	}
@@ -4005,7 +4005,7 @@ void clif_getareachar_pc(struct map_session_data* sd,struct map_session_data* ds
 		clif->charm_single(sd->fd, dstsd);
 
 	for( i = 0; i < dstsd->sc_display_count; i++ ) {
-		clif->sc_load(&sd->bl,dstsd->bl.id,SELF,status->IconChangeTable[dstsd->sc_display[i]->type],dstsd->sc_display[i]->val1,dstsd->sc_display[i]->val2,dstsd->sc_display[i]->val3);
+		clif->sc_load(&sd->bl,dstsd->bl.id,SELF,status->dbs->IconChangeTable[dstsd->sc_display[i]->type],dstsd->sc_display[i]->val1,dstsd->sc_display[i]->val2,dstsd->sc_display[i]->val3);
 	}
 	if( (sd->status.party_id && dstsd->status.party_id == sd->status.party_id) || //Party-mate, or hpdisp setting.
 		(sd->bg_id && sd->bg_id == dstsd->bg_id) || //BattleGround
@@ -5190,13 +5190,13 @@ void clif_skill_produce_mix_list(struct map_session_data *sd, int skill_id , int
 	WFIFOW(fd, 0)=0x18d;
 
 	for(i=0,c=0;i<MAX_SKILL_PRODUCE_DB;i++){
-		if( skill->can_produce_mix(sd,skill->produce_db[i].nameid, trigger, 1) &&
-			( ( skill_id > 0 && skill->produce_db[i].req_skill == skill_id ) || skill_id < 0 )
+		if( skill->can_produce_mix(sd,skill->dbs->produce_db[i].nameid, trigger, 1) &&
+			( ( skill_id > 0 && skill->dbs->produce_db[i].req_skill == skill_id ) || skill_id < 0 )
 			){
-			if((view = itemdb_viewid(skill->produce_db[i].nameid)) > 0)
+			if((view = itemdb_viewid(skill->dbs->produce_db[i].nameid)) > 0)
 				WFIFOW(fd,c*8+ 4)= view;
 			else
-				WFIFOW(fd,c*8+ 4)= skill->produce_db[i].nameid;
+				WFIFOW(fd,c*8+ 4)= skill->dbs->produce_db[i].nameid;
 			WFIFOW(fd,c*8+ 6)= 0;
 			WFIFOW(fd,c*8+ 8)= 0;
 			WFIFOW(fd,c*8+10)= 0;
@@ -5237,13 +5237,13 @@ void clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill_id
 
 	c = 0;
 	for( i = 0; i < MAX_SKILL_PRODUCE_DB; i++ ) {
-		if( !skill->can_produce_mix(sd,skill->produce_db[i].nameid,trigger, qty) )
+		if( !skill->can_produce_mix(sd,skill->dbs->produce_db[i].nameid,trigger, qty) )
 			continue;
 
-		if( (view = itemdb_viewid(skill->produce_db[i].nameid)) > 0 )
+		if( (view = itemdb_viewid(skill->dbs->produce_db[i].nameid)) > 0 )
 			WFIFOW(fd, 6 + 2 * c) = view;
 		else
-			WFIFOW(fd, 6 + 2 * c) = skill->produce_db[i].nameid;
+			WFIFOW(fd, 6 + 2 * c) = skill->dbs->produce_db[i].nameid;
 
 		c++;
 	}
@@ -16723,11 +16723,11 @@ int clif_elementalconverter_list(struct map_session_data *sd) {
 	WFIFOW(fd, 0)=0x1ad;
 
 	for(i=0,c=0;i<MAX_SKILL_PRODUCE_DB;i++){
-		if( skill->can_produce_mix(sd,skill->produce_db[i].nameid,23, 1) ){
-			if((view = itemdb_viewid(skill->produce_db[i].nameid)) > 0)
+		if( skill->can_produce_mix(sd,skill->dbs->produce_db[i].nameid,23, 1) ){
+			if((view = itemdb_viewid(skill->dbs->produce_db[i].nameid)) > 0)
 				WFIFOW(fd,c*2+ 4)= view;
 			else
-				WFIFOW(fd,c*2+ 4)= skill->produce_db[i].nameid;
+				WFIFOW(fd,c*2+ 4)= skill->dbs->produce_db[i].nameid;
 			c++;
 		}
 	}
diff --git a/src/map/elemental.c b/src/map/elemental.c
index bf0d42ce9..459ce2a39 100644
--- a/src/map/elemental.c
+++ b/src/map/elemental.c
@@ -586,8 +586,8 @@ struct skill_condition elemental_skill_get_requirements(uint16 skill_id, uint16
 	if( skill_lv < 1 || skill_lv > MAX_SKILL_LEVEL )
 		return req;
 
-	req.hp = skill->db[idx].hp[skill_lv-1];
-	req.sp = skill->db[idx].sp[skill_lv-1];
+	req.hp = skill->dbs->db[idx].hp[skill_lv-1];
+	req.sp = skill->dbs->db[idx].sp[skill_lv-1];
 
 	return req;
 }
diff --git a/src/map/homunculus.c b/src/map/homunculus.c
index dd158fc5d..305d60f5b 100644
--- a/src/map/homunculus.c
+++ b/src/map/homunculus.c
@@ -43,11 +43,12 @@
 #include <string.h>
 
 struct homunculus_interface homunculus_s;
+struct homun_dbs homundbs;
 
 //Returns the viewdata for homunculus
 struct view_data* homunculus_get_viewdata(int class_) {
 	if (homdb_checkid(class_))
-		return &homun->viewdb[class_-HM_CLASS_BASE];
+		return &homun->dbs->viewdb[class_-HM_CLASS_BASE];
 	return NULL;
 }
 
@@ -193,13 +194,13 @@ int homunculus_calc_skilltree(struct homun_data *hd, int flag_evolve) {
 	if( hd->homunculus.prev_class != 0 ) {
 		c = hd->homunculus.prev_class - HM_CLASS_BASE;
 
-		for( i = 0; i < MAX_SKILL_TREE && ( id = homun->skill_tree[c][i].id ) > 0; i++ ) {
+		for( i = 0; i < MAX_SKILL_TREE && ( id = homun->dbs->skill_tree[c][i].id ) > 0; i++ ) {
 			if( hd->homunculus.hskill[ id - HM_SKILLBASE ].id )
 				continue; //Skill already known.
 			if(!battle_config.skillfree) {
 				for( j = 0; j < MAX_PC_SKILL_REQUIRE; j++ ) {
-					if( homun->skill_tree[c][i].need[j].id &&
-					   homun->checkskill(hd,homun->skill_tree[c][i].need[j].id) < homun->skill_tree[c][i].need[j].lv ) {
+					if( homun->dbs->skill_tree[c][i].need[j].id &&
+					   homun->checkskill(hd,homun->dbs->skill_tree[c][i].need[j].id) < homun->dbs->skill_tree[c][i].need[j].lv ) {
 						f = 0;
 						break;
 					}
@@ -214,16 +215,16 @@ int homunculus_calc_skilltree(struct homun_data *hd, int flag_evolve) {
 
 	c = hd->homunculus.class_ - HM_CLASS_BASE;
 
-	for( i = 0; i < MAX_SKILL_TREE && ( id = homun->skill_tree[c][i].id ) > 0; i++ ) {
+	for( i = 0; i < MAX_SKILL_TREE && ( id = homun->dbs->skill_tree[c][i].id ) > 0; i++ ) {
 		if( hd->homunculus.hskill[ id - HM_SKILLBASE ].id )
 			continue; //Skill already known.
 		j = ( flag_evolve ) ? 10 : hd->homunculus.intimacy;
-		if( j < homun->skill_tree[c][i].intimacylv )
+		if( j < homun->dbs->skill_tree[c][i].intimacylv )
 			continue;
 		if(!battle_config.skillfree) {
 			for( j = 0; j < MAX_PC_SKILL_REQUIRE; j++ ) {
-				if( homun->skill_tree[c][i].need[j].id &&
-					homun->checkskill(hd,homun->skill_tree[c][i].need[j].id) < homun->skill_tree[c][i].need[j].lv ) {
+				if( homun->dbs->skill_tree[c][i].need[j].id &&
+					homun->checkskill(hd,homun->dbs->skill_tree[c][i].need[j].id) < homun->dbs->skill_tree[c][i].need[j].lv ) {
 					f = 0;
 					break;
 				}
@@ -252,9 +253,9 @@ int homunculus_checkskill(struct homun_data *hd,uint16 skill_id) {
 int homunculus_skill_tree_get_max(int id, int b_class) {
 	int i, skill_id;
 	b_class -= HM_CLASS_BASE;
-	for(i=0;(skill_id=homun->skill_tree[b_class][i].id)>0;i++)
+	for(i=0;(skill_id=homun->dbs->skill_tree[b_class][i].id)>0;i++)
 		if (id == skill_id)
-			return homun->skill_tree[b_class][i].max;
+			return homun->dbs->skill_tree[b_class][i].max;
 	return skill->get_max(id);
 }
 
@@ -316,7 +317,7 @@ bool homunculus_levelup(struct homun_data *hd) {
 		hom->skillpts++; //1 skillpoint each 3 base level
 
 	hom->exp -= hd->exp_next;
-	hd->exp_next = homun->exptable[hom->level - 1];
+	hd->exp_next = homun->dbs->exptable[hom->level - 1];
 
 	max  = &hd->homunculusDB->gmax;
 	min  = &hd->homunculusDB->gmin;
@@ -366,7 +367,7 @@ int homunculus_change_class(struct homun_data *hd, short class_) {
 	i = homun->db_search(class_,HOMUNCULUS_CLASS);
 	if(i < 0)
 		return 0;
-	hd->homunculusDB = &homun->db[i];
+	hd->homunculusDB = &homun->dbs->db[i];
 	hd->homunculus.class_ = class_;
 	status->set_viewdata(&hd->bl, class_);
 	homun->calc_skilltree(hd, 1);
@@ -703,16 +704,16 @@ int homunculus_db_search(int key,int type) {
 	int i;
 
 	for(i=0;i<MAX_HOMUNCULUS_CLASS;i++) {
-		if(homun->db[i].base_class <= 0)
+		if(homun->dbs->db[i].base_class <= 0)
 			continue;
 		switch(type) {
 			case HOMUNCULUS_CLASS:
-				if(homun->db[i].base_class == key ||
-					homun->db[i].evo_class == key)
+				if(homun->dbs->db[i].base_class == key ||
+					homun->dbs->db[i].evo_class == key)
 					return i;
 				break;
 			case HOMUNCULUS_FOOD:
-				if(homun->db[i].foodID == key)
+				if(homun->dbs->db[i].foodID == key)
 					return i;
 				break;
 			default:
@@ -743,9 +744,9 @@ bool homunculus_create(struct map_session_data *sd, struct s_homunculus *hom) {
 	hd->bl.id = npc->get_new_npc_id();
 
 	hd->master = sd;
-	hd->homunculusDB = &homun->db[i];
+	hd->homunculusDB = &homun->dbs->db[i];
 	memcpy(&hd->homunculus, hom, sizeof(struct s_homunculus));
-	hd->exp_next = homun->exptable[hd->homunculus.level - 1];
+	hd->exp_next = homun->dbs->exptable[hd->homunculus.level - 1];
 
 	status->set_viewdata(&hd->bl, hd->homunculus.class_);
 	status->change_init(&hd->bl);
@@ -879,7 +880,7 @@ bool homunculus_creation_request(struct map_session_data *sd, int class_) {
 
 	memset(&hom, 0, sizeof(struct s_homunculus));
 	//Initial data
-	safestrncpy(hom.name, homun->db[i].name, NAME_LENGTH-1);
+	safestrncpy(hom.name, homun->dbs->db[i].name, NAME_LENGTH-1);
 	hom.class_ = class_;
 	hom.level = 1;
 	hom.hunger = 32; //32%
@@ -887,7 +888,7 @@ bool homunculus_creation_request(struct map_session_data *sd, int class_) {
 	hom.char_id = sd->status.char_id;
 
 	hom.hp = 10 ;
-	base = &homun->db[i].base;
+	base = &homun->dbs->db[i].base;
 	hom.max_hp = base->HP;
 	hom.max_sp = base->SP;
 	hom.str = base->str *10;
@@ -963,7 +964,7 @@ void homunculus_stat_reset(struct homun_data *hd) {
 	hom->dex = base->dex *10;
 	hom->luk = base->luk *10;
 	hom->exp = 0;
-	hd->exp_next = homun->exptable[0];
+	hd->exp_next = homun->dbs->exptable[0];
 	memset(&hd->homunculus.hskill, 0, sizeof hd->homunculus.hskill);
 	hd->homunculus.skillpts = 0;
 }
@@ -1026,7 +1027,7 @@ bool homunculus_read_db_sub(char* str[], int columns, int current) {
 		ShowError("homunculus_read_db_sub : Invalid class %d\n", classid);
 		return false;
 	}
-	db = &homun->db[current];
+	db = &homun->dbs->db[current];
 	db->base_class = classid;
 	classid = atoi(str[1]);
 	if (classid < HM_CLASS_BASE || classid > HM_CLASS_MAX) {
@@ -1129,8 +1130,7 @@ bool homunculus_read_db_sub(char* str[], int columns, int current) {
 void homunculus_read_db(void) {
 	int i;
 	const char *filename[]={DBPATH"homunculus_db.txt","homunculus_db2.txt"};
-
-	memset(homun->db,0,sizeof(homun->db));
+	memset(homun->dbs->db, 0, sizeof(homun->dbs->db));
 	for(i = 0; i<ARRAYLENGTH(filename); i++) {
 		if( i > 0 ) {
 			char filepath[256];
@@ -1165,23 +1165,23 @@ bool homunculus_read_skill_db_sub(char* split[], int columns, int current) {
 
 	k = atoi(split[1]); //This is to avoid adding two lines for the same skill. [Skotlex]
 	// Search an empty line or a line with the same skill_id (stored in j)
-	ARR_FIND( 0, MAX_SKILL_TREE, j, !homun->skill_tree[classid][j].id || homun->skill_tree[classid][j].id == k );
+	ARR_FIND( 0, MAX_SKILL_TREE, j, !homun->dbs->skill_tree[classid][j].id || homun->dbs->skill_tree[classid][j].id == k );
 	if (j == MAX_SKILL_TREE) {
 		ShowWarning("Unable to load skill %d into homunculus %d's tree. Maximum number of skills per class has been reached.\n", k, classid);
 		return false;
 	}
 
-	homun->skill_tree[classid][j].id = k;
-	homun->skill_tree[classid][j].max = atoi(split[2]);
+	homun->dbs->skill_tree[classid][j].id = k;
+	homun->dbs->skill_tree[classid][j].max = atoi(split[2]);
 	if (minJobLevelPresent)
-		homun->skill_tree[classid][j].joblv = atoi(split[3]);
+		homun->dbs->skill_tree[classid][j].joblv = atoi(split[3]);
 
 	for( k = 0; k < MAX_PC_SKILL_REQUIRE; k++ ) {
-		homun->skill_tree[classid][j].need[k].id = atoi(split[3+k*2+minJobLevelPresent]);
-		homun->skill_tree[classid][j].need[k].lv = atoi(split[3+k*2+minJobLevelPresent+1]);
+		homun->dbs->skill_tree[classid][j].need[k].id = atoi(split[3+k*2+minJobLevelPresent]);
+		homun->dbs->skill_tree[classid][j].need[k].lv = atoi(split[3+k*2+minJobLevelPresent+1]);
 	}
 
-	homun->skill_tree[classid][j].intimacylv = atoi(split[13+minJobLevelPresent]);
+	homun->dbs->skill_tree[classid][j].intimacylv = atoi(split[13+minJobLevelPresent]);
 
 	return true;
 }
@@ -1205,9 +1205,8 @@ int8 homunculus_get_intimacy_grade(struct homun_data *hd) {
 }
 
 void homunculus_skill_db_read(void) {
-	memset(homun->skill_tree,0,sizeof(homun->skill_tree));
+	memset(homun->dbs->skill_tree, 0, sizeof(homun->dbs->skill_tree));
 	sv->readdb(map->db_path, "homun_skill_tree.txt", ',', 13, 15, -1, homun->read_skill_db_sub);
-
 }
 
 void homunculus_exp_db_read(void) {
@@ -1217,7 +1216,7 @@ void homunculus_exp_db_read(void) {
 		DBPATH"exp_homun.txt",
 		"exp_homun2.txt"};
 
-	memset(homun->exptable,0,sizeof(homun->exptable));
+	memset(homun->dbs->exptable, 0, sizeof(homun->dbs->exptable));
 	for(i = 0; i < 2; i++) {
 		FILE *fp;
 		sprintf(line, "%s/%s", map->db_path, filename[i]);
@@ -1231,13 +1230,13 @@ void homunculus_exp_db_read(void) {
 			if(line[0] == '/' && line[1] == '/')
 				continue;
 
-			if (!(homun->exptable[j++] = (unsigned int)strtoul(line, NULL, 10)))
+			if (!(homun->dbs->exptable[j++] = (unsigned int)strtoul(line, NULL, 10)))
 				break;
 		}
 		// Last permitted level have to be 0!
-		if (homun->exptable[MAX_LEVEL - 1]) {
+		if (homun->dbs->exptable[MAX_LEVEL - 1]) {
 			ShowWarning("homunculus_exp_db_read: Reached max level in exp_homun [%d]. Remaining lines were not read.\n ", MAX_LEVEL);
-			homun->exptable[MAX_LEVEL - 1] = 0;
+			homun->dbs->exptable[MAX_LEVEL - 1] = 0;
 		}
 		fclose(fp);
 		ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' levels in '"CL_WHITE"%s"CL_RESET"'.\n", j, filename[i]);
@@ -1266,9 +1265,9 @@ void do_init_homunculus(bool minimal) {
 	timer->add_func_list(homun->hunger_timer, "homunculus_hunger_timer");
 
 	//Stock view data for homuncs
-	memset(&homun->viewdb, 0, sizeof(homun->viewdb));
-	for (class_ = 0; class_ < ARRAYLENGTH(homun->viewdb); class_++)
-		homun->viewdb[class_].class_ = HM_CLASS_BASE+class_;
+	memset(homun->dbs->viewdb, 0, sizeof(homun->dbs->viewdb));
+	for (class_ = 0; class_ < MAX_HOMUNCULUS_CLASS; class_++)
+		homun->dbs->viewdb[class_].class_ = HM_CLASS_BASE+class_;
 }
 
 void do_final_homunculus(void) {
@@ -1277,7 +1276,8 @@ void do_final_homunculus(void) {
 
 void homunculus_defaults(void) {
 	homun = &homunculus_s;
-	
+	homun->dbs = &homundbs;
+
 	homun->init = do_init_homunculus;
 	homun->final = do_final_homunculus;
 	homun->reload = homunculus_reload;
diff --git a/src/map/homunculus.h b/src/map/homunculus.h
index 32e48b1e9..95b613fff 100644
--- a/src/map/homunculus.h
+++ b/src/map/homunculus.h
@@ -99,12 +99,16 @@ enum homun_type {
 	HT_INVALID = -1, // Invalid Homunculus
 };
 
-/* homunculus.c interface */
-struct homunculus_interface {
+struct homun_dbs {
 	unsigned int exptable[MAX_LEVEL];
 	struct view_data viewdb[MAX_HOMUNCULUS_CLASS];
 	struct s_homunculus_db db[MAX_HOMUNCULUS_CLASS];
 	struct homun_skill_tree_entry skill_tree[MAX_HOMUNCULUS_CLASS][MAX_SKILL_TREE];
+};
+
+/* homunculus.c interface */
+struct homunculus_interface {
+	struct homun_dbs *dbs;
 	/* */
 	void (*init) (bool minimal);
 	void (*final) (void);
diff --git a/src/map/mercenary.c b/src/map/mercenary.c
index ffcb26629..c60234d5d 100644
--- a/src/map/mercenary.c
+++ b/src/map/mercenary.c
@@ -42,6 +42,7 @@
 #include <string.h>
 
 struct mercenary_interface mercenary_s;
+struct s_mercenary_db mercdb[MAX_MERCENARY_CLASS];
 
 int merc_search_index(int class_)
 {
@@ -449,7 +450,7 @@ bool read_mercenarydb_sub(char* str[], int columns, int current) {
 }
 
 int read_mercenarydb(void) {
-	memset(mercenary->db,0,sizeof(mercenary->db));
+	memset(mercenary->db, 0, sizeof(struct s_mercenary_db) * MAX_MERCENARY_CLASS);
 	sv->readdb(map->db_path, "mercenary_db.txt", ',', 26, 26, MAX_MERCENARY_CLASS, mercenary->read_db_sub);
 
 	return 0;
@@ -511,7 +512,8 @@ void mercenary_defaults(void) {
 	mercenary = &mercenary_s;
 
 	/* vars */
-	memset(mercenary->db,0,sizeof(mercenary->db));
+	mercenary->db = mercdb;
+	memset(mercenary->db, 0, sizeof(struct s_mercenary_db) * MAX_MERCENARY_CLASS);
 
 	/* funcs */
 	
diff --git a/src/map/mercenary.h b/src/map/mercenary.h
index 29a2c6ba0..c96b5a5ef 100644
--- a/src/map/mercenary.h
+++ b/src/map/mercenary.h
@@ -58,7 +58,7 @@ struct mercenary_interface {
 
 	/* vars */
 
-	struct s_mercenary_db db[MAX_MERCENARY_CLASS];
+	struct s_mercenary_db *db;
 
 	/* funcs */
 
diff --git a/src/map/mob.c b/src/map/mob.c
index 493e30049..8112c208c 100644
--- a/src/map/mob.c
+++ b/src/map/mob.c
@@ -3402,7 +3402,7 @@ int mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, cons
 		int idx = pc->skill_tree[pc->class2idx(sd->status.class_)][j].idx;
 		int skill_id = pc->skill_tree[pc->class2idx(sd->status.class_)][j].id;
 		if (!skill_id || sd->status.skill[idx].lv < 1 ||
-			(skill->db[idx].inf2&(INF2_WEDDING_SKILL|INF2_GUILD_SKILL))
+			(skill->dbs->db[idx].inf2&(INF2_WEDDING_SKILL|INF2_GUILD_SKILL))
 		)
 			continue;
 		for(h = 0; h < map->list[sd->bl.m].zone->disabled_skills_count; h++) {
@@ -3435,7 +3435,7 @@ int mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, cons
 		ms[i].casttime = skill->cast_fix(&sd->bl,skill_id, ms[i].skill_lv);
 		ms[i].delay = 5000+skill->delay_fix(&sd->bl,skill_id, ms[i].skill_lv);
 
-		inf = skill->db[idx].inf;
+		inf = skill->dbs->db[idx].inf;
 		if (inf&INF_ATTACK_SKILL) {
 			ms[i].target = MST_TARGET;
 			ms[i].cond1 = MSC_ALWAYS;
@@ -4399,13 +4399,13 @@ bool mob_parse_row_mobskilldb(char** str, int columns, int current)
 	if ( skill->get_casttype2(sidx) == CAST_GROUND) {//Ground skill.
 		if (ms->target > MST_AROUND) {
 			ShowWarning("mob_parse_row_mobskilldb: Wrong mob skill target for ground skill %d (%s) for %s.\n",
-				ms->skill_id, skill->db[sidx].name,
+				ms->skill_id, skill->dbs->db[sidx].name,
 				mob_id < 0?"all mobs":mob->db_data[mob_id]->sprite);
 			ms->target = MST_TARGET;
 		}
 	} else if (ms->target > MST_MASTER) {
 		ShowWarning("mob_parse_row_mobskilldb: Wrong mob skill target 'around' for non-ground skill %d (%s) for %s.\n",
-			ms->skill_id, skill->db[sidx].name,
+			ms->skill_id, skill->dbs->db[sidx].name,
 			mob_id < 0?"all mobs":mob->db_data[mob_id]->sprite);
 		ms->target = MST_TARGET;
 	}
diff --git a/src/map/pc.c b/src/map/pc.c
index b9ef479dc..8b52f615d 100644
--- a/src/map/pc.c
+++ b/src/map/pc.c
@@ -1389,7 +1389,7 @@ int pc_calc_skillpoint(struct map_session_data* sd) {
 	for (i = 1; i < MAX_SKILL; i++) {
 		int skill_lv = pc->checkskill2(sd,i);
 		if (skill_lv > 0) {
-			inf2 = skill->db[i].inf2;
+			inf2 = skill->dbs->db[i].inf2;
 			if((!(inf2&INF2_QUEST_SKILL) || battle_config.quest_skill_learn) &&
 				!(inf2&(INF2_WEDDING_SKILL|INF2_SPIRIT_SKILL|INF2_GUILD_SKILL)) //Do not count wedding/link skills. [Skotlex]
 				) {
@@ -1428,7 +1428,7 @@ int pc_calc_skilltree(struct map_session_data *sd)
 			sd->status.skill[i].id = 0; //First clear skills.
 		/* permanent skills that must be re-checked */
 		if( sd->status.skill[i].flag == SKILL_FLAG_PERMANENT ) {
-			switch( skill->db[i].nameid ) {
+			switch( skill->dbs->db[i].nameid ) {
 				case NV_TRICKDEAD:
 					if( (sd->class_&(MAPID_BASEMASK|JOBL_2)) != MAPID_NOVICE ) {
 							sd->status.skill[i].id = 0;
@@ -1447,21 +1447,21 @@ int pc_calc_skilltree(struct map_session_data *sd)
 			sd->status.skill[i].flag = SKILL_FLAG_PERMANENT;
 		}
 
-		if( sd->sc.count && sd->sc.data[SC_SOULLINK] && sd->sc.data[SC_SOULLINK]->val2 == SL_BARDDANCER && skill->db[i].nameid >= DC_HUMMING && skill->db[i].nameid <= DC_SERVICEFORYOU )
+		if( sd->sc.count && sd->sc.data[SC_SOULLINK] && sd->sc.data[SC_SOULLINK]->val2 == SL_BARDDANCER && skill->dbs->db[i].nameid >= DC_HUMMING && skill->dbs->db[i].nameid <= DC_SERVICEFORYOU )
 		{ //Enable Bard/Dancer spirit linked skills.
 			if( sd->status.sex )
 			{ //Link dancer skills to bard.
 				// i can be < 8?
 				if( sd->status.skill[i-8].lv < 10 )
 					continue;
-				sd->status.skill[i].id = skill->db[i].nameid;
+				sd->status.skill[i].id = skill->dbs->db[i].nameid;
 				sd->status.skill[i].lv = sd->status.skill[i-8].lv; // Set the level to the same as the linking skill
 				sd->status.skill[i].flag = SKILL_FLAG_TEMPORARY; // Tag it as a non-savable, non-uppable, bonus skill
 			} else { //Link bard skills to dancer.
 				if( sd->status.skill[i].lv < 10 )
 					continue;
 				// i can be < 8?
-				sd->status.skill[i-8].id = skill->db[i-8].nameid;
+				sd->status.skill[i-8].id = skill->dbs->db[i-8].nameid;
 				sd->status.skill[i-8].lv = sd->status.skill[i].lv; // Set the level to the same as the linking skill
 				sd->status.skill[i-8].flag = SKILL_FLAG_TEMPORARY; // Tag it as a non-savable, non-uppable, bonus skill
 			}
@@ -1470,7 +1470,7 @@ int pc_calc_skilltree(struct map_session_data *sd)
 
 	if( pc_has_permission(sd, PC_PERM_ALL_SKILL) ) {
 		for( i = 0; i < MAX_SKILL; i++ ) {
-			switch(skill->db[i].nameid) {
+			switch(skill->dbs->db[i].nameid) {
 				/**
 				 * Dummy skills must be added here otherwise they'll be displayed in the,
 				 * skill tree and since they have no icons they'll give resource errors
@@ -1493,10 +1493,10 @@ int pc_calc_skilltree(struct map_session_data *sd)
 				default:
 					break;
 			}
-			if( skill->db[i].inf2&(INF2_NPC_SKILL|INF2_GUILD_SKILL) )
+			if( skill->dbs->db[i].inf2&(INF2_NPC_SKILL|INF2_GUILD_SKILL) )
 				continue; //Only skills you can't have are npc/guild ones
-			if( skill->db[i].max > 0 )
-				sd->status.skill[i].id = skill->db[i].nameid;
+			if( skill->dbs->db[i].max > 0 )
+				sd->status.skill[i].id = skill->dbs->db[i].nameid;
 		}
 		return 0;
 	}
@@ -1539,7 +1539,7 @@ int pc_calc_skilltree(struct map_session_data *sd)
 			}
 			if( f ) {
 				int inf2;
-				inf2 = skill->db[idx].inf2;
+				inf2 = skill->dbs->db[idx].inf2;
 				
 				if(!sd->status.skill[idx].lv && (
 					(inf2&INF2_QUEST_SKILL && !battle_config.quest_skill_learn) ||
@@ -1570,7 +1570,7 @@ int pc_calc_skilltree(struct map_session_data *sd)
 
 		for( i = 0; i < MAX_SKILL_TREE && (id = pc->skill_tree[c][i].id) > 0; i++ ) {
 			int idx = pc->skill_tree[c][i].idx;
-			if( (skill->db[idx].inf2&(INF2_QUEST_SKILL|INF2_WEDDING_SKILL)) )
+			if( (skill->dbs->db[idx].inf2&(INF2_QUEST_SKILL|INF2_WEDDING_SKILL)) )
 				continue; //Do not include Quest/Wedding skills.
 
 			if( sd->status.skill[idx].id == 0 ) {
@@ -1640,7 +1640,7 @@ void pc_check_skilltree(struct map_session_data *sd, int skill_id)
 					continue;
 			}
 
-			j = skill->db[idx].inf2;
+			j = skill->dbs->db[idx].inf2;
 			if( !sd->status.skill[idx].lv && (
 				(j&INF2_QUEST_SKILL && !battle_config.quest_skill_learn) ||
 				j&INF2_WEDDING_SKILL ||
@@ -4017,7 +4017,7 @@ int pc_skill(TBL_PC* sd, int id, int level, int flag)
 				clif->deleteskill(sd,id);
 			} else
 				clif->addskill(sd,id);
-			if( !skill->db[index].inf ) //Only recalculate for passive skills.
+			if( !skill->dbs->db[index].inf ) //Only recalculate for passive skills.
 				status_calc_pc(sd, SCO_NONE);
 		break;
 		case SKILL_GRANT_TEMPORARY: //Item bonus skill.
@@ -4051,7 +4051,7 @@ int pc_skill(TBL_PC* sd, int id, int level, int flag)
 				clif->deleteskill(sd,id);
 			} else
 				clif->addskill(sd,id);
-			if( !skill->db[index].inf ) //Only recalculate for passive skills.
+			if( !skill->dbs->db[index].inf ) //Only recalculate for passive skills.
 				status_calc_pc(sd, SCO_NONE);
 			break;
 		default: //Unknown flag?
@@ -5706,14 +5706,14 @@ int pc_checkskill2(struct map_session_data *sd,uint16 index) {
 		ShowError("pc_checkskill: Invalid skill index %d (char_id=%d).\n", index, sd->status.char_id);
 		return 0;
 	}
-	if( skill->db[index].nameid >= GD_SKILLBASE && skill->db[index].nameid < GD_MAX ) {
+	if( skill->dbs->db[index].nameid >= GD_SKILLBASE && skill->dbs->db[index].nameid < GD_MAX ) {
 		struct guild *g;
 		
 		if( sd->status.guild_id>0 && (g=sd->guild)!=NULL)
-			return guild->checkskill(g,skill->db[index].nameid);
+			return guild->checkskill(g,skill->dbs->db[index].nameid);
 		return 0;
 	}
-	if(sd->status.skill[index].id == skill->db[index].nameid)
+	if(sd->status.skill[index].id == skill->dbs->db[index].nameid)
 		return (sd->status.skill[index].lv);
 	
 	return 0;
@@ -7015,7 +7015,7 @@ int pc_skillup(struct map_session_data *sd,uint16 skill_id) {
 	{
 		sd->status.skill[index].lv++;
 		sd->status.skill_point--;
-		if( !skill->db[index].inf )
+		if( !skill->dbs->db[index].inf )
 			status_calc_pc(sd,SCO_NONE); // Only recalculate for passive skills.
 		else if( sd->status.skill_point == 0 && (sd->class_&MAPID_UPPERMASK) == MAPID_TAEKWON && sd->status.base_level >= 90 && pc->famerank(sd->status.char_id, MAPID_TAEKWON) )
 			pc->calc_skilltree(sd); // Required to grant all TK Ranger skills.
@@ -7060,22 +7060,22 @@ int pc_allskillup(struct map_session_data *sd)
 	if (pc_has_permission(sd, PC_PERM_ALL_SKILL)) { //Get ALL skills except npc/guild ones. [Skotlex]
 		//and except SG_DEVIL [Komurka] and MO_TRIPLEATTACK and RG_SNATCHER [ultramage]
 		for(i=0;i<MAX_SKILL;i++){
-			switch( skill->db[i].nameid ) {
+			switch( skill->dbs->db[i].nameid ) {
 				case SG_DEVIL:
 				case MO_TRIPLEATTACK:
 				case RG_SNATCHER:
 					continue;
 				default:
-					if( !(skill->db[i].inf2&(INF2_NPC_SKILL|INF2_GUILD_SKILL)) )
-						if ( ( sd->status.skill[i].lv = skill->db[i].max ) )//Nonexistant skills should return a max of 0 anyway.
-							sd->status.skill[i].id = skill->db[i].nameid;
+					if( !(skill->dbs->db[i].inf2&(INF2_NPC_SKILL|INF2_GUILD_SKILL)) )
+						if ( ( sd->status.skill[i].lv = skill->dbs->db[i].max ) )//Nonexistant skills should return a max of 0 anyway.
+							sd->status.skill[i].id = skill->dbs->db[i].nameid;
 			}
 		}
 	} else {
 		int id;
 		for (i = 0; i < MAX_SKILL_TREE && (id=pc->skill_tree[pc->class2idx(sd->status.class_)][i].id) > 0; i++) {
 			int idx = pc->skill_tree[pc->class2idx(sd->status.class_)][i].idx;
-			int inf2 = skill->db[idx].inf2;
+			int inf2 = skill->dbs->db[idx].inf2;
 			if (
 				(inf2&INF2_QUEST_SKILL && !battle_config.quest_skill_learn) ||
 				(inf2&(INF2_WEDDING_SKILL|INF2_SPIRIT_SKILL)) ||
@@ -7298,17 +7298,17 @@ int pc_resetskill(struct map_session_data* sd, int flag)
 
 	for( i = 1; i < MAX_SKILL; i++ ) {
 		// FIXME: We're looping on i = [1..MAX_SKILL-1] (which makes sense as index for sd->status.skill[]) but then we're using the
-		// same i to access skill->db[], and especially to check skill_ischangesex(). This is wrong.
+		// same i to access skill->dbs->db[], and especially to check skill_ischangesex(). This is wrong.
 		uint16 skill_id = 0;
 		int lv = sd->status.skill[i].lv;
 		if (lv < 1) continue;
 
-		inf2 = skill->db[i].inf2;
+		inf2 = skill->dbs->db[i].inf2;
 
 		if( inf2&(INF2_WEDDING_SKILL|INF2_SPIRIT_SKILL) ) //Avoid reseting wedding/linker skills.
 			continue;
 		
-		skill_id = skill->db[i].nameid;
+		skill_id = skill->dbs->db[i].nameid;
 		
 		// Don't reset trick dead if not a novice/baby
 		if( skill_id == NV_TRICKDEAD && (sd->class_&(MAPID_BASEMASK|JOBL_2)) != MAPID_NOVICE ) {
diff --git a/src/map/quest.c b/src/map/quest.c
index da5f73caa..463a3395a 100644
--- a/src/map/quest.c
+++ b/src/map/quest.c
@@ -37,6 +37,7 @@
 #include <time.h>
 
 struct quest_interface quest_s;
+struct quest_db *db_data[MAX_QUEST_DB]; ///< Quest database
 
 /**
  * Searches a quest by ID.
@@ -618,6 +619,7 @@ void do_reload_quest(void) {
  */
 void quest_defaults(void) {
 	quest = &quest_s;
+	quest->db_data = db_data;
 
 	memset(&quest->db, 0, sizeof(quest->db));
 	memset(&quest->dummy, 0, sizeof(quest->dummy));
diff --git a/src/map/quest.h b/src/map/quest.h
index 014f82527..9b5199625 100644
--- a/src/map/quest.h
+++ b/src/map/quest.h
@@ -40,7 +40,7 @@ enum quest_check_type {
 };
 
 struct quest_interface {
-	struct quest_db *db_data[MAX_QUEST_DB]; ///< Quest database
+	struct quest_db **db_data; ///< Quest database
 	struct quest_db dummy;                  ///< Dummy entry for invalid quest lookups
 	/* */
 	void (*init) (bool minimal);
diff --git a/src/map/skill.c b/src/map/skill.c
index d8f967c6c..f2154aa22 100644
--- a/src/map/skill.c
+++ b/src/map/skill.c
@@ -62,6 +62,7 @@
 #endif
 
 struct skill_interface skill_s;
+struct s_skill_dbs skilldbs;
 
 //Since only mob-casted splash skills can hit ice-walls
 static inline int splash_target(struct block_list* bl) {
@@ -121,11 +122,11 @@ int skill_get_index( uint16 skill_id ) {
 }
 
 const char* skill_get_name( uint16 skill_id ) {
-	return skill->db[skill->get_index(skill_id)].name;
+	return skill->dbs->db[skill->get_index(skill_id)].name;
 }
 
 const char* skill_get_desc( uint16 skill_id ) {
-	return skill->db[skill->get_index(skill_id)].desc;
+	return skill->dbs->db[skill->get_index(skill_id)].desc;
 }
 
 // out of bounds error checking [celest]
@@ -138,58 +139,58 @@ void skill_chk(uint16* skill_id) {
 	skill->chk(&(id)); \
 	if(!(id)) return 0; \
 	if( (lv) > MAX_SKILL_LEVEL && (var) > 1 ) { \
-		int lv2__ = (lv); (lv) = skill->db[(id)].max; \
+		int lv2__ = (lv); (lv) = skill->dbs->db[(id)].max; \
 		return (var) + ((lv2__-(lv))/2);\
 	} \
 	return (var);\
 } while(0)
 #define skill_glv(lv) min((lv),MAX_SKILL_LEVEL-1)
 // Skill DB
-int skill_get_hit( uint16 skill_id )               { skill_get (skill->db[skill_id].hit, skill_id); }
-int skill_get_inf( uint16 skill_id )               { skill_get (skill->db[skill_id].inf, skill_id); }
-int skill_get_ele( uint16 skill_id , uint16 skill_lv )      { Assert_ret(skill_lv > 0); skill_get (skill->db[skill_id].element[skill_glv(skill_lv-1)], skill_id); }
-int skill_get_nk( uint16 skill_id )                { skill_get (skill->db[skill_id].nk, skill_id); }
-int skill_get_max( uint16 skill_id )               { skill_get (skill->db[skill_id].max, skill_id); }
-int skill_get_range( uint16 skill_id , uint16 skill_lv )    { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].range[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_splash( uint16 skill_id , uint16 skill_lv )   { Assert_ret(skill_lv > 0); skill_get2 ( (skill->db[skill_id].splash[skill_glv(skill_lv-1)]>=0?skill->db[skill_id].splash[skill_glv(skill_lv-1)]:AREA_SIZE), skill_id, skill_lv);  }
-int skill_get_hp( uint16 skill_id ,uint16 skill_lv )        { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].hp[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_sp( uint16 skill_id ,uint16 skill_lv )        { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].sp[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_hp_rate(uint16 skill_id, uint16 skill_lv )    { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].hp_rate[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_sp_rate(uint16 skill_id, uint16 skill_lv )    { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].sp_rate[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_state(uint16 skill_id)               { skill_get (skill->db[skill_id].state, skill_id); }
-int skill_get_spiritball(uint16 skill_id, uint16 skill_lv)  { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].spiritball[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_itemid(uint16 skill_id, int idx)     { skill_get (skill->db[skill_id].itemid[idx], skill_id); }
-int skill_get_itemqty(uint16 skill_id, int idx)    { skill_get (skill->db[skill_id].amount[idx], skill_id); }
-int skill_get_zeny( uint16 skill_id ,uint16 skill_lv )      { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].zeny[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_num( uint16 skill_id ,uint16 skill_lv )       { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].num[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_cast( uint16 skill_id ,uint16 skill_lv )      { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].cast[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_delay( uint16 skill_id ,uint16 skill_lv )     { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].delay[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_walkdelay( uint16 skill_id ,uint16 skill_lv ) { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].walkdelay[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_time( uint16 skill_id ,uint16 skill_lv )      { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].upkeep_time[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_time2( uint16 skill_id ,uint16 skill_lv )     { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].upkeep_time2[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_castdef( uint16 skill_id )           { skill_get (skill->db[skill_id].cast_def_rate, skill_id); }
-int skill_get_weapontype( uint16 skill_id )        { skill_get (skill->db[skill_id].weapon, skill_id); }
-int skill_get_ammotype( uint16 skill_id )          { skill_get (skill->db[skill_id].ammo, skill_id); }
-int skill_get_ammo_qty( uint16 skill_id, uint16 skill_lv )  { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].ammo_qty[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_inf2( uint16 skill_id )              { skill_get (skill->db[skill_id].inf2, skill_id); }
-int skill_get_castcancel( uint16 skill_id )        { skill_get (skill->db[skill_id].castcancel, skill_id); }
-int skill_get_maxcount( uint16 skill_id ,uint16 skill_lv )  { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].maxcount[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_blewcount( uint16 skill_id ,uint16 skill_lv ) { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].blewcount[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_mhp( uint16 skill_id ,uint16 skill_lv )       { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].mhp[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_castnodex( uint16 skill_id ,uint16 skill_lv ) { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].castnodex[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_delaynodex( uint16 skill_id ,uint16 skill_lv ){ Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].delaynodex[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_type( uint16 skill_id )              { skill_get (skill->db[skill_id].skill_type, skill_id); }
-int skill_get_unit_id ( uint16 skill_id, int flag ){ skill_get (skill->db[skill_id].unit_id[flag], skill_id); }
-int skill_get_unit_interval( uint16 skill_id )     { skill_get (skill->db[skill_id].unit_interval, skill_id); }
-int skill_get_unit_range( uint16 skill_id, uint16 skill_lv ) { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].unit_range[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_unit_target( uint16 skill_id )       { skill_get (skill->db[skill_id].unit_target&BCT_ALL, skill_id); }
-int skill_get_unit_bl_target( uint16 skill_id )    { skill_get (skill->db[skill_id].unit_target&BL_ALL, skill_id); }
-int skill_get_unit_flag( uint16 skill_id )         { skill_get (skill->db[skill_id].unit_flag, skill_id); }
-int skill_get_unit_layout_type( uint16 skill_id ,uint16 skill_lv ){ Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].unit_layout_type[skill_glv(skill_lv-1)], skill_id, skill_lv); }
-int skill_get_cooldown( uint16 skill_id, uint16 skill_lv )     { Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].cooldown[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_hit( uint16 skill_id )               { skill_get (skill->dbs->db[skill_id].hit, skill_id); }
+int skill_get_inf( uint16 skill_id )               { skill_get (skill->dbs->db[skill_id].inf, skill_id); }
+int skill_get_ele( uint16 skill_id , uint16 skill_lv )      { Assert_ret(skill_lv > 0); skill_get (skill->dbs->db[skill_id].element[skill_glv(skill_lv-1)], skill_id); }
+int skill_get_nk( uint16 skill_id )                { skill_get (skill->dbs->db[skill_id].nk, skill_id); }
+int skill_get_max( uint16 skill_id )               { skill_get (skill->dbs->db[skill_id].max, skill_id); }
+int skill_get_range( uint16 skill_id , uint16 skill_lv )    { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].range[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_splash( uint16 skill_id , uint16 skill_lv )   { Assert_ret(skill_lv > 0); skill_get2 ( (skill->dbs->db[skill_id].splash[skill_glv(skill_lv-1)]>=0?skill->dbs->db[skill_id].splash[skill_glv(skill_lv-1)]:AREA_SIZE), skill_id, skill_lv);  }
+int skill_get_hp( uint16 skill_id ,uint16 skill_lv )        { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].hp[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_sp( uint16 skill_id ,uint16 skill_lv )        { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].sp[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_hp_rate(uint16 skill_id, uint16 skill_lv )    { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].hp_rate[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_sp_rate(uint16 skill_id, uint16 skill_lv )    { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].sp_rate[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_state(uint16 skill_id)               { skill_get (skill->dbs->db[skill_id].state, skill_id); }
+int skill_get_spiritball(uint16 skill_id, uint16 skill_lv)  { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].spiritball[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_itemid(uint16 skill_id, int idx)     { skill_get (skill->dbs->db[skill_id].itemid[idx], skill_id); }
+int skill_get_itemqty(uint16 skill_id, int idx)    { skill_get (skill->dbs->db[skill_id].amount[idx], skill_id); }
+int skill_get_zeny( uint16 skill_id ,uint16 skill_lv )      { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].zeny[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_num( uint16 skill_id ,uint16 skill_lv )       { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].num[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_cast( uint16 skill_id ,uint16 skill_lv )      { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].cast[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_delay( uint16 skill_id ,uint16 skill_lv )     { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].delay[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_walkdelay( uint16 skill_id ,uint16 skill_lv ) { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].walkdelay[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_time( uint16 skill_id ,uint16 skill_lv )      { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].upkeep_time[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_time2( uint16 skill_id ,uint16 skill_lv )     { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].upkeep_time2[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_castdef( uint16 skill_id )           { skill_get (skill->dbs->db[skill_id].cast_def_rate, skill_id); }
+int skill_get_weapontype( uint16 skill_id )        { skill_get (skill->dbs->db[skill_id].weapon, skill_id); }
+int skill_get_ammotype( uint16 skill_id )          { skill_get (skill->dbs->db[skill_id].ammo, skill_id); }
+int skill_get_ammo_qty( uint16 skill_id, uint16 skill_lv )  { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].ammo_qty[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_inf2( uint16 skill_id )              { skill_get (skill->dbs->db[skill_id].inf2, skill_id); }
+int skill_get_castcancel( uint16 skill_id )        { skill_get (skill->dbs->db[skill_id].castcancel, skill_id); }
+int skill_get_maxcount( uint16 skill_id ,uint16 skill_lv )  { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].maxcount[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_blewcount( uint16 skill_id ,uint16 skill_lv ) { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].blewcount[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_mhp( uint16 skill_id ,uint16 skill_lv )       { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].mhp[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_castnodex( uint16 skill_id ,uint16 skill_lv ) { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].castnodex[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_delaynodex( uint16 skill_id ,uint16 skill_lv ){ Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].delaynodex[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_type( uint16 skill_id )              { skill_get (skill->dbs->db[skill_id].skill_type, skill_id); }
+int skill_get_unit_id ( uint16 skill_id, int flag ){ skill_get (skill->dbs->db[skill_id].unit_id[flag], skill_id); }
+int skill_get_unit_interval( uint16 skill_id )     { skill_get (skill->dbs->db[skill_id].unit_interval, skill_id); }
+int skill_get_unit_range( uint16 skill_id, uint16 skill_lv ) { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].unit_range[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_unit_target( uint16 skill_id )       { skill_get (skill->dbs->db[skill_id].unit_target&BCT_ALL, skill_id); }
+int skill_get_unit_bl_target( uint16 skill_id )    { skill_get (skill->dbs->db[skill_id].unit_target&BL_ALL, skill_id); }
+int skill_get_unit_flag( uint16 skill_id )         { skill_get (skill->dbs->db[skill_id].unit_flag, skill_id); }
+int skill_get_unit_layout_type( uint16 skill_id ,uint16 skill_lv ){ Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].unit_layout_type[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int skill_get_cooldown( uint16 skill_id, uint16 skill_lv )     { Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].cooldown[skill_glv(skill_lv-1)], skill_id, skill_lv); }
 int skill_get_fixed_cast( uint16 skill_id ,uint16 skill_lv ) {
 #ifdef RENEWAL_CAST
-	Assert_ret(skill_lv > 0); skill_get2 (skill->db[skill_id].fixed_cast[skill_glv(skill_lv-1)], skill_id, skill_lv);
+	Assert_ret(skill_lv > 0); skill_get2 (skill->dbs->db[skill_id].fixed_cast[skill_glv(skill_lv-1)], skill_id, skill_lv);
 #else
 	return 0;
 #endif
@@ -223,17 +224,17 @@ int skill_get_casttype (uint16 skill_id) {
 }
 
 int skill_get_casttype2 (uint16 index) {
-	int inf = skill->db[index].inf;
+	int inf = skill->dbs->db[index].inf;
 	if (inf&(INF_GROUND_SKILL))
 		return CAST_GROUND;
 	if (inf&INF_SUPPORT_SKILL)
 		return CAST_NODAMAGE;
 	if (inf&INF_SELF_SKILL) {
-		if(skill->db[index].inf2&INF2_NO_TARGET_SELF)
+		if(skill->dbs->db[index].inf2&INF2_NO_TARGET_SELF)
 			return CAST_DAMAGE; //Combo skill.
 		return CAST_NODAMAGE;
 	}
-	if (skill->db[index].nk&NK_NO_DAMAGE)
+	if (skill->dbs->db[index].nk&NK_NO_DAMAGE)
 		return CAST_NODAMAGE;
 	return CAST_DAMAGE;
 }
@@ -438,7 +439,7 @@ int can_copy (struct map_session_data *sd, uint16 skill_id, struct block_list* b
 	if( !(sd->sc.data[SC__REPRODUCE]) && ((skill_id >= RK_ENCHANTBLADE && skill_id <= LG_OVERBRAND_PLUSATK) || (skill_id >= RL_GLITTERING_GREED && skill_id <= OB_AKAITSUKI) || (skill_id >= GC_DARKCROW && skill_id <= NC_MAGMA_ERUPTION_DOTDAMAGE)))
 		return 0;
 	// Reproduce will only copy skills according on the list. [Jobbie]
-	else if( sd->sc.data[SC__REPRODUCE] && !skill->reproduce_db[skill->get_index(skill_id)] )
+	else if( sd->sc.data[SC__REPRODUCE] && !skill->dbs->reproduce_db[skill->get_index(skill_id)] )
 		return 0;
 
 	return 1;
@@ -619,19 +620,19 @@ struct s_skill_unit_layout* skill_get_unit_layout (uint16 skill_id, uint16 skill
 	}
 
 	if (pos != -1) // simple single-definition layout
-		return &skill->unit_layout[pos];
+		return &skill->dbs->unit_layout[pos];
 
 	dir = (src->x == x && src->y == y) ? 6 : map->calc_dir(src,x,y); // 6 - default aegis direction
 
 	if (skill_id == MG_FIREWALL)
-		return &skill->unit_layout [skill->firewall_unit_pos + dir];
+		return &skill->dbs->unit_layout [skill->firewall_unit_pos + dir];
 	else if (skill_id == WZ_ICEWALL)
-		return &skill->unit_layout [skill->icewall_unit_pos + dir];
+		return &skill->dbs->unit_layout [skill->icewall_unit_pos + dir];
 	else if( skill_id == WL_EARTHSTRAIN ) //Warlock
-		return &skill->unit_layout [skill->earthstrain_unit_pos + dir];
+		return &skill->dbs->unit_layout [skill->earthstrain_unit_pos + dir];
 
 	ShowError("skill_get_unit_layout: unknown unit layout for skill %d (level %d)\n", skill_id, skill_lv);
-	return &skill->unit_layout[0]; // default 1x1 layout
+	return &skill->dbs->unit_layout[0]; // default 1x1 layout
 }
 
 /*==========================================
@@ -3086,15 +3087,15 @@ int skill_check_condition_mercenary(struct block_list *bl, int skill_id, int lv,
 	// Requirements
 	for( i = 0; i < ARRAYLENGTH(itemid); i++ )
 	{
-		itemid[i] = skill->db[idx].itemid[i];
-		amount[i] = skill->db[idx].amount[i];
-	}
-	hp = skill->db[idx].hp[lv-1];
-	sp = skill->db[idx].sp[lv-1];
-	hp_rate = skill->db[idx].hp_rate[lv-1];
-	sp_rate = skill->db[idx].sp_rate[lv-1];
-	state = skill->db[idx].state;
-	if( (mhp = skill->db[idx].mhp[lv-1]) > 0 )
+		itemid[i] = skill->dbs->db[idx].itemid[i];
+		amount[i] = skill->dbs->db[idx].amount[i];
+	}
+	hp = skill->dbs->db[idx].hp[lv-1];
+	sp = skill->dbs->db[idx].sp[lv-1];
+	hp_rate = skill->dbs->db[idx].hp_rate[lv-1];
+	sp_rate = skill->dbs->db[idx].sp_rate[lv-1];
+	state = skill->dbs->db[idx].state;
+	if( (mhp = skill->dbs->db[idx].mhp[lv-1]) > 0 )
 		hp += (st->max_hp * mhp) / 100;
 	if( hp_rate > 0 )
 		hp += (st->hp * hp_rate) / 100;
@@ -5538,10 +5539,10 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
 				int abra_skill_id = 0, abra_skill_lv, abra_idx;
 				do {
 					abra_idx = rnd() % MAX_SKILL_ABRA_DB;
-					abra_skill_id = skill->abra_db[abra_idx].skill_id;
+					abra_skill_id = skill->dbs->abra_db[abra_idx].skill_id;
 				} while (abra_skill_id == 0 ||
-					skill->abra_db[abra_idx].req_lv > skill_lv || //Required lv for it to appear
-					rnd()%10000 >= skill->abra_db[abra_idx].per
+					skill->dbs->abra_db[abra_idx].req_lv > skill_lv || //Required lv for it to appear
+					rnd()%10000 >= skill->dbs->abra_db[abra_idx].per
 				);
 				abra_skill_lv = min(skill_lv, skill->get_max(abra_skill_id));
 				clif->skill_nodamage (src, bl, skill_id, skill_lv, 1);
@@ -6460,7 +6461,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
 				// custom hack to make the mob display the skill, because these skills don't show the skill use text themselves
 				//NOTE: mobs don't have the sprite animation that is used when performing this skill (will cause glitches)
 				char temp[70];
-				snprintf(temp, sizeof(temp), "%s : %s !!",md->name,skill->db[skill_id].desc);
+				snprintf(temp, sizeof(temp), "%s : %s !!",md->name,skill->dbs->db[skill_id].desc);
 				clif->disp_overhead(&md->bl,temp);
 			}
 			break;
@@ -6658,7 +6659,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
 					return 1;
 				}
 				if( sd->skillitem != skill_id )
-					status_zap(src,0,skill->db[skill->get_index(skill_id)].sp[skill_lv]); // consume sp only if succeeded
+					status_zap(src,0,skill->dbs->db[skill->get_index(skill_id)].sp[skill_lv]); // consume sp only if succeeded
 			}
 			break;
 
@@ -6836,13 +6837,13 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
 				if( sd ) {
 					int x,bonus=100, potion = min(500+skill_lv,505);
 					x = skill_lv%11 - 1;
-					i = pc->search_inventory(sd,skill->db[skill_id].itemid[x]);
-					if (i == INDEX_NOT_FOUND || skill->db[skill_id].itemid[x] <= 0) {
+					i = pc->search_inventory(sd,skill->dbs->db[skill_id].itemid[x]);
+					if (i == INDEX_NOT_FOUND || skill->dbs->db[skill_id].itemid[x] <= 0) {
 						clif->skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
 						map->freeblock_unlock();
 						return 1;
 					}
-					if(sd->inventory_data[i] == NULL || sd->status.inventory[i].amount < skill->db[skill_id].amount[x]) {
+					if(sd->inventory_data[i] == NULL || sd->status.inventory[i].amount < skill->dbs->db[skill_id].amount[x]) {
 						clif->skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
 						map->freeblock_unlock();
 						return 1;
@@ -7384,14 +7385,14 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
 
 		case WE_MALE:
 		{
-			int hp_rate = (!skill_lv)? 0:skill->db[skill_id].hp_rate[skill_lv-1];
+			int hp_rate = (!skill_lv)? 0:skill->dbs->db[skill_id].hp_rate[skill_lv-1];
 			int gain_hp = tstatus->max_hp*abs(hp_rate)/100; // The earned is the same % of the target HP than it cost the caster. [Skotlex]
 			clif->skill_nodamage(src,bl,skill_id,status->heal(bl, gain_hp, 0, 0),1);
 		}
 			break;
 		case WE_FEMALE:
 		{
-			int sp_rate = (!skill_lv)? 0:skill->db[skill_id].sp_rate[skill_lv-1];
+			int sp_rate = (!skill_lv)? 0:skill->dbs->db[skill_id].sp_rate[skill_lv-1];
 			int gain_sp = tstatus->max_sp*abs(sp_rate)/100;// The earned is the same % of the target SP than it cost the caster. [Skotlex]
 			clif->skill_nodamage(src,bl,skill_id,status->heal(bl, 0, gain_sp, 0),1);
 		}
@@ -7455,15 +7456,15 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
 							int i;
 							// get back all items used to deploy the trap
 							for( i = 0; i < 10; i++ ) {
-								if( skill->db[su->group->skill_id].itemid[i] > 0 ) {
+								if( skill->dbs->db[su->group->skill_id].itemid[i] > 0 ) {
 									int success;
 									struct item item_tmp;
 									memset(&item_tmp,0,sizeof(item_tmp));
-									item_tmp.nameid = skill->db[su->group->skill_id].itemid[i];
+									item_tmp.nameid = skill->dbs->db[su->group->skill_id].itemid[i];
 									item_tmp.identify = 1;
-									if( item_tmp.nameid && (success=pc->additem(sd,&item_tmp,skill->db[su->group->skill_id].amount[i],LOG_TYPE_OTHER)) ) {
+									if( item_tmp.nameid && (success=pc->additem(sd,&item_tmp,skill->dbs->db[su->group->skill_id].amount[i],LOG_TYPE_OTHER)) ) {
 										clif->additem(sd,0,0,success);
-										map->addflooritem(&item_tmp,skill->db[su->group->skill_id].amount[i],sd->bl.m,sd->bl.x,sd->bl.y,0,0,0,0);
+										map->addflooritem(&item_tmp,skill->dbs->db[su->group->skill_id].amount[i],sd->bl.m,sd->bl.x,sd->bl.y,0,0,0,0);
 									}
 								}
 							}
@@ -7693,7 +7694,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
 					map->freeblock_unlock();
 					return 0;
 				}
-				status_zap(src,0,skill->db[skill->get_index(skill_id)].sp[skill_lv]); // consume sp only if succeeded [Inkfish]
+				status_zap(src,0,skill->dbs->db[skill->get_index(skill_id)].sp[skill_lv]); // consume sp only if succeeded [Inkfish]
 				do {
 					int eff = rnd() % 14;
 					if( eff == 5 )
@@ -9232,8 +9233,8 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin
 				int improv_skill_id = 0, improv_skill_lv, improv_idx;
 				do {
 					improv_idx = rnd() % MAX_SKILL_IMPROVISE_DB;
-					improv_skill_id = skill->improvise_db[improv_idx].skill_id;
-				} while( improv_skill_id == 0 || rnd()%10000 >= skill->improvise_db[improv_idx].per );
+					improv_skill_id = skill->dbs->improvise_db[improv_idx].skill_id;
+				} while( improv_skill_id == 0 || rnd()%10000 >= skill->dbs->improvise_db[improv_idx].per );
 				improv_skill_lv = 4 + skill_lv;
 				clif->skill_nodamage (src, bl, skill_id, skill_lv, 1);
 
@@ -10528,9 +10529,9 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
 		case CR_SLIMPITCHER:
 			if (sd) {
 				int i = skill_lv%11 - 1;
-				int j = pc->search_inventory(sd,skill->db[skill_id].itemid[i]);
-				if (j == INDEX_NOT_FOUND || skill->db[skill_id].itemid[i] <= 0
-				 || sd->inventory_data[j] == NULL || sd->status.inventory[j].amount < skill->db[skill_id].amount[i]
+				int j = pc->search_inventory(sd,skill->dbs->db[skill_id].itemid[i]);
+				if (j == INDEX_NOT_FOUND || skill->dbs->db[skill_id].itemid[i] <= 0
+				 || sd->inventory_data[j] == NULL || sd->status.inventory[j].amount < skill->dbs->db[skill_id].amount[i]
 				) {
 					clif->skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
 					return 1;
@@ -10559,7 +10560,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
 			} else {
 				int i = skill_lv%11 - 1;
 				struct item_data *item;
-				i = skill->db[skill_id].itemid[i];
+				i = skill->dbs->db[skill_id].itemid[i];
 				item = itemdb->search(i);
 				script->potion_flag = 1;
 				script->potion_hp = 0;
@@ -14284,17 +14285,17 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16
 
 	st = &sd->battle_status;
 
-	req.hp = skill->db[idx].hp[skill_lv-1];
-	hp_rate = skill->db[idx].hp_rate[skill_lv-1];
+	req.hp = skill->dbs->db[idx].hp[skill_lv-1];
+	hp_rate = skill->dbs->db[idx].hp_rate[skill_lv-1];
 	if(hp_rate > 0)
 		req.hp += (st->hp * hp_rate)/100;
 	else
 		req.hp += (st->max_hp * (-hp_rate))/100;
 
-	req.sp = skill->db[idx].sp[skill_lv-1];
+	req.sp = skill->dbs->db[idx].sp[skill_lv-1];
 	if((sd->skill_id_old == BD_ENCORE) && skill_id == sd->skill_id_dance)
 		req.sp /= 2;
-	sp_rate = skill->db[idx].sp_rate[skill_lv-1];
+	sp_rate = skill->dbs->db[idx].sp_rate[skill_lv-1];
 	if(sp_rate > 0)
 		req.sp += (st->sp * sp_rate)/100;
 	else
@@ -14322,22 +14323,22 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16
 			req.sp -= req.sp * sc->data[SC_TELEKINESIS_INTENSE]->val2 / 100;
 	}
 
-	req.zeny = skill->db[idx].zeny[skill_lv-1];
+	req.zeny = skill->dbs->db[idx].zeny[skill_lv-1];
 
 	if( sc && sc->data[SC__UNLUCKY] )
 		req.zeny += sc->data[SC__UNLUCKY]->val1 * 500;
 
-	req.spiritball = skill->db[idx].spiritball[skill_lv-1];
+	req.spiritball = skill->dbs->db[idx].spiritball[skill_lv-1];
 
-	req.state = skill->db[idx].state;
+	req.state = skill->dbs->db[idx].state;
 
-	req.mhp = skill->db[idx].mhp[skill_lv-1];
+	req.mhp = skill->dbs->db[idx].mhp[skill_lv-1];
 
-	req.weapon = skill->db[idx].weapon;
+	req.weapon = skill->dbs->db[idx].weapon;
 
-	req.ammo_qty = skill->db[idx].ammo_qty[skill_lv-1];
+	req.ammo_qty = skill->dbs->db[idx].ammo_qty[skill_lv-1];
 	if (req.ammo_qty)
-		req.ammo = skill->db[idx].ammo;
+		req.ammo = skill->dbs->db[idx].ammo;
 
 	if (!req.ammo && skill_id && skill->isammotype(sd, skill_id)) {
 		//Assume this skill is using the weapon, therefore it requires arrows.
@@ -14363,11 +14364,11 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16
 					continue;
 				break;
 			case AB_ADORAMUS:
-				if( itemid_isgemstone(skill->db[idx].itemid[i]) && skill->check_pc_partner(sd,skill_id,&skill_lv, 1, 2) )
+				if( itemid_isgemstone(skill->dbs->db[idx].itemid[i]) && skill->check_pc_partner(sd,skill_id,&skill_lv, 1, 2) )
 					continue;
 				break;
 			case WL_COMET:
-				if( itemid_isgemstone(skill->db[idx].itemid[i]) && skill->check_pc_partner(sd,skill_id,&skill_lv, 1, 0) )
+				if( itemid_isgemstone(skill->dbs->db[idx].itemid[i]) && skill->check_pc_partner(sd,skill_id,&skill_lv, 1, 0) )
 					continue;
 				break;
 			case GN_FIRE_EXPANSION:
@@ -14393,8 +14394,8 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16
 			}
 		}
 
-		req.itemid[i] = skill->db[idx].itemid[i];
-		req.amount[i] = skill->db[idx].amount[i];
+		req.itemid[i] = skill->dbs->db[idx].itemid[i];
+		req.amount[i] = skill->dbs->db[idx].amount[i];
 
 		if (itemid_isgemstone(req.itemid[i]) && skill_id != HW_GANBANTEIN) {
 			if (sd->special_state.no_gemstone) {
@@ -14436,8 +14437,8 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16
 		case SO_FIRE_INSIGNIA:
 		case SO_WIND_INSIGNIA:
 		case SO_EARTH_INSIGNIA:
-			req.itemid[skill_lv-1] = skill->db[idx].itemid[skill_lv-1];
-			req.amount[skill_lv-1] = skill->db[idx].amount[skill_lv-1];
+			req.itemid[skill_lv-1] = skill->dbs->db[idx].itemid[skill_lv-1];
+			req.amount[skill_lv-1] = skill->dbs->db[idx].amount[skill_lv-1];
 			break;
 	}
 	if (skill_id == NC_REPAIR) {
@@ -16803,9 +16804,9 @@ int skill_can_produce_mix (struct map_session_data *sd, int nameid, int trigger,
 		return 0;
 
 	for(i=0;i<MAX_SKILL_PRODUCE_DB;i++){
-		if(skill->produce_db[i].nameid == nameid ){
-			if((j=skill->produce_db[i].req_skill)>0 &&
-				pc->checkskill(sd,j) < skill->produce_db[i].req_skill_lv)
+		if(skill->dbs->produce_db[i].nameid == nameid ){
+			if((j=skill->dbs->produce_db[i].req_skill)>0 &&
+				pc->checkskill(sd,j) < skill->dbs->produce_db[i].req_skill_lv)
 					continue; // must iterate again to check other skills that produce it. [malufett]
 			if( j > 0 && sd->menuskill_id > 0 && sd->menuskill_id != j )
 				continue; // special case
@@ -16823,22 +16824,22 @@ int skill_can_produce_mix (struct map_session_data *sd, int nameid, int trigger,
 
 	if(trigger>=0){
 		if(trigger>20) { // Non-weapon, non-food item (itemlv must match)
-			if(skill->produce_db[i].itemlv!=trigger)
+			if(skill->dbs->produce_db[i].itemlv!=trigger)
 				return 0;
 		} else if(trigger>10) { // Food (any item level between 10 and 20 will do)
-			if(skill->produce_db[i].itemlv<=10 || skill->produce_db[i].itemlv>20)
+			if(skill->dbs->produce_db[i].itemlv<=10 || skill->dbs->produce_db[i].itemlv>20)
 				return 0;
 		} else { // Weapon (itemlv must be higher or equal)
-			if(skill->produce_db[i].itemlv>trigger)
+			if(skill->dbs->produce_db[i].itemlv>trigger)
 				return 0;
 		}
 	}
 
 	for (j = 0; j < MAX_PRODUCE_RESOURCE; j++) {
-		int id = skill->produce_db[i].mat_id[j];
+		int id = skill->dbs->produce_db[i].mat_id[j];
 		if (id <= 0)
 			continue;
-		if (skill->produce_db[i].mat_amount[j] <= 0) {
+		if (skill->dbs->produce_db[i].mat_amount[j] <= 0) {
 			if (pc->search_inventory(sd,id) == INDEX_NOT_FOUND)
 				return 0;
 		} else {
@@ -16846,7 +16847,7 @@ int skill_can_produce_mix (struct map_session_data *sd, int nameid, int trigger,
 			for(y=0,x=0;y<MAX_INVENTORY;y++)
 				if( sd->status.inventory[y].nameid == id )
 					x+=sd->status.inventory[y].amount;
-			if(x<qty*skill->produce_db[i].mat_amount[j])
+			if(x<qty*skill->dbs->produce_db[i].mat_amount[j])
 				return 0;
 		}
 	}
@@ -16877,7 +16878,7 @@ int skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid,
 		qty = 1;
 
 	if (!skill_id) //A skill can be specified for some override cases.
-		skill_id = skill->produce_db[idx].req_skill;
+		skill_id = skill->dbs->produce_db[idx].req_skill;
 
 	if( skill_id == GC_RESEARCHNEWPOISON )
 		skill_id = GC_CREATENEWPOISON;
@@ -16934,10 +16935,10 @@ int skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid,
 
 	for(i=0;i<MAX_PRODUCE_RESOURCE;i++){
 		int j,id,x;
-		if( (id=skill->produce_db[idx].mat_id[i]) <= 0 )
+		if( (id=skill->dbs->produce_db[idx].mat_id[i]) <= 0 )
 			continue;
 		num++;
-		x=( skill_id == RK_RUNEMASTERY ? 1 : qty)*skill->produce_db[idx].mat_amount[i];
+		x=( skill_id == RK_RUNEMASTERY ? 1 : qty)*skill->dbs->produce_db[idx].mat_amount[i];
 		do{
 			int y=0;
 			j = pc->search_inventory(sd,id);
@@ -17078,8 +17079,8 @@ int skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid,
 				break;
 			case GN_CHANGEMATERIAL:
 				for(i=0; i<MAX_SKILL_PRODUCE_DB; i++)
-					if( skill->changematerial_db[i].itemid == nameid ){
-						make_per = skill->changematerial_db[i].rate * 10;
+					if( skill->dbs->changematerial_db[i].itemid == nameid ){
+						make_per = skill->dbs->changematerial_db[i].rate * 10;
 						break;
 					}
 				break;
@@ -17191,7 +17192,7 @@ int skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid,
 							+ 20  * (sd->status.base_level + 1)
 							+ 20  * (st->dex + 1)
 							+ 100 * (rnd()%(30+5*(sd->cook_mastery/400) - (6+sd->cook_mastery/80)) + (6+sd->cook_mastery/80))
-							- 400 * (skill->produce_db[idx].itemlv - 11 + 1)
+							- 400 * (skill->dbs->produce_db[idx].itemlv - 11 + 1)
 							- 10  * (100 - st->luk + 1)
 							- 500 * (num - 1)
 							- 100 * (rnd()%4 + 1);
@@ -17347,11 +17348,11 @@ int skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid,
 					clif->misceffect(&sd->bl,5);
 					break;
 				default: //Those that don't require a skill?
-					if( skill->produce_db[idx].itemlv > 10 && skill->produce_db[idx].itemlv <= 20)
+					if( skill->dbs->produce_db[idx].itemlv > 10 && skill->dbs->produce_db[idx].itemlv <= 20)
 					{ //Cooking items.
 						clif->specialeffect(&sd->bl, 608, AREA);
 						if( sd->cook_mastery < 1999 )
-							pc_setglobalreg(sd, script->add_str("COOK_MASTERY"),sd->cook_mastery + ( 1 << ( (skill->produce_db[idx].itemlv - 11) / 2 ) ) * 5);
+							pc_setglobalreg(sd, script->add_str("COOK_MASTERY"),sd->cook_mastery + ( 1 << ( (skill->dbs->produce_db[idx].itemlv - 11) / 2 ) ) * 5);
 					}
 					break;
 			}
@@ -17359,10 +17360,10 @@ int skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid,
 		if ( skill_id == GN_CHANGEMATERIAL && tmp_item.amount) { //Success
 			int j, k = 0;
 			for(i=0; i<MAX_SKILL_PRODUCE_DB; i++)
-				if( skill->changematerial_db[i].itemid == nameid ){
+				if( skill->dbs->changematerial_db[i].itemid == nameid ){
 					for(j=0; j<5; j++){
-						if( rnd()%1000 < skill->changematerial_db[i].qty_rate[j] ){
-							tmp_item.amount = qty * skill->changematerial_db[i].qty[j];
+						if( rnd()%1000 < skill->dbs->changematerial_db[i].qty_rate[j] ){
+							tmp_item.amount = qty * skill->dbs->changematerial_db[i].qty[j];
 							if((flag = pc->additem(sd,&tmp_item,tmp_item.amount,LOG_TYPE_PRODUCE))) {
 								clif->additem(sd,0,0,flag);
 								map->addflooritem(&tmp_item,tmp_item.amount,sd->bl.m,sd->bl.x,sd->bl.y,0,0,0,0);
@@ -17450,11 +17451,11 @@ int skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid,
 				clif->msgtable_skill(sd, skill_id, MSG_SKILL_FAILURE);
 				break;
 			default:
-				if( skill->produce_db[idx].itemlv > 10 && skill->produce_db[idx].itemlv <= 20 )
+				if( skill->dbs->produce_db[idx].itemlv > 10 && skill->dbs->produce_db[idx].itemlv <= 20 )
 				{ //Cooking items.
 					clif->specialeffect(&sd->bl, 609, AREA);
 					if( sd->cook_mastery > 0 )
-						pc_setglobalreg(sd, script->add_str("COOK_MASTERY"), sd->cook_mastery - ( 1 << ((skill->produce_db[idx].itemlv - 11) / 2) ) - ( ( ( 1 << ((skill->produce_db[idx].itemlv - 11) / 2) ) >> 1 ) * 3 ));
+						pc_setglobalreg(sd, script->add_str("COOK_MASTERY"), sd->cook_mastery - ( 1 << ((skill->dbs->produce_db[idx].itemlv - 11) / 2) ) - ( ( ( 1 << ((skill->dbs->produce_db[idx].itemlv - 11) / 2) ) >> 1 ) * 3 ));
 				}
 		}
 	}
@@ -17472,7 +17473,7 @@ int skill_arrow_create (struct map_session_data *sd, int nameid)
 		return 1;
 
 	for(i=0;i<MAX_SKILL_ARROW_DB;i++)
-		if(nameid == skill->arrow_db[i].nameid) {
+		if(nameid == skill->dbs->arrow_db[i].nameid) {
 			index = i;
 			break;
 		}
@@ -17484,8 +17485,8 @@ int skill_arrow_create (struct map_session_data *sd, int nameid)
 	for(i=0;i<MAX_ARROW_RESOURCE;i++) {
 		memset(&tmp_item,0,sizeof(tmp_item));
 		tmp_item.identify = 1;
-		tmp_item.nameid = skill->arrow_db[index].cre_id[i];
-		tmp_item.amount = skill->arrow_db[index].cre_amount[i];
+		tmp_item.nameid = skill->dbs->arrow_db[index].cre_id[i];
+		tmp_item.amount = skill->dbs->arrow_db[index].cre_amount[i];
 		if(battle_config.produce_item_name_input&0x4) {
 			tmp_item.card[0]=CARD0_CREATE;
 			tmp_item.card[1]=0;
@@ -17612,10 +17613,10 @@ int skill_spellbook (struct map_session_data *sd, int nameid) {
 		return 0;
 	}
 
-	ARR_FIND(0,MAX_SKILL_SPELLBOOK_DB,i,skill->spellbook_db[i].nameid == nameid); // Search for information of this item
+	ARR_FIND(0,MAX_SKILL_SPELLBOOK_DB,i,skill->dbs->spellbook_db[i].nameid == nameid); // Search for information of this item
 	if( i == MAX_SKILL_SPELLBOOK_DB ) return 0;
 
-	if( !pc->checkskill(sd, (skill_id = skill->spellbook_db[i].skill_id)) )
+	if( !pc->checkskill(sd, (skill_id = skill->dbs->spellbook_db[i].skill_id)) )
 	{ // User don't know the skill
 		sc_start(&sd->bl, &sd->bl, SC_SLEEP, 100, 1, skill->get_time(WL_READING_SB, pc->checkskill(sd,WL_READING_SB)));
 		clif->skill_fail(sd, WL_READING_SB, USESKILL_FAIL_SPELLBOOK_DIFFICULT_SLEEP, 0);
@@ -17623,7 +17624,7 @@ int skill_spellbook (struct map_session_data *sd, int nameid) {
 	}
 
 	max_preserve = 4 * pc->checkskill(sd, WL_FREEZE_SP) + (status_get_int(&sd->bl) + sd->status.base_level) / 10;
-	point = skill->spellbook_db[i].point;
+	point = skill->dbs->spellbook_db[i].point;
 
 	if( sc && sc->data[SC_READING_SB] ) {
 		if( (sc->data[SC_READING_SB]->val2 + point) > max_preserve ) {
@@ -17746,13 +17747,13 @@ int skill_changematerial(struct map_session_data *sd, int n, unsigned short *ite
 
 	// Search for objects that can be created.
 	for( i = 0; i < MAX_SKILL_PRODUCE_DB; i++ ) {
-		if( skill->produce_db[i].itemlv == 26 ) {
+		if( skill->dbs->produce_db[i].itemlv == 26 ) {
 			p = 0;
 			do {
 				c = 0;
 				// Verification of overlap between the objects required and the list submitted.
 				for( j = 0; j < MAX_PRODUCE_RESOURCE; j++ ) {
-					if( skill->produce_db[i].mat_id[j] > 0 ) {
+					if( skill->dbs->produce_db[i].mat_id[j] > 0 ) {
 						for( k = 0; k < n; k++ ) {
 							int idx = item_list[k*2+0]-2;
 							nameid = sd->status.inventory[idx].nameid;
@@ -17761,8 +17762,8 @@ int skill_changematerial(struct map_session_data *sd, int n, unsigned short *ite
 								clif->msgtable_skill(sd, GN_CHANGEMATERIAL, MSG_SKILL_ITEM_NEED_IDENTIFY);
 								return 0;
 							}
-							if( nameid == skill->produce_db[i].mat_id[j] && (amount-p*skill->produce_db[i].mat_amount[j]) >= skill->produce_db[i].mat_amount[j]
-								&& (amount-p*skill->produce_db[i].mat_amount[j])%skill->produce_db[i].mat_amount[j] == 0 ) // must be in exact amount
+							if( nameid == skill->dbs->produce_db[i].mat_id[j] && (amount-p*skill->dbs->produce_db[i].mat_amount[j]) >= skill->dbs->produce_db[i].mat_amount[j]
+								&& (amount-p*skill->dbs->produce_db[i].mat_amount[j])%skill->dbs->produce_db[i].mat_amount[j] == 0 ) // must be in exact amount
 								c++; // match
 						}
 					}
@@ -17773,7 +17774,7 @@ int skill_changematerial(struct map_session_data *sd, int n, unsigned short *ite
 			} while(n == j && c == n);
 			p--;
 			if ( p > 0 ) {
-				skill->produce_mix(sd,GN_CHANGEMATERIAL,skill->produce_db[i].nameid,0,0,0,p);
+				skill->produce_mix(sd,GN_CHANGEMATERIAL,skill->dbs->produce_db[i].nameid,0,0,0,p);
 				return 1;
 			}
 		}
@@ -18089,25 +18090,25 @@ void skill_init_unit_layout (void)
 
 	//when != it was already cleared during skill_defaults() no need to repeat
 	if( runflag == MAPSERVER_ST_RUNNING )
-		memset(skill->unit_layout,0,sizeof(skill->unit_layout));
+		memset(skill->dbs->unit_layout, 0, sizeof(skill->dbs->unit_layout));
 
 	// standard square layouts go first
 	for (i=0; i<=MAX_SQUARE_LAYOUT; i++) {
 		int size = i*2+1;
-		skill->unit_layout[i].count = size*size;
+		skill->dbs->unit_layout[i].count = size*size;
 		for (j=0; j<size*size; j++) {
-			skill->unit_layout[i].dx[j] = (j%size-i);
-			skill->unit_layout[i].dy[j] = (j/size-i);
+			skill->dbs->unit_layout[i].dx[j] = (j%size-i);
+			skill->dbs->unit_layout[i].dy[j] = (j/size-i);
 		}
 	}
 
 	// afterwards add special ones
 	pos = i;
 	for (i=0;i<MAX_SKILL_DB;i++) {
-		if (!skill->db[i].unit_id[0] || skill->db[i].unit_layout_type[0] != -1)
+		if (!skill->dbs->db[i].unit_id[0] || skill->dbs->db[i].unit_layout_type[0] != -1)
 			continue;
 
-		switch (skill->db[i].nameid) {
+		switch (skill->dbs->db[i].nameid) {
 			case MG_FIREWALL:
 			case WZ_ICEWALL:
 			case WL_EARTHSTRAIN://Warlock
@@ -18121,9 +18122,9 @@ void skill_init_unit_layout (void)
 					static const int dy[]={
 						-2,-2,-2,-1,-1,-1,-1,-1, 0, 0,
 						 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2};
-					skill->unit_layout[pos].count = 21;
-					memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-					memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+					skill->dbs->unit_layout[pos].count = 21;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			case PR_MAGNUS: {
@@ -18135,18 +18136,18 @@ void skill_init_unit_layout (void)
 						-3,-3,-3,-2,-2,-2,-1,-1,-1,-1,
 						-1,-1,-1, 0, 0, 0, 0, 0, 0, 0,
 						 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3};
-					skill->unit_layout[pos].count = 33;
-					memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-					memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+					skill->dbs->unit_layout[pos].count = 33;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			case MH_POISON_MIST:
 			case AS_VENOMDUST: {
 					static const int dx[] = {-1, 0, 0, 0, 1};
 					static const int dy[] = { 0,-1, 0, 1, 0};
-					skill->unit_layout[pos].count = 5;
-					memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-					memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+					skill->dbs->unit_layout[pos].count = 5;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			case CR_GRANDCROSS:
@@ -18159,9 +18160,9 @@ void skill_init_unit_layout (void)
 						-4,-3,-2,-2,-2,-1,-1,-1,-1,-1,
 						 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
 						 1, 1, 1, 1, 2, 2, 2, 3, 4};
-					skill->unit_layout[pos].count = 29;
-					memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-					memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+					skill->dbs->unit_layout[pos].count = 29;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			case PF_FOGWALL: {
@@ -18169,9 +18170,9 @@ void skill_init_unit_layout (void)
 						-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2};
 					static const int dy[] = {
 						-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1};
-					skill->unit_layout[pos].count = 15;
-					memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-					memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+					skill->dbs->unit_layout[pos].count = 15;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			case PA_GOSPEL: {
@@ -18185,17 +18186,17 @@ void skill_init_unit_layout (void)
 						-1,-1,-1, 0, 0, 0, 0, 0, 0, 0,
 						 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
 						 3, 3, 3};
-					skill->unit_layout[pos].count = 33;
-					memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-					memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+					skill->dbs->unit_layout[pos].count = 33;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			case NJ_KAENSIN: {
 					static const int dx[] = {-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2};
 					static const int dy[] = { 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0,-1,-1,-1,-1,-1,-2,-2,-2,-2,-2};
-					skill->unit_layout[pos].count = 24;
-					memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-					memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+					skill->dbs->unit_layout[pos].count = 24;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			case NJ_TATAMIGAESHI: {
@@ -18210,29 +18211,29 @@ void skill_init_unit_layout (void)
 					static const int dy3[] = { 0, 0, 0, 0, 0, 0,-3,-2,-1, 1, 2, 3};
 					//lv1
 					j = 0;
-					skill->unit_layout[pos].count = 4;
-					memcpy(skill->unit_layout[pos].dx,dx1,sizeof(dx1));
-					memcpy(skill->unit_layout[pos].dy,dy1,sizeof(dy1));
-					skill->db[i].unit_layout_type[j] = pos;
+					skill->dbs->unit_layout[pos].count = 4;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx1,sizeof(dx1));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy1,sizeof(dy1));
+					skill->dbs->db[i].unit_layout_type[j] = pos;
 					//lv2/3
 					j++;
 					pos++;
-					skill->unit_layout[pos].count = 8;
-					memcpy(skill->unit_layout[pos].dx,dx2,sizeof(dx2));
-					memcpy(skill->unit_layout[pos].dy,dy2,sizeof(dy2));
-					skill->db[i].unit_layout_type[j] = pos;
-					skill->db[i].unit_layout_type[++j] = pos;
+					skill->dbs->unit_layout[pos].count = 8;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx2,sizeof(dx2));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy2,sizeof(dy2));
+					skill->dbs->db[i].unit_layout_type[j] = pos;
+					skill->dbs->db[i].unit_layout_type[++j] = pos;
 					//lv4/5
 					j++;
 					pos++;
-					skill->unit_layout[pos].count = 12;
-					memcpy(skill->unit_layout[pos].dx,dx3,sizeof(dx3));
-					memcpy(skill->unit_layout[pos].dy,dy3,sizeof(dy3));
-					skill->db[i].unit_layout_type[j] = pos;
-					skill->db[i].unit_layout_type[++j] = pos;
+					skill->dbs->unit_layout[pos].count = 12;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx3,sizeof(dx3));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy3,sizeof(dy3));
+					skill->dbs->db[i].unit_layout_type[j] = pos;
+					skill->dbs->db[i].unit_layout_type[++j] = pos;
 					//Fill in the rest using lv 5.
 					for (;j<MAX_SKILL_LEVEL;j++)
-						skill->db[i].unit_layout_type[j] = pos;
+						skill->dbs->db[i].unit_layout_type[j] = pos;
 					//Skip, this way the check below will fail and continue to the next skill.
 					pos++;
 				}
@@ -18240,27 +18241,27 @@ void skill_init_unit_layout (void)
 			case GN_WALLOFTHORN: {
 					static const int dx[] = {-1,-2,-2,-2,-2,-2,-1, 0, 1, 2, 2, 2, 2, 2, 1, 0};
 					static const int dy[] = { 2, 2, 1, 0,-1,-2,-2,-2,-2,-2,-1, 0, 1, 2, 2, 2};
-					skill->unit_layout[pos].count = 16;
-					memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-					memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+					skill->dbs->unit_layout[pos].count = 16;
+					memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+					memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			case EL_FIRE_MANTLE: {
 				static const int dx[] = {-1, 0, 1, 1, 1, 0,-1,-1};
 				static const int dy[] = { 1, 1, 1, 0,-1,-1,-1, 0};
-				skill->unit_layout[pos].count = 8;
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				skill->dbs->unit_layout[pos].count = 8;
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 				}
 				break;
 			default:
 				ShowError("unknown unit layout at skill %d\n",i);
 				break;
 		}
-		if (!skill->unit_layout[pos].count)
+		if (!skill->dbs->unit_layout[pos].count)
 			continue;
 		for (j=0;j<MAX_SKILL_LEVEL;j++)
-			skill->db[i].unit_layout_type[j] = pos;
+			skill->dbs->db[i].unit_layout_type[j] = pos;
 		pos++;
 	}
 
@@ -18268,60 +18269,60 @@ void skill_init_unit_layout (void)
 	skill->firewall_unit_pos = pos;
 	for (i=0;i<8;i++) {
 		if (i&1) {
-			skill->unit_layout[pos].count = 5;
+			skill->dbs->unit_layout[pos].count = 5;
 			if (i&0x2) {
 				int dx[] = {-1,-1, 0, 0, 1};
 				int dy[] = { 1, 0, 0,-1,-1};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			} else {
 				int dx[] = { 1, 1 ,0, 0,-1};
 				int dy[] = { 1, 0, 0,-1,-1};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			}
 		} else {
-			skill->unit_layout[pos].count = 3;
+			skill->dbs->unit_layout[pos].count = 3;
 			if (i%4==0) {
 				int dx[] = {-1, 0, 1};
 				int dy[] = { 0, 0, 0};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			} else {
 				int dx[] = { 0, 0, 0};
 				int dy[] = {-1, 0, 1};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			}
 		}
 		pos++;
 	}
 	skill->icewall_unit_pos = pos;
 	for (i=0;i<8;i++) {
-		skill->unit_layout[pos].count = 5;
+		skill->dbs->unit_layout[pos].count = 5;
 		if (i&1) {
 			if (i&0x2) {
 				int dx[] = {-2,-1, 0, 1, 2};
 				int dy[] = { 2, 1, 0,-1,-2};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			} else {
 				int dx[] = { 2, 1 ,0,-1,-2};
 				int dy[] = { 2, 1, 0,-1,-2};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			}
 		} else {
 			if (i%4==0) {
 				int dx[] = {-2,-1, 0, 1, 2};
 				int dy[] = { 0, 0, 0, 0, 0};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			} else {
 				int dx[] = { 0, 0, 0, 0, 0};
 				int dy[] = {-2,-1, 0, 1, 2};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			}
 		}
 		pos++;
@@ -18329,15 +18330,15 @@ void skill_init_unit_layout (void)
 	skill->earthstrain_unit_pos = pos;
 	for( i = 0; i < 8; i++ )
 	{ // For each Direction
-		skill->unit_layout[pos].count = 15;
+		skill->dbs->unit_layout[pos].count = 15;
 		switch( i )
 		{
 		case 0: case 1: case 3: case 4: case 5: case 7:
 			{
 				int dx[] = {-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
 				int dy[] = { 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			}
 			break;
 		case 2:
@@ -18345,8 +18346,8 @@ void skill_init_unit_layout (void)
 			{
 				int dx[] = { 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0};
 				int dy[] = {-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
-				memcpy(skill->unit_layout[pos].dx,dx,sizeof(dx));
-				memcpy(skill->unit_layout[pos].dy,dy,sizeof(dy));
+				memcpy(skill->dbs->unit_layout[pos].dx,dx,sizeof(dx));
+				memcpy(skill->dbs->unit_layout[pos].dy,dy,sizeof(dy));
 			}
 			break;
 		}
@@ -18593,36 +18594,36 @@ bool skill_parse_row_skilldb(char* split[], int columns, int current) {
 	if( !idx ) // invalid skill id
 		return false;
 
-	skill->db[idx].nameid = skill_id;
-	skill->split_atoi(split[1],skill->db[idx].range);
-	skill->db[idx].hit = atoi(split[2]);
-	skill->db[idx].inf = atoi(split[3]);
-	skill->split_atoi(split[4],skill->db[idx].element);
-	skill->db[idx].nk = (int)strtol(split[5], NULL, 0);
-	skill->split_atoi(split[6],skill->db[idx].splash);
-	skill->db[idx].max = atoi(split[7]);
-	skill->split_atoi(split[8],skill->db[idx].num);
+	skill->dbs->db[idx].nameid = skill_id;
+	skill->split_atoi(split[1],skill->dbs->db[idx].range);
+	skill->dbs->db[idx].hit = atoi(split[2]);
+	skill->dbs->db[idx].inf = atoi(split[3]);
+	skill->split_atoi(split[4],skill->dbs->db[idx].element);
+	skill->dbs->db[idx].nk = (int)strtol(split[5], NULL, 0);
+	skill->split_atoi(split[6],skill->dbs->db[idx].splash);
+	skill->dbs->db[idx].max = atoi(split[7]);
+	skill->split_atoi(split[8],skill->dbs->db[idx].num);
 
 	if( strcmpi(split[9],"yes") == 0 )
-		skill->db[idx].castcancel = 1;
+		skill->dbs->db[idx].castcancel = 1;
 	else
-		skill->db[idx].castcancel = 0;
-	skill->db[idx].cast_def_rate = atoi(split[10]);
-	skill->db[idx].inf2 = (int)strtol(split[11], NULL, 0);
-	skill->split_atoi(split[12],skill->db[idx].maxcount);
+		skill->dbs->db[idx].castcancel = 0;
+	skill->dbs->db[idx].cast_def_rate = atoi(split[10]);
+	skill->dbs->db[idx].inf2 = (int)strtol(split[11], NULL, 0);
+	skill->split_atoi(split[12],skill->dbs->db[idx].maxcount);
 	if( strcmpi(split[13],"weapon") == 0 )
-		skill->db[idx].skill_type = BF_WEAPON;
+		skill->dbs->db[idx].skill_type = BF_WEAPON;
 	else if( strcmpi(split[13],"magic") == 0 )
-		skill->db[idx].skill_type = BF_MAGIC;
+		skill->dbs->db[idx].skill_type = BF_MAGIC;
 	else if( strcmpi(split[13],"misc") == 0 )
-		skill->db[idx].skill_type = BF_MISC;
+		skill->dbs->db[idx].skill_type = BF_MISC;
 	else
-		skill->db[idx].skill_type = 0;
-	skill->split_atoi(split[14],skill->db[idx].blewcount);
-	safestrncpy(skill->db[idx].name, trim(split[15]), sizeof(skill->db[idx].name));
-	safestrncpy(skill->db[idx].desc, trim(split[16]), sizeof(skill->db[idx].desc));
-	strdb_iput(skill->name2id_db, skill->db[idx].name, skill_id);
-	script->set_constant2(skill->db[idx].name,(int)skill_id,0);
+		skill->dbs->db[idx].skill_type = 0;
+	skill->split_atoi(split[14],skill->dbs->db[idx].blewcount);
+	safestrncpy(skill->dbs->db[idx].name, trim(split[15]), sizeof(skill->dbs->db[idx].name));
+	safestrncpy(skill->dbs->db[idx].desc, trim(split[16]), sizeof(skill->dbs->db[idx].desc));
+	strdb_iput(skill->name2id_db, skill->dbs->db[idx].name, skill_id);
+	script->set_constant2(skill->dbs->db[idx].name,(int)skill_id,0);
 
 	return true;
 }
@@ -18637,22 +18638,22 @@ bool skill_parse_row_requiredb(char* split[], int columns, int current) {
 	if( !idx ) // invalid skill id
 		return false;
 
-	skill->split_atoi(split[1],skill->db[idx].hp);
-	skill->split_atoi(split[2],skill->db[idx].mhp);
-	skill->split_atoi(split[3],skill->db[idx].sp);
-	skill->split_atoi(split[4],skill->db[idx].hp_rate);
-	skill->split_atoi(split[5],skill->db[idx].sp_rate);
-	skill->split_atoi(split[6],skill->db[idx].zeny);
+	skill->split_atoi(split[1],skill->dbs->db[idx].hp);
+	skill->split_atoi(split[2],skill->dbs->db[idx].mhp);
+	skill->split_atoi(split[3],skill->dbs->db[idx].sp);
+	skill->split_atoi(split[4],skill->dbs->db[idx].hp_rate);
+	skill->split_atoi(split[5],skill->dbs->db[idx].sp_rate);
+	skill->split_atoi(split[6],skill->dbs->db[idx].zeny);
 
 	//Which weapon type are required, see doc/item_db for types
 	p = split[7];
 	for( j = 0; j < 32; j++ ) {
 		int l = atoi(p);
 		if( l == 99 ) { // Any weapon
-			skill->db[idx].weapon = 0;
+			skill->dbs->db[idx].weapon = 0;
 			break;
 		} else
-			skill->db[idx].weapon |= 1<<l;
+			skill->dbs->db[idx].weapon |= 1<<l;
 		p = strchr(p,':');
 		if(!p)
 			break;
@@ -18664,49 +18665,49 @@ bool skill_parse_row_requiredb(char* split[], int columns, int current) {
 	for( j = 0; j < 32; j++ ) {
 		int l = atoi(p);
 		if( l == 99 ) { // Any ammo type
-			skill->db[idx].ammo = 0xFFFFFFFF;
+			skill->dbs->db[idx].ammo = 0xFFFFFFFF;
 			break;
 		} else if( l ) // 0 stands for no requirement
-			skill->db[idx].ammo |= 1<<l;
+			skill->dbs->db[idx].ammo |= 1<<l;
 		p = strchr(p,':');
 		if( !p )
 			break;
 		p++;
 	}
-	skill->split_atoi(split[9],skill->db[idx].ammo_qty);
-
-	if(      strcmpi(split[10],"hiding")              == 0 ) skill->db[idx].state = ST_HIDING;
-	else if( strcmpi(split[10],"cloaking")            == 0 ) skill->db[idx].state = ST_CLOAKING;
-	else if( strcmpi(split[10],"hidden")              == 0 ) skill->db[idx].state = ST_HIDDEN;
-	else if( strcmpi(split[10],"riding")              == 0 ) skill->db[idx].state = ST_RIDING;
-	else if( strcmpi(split[10],"falcon")              == 0 ) skill->db[idx].state = ST_FALCON;
-	else if( strcmpi(split[10],"cart")                == 0 ) skill->db[idx].state = ST_CART;
-	else if( strcmpi(split[10],"shield")              == 0 ) skill->db[idx].state = ST_SHIELD;
-	else if( strcmpi(split[10],"sight")               == 0 ) skill->db[idx].state = ST_SIGHT;
-	else if( strcmpi(split[10],"explosionspirits")    == 0 ) skill->db[idx].state = ST_EXPLOSIONSPIRITS;
-	else if( strcmpi(split[10],"cartboost")           == 0 ) skill->db[idx].state = ST_CARTBOOST;
-	else if( strcmpi(split[10],"recover_weight_rate") == 0 ) skill->db[idx].state = ST_RECOV_WEIGHT_RATE;
-	else if( strcmpi(split[10],"move_enable")         == 0 ) skill->db[idx].state = ST_MOVE_ENABLE;
-	else if( strcmpi(split[10],"water")               == 0 ) skill->db[idx].state = ST_WATER;
-	else if( strcmpi(split[10],"dragon")              == 0 ) skill->db[idx].state = ST_RIDINGDRAGON;
-	else if( strcmpi(split[10],"warg")                == 0 ) skill->db[idx].state = ST_WUG;
-	else if( strcmpi(split[10],"ridingwarg")          == 0 ) skill->db[idx].state = ST_RIDINGWUG;
-	else if( strcmpi(split[10],"mado")                == 0 ) skill->db[idx].state = ST_MADO;
-	else if( strcmpi(split[10],"elementalspirit")     == 0 ) skill->db[idx].state = ST_ELEMENTALSPIRIT;
-	else if( strcmpi(split[10],"poisonweapon")        == 0 ) skill->db[idx].state = ST_POISONINGWEAPON;
-	else if( strcmpi(split[10],"rollingcutter")       == 0 ) skill->db[idx].state = ST_ROLLINGCUTTER;
-	else if( strcmpi(split[10],"mh_fighting")         == 0 ) skill->db[idx].state = ST_MH_FIGHTING;
-	else if( strcmpi(split[10],"mh_grappling")        == 0 ) skill->db[idx].state = ST_MH_GRAPPLING;
-	else if( strcmpi(split[10],"peco")                == 0 ) skill->db[idx].state = ST_PECO;
+	skill->split_atoi(split[9],skill->dbs->db[idx].ammo_qty);
+
+	if(      strcmpi(split[10],"hiding")              == 0 ) skill->dbs->db[idx].state = ST_HIDING;
+	else if( strcmpi(split[10],"cloaking")            == 0 ) skill->dbs->db[idx].state = ST_CLOAKING;
+	else if( strcmpi(split[10],"hidden")              == 0 ) skill->dbs->db[idx].state = ST_HIDDEN;
+	else if( strcmpi(split[10],"riding")              == 0 ) skill->dbs->db[idx].state = ST_RIDING;
+	else if( strcmpi(split[10],"falcon")              == 0 ) skill->dbs->db[idx].state = ST_FALCON;
+	else if( strcmpi(split[10],"cart")                == 0 ) skill->dbs->db[idx].state = ST_CART;
+	else if( strcmpi(split[10],"shield")              == 0 ) skill->dbs->db[idx].state = ST_SHIELD;
+	else if( strcmpi(split[10],"sight")               == 0 ) skill->dbs->db[idx].state = ST_SIGHT;
+	else if( strcmpi(split[10],"explosionspirits")    == 0 ) skill->dbs->db[idx].state = ST_EXPLOSIONSPIRITS;
+	else if( strcmpi(split[10],"cartboost")           == 0 ) skill->dbs->db[idx].state = ST_CARTBOOST;
+	else if( strcmpi(split[10],"recover_weight_rate") == 0 ) skill->dbs->db[idx].state = ST_RECOV_WEIGHT_RATE;
+	else if( strcmpi(split[10],"move_enable")         == 0 ) skill->dbs->db[idx].state = ST_MOVE_ENABLE;
+	else if( strcmpi(split[10],"water")               == 0 ) skill->dbs->db[idx].state = ST_WATER;
+	else if( strcmpi(split[10],"dragon")              == 0 ) skill->dbs->db[idx].state = ST_RIDINGDRAGON;
+	else if( strcmpi(split[10],"warg")                == 0 ) skill->dbs->db[idx].state = ST_WUG;
+	else if( strcmpi(split[10],"ridingwarg")          == 0 ) skill->dbs->db[idx].state = ST_RIDINGWUG;
+	else if( strcmpi(split[10],"mado")                == 0 ) skill->dbs->db[idx].state = ST_MADO;
+	else if( strcmpi(split[10],"elementalspirit")     == 0 ) skill->dbs->db[idx].state = ST_ELEMENTALSPIRIT;
+	else if( strcmpi(split[10],"poisonweapon")        == 0 ) skill->dbs->db[idx].state = ST_POISONINGWEAPON;
+	else if( strcmpi(split[10],"rollingcutter")       == 0 ) skill->dbs->db[idx].state = ST_ROLLINGCUTTER;
+	else if( strcmpi(split[10],"mh_fighting")         == 0 ) skill->dbs->db[idx].state = ST_MH_FIGHTING;
+	else if( strcmpi(split[10],"mh_grappling")        == 0 ) skill->dbs->db[idx].state = ST_MH_GRAPPLING;
+	else if( strcmpi(split[10],"peco")                == 0 ) skill->dbs->db[idx].state = ST_PECO;
 	/**
 	 * Unknown or no state
 	 **/
-	else skill->db[idx].state = ST_NONE;
+	else skill->dbs->db[idx].state = ST_NONE;
 
-	skill->split_atoi(split[11],skill->db[idx].spiritball);
+	skill->split_atoi(split[11],skill->dbs->db[idx].spiritball);
 	for( j = 0; j < MAX_SKILL_ITEM_REQUIRE; j++ ) {
-		skill->db[idx].itemid[j] = atoi(split[12+ 2*j]);
-		skill->db[idx].amount[j] = atoi(split[13+ 2*j]);
+		skill->dbs->db[idx].itemid[j] = atoi(split[12+ 2*j]);
+		skill->dbs->db[idx].amount[j] = atoi(split[13+ 2*j]);
 	}
 
 	return true;
@@ -18719,14 +18720,14 @@ bool skill_parse_row_castdb(char* split[], int columns, int current) {
 	if( !idx ) // invalid skill id
 		return false;
 
-	skill->split_atoi(split[1],skill->db[idx].cast);
-	skill->split_atoi(split[2],skill->db[idx].delay);
-	skill->split_atoi(split[3],skill->db[idx].walkdelay);
-	skill->split_atoi(split[4],skill->db[idx].upkeep_time);
-	skill->split_atoi(split[5],skill->db[idx].upkeep_time2);
-	skill->split_atoi(split[6],skill->db[idx].cooldown);
+	skill->split_atoi(split[1],skill->dbs->db[idx].cast);
+	skill->split_atoi(split[2],skill->dbs->db[idx].delay);
+	skill->split_atoi(split[3],skill->dbs->db[idx].walkdelay);
+	skill->split_atoi(split[4],skill->dbs->db[idx].upkeep_time);
+	skill->split_atoi(split[5],skill->dbs->db[idx].upkeep_time2);
+	skill->split_atoi(split[6],skill->dbs->db[idx].cooldown);
 #ifdef RENEWAL_CAST
-	skill->split_atoi(split[7],skill->db[idx].fixed_cast);
+	skill->split_atoi(split[7],skill->dbs->db[idx].fixed_cast);
 #endif
 	return true;
 }
@@ -18738,9 +18739,9 @@ bool skill_parse_row_castnodexdb(char* split[], int columns, int current) {
 	if( !idx ) // invalid skill id
 		return false;
 
-	skill->split_atoi(split[1],skill->db[idx].castnodex);
+	skill->split_atoi(split[1],skill->dbs->db[idx].castnodex);
 	if( split[2] ) // optional column
-		skill->split_atoi(split[2],skill->db[idx].delaynodex);
+		skill->split_atoi(split[2],skill->dbs->db[idx].delaynodex);
 
 	return true;
 }
@@ -18752,37 +18753,37 @@ bool skill_parse_row_unitdb(char* split[], int columns, int current) {
 	if( !idx ) // invalid skill id
 		return false;
 
-	skill->db[idx].unit_id[0] = (int)strtol(split[1],NULL,16);
-	skill->db[idx].unit_id[1] = (int)strtol(split[2],NULL,16);
-	skill->split_atoi(split[3],skill->db[idx].unit_layout_type);
-	skill->split_atoi(split[4],skill->db[idx].unit_range);
-	skill->db[idx].unit_interval = atoi(split[5]);
-
-	if( strcmpi(split[6],"noenemy")==0 ) skill->db[idx].unit_target = BCT_NOENEMY;
-	else if( strcmpi(split[6],"friend")==0 ) skill->db[idx].unit_target = BCT_NOENEMY;
-	else if( strcmpi(split[6],"party")==0 ) skill->db[idx].unit_target = BCT_PARTY;
-	else if( strcmpi(split[6],"ally")==0 ) skill->db[idx].unit_target = BCT_PARTY|BCT_GUILD;
-	else if( strcmpi(split[6],"guild")==0 ) skill->db[idx].unit_target = BCT_GUILD;
-	else if( strcmpi(split[6],"all")==0 ) skill->db[idx].unit_target = BCT_ALL;
-	else if( strcmpi(split[6],"enemy")==0 ) skill->db[idx].unit_target = BCT_ENEMY;
-	else if( strcmpi(split[6],"self")==0 ) skill->db[idx].unit_target = BCT_SELF;
-	else if( strcmpi(split[6],"sameguild")==0 ) skill->db[idx].unit_target = BCT_GUILD|BCT_SAMEGUILD;
-	else if( strcmpi(split[6],"noone")==0 ) skill->db[idx].unit_target = BCT_NOONE;
-	else skill->db[idx].unit_target = (int)strtol(split[6],NULL,16);
-
-	skill->db[idx].unit_flag = (int)strtol(split[7],NULL,16);
-
-	if (skill->db[idx].unit_flag&UF_DEFNOTENEMY && battle_config.defnotenemy)
-		skill->db[idx].unit_target = BCT_NOENEMY;
+	skill->dbs->db[idx].unit_id[0] = (int)strtol(split[1],NULL,16);
+	skill->dbs->db[idx].unit_id[1] = (int)strtol(split[2],NULL,16);
+	skill->split_atoi(split[3],skill->dbs->db[idx].unit_layout_type);
+	skill->split_atoi(split[4],skill->dbs->db[idx].unit_range);
+	skill->dbs->db[idx].unit_interval = atoi(split[5]);
+
+	if( strcmpi(split[6],"noenemy")==0 ) skill->dbs->db[idx].unit_target = BCT_NOENEMY;
+	else if( strcmpi(split[6],"friend")==0 ) skill->dbs->db[idx].unit_target = BCT_NOENEMY;
+	else if( strcmpi(split[6],"party")==0 ) skill->dbs->db[idx].unit_target = BCT_PARTY;
+	else if( strcmpi(split[6],"ally")==0 ) skill->dbs->db[idx].unit_target = BCT_PARTY|BCT_GUILD;
+	else if( strcmpi(split[6],"guild")==0 ) skill->dbs->db[idx].unit_target = BCT_GUILD;
+	else if( strcmpi(split[6],"all")==0 ) skill->dbs->db[idx].unit_target = BCT_ALL;
+	else if( strcmpi(split[6],"enemy")==0 ) skill->dbs->db[idx].unit_target = BCT_ENEMY;
+	else if( strcmpi(split[6],"self")==0 ) skill->dbs->db[idx].unit_target = BCT_SELF;
+	else if( strcmpi(split[6],"sameguild")==0 ) skill->dbs->db[idx].unit_target = BCT_GUILD|BCT_SAMEGUILD;
+	else if( strcmpi(split[6],"noone")==0 ) skill->dbs->db[idx].unit_target = BCT_NOONE;
+	else skill->dbs->db[idx].unit_target = (int)strtol(split[6],NULL,16);
+
+	skill->dbs->db[idx].unit_flag = (int)strtol(split[7],NULL,16);
+
+	if (skill->dbs->db[idx].unit_flag&UF_DEFNOTENEMY && battle_config.defnotenemy)
+		skill->dbs->db[idx].unit_target = BCT_NOENEMY;
 
 	//By default, target just characters.
-	skill->db[idx].unit_target |= BL_CHAR;
-	if (skill->db[idx].unit_flag&UF_NOPC)
-		skill->db[idx].unit_target &= ~BL_PC;
-	if (skill->db[idx].unit_flag&UF_NOMOB)
-		skill->db[idx].unit_target &= ~BL_MOB;
-	if (skill->db[idx].unit_flag&UF_SKILL)
-		skill->db[idx].unit_target |= BL_SKILL;
+	skill->dbs->db[idx].unit_target |= BL_CHAR;
+	if (skill->dbs->db[idx].unit_flag&UF_NOPC)
+		skill->dbs->db[idx].unit_target &= ~BL_PC;
+	if (skill->dbs->db[idx].unit_flag&UF_NOMOB)
+		skill->dbs->db[idx].unit_target &= ~BL_MOB;
+	if (skill->dbs->db[idx].unit_flag&UF_SKILL)
+		skill->dbs->db[idx].unit_target |= BL_SKILL;
 
 	return true;
 }
@@ -18795,14 +18796,14 @@ bool skill_parse_row_producedb(char* split[], int columns, int current) {
 	if( !i )
 		return false;
 
-	skill->produce_db[current].nameid = i;
-	skill->produce_db[current].itemlv = atoi(split[1]);
-	skill->produce_db[current].req_skill = atoi(split[2]);
-	skill->produce_db[current].req_skill_lv = atoi(split[3]);
+	skill->dbs->produce_db[current].nameid = i;
+	skill->dbs->produce_db[current].itemlv = atoi(split[1]);
+	skill->dbs->produce_db[current].req_skill = atoi(split[2]);
+	skill->dbs->produce_db[current].req_skill_lv = atoi(split[3]);
 
 	for( x = 4, y = 0; x+1 < columns && split[x] && split[x+1] && y < MAX_PRODUCE_RESOURCE; x += 2, y++ ) {
-		skill->produce_db[current].mat_id[y] = atoi(split[x]);
-		skill->produce_db[current].mat_amount[y] = atoi(split[x+1]);
+		skill->dbs->produce_db[current].mat_id[y] = atoi(split[x]);
+		skill->dbs->produce_db[current].mat_amount[y] = atoi(split[x+1]);
 	}
 
 	return true;
@@ -18816,11 +18817,11 @@ bool skill_parse_row_createarrowdb(char* split[], int columns, int current) {
 	if( !i )
 		return false;
 
-	skill->arrow_db[current].nameid = i;
+	skill->dbs->arrow_db[current].nameid = i;
 
 	for( x = 1, y = 0; x+1 < columns && split[x] && split[x+1] && y < MAX_ARROW_RESOURCE; x += 2, y++ ) {
-		skill->arrow_db[current].cre_id[y] = atoi(split[x]);
-		skill->arrow_db[current].cre_amount[y] = atoi(split[x+1]);
+		skill->dbs->arrow_db[current].cre_id[y] = atoi(split[x]);
+		skill->dbs->arrow_db[current].cre_amount[y] = atoi(split[x+1]);
 	}
 
 	return true;
@@ -18839,9 +18840,9 @@ bool skill_parse_row_spellbookdb(char* split[], int columns, int current) {
 	if( points < 1 )
 		ShowError("spellbook_db: PreservePoints have to be 1 or above! (%d/%s)\n", skill_id, skill->get_name(skill_id));
 	else {
-		skill->spellbook_db[current].skill_id = skill_id;
-		skill->spellbook_db[current].point = points;
-		skill->spellbook_db[current].nameid = nameid;
+		skill->dbs->spellbook_db[current].skill_id = skill_id;
+		skill->dbs->spellbook_db[current].point = points;
+		skill->dbs->spellbook_db[current].nameid = nameid;
 
 		return true;
 	}
@@ -18869,8 +18870,8 @@ bool skill_parse_row_improvisedb(char* split[], int columns, int current) {
 		ShowError("skill_improvise_db: Maximum amount of entries reached (%d), increase MAX_SKILL_IMPROVISE_DB\n",MAX_SKILL_IMPROVISE_DB);
 		return false;
 	}
-	skill->improvise_db[current].skill_id = skill_id;
-	skill->improvise_db[current].per = j; // Still need confirm it.
+	skill->dbs->improvise_db[current].skill_id = skill_id;
+	skill->dbs->improvise_db[current].per = j; // Still need confirm it.
 
 	return true;
 }
@@ -18887,7 +18888,7 @@ bool skill_parse_row_magicmushroomdb(char* split[], int column, int current) {
 		return false;
 	}
 
-	skill->magicmushroom_db[current].skill_id = skill_id;
+	skill->dbs->magicmushroom_db[current].skill_id = skill_id;
 
 	return true;
 }
@@ -18898,7 +18899,7 @@ bool skill_parse_row_reproducedb(char* split[], int column, int current) {
 	if( !idx )
 		return false;
 
-	skill->reproduce_db[idx] = true;
+	skill->dbs->reproduce_db[idx] = true;
 
 	return true;
 }
@@ -18916,9 +18917,9 @@ bool skill_parse_row_abradb(char* split[], int columns, int current) {
 		return false;
 	}
 
-	skill->abra_db[current].skill_id = skill_id;
-	skill->abra_db[current].req_lv = atoi(split[2]);
-	skill->abra_db[current].per = atoi(split[3]);
+	skill->dbs->abra_db[current].skill_id = skill_id;
+	skill->dbs->abra_db[current].req_lv = atoi(split[2]);
+	skill->dbs->abra_db[current].per = atoi(split[3]);
 
 	return true;
 }
@@ -18930,8 +18931,8 @@ bool skill_parse_row_changematerialdb(char* split[], int columns, int current) {
 	int x,y;
 
 	for(x=0; x<MAX_SKILL_PRODUCE_DB; x++){
-		if( skill->produce_db[x].nameid == skill_id )
-			if( skill->produce_db[x].req_skill == GN_CHANGEMATERIAL )
+		if( skill->dbs->produce_db[x].nameid == skill_id )
+			if( skill->dbs->produce_db[x].req_skill == GN_CHANGEMATERIAL )
 				break;
 	}
 
@@ -18945,12 +18946,12 @@ bool skill_parse_row_changematerialdb(char* split[], int columns, int current) {
 		return false;
 	}
 
-	skill->changematerial_db[current].itemid = skill_id;
-	skill->changematerial_db[current].rate = j;
+	skill->dbs->changematerial_db[current].itemid = skill_id;
+	skill->dbs->changematerial_db[current].rate = j;
 
 	for( x = 2, y = 0; x+1 < columns && split[x] && split[x+1] && y < 5; x += 2, y++ ) {
-		skill->changematerial_db[current].qty[y] = atoi(split[x]);
-		skill->changematerial_db[current].qty_rate[y] = atoi(split[x+1]);
+		skill->dbs->changematerial_db[current].qty[y] = atoi(split[x]);
+		skill->dbs->changematerial_db[current].qty_rate[y] = atoi(split[x+1]);
 	}
 
 	return true;
@@ -18974,12 +18975,12 @@ void skill_readdb(bool minimal) {
 
 	/* when != it was called during init and this procedure was already performed by skill_defaults()  */
 	if( runflag == MAPSERVER_ST_RUNNING ) {
-		memset(ZEROED_BLOCK_POS(skill), 0, ZEROED_BLOCK_SIZE(skill));
+		memset(ZEROED_BLOCK_POS(skill->dbs), 0, ZEROED_BLOCK_SIZE(skill->dbs));
 	}
 
 	// load skill databases
-	safestrncpy(skill->db[0].name, "UNKNOWN_SKILL", sizeof(skill->db[0].name));
-	safestrncpy(skill->db[0].desc, "Unknown Skill", sizeof(skill->db[0].desc));
+	safestrncpy(skill->dbs->db[0].name, "UNKNOWN_SKILL", sizeof(skill->dbs->db[0].name));
+	safestrncpy(skill->dbs->db[0].desc, "Unknown Skill", sizeof(skill->dbs->db[0].desc));
 
 #ifdef ENABLE_CASE_CHECK
 	script->parser_current_file = DBPATH"skill_db.txt";
@@ -19097,6 +19098,8 @@ void skill_defaults(void) {
 	const int skill_deluge_eff[5]  = {  5,  9, 12, 14, 15 };
 
 	skill = &skill_s;
+	skill->dbs = &skilldbs;
+
 	skill->init = do_init_skill;
 	skill->final = do_final_skill;
 	skill->reload = skill_reload;
@@ -19114,8 +19117,8 @@ void skill_defaults(void) {
 	skill->cd_ers = NULL;
 	skill->cd_entry_ers = NULL;
 
-	memset(ZEROED_BLOCK_POS(skill), 0, ZEROED_BLOCK_SIZE(skill));
-	memset(skill->unit_layout, 0, sizeof(skill->unit_layout));
+	memset(ZEROED_BLOCK_POS(skill->dbs), 0, ZEROED_BLOCK_SIZE(skill->dbs));
+	memset(skill->dbs->unit_layout, 0, sizeof(skill->dbs->unit_layout));
 
 	/* */
 	memcpy(skill->enchant_eff, skill_enchant_eff, sizeof(skill->enchant_eff));
diff --git a/src/map/skill.h b/src/map/skill.h
index 6e56e276b..aa0188be6 100644
--- a/src/map/skill.h
+++ b/src/map/skill.h
@@ -1814,6 +1814,21 @@ struct s_skill_spellbook_db {
 
 typedef int (*SkillFunc)(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 tick, int flag);
 
+struct s_skill_dbs {
+BEGIN_ZEROED_BLOCK; // This block will be zeroed in skill_defaults() as well as skill_readdb()
+	struct s_skill_db db[MAX_SKILL_DB];
+	struct s_skill_produce_db produce_db[MAX_SKILL_PRODUCE_DB];
+	struct s_skill_arrow_db arrow_db[MAX_SKILL_ARROW_DB];
+	struct s_skill_abra_db abra_db[MAX_SKILL_ABRA_DB];
+	struct s_skill_magicmushroom_db magicmushroom_db[MAX_SKILL_MAGICMUSHROOM_DB];
+	struct s_skill_improvise_db improvise_db[MAX_SKILL_IMPROVISE_DB];
+	struct s_skill_changematerial_db changematerial_db[MAX_SKILL_PRODUCE_DB];
+	struct s_skill_spellbook_db spellbook_db[MAX_SKILL_SPELLBOOK_DB];
+	bool reproduce_db[MAX_SKILL_DB];
+END_ZEROED_BLOCK;
+	struct s_skill_unit_layout unit_layout[MAX_SKILL_UNIT_LAYOUT];
+};
+
 /**
  * Skill.c Interface
  **/
@@ -1835,18 +1850,7 @@ struct skill_interface {
 	struct eri *cd_ers; // ERS Storage for skill cool down managers [Ind/Hercules]
 	struct eri *cd_entry_ers; // ERS Storage for skill cool down entries [Ind/Hercules]
 	/* */
-BEGIN_ZEROED_BLOCK; // This block will be zeroed in skill_defaults() as well as skill_readdb()
-	struct s_skill_db db[MAX_SKILL_DB];
-	struct s_skill_produce_db produce_db[MAX_SKILL_PRODUCE_DB];
-	struct s_skill_arrow_db arrow_db[MAX_SKILL_ARROW_DB];
-	struct s_skill_abra_db abra_db[MAX_SKILL_ABRA_DB];
-	struct s_skill_magicmushroom_db magicmushroom_db[MAX_SKILL_MAGICMUSHROOM_DB];
-	struct s_skill_improvise_db improvise_db[MAX_SKILL_IMPROVISE_DB];
-	struct s_skill_changematerial_db changematerial_db[MAX_SKILL_PRODUCE_DB];
-	struct s_skill_spellbook_db spellbook_db[MAX_SKILL_SPELLBOOK_DB];
-	bool reproduce_db[MAX_SKILL_DB];
-END_ZEROED_BLOCK;
-	struct s_skill_unit_layout unit_layout[MAX_SKILL_UNIT_LAYOUT];
+	struct s_skill_dbs *dbs;
 	/* */
 	int enchant_eff[5];
 	int deluge_eff[5];
diff --git a/src/map/status.c b/src/map/status.c
index d88bcf146..c21e81aab 100644
--- a/src/map/status.c
+++ b/src/map/status.c
@@ -44,6 +44,7 @@
 #include <time.h>
 
 struct status_interface status_s;
+struct s_status_dbs statusdbs;
 
 /**
 * Returns the status change associated with a skill.
@@ -56,7 +57,7 @@ sc_type status_skill2sc(int skill_id) {
 		ShowError("status_skill2sc: Unsupported skill id %d\n", skill_id);
 		return SC_NONE;
 	}
-	return status->Skill2SCTable[idx];
+	return status->dbs->Skill2SCTable[idx];
 }
 
 /**
@@ -72,7 +73,7 @@ int status_sc2skill(sc_type sc)
 		return 0;
 	}
 
-	return status->SkillChangeTable[sc];
+	return status->dbs->SkillChangeTable[sc];
 }
 
 /**
@@ -87,7 +88,7 @@ unsigned int status_sc2scb_flag(sc_type sc)
 		return SCB_NONE;
 	}
 
-	return status->ChangeFlagTable[sc];
+	return status->dbs->ChangeFlagTable[sc];
 }
 
 /**
@@ -102,7 +103,7 @@ int status_type2relevant_bl_types(int type)
 		return BL_NUL;
 	}
 
-	return status->RelevantBLTypes[type];
+	return status->dbs->RelevantBLTypes[type];
 }
 
 static void set_sc(uint16 skill_id, sc_type sc, int icon, unsigned int flag) {
@@ -116,35 +117,35 @@ static void set_sc(uint16 skill_id, sc_type sc, int icon, unsigned int flag) {
 		return;
 	}
 
-	if( status->SkillChangeTable[sc] == 0 )
-		status->SkillChangeTable[sc] = skill_id;
-	if( status->IconChangeTable[sc] == SI_BLANK )
-		status->IconChangeTable[sc] = icon;
-	status->ChangeFlagTable[sc] |= flag;
+	if( status->dbs->SkillChangeTable[sc] == 0 )
+		status->dbs->SkillChangeTable[sc] = skill_id;
+	if( status->dbs->IconChangeTable[sc] == SI_BLANK )
+		status->dbs->IconChangeTable[sc] = icon;
+	status->dbs->ChangeFlagTable[sc] |= flag;
 
-	if( status->Skill2SCTable[idx] == SC_NONE )
-		status->Skill2SCTable[idx] = sc;
+	if( status->dbs->Skill2SCTable[idx] == SC_NONE )
+		status->dbs->Skill2SCTable[idx] = sc;
 }
 
 void initChangeTables(void) {
 #define add_sc(skill,sc) set_sc((skill),(sc),SI_BLANK,SCB_NONE)
 // indicates that the status displays a visual effect for the affected unit, and should be sent to the client for all supported units
-#define set_sc_with_vfx(skill, sc, icon, flag) do { set_sc((skill), (sc), (icon), (flag)); if((icon) < SI_MAX) status->RelevantBLTypes[(icon)] |= BL_SCEFFECT; } while(0)
+#define set_sc_with_vfx(skill, sc, icon, flag) do { set_sc((skill), (sc), (icon), (flag)); if((icon) < SI_MAX) status->dbs->RelevantBLTypes[(icon)] |= BL_SCEFFECT; } while(0)
 
 	int i;
 
 	for (i = 0; i < SC_MAX; i++)
-		status->IconChangeTable[i] = SI_BLANK;
+		status->dbs->IconChangeTable[i] = SI_BLANK;
 
 	for (i = 0; i < MAX_SKILL; i++)
-		status->Skill2SCTable[i] = SC_NONE;
+		status->dbs->Skill2SCTable[i] = SC_NONE;
 
 	for (i = 0; i < SI_MAX; i++)
-		status->RelevantBLTypes[i] = BL_PC;
+		status->dbs->RelevantBLTypes[i] = BL_PC;
 
-	memset(status->SkillChangeTable, 0, sizeof(status->SkillChangeTable));
-	memset(status->ChangeFlagTable, 0, sizeof(status->ChangeFlagTable));
-	memset(status->DisplayType, 0, sizeof(status->DisplayType));
+	memset(status->dbs->SkillChangeTable, 0, sizeof(status->dbs->SkillChangeTable));
+	memset(status->dbs->ChangeFlagTable, 0, sizeof(status->dbs->ChangeFlagTable));
+	memset(status->dbs->DisplayType, 0, sizeof(status->dbs->DisplayType));
 
 	//First we define the skill for common ailments. These are used in skill_additional_effect through sc cards. [Skotlex]
 	set_sc( NPC_PETRIFYATTACK , SC_STONE     , SI_BLANK    , SCB_DEF_ELE|SCB_DEF|SCB_MDEF );
@@ -754,303 +755,303 @@ void initChangeTables(void) {
 	set_sc_with_vfx( GN_ILLUSIONDOPING   , SC_ILLUSIONDOPING    , SI_ILLUSIONDOPING     , SCB_HIT );
 
 	// Storing the target job rather than simply SC_SOULLINK simplifies code later on.
-	status->Skill2SCTable[SL_ALCHEMIST]   = (sc_type)MAPID_ALCHEMIST,
-		status->Skill2SCTable[SL_MONK]        = (sc_type)MAPID_MONK,
-		status->Skill2SCTable[SL_STAR]        = (sc_type)MAPID_STAR_GLADIATOR,
-		status->Skill2SCTable[SL_SAGE]        = (sc_type)MAPID_SAGE,
-		status->Skill2SCTable[SL_CRUSADER]    = (sc_type)MAPID_CRUSADER,
-		status->Skill2SCTable[SL_SUPERNOVICE] = (sc_type)MAPID_SUPER_NOVICE,
-		status->Skill2SCTable[SL_KNIGHT]      = (sc_type)MAPID_KNIGHT,
-		status->Skill2SCTable[SL_WIZARD]      = (sc_type)MAPID_WIZARD,
-		status->Skill2SCTable[SL_PRIEST]      = (sc_type)MAPID_PRIEST,
-		status->Skill2SCTable[SL_BARDDANCER]  = (sc_type)MAPID_BARDDANCER,
-		status->Skill2SCTable[SL_ROGUE]       = (sc_type)MAPID_ROGUE,
-		status->Skill2SCTable[SL_ASSASIN]     = (sc_type)MAPID_ASSASSIN,
-		status->Skill2SCTable[SL_BLACKSMITH]  = (sc_type)MAPID_BLACKSMITH,
-		status->Skill2SCTable[SL_HUNTER]      = (sc_type)MAPID_HUNTER,
-		status->Skill2SCTable[SL_SOULLINKER]  = (sc_type)MAPID_SOUL_LINKER,
+	status->dbs->Skill2SCTable[SL_ALCHEMIST]   = (sc_type)MAPID_ALCHEMIST,
+		status->dbs->Skill2SCTable[SL_MONK]        = (sc_type)MAPID_MONK,
+		status->dbs->Skill2SCTable[SL_STAR]        = (sc_type)MAPID_STAR_GLADIATOR,
+		status->dbs->Skill2SCTable[SL_SAGE]        = (sc_type)MAPID_SAGE,
+		status->dbs->Skill2SCTable[SL_CRUSADER]    = (sc_type)MAPID_CRUSADER,
+		status->dbs->Skill2SCTable[SL_SUPERNOVICE] = (sc_type)MAPID_SUPER_NOVICE,
+		status->dbs->Skill2SCTable[SL_KNIGHT]      = (sc_type)MAPID_KNIGHT,
+		status->dbs->Skill2SCTable[SL_WIZARD]      = (sc_type)MAPID_WIZARD,
+		status->dbs->Skill2SCTable[SL_PRIEST]      = (sc_type)MAPID_PRIEST,
+		status->dbs->Skill2SCTable[SL_BARDDANCER]  = (sc_type)MAPID_BARDDANCER,
+		status->dbs->Skill2SCTable[SL_ROGUE]       = (sc_type)MAPID_ROGUE,
+		status->dbs->Skill2SCTable[SL_ASSASIN]     = (sc_type)MAPID_ASSASSIN,
+		status->dbs->Skill2SCTable[SL_BLACKSMITH]  = (sc_type)MAPID_BLACKSMITH,
+		status->dbs->Skill2SCTable[SL_HUNTER]      = (sc_type)MAPID_HUNTER,
+		status->dbs->Skill2SCTable[SL_SOULLINKER]  = (sc_type)MAPID_SOUL_LINKER,
 
 	//Status that don't have a skill associated.
-	status->IconChangeTable[SC_WEIGHTOVER50] = SI_WEIGHTOVER50;
-	status->IconChangeTable[SC_WEIGHTOVER90] = SI_WEIGHTOVER90;
-	status->IconChangeTable[SC_ATTHASTE_POTION1] = SI_ATTHASTE_POTION1;
-	status->IconChangeTable[SC_ATTHASTE_POTION2] = SI_ATTHASTE_POTION2;
-	status->IconChangeTable[SC_ATTHASTE_POTION3] = SI_ATTHASTE_POTION3;
-	status->IconChangeTable[SC_ATTHASTE_INFINITY] = SI_ATTHASTE_INFINITY;
-	status->IconChangeTable[SC_MOVHASTE_HORSE] = SI_MOVHASTE_HORSE;
-	status->IconChangeTable[SC_MOVHASTE_INFINITY] = SI_MOVHASTE_INFINITY;
-	status->IconChangeTable[SC_CHASEWALK2] = SI_INCSTR;
-	status->IconChangeTable[SC_MIRACLE] = SI_SOULLINK;
-	status->IconChangeTable[SC_CLAIRVOYANCE] = SI_CLAIRVOYANCE;
-	status->IconChangeTable[SC_FOOD_STR] = SI_FOOD_STR;
-	status->IconChangeTable[SC_FOOD_AGI] = SI_FOOD_AGI;
-	status->IconChangeTable[SC_FOOD_VIT] = SI_FOOD_VIT;
-	status->IconChangeTable[SC_FOOD_INT] = SI_FOOD_INT;
-	status->IconChangeTable[SC_FOOD_DEX] = SI_FOOD_DEX;
-	status->IconChangeTable[SC_FOOD_LUK] = SI_FOOD_LUK;
-	status->IconChangeTable[SC_FOOD_BASICAVOIDANCE]= SI_FOOD_BASICAVOIDANCE;
-	status->IconChangeTable[SC_FOOD_BASICHIT] = SI_FOOD_BASICHIT;
-	status->IconChangeTable[SC_MANU_ATK] = SI_MANU_ATK;
-	status->IconChangeTable[SC_MANU_DEF] = SI_MANU_DEF;
-	status->IconChangeTable[SC_SPL_ATK] = SI_SPL_ATK;
-	status->IconChangeTable[SC_SPL_DEF] = SI_SPL_DEF;
-	status->IconChangeTable[SC_MANU_MATK] = SI_MANU_MATK;
-	status->IconChangeTable[SC_SPL_MATK] = SI_SPL_MATK;
-	status->IconChangeTable[SC_PLUSATTACKPOWER] = SI_PLUSATTACKPOWER;
-	status->IconChangeTable[SC_PLUSMAGICPOWER] = SI_PLUSMAGICPOWER;
+	status->dbs->IconChangeTable[SC_WEIGHTOVER50] = SI_WEIGHTOVER50;
+	status->dbs->IconChangeTable[SC_WEIGHTOVER90] = SI_WEIGHTOVER90;
+	status->dbs->IconChangeTable[SC_ATTHASTE_POTION1] = SI_ATTHASTE_POTION1;
+	status->dbs->IconChangeTable[SC_ATTHASTE_POTION2] = SI_ATTHASTE_POTION2;
+	status->dbs->IconChangeTable[SC_ATTHASTE_POTION3] = SI_ATTHASTE_POTION3;
+	status->dbs->IconChangeTable[SC_ATTHASTE_INFINITY] = SI_ATTHASTE_INFINITY;
+	status->dbs->IconChangeTable[SC_MOVHASTE_HORSE] = SI_MOVHASTE_HORSE;
+	status->dbs->IconChangeTable[SC_MOVHASTE_INFINITY] = SI_MOVHASTE_INFINITY;
+	status->dbs->IconChangeTable[SC_CHASEWALK2] = SI_INCSTR;
+	status->dbs->IconChangeTable[SC_MIRACLE] = SI_SOULLINK;
+	status->dbs->IconChangeTable[SC_CLAIRVOYANCE] = SI_CLAIRVOYANCE;
+	status->dbs->IconChangeTable[SC_FOOD_STR] = SI_FOOD_STR;
+	status->dbs->IconChangeTable[SC_FOOD_AGI] = SI_FOOD_AGI;
+	status->dbs->IconChangeTable[SC_FOOD_VIT] = SI_FOOD_VIT;
+	status->dbs->IconChangeTable[SC_FOOD_INT] = SI_FOOD_INT;
+	status->dbs->IconChangeTable[SC_FOOD_DEX] = SI_FOOD_DEX;
+	status->dbs->IconChangeTable[SC_FOOD_LUK] = SI_FOOD_LUK;
+	status->dbs->IconChangeTable[SC_FOOD_BASICAVOIDANCE]= SI_FOOD_BASICAVOIDANCE;
+	status->dbs->IconChangeTable[SC_FOOD_BASICHIT] = SI_FOOD_BASICHIT;
+	status->dbs->IconChangeTable[SC_MANU_ATK] = SI_MANU_ATK;
+	status->dbs->IconChangeTable[SC_MANU_DEF] = SI_MANU_DEF;
+	status->dbs->IconChangeTable[SC_SPL_ATK] = SI_SPL_ATK;
+	status->dbs->IconChangeTable[SC_SPL_DEF] = SI_SPL_DEF;
+	status->dbs->IconChangeTable[SC_MANU_MATK] = SI_MANU_MATK;
+	status->dbs->IconChangeTable[SC_SPL_MATK] = SI_SPL_MATK;
+	status->dbs->IconChangeTable[SC_PLUSATTACKPOWER] = SI_PLUSATTACKPOWER;
+	status->dbs->IconChangeTable[SC_PLUSMAGICPOWER] = SI_PLUSMAGICPOWER;
 	//Cash Items
-	status->IconChangeTable[SC_FOOD_STR_CASH] = SI_FOOD_STR_CASH;
-	status->IconChangeTable[SC_FOOD_AGI_CASH] = SI_FOOD_AGI_CASH;
-	status->IconChangeTable[SC_FOOD_VIT_CASH] = SI_FOOD_VIT_CASH;
-	status->IconChangeTable[SC_FOOD_DEX_CASH] = SI_FOOD_DEX_CASH;
-	status->IconChangeTable[SC_FOOD_INT_CASH] = SI_FOOD_INT_CASH;
-	status->IconChangeTable[SC_FOOD_LUK_CASH] = SI_FOOD_LUK_CASH;
-	status->IconChangeTable[SC_CASH_PLUSEXP] = SI_CASH_PLUSEXP;
-	status->IconChangeTable[SC_CASH_RECEIVEITEM] = SI_CASH_RECEIVEITEM;
-	status->IconChangeTable[SC_CASH_PLUSONLYJOBEXP] = SI_CASH_PLUSONLYJOBEXP;
-	status->IconChangeTable[SC_CASH_DEATHPENALTY] = SI_CASH_DEATHPENALTY;
-	status->IconChangeTable[SC_CASH_BOSS_ALARM] = SI_CASH_BOSS_ALARM;
-	status->IconChangeTable[SC_PROTECT_DEF] = SI_PROTECT_DEF;
-	status->IconChangeTable[SC_PROTECT_MDEF] = SI_PROTECT_MDEF;
-	status->IconChangeTable[SC_CRITICALPERCENT] = SI_CRITICALPERCENT;
-	status->IconChangeTable[SC_PLUSAVOIDVALUE] = SI_PLUSAVOIDVALUE;
-	status->IconChangeTable[SC_HEALPLUS] = SI_HEALPLUS;
-	status->IconChangeTable[SC_S_LIFEPOTION] = SI_S_LIFEPOTION;
-	status->IconChangeTable[SC_L_LIFEPOTION] = SI_L_LIFEPOTION;
-	status->IconChangeTable[SC_ATKER_BLOOD] = SI_ATKER_BLOOD;
-	status->IconChangeTable[SC_TARGET_BLOOD] = SI_TARGET_BLOOD;
+	status->dbs->IconChangeTable[SC_FOOD_STR_CASH] = SI_FOOD_STR_CASH;
+	status->dbs->IconChangeTable[SC_FOOD_AGI_CASH] = SI_FOOD_AGI_CASH;
+	status->dbs->IconChangeTable[SC_FOOD_VIT_CASH] = SI_FOOD_VIT_CASH;
+	status->dbs->IconChangeTable[SC_FOOD_DEX_CASH] = SI_FOOD_DEX_CASH;
+	status->dbs->IconChangeTable[SC_FOOD_INT_CASH] = SI_FOOD_INT_CASH;
+	status->dbs->IconChangeTable[SC_FOOD_LUK_CASH] = SI_FOOD_LUK_CASH;
+	status->dbs->IconChangeTable[SC_CASH_PLUSEXP] = SI_CASH_PLUSEXP;
+	status->dbs->IconChangeTable[SC_CASH_RECEIVEITEM] = SI_CASH_RECEIVEITEM;
+	status->dbs->IconChangeTable[SC_CASH_PLUSONLYJOBEXP] = SI_CASH_PLUSONLYJOBEXP;
+	status->dbs->IconChangeTable[SC_CASH_DEATHPENALTY] = SI_CASH_DEATHPENALTY;
+	status->dbs->IconChangeTable[SC_CASH_BOSS_ALARM] = SI_CASH_BOSS_ALARM;
+	status->dbs->IconChangeTable[SC_PROTECT_DEF] = SI_PROTECT_DEF;
+	status->dbs->IconChangeTable[SC_PROTECT_MDEF] = SI_PROTECT_MDEF;
+	status->dbs->IconChangeTable[SC_CRITICALPERCENT] = SI_CRITICALPERCENT;
+	status->dbs->IconChangeTable[SC_PLUSAVOIDVALUE] = SI_PLUSAVOIDVALUE;
+	status->dbs->IconChangeTable[SC_HEALPLUS] = SI_HEALPLUS;
+	status->dbs->IconChangeTable[SC_S_LIFEPOTION] = SI_S_LIFEPOTION;
+	status->dbs->IconChangeTable[SC_L_LIFEPOTION] = SI_L_LIFEPOTION;
+	status->dbs->IconChangeTable[SC_ATKER_BLOOD] = SI_ATKER_BLOOD;
+	status->dbs->IconChangeTable[SC_TARGET_BLOOD] = SI_TARGET_BLOOD;
 	// Mercenary Bonus Effects
-	status->IconChangeTable[SC_MER_FLEE] = SI_MER_FLEE;
-	status->IconChangeTable[SC_MER_ATK] = SI_MER_ATK;
-	status->IconChangeTable[SC_MER_HP] = SI_MER_HP;
-	status->IconChangeTable[SC_MER_SP] = SI_MER_SP;
-	status->IconChangeTable[SC_MER_HIT] = SI_MER_HIT;
+	status->dbs->IconChangeTable[SC_MER_FLEE] = SI_MER_FLEE;
+	status->dbs->IconChangeTable[SC_MER_ATK] = SI_MER_ATK;
+	status->dbs->IconChangeTable[SC_MER_HP] = SI_MER_HP;
+	status->dbs->IconChangeTable[SC_MER_SP] = SI_MER_SP;
+	status->dbs->IconChangeTable[SC_MER_HIT] = SI_MER_HIT;
 	// Warlock Spheres
-	status->IconChangeTable[SC_SUMMON1] = SI_SPHERE_1;
-	status->IconChangeTable[SC_SUMMON2] = SI_SPHERE_2;
-	status->IconChangeTable[SC_SUMMON3] = SI_SPHERE_3;
-	status->IconChangeTable[SC_SUMMON4] = SI_SPHERE_4;
-	status->IconChangeTable[SC_SUMMON5] = SI_SPHERE_5;
+	status->dbs->IconChangeTable[SC_SUMMON1] = SI_SPHERE_1;
+	status->dbs->IconChangeTable[SC_SUMMON2] = SI_SPHERE_2;
+	status->dbs->IconChangeTable[SC_SUMMON3] = SI_SPHERE_3;
+	status->dbs->IconChangeTable[SC_SUMMON4] = SI_SPHERE_4;
+	status->dbs->IconChangeTable[SC_SUMMON5] = SI_SPHERE_5;
 	// Warlock Preserved spells
-	status->IconChangeTable[SC_SPELLBOOK1] = SI_SPELLBOOK1;
-	status->IconChangeTable[SC_SPELLBOOK2] = SI_SPELLBOOK2;
-	status->IconChangeTable[SC_SPELLBOOK3] = SI_SPELLBOOK3;
-	status->IconChangeTable[SC_SPELLBOOK4] = SI_SPELLBOOK4;
-	status->IconChangeTable[SC_SPELLBOOK5] = SI_SPELLBOOK5;
-	status->IconChangeTable[SC_SPELLBOOK6] = SI_SPELLBOOK6;
-	status->IconChangeTable[SC_SPELLBOOK7] = SI_SPELLBOOK7;
-
-	status->IconChangeTable[SC_NEUTRALBARRIER_MASTER] = SI_NEUTRALBARRIER_MASTER;
-	status->IconChangeTable[SC_STEALTHFIELD_MASTER] = SI_STEALTHFIELD_MASTER;
-	status->IconChangeTable[SC_OVERHEAT] = SI_OVERHEAT;
-	status->IconChangeTable[SC_OVERHEAT_LIMITPOINT] = SI_OVERHEAT_LIMITPOINT;
-
-	status->IconChangeTable[SC_HALLUCINATIONWALK_POSTDELAY] = SI_HALLUCINATIONWALK_POSTDELAY;
-	status->IconChangeTable[SC_TOXIN] = SI_TOXIN;
-	status->IconChangeTable[SC_PARALYSE] = SI_PARALYSE;
-	status->IconChangeTable[SC_VENOMBLEED] = SI_VENOMBLEED;
-	status->IconChangeTable[SC_MAGICMUSHROOM] = SI_MAGICMUSHROOM;
-	status->IconChangeTable[SC_DEATHHURT] = SI_DEATHHURT;
-	status->IconChangeTable[SC_PYREXIA] = SI_PYREXIA;
-	status->IconChangeTable[SC_OBLIVIONCURSE] = SI_OBLIVIONCURSE;
-	status->IconChangeTable[SC_LEECHESEND] = SI_LEECHESEND;
-
-	status->IconChangeTable[SC_SHIELDSPELL_DEF] = SI_SHIELDSPELL_DEF;
-	status->IconChangeTable[SC_SHIELDSPELL_MDEF] = SI_SHIELDSPELL_MDEF;
-	status->IconChangeTable[SC_SHIELDSPELL_REF] = SI_SHIELDSPELL_REF;
-	status->IconChangeTable[SC_BANDING_DEFENCE] = SI_BANDING_DEFENCE;
-
-	status->IconChangeTable[SC_CURSEDCIRCLE_ATKER] = SI_CURSEDCIRCLE_ATKER;
-
-	status->IconChangeTable[SC_STOMACHACHE] = SI_STOMACHACHE;
-	status->IconChangeTable[SC_MYSTERIOUS_POWDER] = SI_MYSTERIOUS_POWDER;
-	status->IconChangeTable[SC_MELON_BOMB] = SI_MELON_BOMB;
-	status->IconChangeTable[SC_BANANA_BOMB] = SI_BANANA_BOMB;
-	status->IconChangeTable[SC_BANANA_BOMB_SITDOWN_POSTDELAY] = SI_BANANA_BOMB_SITDOWN_POSTDELAY;
+	status->dbs->IconChangeTable[SC_SPELLBOOK1] = SI_SPELLBOOK1;
+	status->dbs->IconChangeTable[SC_SPELLBOOK2] = SI_SPELLBOOK2;
+	status->dbs->IconChangeTable[SC_SPELLBOOK3] = SI_SPELLBOOK3;
+	status->dbs->IconChangeTable[SC_SPELLBOOK4] = SI_SPELLBOOK4;
+	status->dbs->IconChangeTable[SC_SPELLBOOK5] = SI_SPELLBOOK5;
+	status->dbs->IconChangeTable[SC_SPELLBOOK6] = SI_SPELLBOOK6;
+	status->dbs->IconChangeTable[SC_SPELLBOOK7] = SI_SPELLBOOK7;
+
+	status->dbs->IconChangeTable[SC_NEUTRALBARRIER_MASTER] = SI_NEUTRALBARRIER_MASTER;
+	status->dbs->IconChangeTable[SC_STEALTHFIELD_MASTER] = SI_STEALTHFIELD_MASTER;
+	status->dbs->IconChangeTable[SC_OVERHEAT] = SI_OVERHEAT;
+	status->dbs->IconChangeTable[SC_OVERHEAT_LIMITPOINT] = SI_OVERHEAT_LIMITPOINT;
+
+	status->dbs->IconChangeTable[SC_HALLUCINATIONWALK_POSTDELAY] = SI_HALLUCINATIONWALK_POSTDELAY;
+	status->dbs->IconChangeTable[SC_TOXIN] = SI_TOXIN;
+	status->dbs->IconChangeTable[SC_PARALYSE] = SI_PARALYSE;
+	status->dbs->IconChangeTable[SC_VENOMBLEED] = SI_VENOMBLEED;
+	status->dbs->IconChangeTable[SC_MAGICMUSHROOM] = SI_MAGICMUSHROOM;
+	status->dbs->IconChangeTable[SC_DEATHHURT] = SI_DEATHHURT;
+	status->dbs->IconChangeTable[SC_PYREXIA] = SI_PYREXIA;
+	status->dbs->IconChangeTable[SC_OBLIVIONCURSE] = SI_OBLIVIONCURSE;
+	status->dbs->IconChangeTable[SC_LEECHESEND] = SI_LEECHESEND;
+
+	status->dbs->IconChangeTable[SC_SHIELDSPELL_DEF] = SI_SHIELDSPELL_DEF;
+	status->dbs->IconChangeTable[SC_SHIELDSPELL_MDEF] = SI_SHIELDSPELL_MDEF;
+	status->dbs->IconChangeTable[SC_SHIELDSPELL_REF] = SI_SHIELDSPELL_REF;
+	status->dbs->IconChangeTable[SC_BANDING_DEFENCE] = SI_BANDING_DEFENCE;
+
+	status->dbs->IconChangeTable[SC_CURSEDCIRCLE_ATKER] = SI_CURSEDCIRCLE_ATKER;
+
+	status->dbs->IconChangeTable[SC_STOMACHACHE] = SI_STOMACHACHE;
+	status->dbs->IconChangeTable[SC_MYSTERIOUS_POWDER] = SI_MYSTERIOUS_POWDER;
+	status->dbs->IconChangeTable[SC_MELON_BOMB] = SI_MELON_BOMB;
+	status->dbs->IconChangeTable[SC_BANANA_BOMB] = SI_BANANA_BOMB;
+	status->dbs->IconChangeTable[SC_BANANA_BOMB_SITDOWN_POSTDELAY] = SI_BANANA_BOMB_SITDOWN_POSTDELAY;
 
 	//Genetics New Food Items Status Icons
-	status->IconChangeTable[SC_SAVAGE_STEAK] = SI_SAVAGE_STEAK;
-	status->IconChangeTable[SC_COCKTAIL_WARG_BLOOD] = SI_COCKTAIL_WARG_BLOOD;
-	status->IconChangeTable[SC_MINOR_BBQ] = SI_MINOR_BBQ;
-	status->IconChangeTable[SC_SIROMA_ICE_TEA] = SI_SIROMA_ICE_TEA;
-	status->IconChangeTable[SC_DROCERA_HERB_STEAMED] = SI_DROCERA_HERB_STEAMED;
-	status->IconChangeTable[SC_PUTTI_TAILS_NOODLES] = SI_PUTTI_TAILS_NOODLES;
-
-	status->IconChangeTable[SC_BOOST500] |= SI_BOOST500;
-	status->IconChangeTable[SC_FULL_SWING_K] |= SI_FULL_SWING_K;
-	status->IconChangeTable[SC_MANA_PLUS] |= SI_MANA_PLUS;
-	status->IconChangeTable[SC_MUSTLE_M] |= SI_MUSTLE_M;
-	status->IconChangeTable[SC_LIFE_FORCE_F] |= SI_LIFE_FORCE_F;
-	status->IconChangeTable[SC_EXTRACT_WHITE_POTION_Z] |= SI_EXTRACT_WHITE_POTION_Z;
-	status->IconChangeTable[SC_VITATA_500] |= SI_VITATA_500;
-	status->IconChangeTable[SC_EXTRACT_SALAMINE_JUICE] |= SI_EXTRACT_SALAMINE_JUICE;
+	status->dbs->IconChangeTable[SC_SAVAGE_STEAK] = SI_SAVAGE_STEAK;
+	status->dbs->IconChangeTable[SC_COCKTAIL_WARG_BLOOD] = SI_COCKTAIL_WARG_BLOOD;
+	status->dbs->IconChangeTable[SC_MINOR_BBQ] = SI_MINOR_BBQ;
+	status->dbs->IconChangeTable[SC_SIROMA_ICE_TEA] = SI_SIROMA_ICE_TEA;
+	status->dbs->IconChangeTable[SC_DROCERA_HERB_STEAMED] = SI_DROCERA_HERB_STEAMED;
+	status->dbs->IconChangeTable[SC_PUTTI_TAILS_NOODLES] = SI_PUTTI_TAILS_NOODLES;
+
+	status->dbs->IconChangeTable[SC_BOOST500] |= SI_BOOST500;
+	status->dbs->IconChangeTable[SC_FULL_SWING_K] |= SI_FULL_SWING_K;
+	status->dbs->IconChangeTable[SC_MANA_PLUS] |= SI_MANA_PLUS;
+	status->dbs->IconChangeTable[SC_MUSTLE_M] |= SI_MUSTLE_M;
+	status->dbs->IconChangeTable[SC_LIFE_FORCE_F] |= SI_LIFE_FORCE_F;
+	status->dbs->IconChangeTable[SC_EXTRACT_WHITE_POTION_Z] |= SI_EXTRACT_WHITE_POTION_Z;
+	status->dbs->IconChangeTable[SC_VITATA_500] |= SI_VITATA_500;
+	status->dbs->IconChangeTable[SC_EXTRACT_SALAMINE_JUICE] |= SI_EXTRACT_SALAMINE_JUICE;
 
 	// Elemental Spirit's 'side' status change icons.
-	status->IconChangeTable[SC_CIRCLE_OF_FIRE] = SI_CIRCLE_OF_FIRE;
-	status->IconChangeTable[SC_FIRE_CLOAK] = SI_FIRE_CLOAK;
-	status->IconChangeTable[SC_WATER_SCREEN] = SI_WATER_SCREEN;
-	status->IconChangeTable[SC_WATER_DROP] = SI_WATER_DROP;
-	status->IconChangeTable[SC_WIND_STEP] = SI_WIND_STEP;
-	status->IconChangeTable[SC_WIND_CURTAIN] = SI_WIND_CURTAIN;
-	status->IconChangeTable[SC_SOLID_SKIN] = SI_SOLID_SKIN;
-	status->IconChangeTable[SC_STONE_SHIELD] = SI_STONE_SHIELD;
-	status->IconChangeTable[SC_PYROTECHNIC] = SI_PYROTECHNIC;
-	status->IconChangeTable[SC_HEATER] = SI_HEATER;
-	status->IconChangeTable[SC_TROPIC] = SI_TROPIC;
-	status->IconChangeTable[SC_AQUAPLAY] = SI_AQUAPLAY;
-	status->IconChangeTable[SC_COOLER] = SI_COOLER;
-	status->IconChangeTable[SC_CHILLY_AIR] = SI_CHILLY_AIR;
-	status->IconChangeTable[SC_GUST] = SI_GUST;
-	status->IconChangeTable[SC_BLAST] = SI_BLAST;
-	status->IconChangeTable[SC_WILD_STORM] = SI_WILD_STORM;
-	status->IconChangeTable[SC_PETROLOGY] = SI_PETROLOGY;
-	status->IconChangeTable[SC_CURSED_SOIL] = SI_CURSED_SOIL;
-	status->IconChangeTable[SC_UPHEAVAL] = SI_UPHEAVAL;
-	status->IconChangeTable[SC_PUSH_CART] = SI_ON_PUSH_CART;
-	status->IconChangeTable[SC_REBOUND] = SI_REBOUND;
-	status->IconChangeTable[SC_ALL_RIDING] = SI_ALL_RIDING;
-	status->IconChangeTable[SC_MONSTER_TRANSFORM] = SI_MONSTER_TRANSFORM;
-	status->IconChangeTable[SC_MOONSTAR] = SI_MOONSTAR;
-	status->IconChangeTable[SC_SUPER_STAR] = SI_SUPER_STAR;
-	status->IconChangeTable[SC_STRANGELIGHTS] = SI_STRANGELIGHTS;
-	status->IconChangeTable[SC_DECORATION_OF_MUSIC] = SI_DECORATION_OF_MUSIC;
+	status->dbs->IconChangeTable[SC_CIRCLE_OF_FIRE] = SI_CIRCLE_OF_FIRE;
+	status->dbs->IconChangeTable[SC_FIRE_CLOAK] = SI_FIRE_CLOAK;
+	status->dbs->IconChangeTable[SC_WATER_SCREEN] = SI_WATER_SCREEN;
+	status->dbs->IconChangeTable[SC_WATER_DROP] = SI_WATER_DROP;
+	status->dbs->IconChangeTable[SC_WIND_STEP] = SI_WIND_STEP;
+	status->dbs->IconChangeTable[SC_WIND_CURTAIN] = SI_WIND_CURTAIN;
+	status->dbs->IconChangeTable[SC_SOLID_SKIN] = SI_SOLID_SKIN;
+	status->dbs->IconChangeTable[SC_STONE_SHIELD] = SI_STONE_SHIELD;
+	status->dbs->IconChangeTable[SC_PYROTECHNIC] = SI_PYROTECHNIC;
+	status->dbs->IconChangeTable[SC_HEATER] = SI_HEATER;
+	status->dbs->IconChangeTable[SC_TROPIC] = SI_TROPIC;
+	status->dbs->IconChangeTable[SC_AQUAPLAY] = SI_AQUAPLAY;
+	status->dbs->IconChangeTable[SC_COOLER] = SI_COOLER;
+	status->dbs->IconChangeTable[SC_CHILLY_AIR] = SI_CHILLY_AIR;
+	status->dbs->IconChangeTable[SC_GUST] = SI_GUST;
+	status->dbs->IconChangeTable[SC_BLAST] = SI_BLAST;
+	status->dbs->IconChangeTable[SC_WILD_STORM] = SI_WILD_STORM;
+	status->dbs->IconChangeTable[SC_PETROLOGY] = SI_PETROLOGY;
+	status->dbs->IconChangeTable[SC_CURSED_SOIL] = SI_CURSED_SOIL;
+	status->dbs->IconChangeTable[SC_UPHEAVAL] = SI_UPHEAVAL;
+	status->dbs->IconChangeTable[SC_PUSH_CART] = SI_ON_PUSH_CART;
+	status->dbs->IconChangeTable[SC_REBOUND] = SI_REBOUND;
+	status->dbs->IconChangeTable[SC_ALL_RIDING] = SI_ALL_RIDING;
+	status->dbs->IconChangeTable[SC_MONSTER_TRANSFORM] = SI_MONSTER_TRANSFORM;
+	status->dbs->IconChangeTable[SC_MOONSTAR] = SI_MOONSTAR;
+	status->dbs->IconChangeTable[SC_SUPER_STAR] = SI_SUPER_STAR;
+	status->dbs->IconChangeTable[SC_STRANGELIGHTS] = SI_STRANGELIGHTS;
+	status->dbs->IconChangeTable[SC_DECORATION_OF_MUSIC] = SI_DECORATION_OF_MUSIC;
 
 	//Other SC which are not necessarily associated to skills.
-	status->ChangeFlagTable[SC_ATTHASTE_POTION1] = SCB_ASPD;
-	status->ChangeFlagTable[SC_ATTHASTE_POTION2] = SCB_ASPD;
-	status->ChangeFlagTable[SC_ATTHASTE_POTION3] = SCB_ASPD;
-	status->ChangeFlagTable[SC_ATTHASTE_INFINITY] = SCB_ASPD;
-	status->ChangeFlagTable[SC_MOVHASTE_HORSE] = SCB_SPEED;
-	status->ChangeFlagTable[SC_MOVHASTE_INFINITY] = SCB_SPEED;
-	status->ChangeFlagTable[SC_PLUSATTACKPOWER] = SCB_BATK;
-	status->ChangeFlagTable[SC_PLUSMAGICPOWER] = SCB_MATK;
-	status->ChangeFlagTable[SC_INCALLSTATUS] |= SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK;
-	status->ChangeFlagTable[SC_CHASEWALK2] |= SCB_STR;
-	status->ChangeFlagTable[SC_INCAGI] |= SCB_AGI;
-	status->ChangeFlagTable[SC_INCVIT] |= SCB_VIT;
-	status->ChangeFlagTable[SC_INCINT] |= SCB_INT;
-	status->ChangeFlagTable[SC_INCDEX] |= SCB_DEX;
-	status->ChangeFlagTable[SC_INCLUK] |= SCB_LUK;
-	status->ChangeFlagTable[SC_INCHIT] |= SCB_HIT;
-	status->ChangeFlagTable[SC_INCHITRATE] |= SCB_HIT;
-	status->ChangeFlagTable[SC_INCFLEE] |= SCB_FLEE;
-	status->ChangeFlagTable[SC_INCFLEERATE] |= SCB_FLEE;
-	status->ChangeFlagTable[SC_MTF_HITFLEE] |= SCB_HIT|SCB_FLEE;
-	status->ChangeFlagTable[SC_CRITICALPERCENT] |= SCB_CRI;
-	status->ChangeFlagTable[SC_INCASPDRATE] |= SCB_ASPD;
-	status->ChangeFlagTable[SC_PLUSAVOIDVALUE] |= SCB_FLEE2;
-	status->ChangeFlagTable[SC_INCMHPRATE] |= SCB_MAXHP;
-	status->ChangeFlagTable[SC_INCMSPRATE] |= SCB_MAXSP;
-	status->ChangeFlagTable[SC_INCMHP] |= SCB_MAXHP;
-	status->ChangeFlagTable[SC_MTF_MHP] |= SCB_MAXHP;
-	status->ChangeFlagTable[SC_INCMSP] |= SCB_MAXSP;
-	status->ChangeFlagTable[SC_MTF_MSP] |= SCB_MAXSP;
-	status->ChangeFlagTable[SC_INCATKRATE] |= SCB_BATK|SCB_WATK;
-	status->ChangeFlagTable[SC_INCMATKRATE] |= SCB_MATK;
-	status->ChangeFlagTable[SC_INCDEFRATE] |= SCB_DEF;
-	status->ChangeFlagTable[SC_FOOD_STR] |= SCB_STR;
-	status->ChangeFlagTable[SC_FOOD_AGI] |= SCB_AGI;
-	status->ChangeFlagTable[SC_FOOD_VIT] |= SCB_VIT;
-	status->ChangeFlagTable[SC_FOOD_INT] |= SCB_INT;
-	status->ChangeFlagTable[SC_FOOD_DEX] |= SCB_DEX;
-	status->ChangeFlagTable[SC_FOOD_LUK] |= SCB_LUK;
-	status->ChangeFlagTable[SC_FOOD_BASICHIT] |= SCB_HIT;
-	status->ChangeFlagTable[SC_FOOD_BASICAVOIDANCE] |= SCB_FLEE;
-	status->ChangeFlagTable[SC_BATKFOOD] |= SCB_BATK;
-	status->ChangeFlagTable[SC_WATKFOOD] |= SCB_WATK;
-	status->ChangeFlagTable[SC_MATKFOOD] |= SCB_MATK;
-	status->ChangeFlagTable[SC_ARMORPROPERTY] |= SCB_ALL;
-	status->ChangeFlagTable[SC_ARMOR_RESIST] |= SCB_ALL;
-	status->ChangeFlagTable[SC_ATKER_BLOOD] |= SCB_ALL;
-	status->ChangeFlagTable[SC_WALKSPEED] |= SCB_SPEED;
-	status->ChangeFlagTable[SC_ITEMSCRIPT] |= SCB_ALL;
+	status->dbs->ChangeFlagTable[SC_ATTHASTE_POTION1] = SCB_ASPD;
+	status->dbs->ChangeFlagTable[SC_ATTHASTE_POTION2] = SCB_ASPD;
+	status->dbs->ChangeFlagTable[SC_ATTHASTE_POTION3] = SCB_ASPD;
+	status->dbs->ChangeFlagTable[SC_ATTHASTE_INFINITY] = SCB_ASPD;
+	status->dbs->ChangeFlagTable[SC_MOVHASTE_HORSE] = SCB_SPEED;
+	status->dbs->ChangeFlagTable[SC_MOVHASTE_INFINITY] = SCB_SPEED;
+	status->dbs->ChangeFlagTable[SC_PLUSATTACKPOWER] = SCB_BATK;
+	status->dbs->ChangeFlagTable[SC_PLUSMAGICPOWER] = SCB_MATK;
+	status->dbs->ChangeFlagTable[SC_INCALLSTATUS] |= SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK;
+	status->dbs->ChangeFlagTable[SC_CHASEWALK2] |= SCB_STR;
+	status->dbs->ChangeFlagTable[SC_INCAGI] |= SCB_AGI;
+	status->dbs->ChangeFlagTable[SC_INCVIT] |= SCB_VIT;
+	status->dbs->ChangeFlagTable[SC_INCINT] |= SCB_INT;
+	status->dbs->ChangeFlagTable[SC_INCDEX] |= SCB_DEX;
+	status->dbs->ChangeFlagTable[SC_INCLUK] |= SCB_LUK;
+	status->dbs->ChangeFlagTable[SC_INCHIT] |= SCB_HIT;
+	status->dbs->ChangeFlagTable[SC_INCHITRATE] |= SCB_HIT;
+	status->dbs->ChangeFlagTable[SC_INCFLEE] |= SCB_FLEE;
+	status->dbs->ChangeFlagTable[SC_INCFLEERATE] |= SCB_FLEE;
+	status->dbs->ChangeFlagTable[SC_MTF_HITFLEE] |= SCB_HIT|SCB_FLEE;
+	status->dbs->ChangeFlagTable[SC_CRITICALPERCENT] |= SCB_CRI;
+	status->dbs->ChangeFlagTable[SC_INCASPDRATE] |= SCB_ASPD;
+	status->dbs->ChangeFlagTable[SC_PLUSAVOIDVALUE] |= SCB_FLEE2;
+	status->dbs->ChangeFlagTable[SC_INCMHPRATE] |= SCB_MAXHP;
+	status->dbs->ChangeFlagTable[SC_INCMSPRATE] |= SCB_MAXSP;
+	status->dbs->ChangeFlagTable[SC_INCMHP] |= SCB_MAXHP;
+	status->dbs->ChangeFlagTable[SC_MTF_MHP] |= SCB_MAXHP;
+	status->dbs->ChangeFlagTable[SC_INCMSP] |= SCB_MAXSP;
+	status->dbs->ChangeFlagTable[SC_MTF_MSP] |= SCB_MAXSP;
+	status->dbs->ChangeFlagTable[SC_INCATKRATE] |= SCB_BATK|SCB_WATK;
+	status->dbs->ChangeFlagTable[SC_INCMATKRATE] |= SCB_MATK;
+	status->dbs->ChangeFlagTable[SC_INCDEFRATE] |= SCB_DEF;
+	status->dbs->ChangeFlagTable[SC_FOOD_STR] |= SCB_STR;
+	status->dbs->ChangeFlagTable[SC_FOOD_AGI] |= SCB_AGI;
+	status->dbs->ChangeFlagTable[SC_FOOD_VIT] |= SCB_VIT;
+	status->dbs->ChangeFlagTable[SC_FOOD_INT] |= SCB_INT;
+	status->dbs->ChangeFlagTable[SC_FOOD_DEX] |= SCB_DEX;
+	status->dbs->ChangeFlagTable[SC_FOOD_LUK] |= SCB_LUK;
+	status->dbs->ChangeFlagTable[SC_FOOD_BASICHIT] |= SCB_HIT;
+	status->dbs->ChangeFlagTable[SC_FOOD_BASICAVOIDANCE] |= SCB_FLEE;
+	status->dbs->ChangeFlagTable[SC_BATKFOOD] |= SCB_BATK;
+	status->dbs->ChangeFlagTable[SC_WATKFOOD] |= SCB_WATK;
+	status->dbs->ChangeFlagTable[SC_MATKFOOD] |= SCB_MATK;
+	status->dbs->ChangeFlagTable[SC_ARMORPROPERTY] |= SCB_ALL;
+	status->dbs->ChangeFlagTable[SC_ARMOR_RESIST] |= SCB_ALL;
+	status->dbs->ChangeFlagTable[SC_ATKER_BLOOD] |= SCB_ALL;
+	status->dbs->ChangeFlagTable[SC_WALKSPEED] |= SCB_SPEED;
+	status->dbs->ChangeFlagTable[SC_ITEMSCRIPT] |= SCB_ALL;
 	// Cash Items
-	status->ChangeFlagTable[SC_FOOD_STR_CASH] = SCB_STR;
-	status->ChangeFlagTable[SC_FOOD_AGI_CASH] = SCB_AGI;
-	status->ChangeFlagTable[SC_FOOD_VIT_CASH] = SCB_VIT;
-	status->ChangeFlagTable[SC_FOOD_DEX_CASH] = SCB_DEX;
-	status->ChangeFlagTable[SC_FOOD_INT_CASH] = SCB_INT;
-	status->ChangeFlagTable[SC_FOOD_LUK_CASH] = SCB_LUK;
+	status->dbs->ChangeFlagTable[SC_FOOD_STR_CASH] = SCB_STR;
+	status->dbs->ChangeFlagTable[SC_FOOD_AGI_CASH] = SCB_AGI;
+	status->dbs->ChangeFlagTable[SC_FOOD_VIT_CASH] = SCB_VIT;
+	status->dbs->ChangeFlagTable[SC_FOOD_DEX_CASH] = SCB_DEX;
+	status->dbs->ChangeFlagTable[SC_FOOD_INT_CASH] = SCB_INT;
+	status->dbs->ChangeFlagTable[SC_FOOD_LUK_CASH] = SCB_LUK;
 	// Mercenary Bonus Effects
-	status->ChangeFlagTable[SC_MER_FLEE] |= SCB_FLEE;
-	status->ChangeFlagTable[SC_MER_ATK] |= SCB_WATK;
-	status->ChangeFlagTable[SC_MER_HP] |= SCB_MAXHP;
-	status->ChangeFlagTable[SC_MER_SP] |= SCB_MAXSP;
-	status->ChangeFlagTable[SC_MER_HIT] |= SCB_HIT;
+	status->dbs->ChangeFlagTable[SC_MER_FLEE] |= SCB_FLEE;
+	status->dbs->ChangeFlagTable[SC_MER_ATK] |= SCB_WATK;
+	status->dbs->ChangeFlagTable[SC_MER_HP] |= SCB_MAXHP;
+	status->dbs->ChangeFlagTable[SC_MER_SP] |= SCB_MAXSP;
+	status->dbs->ChangeFlagTable[SC_MER_HIT] |= SCB_HIT;
 	// Guillotine Cross Poison Effects
-	status->ChangeFlagTable[SC_PARALYSE] |= SCB_FLEE|SCB_SPEED|SCB_ASPD;
-	status->ChangeFlagTable[SC_VENOMBLEED] |= SCB_MAXHP;
-	status->ChangeFlagTable[SC_MAGICMUSHROOM] |= SCB_REGEN;
-	status->ChangeFlagTable[SC_DEATHHURT] |= SCB_REGEN;
-	status->ChangeFlagTable[SC_PYREXIA] |= SCB_HIT|SCB_FLEE;
-	status->ChangeFlagTable[SC_OBLIVIONCURSE] |= SCB_REGEN;
+	status->dbs->ChangeFlagTable[SC_PARALYSE] |= SCB_FLEE|SCB_SPEED|SCB_ASPD;
+	status->dbs->ChangeFlagTable[SC_VENOMBLEED] |= SCB_MAXHP;
+	status->dbs->ChangeFlagTable[SC_MAGICMUSHROOM] |= SCB_REGEN;
+	status->dbs->ChangeFlagTable[SC_DEATHHURT] |= SCB_REGEN;
+	status->dbs->ChangeFlagTable[SC_PYREXIA] |= SCB_HIT|SCB_FLEE;
+	status->dbs->ChangeFlagTable[SC_OBLIVIONCURSE] |= SCB_REGEN;
 	// RG status
-	status->ChangeFlagTable[SC_SHIELDSPELL_DEF] |= SCB_WATK;
-	status->ChangeFlagTable[SC_SHIELDSPELL_REF] |= SCB_DEF;
+	status->dbs->ChangeFlagTable[SC_SHIELDSPELL_DEF] |= SCB_WATK;
+	status->dbs->ChangeFlagTable[SC_SHIELDSPELL_REF] |= SCB_DEF;
 	// Meca status
-	status->ChangeFlagTable[SC_STEALTHFIELD_MASTER] |= SCB_SPEED;
-
-	status->ChangeFlagTable[SC_SAVAGE_STEAK] |= SCB_STR;
-	status->ChangeFlagTable[SC_COCKTAIL_WARG_BLOOD] |= SCB_INT;
-	status->ChangeFlagTable[SC_MINOR_BBQ] |= SCB_VIT;
-	status->ChangeFlagTable[SC_SIROMA_ICE_TEA] |= SCB_DEX;
-	status->ChangeFlagTable[SC_DROCERA_HERB_STEAMED] |= SCB_AGI;
-	status->ChangeFlagTable[SC_PUTTI_TAILS_NOODLES] |= SCB_LUK;
-	status->ChangeFlagTable[SC_BOOST500] |= SCB_ASPD;
-	status->ChangeFlagTable[SC_FULL_SWING_K] |= SCB_BATK;
-	status->ChangeFlagTable[SC_MANA_PLUS] |= SCB_MATK;
-	status->ChangeFlagTable[SC_MUSTLE_M] |= SCB_MAXHP;
-	status->ChangeFlagTable[SC_LIFE_FORCE_F] |= SCB_MAXSP;
-	status->ChangeFlagTable[SC_EXTRACT_WHITE_POTION_Z] |= SCB_REGEN;
-	status->ChangeFlagTable[SC_VITATA_500] |= SCB_REGEN;
-	status->ChangeFlagTable[SC_EXTRACT_SALAMINE_JUICE] |= SCB_ASPD;
-	status->ChangeFlagTable[SC_REBOUND] |= SCB_SPEED|SCB_REGEN;
-	status->ChangeFlagTable[SC_DEFSET] |= SCB_DEF|SCB_DEF2;
-	status->ChangeFlagTable[SC_MDEFSET] |= SCB_MDEF|SCB_MDEF2;
-	status->ChangeFlagTable[SC_MYSTERIOUS_POWDER] |= SCB_MAXHP;
-
-	status->ChangeFlagTable[SC_ALL_RIDING] = SCB_SPEED;
-	status->ChangeFlagTable[SC_WEDDING] = SCB_SPEED;
-
-	status->ChangeFlagTable[SC_MTF_ASPD] = SCB_ASPD|SCB_HIT;
-	status->ChangeFlagTable[SC_MTF_MATK] = SCB_MATK;
-	status->ChangeFlagTable[SC_MTF_MLEATKED] |= SCB_ALL;
-
-	status->ChangeFlagTable[SC_MOONSTAR] |= SCB_NONE;
-	status->ChangeFlagTable[SC_SUPER_STAR] |= SCB_NONE;
-	status->ChangeFlagTable[SC_STRANGELIGHTS] |= SCB_NONE;
-	status->ChangeFlagTable[SC_DECORATION_OF_MUSIC] |= SCB_NONE;
-
-	/* status->DisplayType Table [Ind/Hercules] */
-	status->DisplayType[SC_ALL_RIDING]          = true;
-	status->DisplayType[SC_PUSH_CART]           = true;
-	status->DisplayType[SC_SUMMON1]             = true;
-	status->DisplayType[SC_SUMMON2]             = true;
-	status->DisplayType[SC_SUMMON3]             = true;
-	status->DisplayType[SC_SUMMON4]             = true;
-	status->DisplayType[SC_SUMMON5]             = true;
-	status->DisplayType[SC_CAMOUFLAGE]          = true;
-	status->DisplayType[SC_DUPLELIGHT]          = true;
-	status->DisplayType[SC_ORATIO]              = true;
-	status->DisplayType[SC_FROSTMISTY]          = true;
-	status->DisplayType[SC_VENOMIMPRESS]        = true;
-	status->DisplayType[SC_HALLUCINATIONWALK]   = true;
-	status->DisplayType[SC_ROLLINGCUTTER]       = true;
-	status->DisplayType[SC_BANDING]             = true;
-	status->DisplayType[SC_COLD]                = true;
-	status->DisplayType[SC_DEEP_SLEEP]          = true;
-	status->DisplayType[SC_CURSEDCIRCLE_ATKER]  = true;
-	status->DisplayType[SC_CURSEDCIRCLE_TARGET] = true;
-	status->DisplayType[SC_BLOOD_SUCKER]        = true;
-	status->DisplayType[SC__SHADOWFORM]         = true;
-	status->DisplayType[SC_MONSTER_TRANSFORM]   = true;
-	status->DisplayType[SC_MOONSTAR]            = true;
-	status->DisplayType[SC_SUPER_STAR]          = true;
-	status->DisplayType[SC_STRANGELIGHTS]       = true;
-	status->DisplayType[SC_DECORATION_OF_MUSIC] = true;
+	status->dbs->ChangeFlagTable[SC_STEALTHFIELD_MASTER] |= SCB_SPEED;
+
+	status->dbs->ChangeFlagTable[SC_SAVAGE_STEAK] |= SCB_STR;
+	status->dbs->ChangeFlagTable[SC_COCKTAIL_WARG_BLOOD] |= SCB_INT;
+	status->dbs->ChangeFlagTable[SC_MINOR_BBQ] |= SCB_VIT;
+	status->dbs->ChangeFlagTable[SC_SIROMA_ICE_TEA] |= SCB_DEX;
+	status->dbs->ChangeFlagTable[SC_DROCERA_HERB_STEAMED] |= SCB_AGI;
+	status->dbs->ChangeFlagTable[SC_PUTTI_TAILS_NOODLES] |= SCB_LUK;
+	status->dbs->ChangeFlagTable[SC_BOOST500] |= SCB_ASPD;
+	status->dbs->ChangeFlagTable[SC_FULL_SWING_K] |= SCB_BATK;
+	status->dbs->ChangeFlagTable[SC_MANA_PLUS] |= SCB_MATK;
+	status->dbs->ChangeFlagTable[SC_MUSTLE_M] |= SCB_MAXHP;
+	status->dbs->ChangeFlagTable[SC_LIFE_FORCE_F] |= SCB_MAXSP;
+	status->dbs->ChangeFlagTable[SC_EXTRACT_WHITE_POTION_Z] |= SCB_REGEN;
+	status->dbs->ChangeFlagTable[SC_VITATA_500] |= SCB_REGEN;
+	status->dbs->ChangeFlagTable[SC_EXTRACT_SALAMINE_JUICE] |= SCB_ASPD;
+	status->dbs->ChangeFlagTable[SC_REBOUND] |= SCB_SPEED|SCB_REGEN;
+	status->dbs->ChangeFlagTable[SC_DEFSET] |= SCB_DEF|SCB_DEF2;
+	status->dbs->ChangeFlagTable[SC_MDEFSET] |= SCB_MDEF|SCB_MDEF2;
+	status->dbs->ChangeFlagTable[SC_MYSTERIOUS_POWDER] |= SCB_MAXHP;
+
+	status->dbs->ChangeFlagTable[SC_ALL_RIDING] = SCB_SPEED;
+	status->dbs->ChangeFlagTable[SC_WEDDING] = SCB_SPEED;
+
+	status->dbs->ChangeFlagTable[SC_MTF_ASPD] = SCB_ASPD|SCB_HIT;
+	status->dbs->ChangeFlagTable[SC_MTF_MATK] = SCB_MATK;
+	status->dbs->ChangeFlagTable[SC_MTF_MLEATKED] |= SCB_ALL;
+
+	status->dbs->ChangeFlagTable[SC_MOONSTAR] |= SCB_NONE;
+	status->dbs->ChangeFlagTable[SC_SUPER_STAR] |= SCB_NONE;
+	status->dbs->ChangeFlagTable[SC_STRANGELIGHTS] |= SCB_NONE;
+	status->dbs->ChangeFlagTable[SC_DECORATION_OF_MUSIC] |= SCB_NONE;
+
+	/* status->dbs->DisplayType Table [Ind/Hercules] */
+	status->dbs->DisplayType[SC_ALL_RIDING]          = true;
+	status->dbs->DisplayType[SC_PUSH_CART]           = true;
+	status->dbs->DisplayType[SC_SUMMON1]             = true;
+	status->dbs->DisplayType[SC_SUMMON2]             = true;
+	status->dbs->DisplayType[SC_SUMMON3]             = true;
+	status->dbs->DisplayType[SC_SUMMON4]             = true;
+	status->dbs->DisplayType[SC_SUMMON5]             = true;
+	status->dbs->DisplayType[SC_CAMOUFLAGE]          = true;
+	status->dbs->DisplayType[SC_DUPLELIGHT]          = true;
+	status->dbs->DisplayType[SC_ORATIO]              = true;
+	status->dbs->DisplayType[SC_FROSTMISTY]          = true;
+	status->dbs->DisplayType[SC_VENOMIMPRESS]        = true;
+	status->dbs->DisplayType[SC_HALLUCINATIONWALK]   = true;
+	status->dbs->DisplayType[SC_ROLLINGCUTTER]       = true;
+	status->dbs->DisplayType[SC_BANDING]             = true;
+	status->dbs->DisplayType[SC_COLD]                = true;
+	status->dbs->DisplayType[SC_DEEP_SLEEP]          = true;
+	status->dbs->DisplayType[SC_CURSEDCIRCLE_ATKER]  = true;
+	status->dbs->DisplayType[SC_CURSEDCIRCLE_TARGET] = true;
+	status->dbs->DisplayType[SC_BLOOD_SUCKER]        = true;
+	status->dbs->DisplayType[SC__SHADOWFORM]         = true;
+	status->dbs->DisplayType[SC_MONSTER_TRANSFORM]   = true;
+	status->dbs->DisplayType[SC_MOONSTAR]            = true;
+	status->dbs->DisplayType[SC_SUPER_STAR]          = true;
+	status->dbs->DisplayType[SC_STRANGELIGHTS]       = true;
+	status->dbs->DisplayType[SC_DECORATION_OF_MUSIC] = true;
 
 	if( !battle_config.display_hallucination ) //Disable Hallucination.
-		status->IconChangeTable[SC_ILLUSION] = SI_BLANK;
+		status->dbs->IconChangeTable[SC_ILLUSION] = SI_BLANK;
 #undef add_sc
 #undef set_sc_with_vfx
 }
@@ -2089,7 +2090,7 @@ int status_calc_pet_(struct pet_data *pd, enum e_status_calc_opt opt)
 unsigned int status_get_base_maxsp(struct map_session_data* sd, struct status_data *st) {
 	uint64 val = pc->class2idx(sd->status.class_);
 
-	val = status->SP_table[val][sd->status.base_level];
+	val = status->dbs->SP_table[val][sd->status.base_level];
 
 	if ( sd->class_&JOBL_UPPER )
 		val += val * 25 / 100;
@@ -2106,7 +2107,7 @@ unsigned int status_get_base_maxsp(struct map_session_data* sd, struct status_da
 unsigned int status_get_base_maxhp(struct map_session_data *sd, struct status_data *st) {
 	uint64 val = pc->class2idx(sd->status.class_);
 
-	val = status->HP_table[val][sd->status.base_level];
+	val = status->dbs->HP_table[val][sd->status.base_level];
 
 	if ( (sd->class_&MAPID_UPPERMASK) == MAPID_SUPER_NOVICE && sd->status.base_level >= 99 )
 		val += 2000; //Supernovice lvl99 hp bonus.
@@ -2148,7 +2149,7 @@ int status_calc_pc_(struct map_session_data* sd, enum e_status_calc_opt opt) {
 
 	pc->calc_skilltree(sd); // SkillTree calculation
 
-	sd->max_weight = status->max_weight_base[pc->class2idx(sd->status.class_)]+sd->status.str*300;
+	sd->max_weight = status->dbs->max_weight_base[pc->class2idx(sd->status.class_)]+sd->status.str*300;
 
 	if(opt&SCO_FIRST) {
 		//Load Hp/SP from char-received data.
@@ -2285,18 +2286,18 @@ int status_calc_pc_(struct map_session_data* sd, enum e_status_calc_opt opt) {
 			}
 			wa->atk += sd->inventory_data[index]->atk;
 			if ( (r = sd->status.inventory[index].refine) )
-				wa->atk2 = status->refine_info[wlv].bonus[r-1] / 100;
+				wa->atk2 = status->dbs->refine_info[wlv].bonus[r-1] / 100;
 
 #ifdef RENEWAL
 			wa->matk += sd->inventory_data[index]->matk;
 			wa->wlv = wlv;
 			if( r && sd->weapontype1 != W_BOW ) // renewal magic attack refine bonus
-				wa->matk += status->refine_info[wlv].bonus[r-1] / 100;
+				wa->matk += status->dbs->refine_info[wlv].bonus[r-1] / 100;
 #endif
 
 			//Overrefined bonus.
 			if (r)
-				wd->overrefine = status->refine_info[wlv].randombonus_max[r-1] / 100;
+				wd->overrefine = status->dbs->refine_info[wlv].randombonus_max[r-1] / 100;
 
 			wa->range += sd->inventory_data[index]->range;
 			if(sd->inventory_data[index]->script) {
@@ -2324,7 +2325,7 @@ int status_calc_pc_(struct map_session_data* sd, enum e_status_calc_opt opt) {
 		else if(sd->inventory_data[index]->type == IT_ARMOR) {
 			int r;
 			if ( (r = sd->status.inventory[index].refine) )
-				refinedef += status->refine_info[REFINE_TYPE_ARMOR].bonus[r-1];
+				refinedef += status->dbs->refine_info[REFINE_TYPE_ARMOR].bonus[r-1];
 			if(sd->inventory_data[index]->script) {
 				if( i == EQI_HAND_L ) //Shield
 					sd->state.lr_flag = 3;
@@ -2467,12 +2468,12 @@ int status_calc_pc_(struct map_session_data* sd, enum e_status_calc_opt opt) {
 	sd->bonus.splash_range += sd->bonus.splash_add_range;
 
 	// Damage modifiers from weapon type
-	sd->right_weapon.atkmods[0] = status->atkmods[0][sd->weapontype1];
-	sd->right_weapon.atkmods[1] = status->atkmods[1][sd->weapontype1];
-	sd->right_weapon.atkmods[2] = status->atkmods[2][sd->weapontype1];
-	sd->left_weapon.atkmods[0] = status->atkmods[0][sd->weapontype2];
-	sd->left_weapon.atkmods[1] = status->atkmods[1][sd->weapontype2];
-	sd->left_weapon.atkmods[2] = status->atkmods[2][sd->weapontype2];
+	sd->right_weapon.atkmods[0] = status->dbs->atkmods[0][sd->weapontype1];
+	sd->right_weapon.atkmods[1] = status->dbs->atkmods[1][sd->weapontype1];
+	sd->right_weapon.atkmods[2] = status->dbs->atkmods[2][sd->weapontype1];
+	sd->left_weapon.atkmods[0] = status->dbs->atkmods[0][sd->weapontype2];
+	sd->left_weapon.atkmods[1] = status->dbs->atkmods[1][sd->weapontype2];
+	sd->left_weapon.atkmods[2] = status->dbs->atkmods[2][sd->weapontype2];
 
 	if ((pc_isridingpeco(sd) || pc_isridingdragon(sd))
 	    && (sd->status.weapon==W_1HSPEAR || sd->status.weapon==W_2HSPEAR)
@@ -2488,9 +2489,9 @@ int status_calc_pc_(struct map_session_data* sd, enum e_status_calc_opt opt) {
 	// Job bonuses
 	index = pc->class2idx(sd->status.class_);
 	for(i=0;i<(int)sd->status.job_level && i<MAX_LEVEL;i++){
-		if(!status->job_bonus[index][i])
+		if(!status->dbs->job_bonus[index][i])
 			continue;
-		switch(status->job_bonus[index][i]) {
+		switch(status->dbs->job_bonus[index][i]) {
 			case 1: bstatus->str++; break;
 			case 2: bstatus->agi++; break;
 			case 3: bstatus->vit++; break;
@@ -3925,11 +3926,11 @@ int status_base_amotion_pc(struct map_session_data *sd, struct status_data *st)
 #ifdef RENEWAL_ASPD /* [malufett/Hercules] */
 	float temp;
 	int skill_lv, val = 0;
-	amotion = status->aspd_base[pc->class2idx(sd->status.class_)][sd->weapontype1];
+	amotion = status->dbs->aspd_base[pc->class2idx(sd->status.class_)][sd->weapontype1];
 	if ( sd->status.weapon > MAX_WEAPON_TYPE )
-		amotion += status->aspd_base[pc->class2idx(sd->status.class_)][sd->weapontype2] / 4;
+		amotion += status->dbs->aspd_base[pc->class2idx(sd->status.class_)][sd->weapontype2] / 4;
 	if ( sd->status.shield )
-		amotion += status->aspd_base[pc->class2idx(sd->status.class_)][MAX_WEAPON_TYPE];
+		amotion += status->dbs->aspd_base[pc->class2idx(sd->status.class_)][MAX_WEAPON_TYPE];
 	switch ( sd->status.weapon ) {
 		case W_BOW:		case W_MUSICAL:
 		case W_WHIP:	case W_REVOLVER:
@@ -3949,8 +3950,8 @@ int status_base_amotion_pc(struct map_session_data *sd, struct status_data *st)
 #else
 	// base weapon delay
 	amotion = (sd->status.weapon < MAX_WEAPON_TYPE)
-		? (status->aspd_base[pc->class2idx(sd->status.class_)][sd->status.weapon]) // single weapon
-		: (status->aspd_base[pc->class2idx(sd->status.class_)][sd->weapontype1] + status->aspd_base[pc->class2idx(sd->status.class_)][sd->weapontype2]) * 7 / 10; // dual-wield
+		? (status->dbs->aspd_base[pc->class2idx(sd->status.class_)][sd->status.weapon]) // single weapon
+		: (status->dbs->aspd_base[pc->class2idx(sd->status.class_)][sd->weapontype1] + status->dbs->aspd_base[pc->class2idx(sd->status.class_)][sd->weapontype2]) * 7 / 10; // dual-wield
 
 	// percentual delay reduction from stats
 	amotion -= amotion * (4 * st->agi + st->dex) / 1000;
@@ -7525,7 +7526,7 @@ int status_change_start(struct block_list *src, struct block_list *bl, enum sc_t
 	}
 
 	vd = status->get_viewdata(bl);
-	calc_flag = status->ChangeFlagTable[type];
+	calc_flag = status->dbs->ChangeFlagTable[type];
 	if(!(flag&SCFLAG_LOADED)) { // Do not parse val settings when loading SCs
 		switch(type) {
 			case SC_ADORAMUS:
@@ -9056,7 +9057,7 @@ int status_change_start(struct block_list *src, struct block_list *bl, enum sc_t
 				val2 = 20+(20*val1);
 				break;
 			default:
-				if (calc_flag == SCB_NONE && status->SkillChangeTable[type] == 0 && status->IconChangeTable[type] == 0) {
+				if (calc_flag == SCB_NONE && status->dbs->SkillChangeTable[type] == 0 && status->dbs->IconChangeTable[type] == 0) {
 					//Status change with no calc, no icon, and no skill associated...?
 					ShowError("UnknownStatusChange [%d]\n", type);
 					return 0;
@@ -9210,7 +9211,7 @@ int status_change_start(struct block_list *src, struct block_list *bl, enum sc_t
 	}
 
 	/* [Ind/Hercules] */
-	if( sd && status->DisplayType[type] ) {
+	if( sd && status->dbs->DisplayType[type] ) {
 		int dval1 = 0, dval2 = 0, dval3 = 0;
 		switch( type ) {
 			case SC_ALL_RIDING:
@@ -9503,8 +9504,8 @@ int status_change_start(struct block_list *src, struct block_list *bl, enum sc_t
 		calc_flag&=~SCB_DYE;
 	}
 
-	if(!(flag&SCFLAG_NOICON) && !(flag&SCFLAG_LOADED && status->DisplayType[type]))
-		clif->status_change(bl,status->IconChangeTable[type],1,tick,(val_flag&1)?val1:1,(val_flag&2)?val2:0,(val_flag&4)?val3:0);
+	if(!(flag&SCFLAG_NOICON) && !(flag&SCFLAG_LOADED && status->dbs->DisplayType[type]))
+		clif->status_change(bl,status->dbs->IconChangeTable[type],1,tick,(val_flag&1)?val1:1,(val_flag&2)?val2:0,(val_flag&4)?val3:0);
 
 	/**
 	* used as temporary storage for scs with interval ticks, so that the actual duration is sent to the client first.
@@ -9751,7 +9752,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 
 	sc->data[type] = NULL;
 
-	if( sd && status->DisplayType[type] ) {
+	if( sd && status->dbs->DisplayType[type] ) {
 		status->display_remove(sd,type);
 	}
 
@@ -9761,7 +9762,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 #endif
 
 	vd = status->get_viewdata(bl);
-	calc_flag = status->ChangeFlagTable[type];
+	calc_flag = status->dbs->ChangeFlagTable[type];
 	switch(type) {
 		case SC_GRANITIC_ARMOR:
 		{
@@ -10405,7 +10406,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 	}
 
 	//On Aegis, when turning off a status change, first goes the sc packet, then the option packet.
-	clif->sc_end(bl,bl->id,AREA,status->IconChangeTable[type]);
+	clif->sc_end(bl,bl->id,AREA,status->dbs->IconChangeTable[type]);
 
 	if( opt_flag&8 ) //bugreport:681
 		clif->changeoption2(bl);
@@ -10584,7 +10585,7 @@ int status_change_timer(int tid, int64 tick, int id, intptr_t data) {
 				sc->opt1 = OPT1_STONE;
 				clif->changeoption(bl);
 				sc_timer_next(1000+tick, status->change_timer, bl->id, data );
-				status_calc_bl(bl, status->ChangeFlagTable[type]);
+				status_calc_bl(bl, status->dbs->ChangeFlagTable[type]);
 				return 0;
 			}
 			if(--(sce->val3) > 0) {
@@ -10870,7 +10871,7 @@ int status_change_timer(int tid, int64 tick, int id, intptr_t data) {
 						unit->skillcastcancel(bl,0);
 						do {
 							int i = rnd() % MAX_SKILL_MAGICMUSHROOM_DB;
-							mushroom_skill_id = skill->magicmushroom_db[i].skill_id;
+							mushroom_skill_id = skill->dbs->magicmushroom_db[i].skill_id;
 						} while (mushroom_skill_id == 0);
 
 						switch( skill->get_casttype(mushroom_skill_id) ) { // Magic Mushroom skills are buffs or area damage
@@ -11449,7 +11450,7 @@ int status_get_weapon_atk(struct block_list *bl, struct weapon_atk *watk, int fl
 		short index = sd->equip_index[EQI_HAND_R], refine;
 		if ( index >= 0 && sd->inventory_data[index] && sd->inventory_data[index]->type == IT_WEAPON
 			&& (refine = sd->status.inventory[index].refine) < 16 && refine ) {
-			int r = status->refine_info[watk->wlv].randombonus_max[refine + (4 - watk->wlv)] / 100;
+			int r = status->dbs->refine_info[watk->wlv].randombonus_max[refine + (4 - watk->wlv)] / 100;
 			if ( r )
 				max += (rnd() % 100) % r + 1;
 		}
@@ -11548,7 +11549,7 @@ void status_get_matk_sub(struct block_list *bl, int flag, unsigned short *matk_m
 		short index = sd->equip_index[EQI_HAND_R], refine;
 		if ( index >= 0 && sd->inventory_data[index] && sd->inventory_data[index]->type == IT_WEAPON
 			&& (refine = sd->status.inventory[index].refine) < 16 && refine ) {
-			int r =  status->refine_info[sd->inventory_data[index]->wlv].randombonus_max[refine + (4 - sd->inventory_data[index]->wlv)] / 100;
+			int r =  status->dbs->refine_info[sd->inventory_data[index]->wlv].randombonus_max[refine + (4 - sd->inventory_data[index]->wlv)] / 100;
 			if ( r )
 				*matk_max += (rnd() % 100) % r + 1;
 		}
@@ -11991,7 +11992,7 @@ int status_get_refine_chance(enum refine_type wlv, int refine) {
 	if ( refine < 0 || refine >= MAX_REFINE)
 	return 0;
 
-	return status->refine_info[wlv].chance[refine];
+	return status->dbs->refine_info[wlv].chance[refine];
 }
 
 int status_get_sc_type(sc_type type) {
@@ -11999,7 +12000,7 @@ int status_get_sc_type(sc_type type) {
 	if( type <= SC_NONE || type >= SC_MAX )
 		return 0;
 
-	return status->sc_conf[type];
+	return status->dbs->sc_conf[type];
 }
 
 void status_read_job_db_sub(int idx, const char *name, config_setting_t *jdb)
@@ -12050,25 +12051,25 @@ void status_read_job_db_sub(int idx, const char *name, config_setting_t *jdb)
 				continue;
 			}
 			iidx = pc->class2idx(iclass);
-			status->max_weight_base[idx] = status->max_weight_base[iidx];
-			memcpy(&status->aspd_base[idx], &status->aspd_base[iidx], sizeof(status->aspd_base[iidx]));
+			status->dbs->max_weight_base[idx] = status->dbs->max_weight_base[iidx];
+			memcpy(&status->dbs->aspd_base[idx], &status->dbs->aspd_base[iidx], sizeof(status->dbs->aspd_base[iidx]));
 
-			for (i = 1; i <= MAX_LEVEL && status->HP_table[iidx][i]; i++) {
-				status->HP_table[idx][i] = status->HP_table[iidx][i];
+			for (i = 1; i <= MAX_LEVEL && status->dbs->HP_table[iidx][i]; i++) {
+				status->dbs->HP_table[idx][i] = status->dbs->HP_table[iidx][i];
 			}
-			base = (i > 1 ? status->HP_table[idx][1] : 35); // Safe value if none are specified
-			avg_increment = (i > 2 ? (status->HP_table[idx][i] - base) / (i-1) : 5); // Safe value if none are specified
+			base = (i > 1 ? status->dbs->HP_table[idx][1] : 35); // Safe value if none are specified
+			avg_increment = (i > 2 ? (status->dbs->HP_table[idx][i] - base) / (i-1) : 5); // Safe value if none are specified
 			for ( ; i <= pc->max_level[idx][0]; i++) {
-				status->HP_table[idx][i] = min(base + avg_increment * i, battle_config.max_hp);
+				status->dbs->HP_table[idx][i] = min(base + avg_increment * i, battle_config.max_hp);
 			}
 
-			for (i = 1; i <= MAX_LEVEL && status->SP_table[iidx][i]; i++) {
-				status->SP_table[idx][i] = status->SP_table[iidx][i];
+			for (i = 1; i <= MAX_LEVEL && status->dbs->SP_table[iidx][i]; i++) {
+				status->dbs->SP_table[idx][i] = status->dbs->SP_table[iidx][i];
 			}
-			base = (i > 1 ? status->SP_table[idx][1] : 10); // Safe value if none are specified
-			avg_increment = (i > 2 ? (status->SP_table[idx][i] - base) / (i-1) : 1); // Safe value if none are specified
+			base = (i > 1 ? status->dbs->SP_table[idx][1] : 10); // Safe value if none are specified
+			avg_increment = (i > 2 ? (status->dbs->SP_table[idx][i] - base) / (i-1) : 1); // Safe value if none are specified
 			for ( ; i <= pc->max_level[idx][0]; i++) {
-				status->SP_table[idx][i] = min(base + avg_increment * i, battle_config.max_sp);
+				status->dbs->SP_table[idx][i] = min(base + avg_increment * i, battle_config.max_sp);
 			}
 		}
 	}
@@ -12082,13 +12083,13 @@ void status_read_job_db_sub(int idx, const char *name, config_setting_t *jdb)
 				continue;
 			}
 			iidx = pc->class2idx(iclass);
-			for (i = 1; i <= MAX_LEVEL && status->HP_table[iidx][i]; i++) {
-				status->HP_table[idx][i] = status->HP_table[iidx][i];
+			for (i = 1; i <= MAX_LEVEL && status->dbs->HP_table[iidx][i]; i++) {
+				status->dbs->HP_table[idx][i] = status->dbs->HP_table[iidx][i];
 			}
-			base = (i > 1 ? status->HP_table[idx][1] : 35); // Safe value if none are specified
-			avg_increment = (i > 2 ? (status->HP_table[idx][i] - base) / (i-1) : 5); // Safe value if none are specified
+			base = (i > 1 ? status->dbs->HP_table[idx][1] : 35); // Safe value if none are specified
+			avg_increment = (i > 2 ? (status->dbs->HP_table[idx][i] - base) / (i-1) : 5); // Safe value if none are specified
 			for ( ; i <= pc->max_level[idx][0]; i++) {
-				status->HP_table[idx][i] = min(base + avg_increment * i, battle_config.max_hp);
+				status->dbs->HP_table[idx][i] = min(base + avg_increment * i, battle_config.max_hp);
 			}
 		}
 	}
@@ -12102,21 +12103,21 @@ void status_read_job_db_sub(int idx, const char *name, config_setting_t *jdb)
 				continue;
 			}
 			iidx = pc->class2idx(iclass);
-			for (i = 1; i <= MAX_LEVEL && status->SP_table[iidx][i]; i++) {
-				status->SP_table[idx][i] = status->SP_table[iidx][i];
+			for (i = 1; i <= MAX_LEVEL && status->dbs->SP_table[iidx][i]; i++) {
+				status->dbs->SP_table[idx][i] = status->dbs->SP_table[iidx][i];
 			}
-			base = (i > 1 ? status->SP_table[idx][1] : 10); // Safe value if none are specified
-			avg_increment = (i > 2 ? (status->SP_table[idx][i] - base) / (i-1) : 1); // Safe value if none are specified
+			base = (i > 1 ? status->dbs->SP_table[idx][1] : 10); // Safe value if none are specified
+			avg_increment = (i > 2 ? (status->dbs->SP_table[idx][i] - base) / (i-1) : 1); // Safe value if none are specified
 			for ( ; i <= pc->max_level[idx][0]; i++) {
-				status->SP_table[idx][i] = min(avg_increment * i, battle_config.max_sp);
+				status->dbs->SP_table[idx][i] = min(avg_increment * i, battle_config.max_sp);
 			}
 		}
 	}
 
 	if (libconfig->setting_lookup_int(jdb, "Weight", &i32))
-		status->max_weight_base[idx] = i32;
-	else if (!status->max_weight_base[idx])
-		status->max_weight_base[idx] = 20000;
+		status->dbs->max_weight_base[idx] = i32;
+	else if (!status->dbs->max_weight_base[idx])
+		status->dbs->max_weight_base[idx] = 20000;
 
 	if ((temp = libconfig->setting_get_member(jdb, "BaseASPD"))) {
 		int widx = 0;
@@ -12127,7 +12128,7 @@ void status_read_job_db_sub(int idx, const char *name, config_setting_t *jdb)
 
 			ARR_FIND(0, wlen, w, strcmp(wnames[w].name, wname) == 0);
 			if (w != wlen) {
-				status->aspd_base[idx][wnames[w].id] = libconfig->setting_get_int(wpn);
+				status->dbs->aspd_base[idx][wnames[w].id] = libconfig->setting_get_int(wpn);
 			} else {
 				ShowWarning("status_read_job_db: unknown weapon type '%s'!\n", wname);
 			}
@@ -12139,12 +12140,12 @@ void status_read_job_db_sub(int idx, const char *name, config_setting_t *jdb)
 		config_setting_t *hp = NULL;
 		while (level <= MAX_LEVEL && (hp = libconfig->setting_get_elem(temp, level))) {
 			i32 = libconfig->setting_get_int(hp);
-			status->HP_table[idx][++level] = min(i32, battle_config.max_hp);
+			status->dbs->HP_table[idx][++level] = min(i32, battle_config.max_hp);
 		}
-		base = (level > 0 ? status->HP_table[idx][1] : 35); // Safe value if none are specified
-		avg_increment = (level > 1 ? (status->HP_table[idx][level] - base) / level : 5); // Safe value if none are specified
+		base = (level > 0 ? status->dbs->HP_table[idx][1] : 35); // Safe value if none are specified
+		avg_increment = (level > 1 ? (status->dbs->HP_table[idx][level] - base) / level : 5); // Safe value if none are specified
 		for (++level; level <= pc->max_level[idx][0]; ++level) { /* limit only to possible maximum level of the given class */
-			status->HP_table[idx][level] = min(base + avg_increment * level, battle_config.max_hp); /* some are still empty? then let's use the average increase */
+			status->dbs->HP_table[idx][level] = min(base + avg_increment * level, battle_config.max_hp); /* some are still empty? then let's use the average increase */
 		}
 	}
 
@@ -12153,12 +12154,12 @@ void status_read_job_db_sub(int idx, const char *name, config_setting_t *jdb)
 		config_setting_t *sp = NULL;
 		while (level <= MAX_LEVEL && (sp = libconfig->setting_get_elem(temp, level))) {
 			i32 = libconfig->setting_get_int(sp);
-			status->SP_table[idx][++level] = min(i32, battle_config.max_sp);
+			status->dbs->SP_table[idx][++level] = min(i32, battle_config.max_sp);
 		}
-		base = (level > 0 ? status->SP_table[idx][1] : 10); // Safe value if none are specified
-		avg_increment = (level > 1 ? (status->SP_table[idx][level] - base) / level : 1);
+		base = (level > 0 ? status->dbs->SP_table[idx][1] : 10); // Safe value if none are specified
+		avg_increment = (level > 1 ? (status->dbs->SP_table[idx][level] - base) / level : 1);
 		for ( ; level <= pc->max_level[idx][0]; level++ ) {
-			status->SP_table[idx][level] = min(base + avg_increment * level, battle_config.max_sp);
+			status->dbs->SP_table[idx][level] = min(base + avg_increment * level, battle_config.max_sp);
 		}
 	}
 }
@@ -12216,7 +12217,7 @@ bool status_readdb_job2(char* fields[], int columns, int current)
 
 	for(i = 1; i < columns; i++)
 	{
-		status->job_bonus[idx][i-1] = atoi(fields[i]);
+		status->dbs->job_bonus[idx][i-1] = atoi(fields[i]);
 	}
 	return true;
 }
@@ -12227,7 +12228,7 @@ bool status_readdb_sizefix(char* fields[], int columns, int current)
 
 	for(i = 0; i < MAX_WEAPON_TYPE; i++)
 	{
-		status->atkmods[current][i] = atoi(fields[i]);
+		status->dbs->atkmods[current][i] = atoi(fields[i]);
 	}
 	return true;
 }
@@ -12254,14 +12255,14 @@ bool status_readdb_refine(char* fields[], int columns, int current)
 
 		*delim = '\0';
 
-		status->refine_info[current].chance[i] = atoi(fields[4+i]);
+		status->dbs->refine_info[current].chance[i] = atoi(fields[4+i]);
 
 		if (i >= random_bonus_start_level - 1)
-			status->refine_info[current].randombonus_max[i] = random_bonus * (i - random_bonus_start_level + 2);
+			status->dbs->refine_info[current].randombonus_max[i] = random_bonus * (i - random_bonus_start_level + 2);
 
-		status->refine_info[current].bonus[i] = bonus_per_level + atoi(delim+1);
+		status->dbs->refine_info[current].bonus[i] = bonus_per_level + atoi(delim+1);
 		if (i > 0)
-			status->refine_info[current].bonus[i] += status->refine_info[current].bonus[i-1];
+			status->dbs->refine_info[current].bonus[i] += status->dbs->refine_info[current].bonus[i-1];
 	}
 	return true;
 }
@@ -12275,7 +12276,7 @@ bool status_readdb_scconfig(char* fields[], int columns, int current) {
 		return false;
 	}
 
-	status->sc_conf[val] = (int)strtol(fields[1], NULL, 0);
+	status->dbs->sc_conf[val] = (int)strtol(fields[1], NULL, 0);
 
 	return true;
 }
@@ -12294,39 +12295,39 @@ int status_readdb(void)
 	//
 	if( runflag == MAPSERVER_ST_RUNNING ) {//not necessary during boot
 		// reset job_db.conf data
-		memset(status->max_weight_base, 0, sizeof(status->max_weight_base));
-		memset(status->HP_table, 0, sizeof(status->HP_table));
-		memset(status->SP_table, 0, sizeof(status->SP_table));
+		memset(status->dbs->max_weight_base, 0, sizeof(status->dbs->max_weight_base));
+		memset(status->dbs->HP_table, 0, sizeof(status->dbs->HP_table));
+		memset(status->dbs->SP_table, 0, sizeof(status->dbs->SP_table));
 		// reset job_db2.txt data
-		memset(status->job_bonus,0,sizeof(status->job_bonus)); // Job-specific stats bonus
+		memset(status->dbs->job_bonus,0,sizeof(status->dbs->job_bonus)); // Job-specific stats bonus
 	}
 	for ( i = 0; i < CLASS_COUNT; i++ ) {
 		for ( j = 0; j < MAX_WEAPON_TYPE; j++ )
-			status->aspd_base[i][j] = 2000;
+			status->dbs->aspd_base[i][j] = 2000;
 #ifdef RENEWAL_ASPD
-		status->aspd_base[i][MAX_WEAPON_TYPE] = 0;
+		status->dbs->aspd_base[i][MAX_WEAPON_TYPE] = 0;
 #endif
 	}
 
 	// size_fix.txt
-	for(i = 0; i < ARRAYLENGTH(status->atkmods); i++)
+	for(i = 0; i < ARRAYLENGTH(status->dbs->atkmods); i++)
 		for(j = 0; j < MAX_WEAPON_TYPE; j++)
-			status->atkmods[i][j] = 100;
+			status->dbs->atkmods[i][j] = 100;
 
 	// refine_db.txt
-	for(i=0;i<ARRAYLENGTH(status->refine_info);i++) {
+	for(i=0;i<ARRAYLENGTH(status->dbs->refine_info);i++) {
 		for(j=0;j<MAX_REFINE; j++) {
-			status->refine_info[i].chance[j] = 100;
-			status->refine_info[i].bonus[j] = 0;
-			status->refine_info[i].randombonus_max[j] = 0;
+			status->dbs->refine_info[i].chance[j] = 100;
+			status->dbs->refine_info[i].bonus[j] = 0;
+			status->dbs->refine_info[i].randombonus_max[j] = 0;
 		}
 	}
 
 	// read databases
 	//
 	sv->readdb(map->db_path, "job_db2.txt",         ',', 1,                 1+MAX_LEVEL,       -1,                       status->readdb_job2);
-	sv->readdb(map->db_path, DBPATH"size_fix.txt", ',', MAX_WEAPON_TYPE, MAX_WEAPON_TYPE, ARRAYLENGTH(status->atkmods), status->readdb_sizefix);
-	sv->readdb(map->db_path, DBPATH"refine_db.txt", ',', 4+MAX_REFINE,      4+MAX_REFINE,      ARRAYLENGTH(status->refine_info), status->readdb_refine);
+	sv->readdb(map->db_path, DBPATH"size_fix.txt", ',', MAX_WEAPON_TYPE, MAX_WEAPON_TYPE, ARRAYLENGTH(status->dbs->atkmods), status->readdb_sizefix);
+	sv->readdb(map->db_path, DBPATH"refine_db.txt", ',', 4+MAX_REFINE,      4+MAX_REFINE,      ARRAYLENGTH(status->dbs->refine_info), status->readdb_refine);
 	sv->readdb(map->db_path, "sc_config.txt",       ',', 2,                 2,                 SC_MAX,                   status->readdb_scconfig);
 	status->read_job_db();
 
@@ -12362,6 +12363,7 @@ void do_final_status(void) {
 *-------------------------------------*/
 void status_defaults(void) {
 	status = &status_s;
+	status->dbs = &statusdbs;
 
 	/* vars */
 	//we need it for new cards 15 Feb 2005, to check if the combo cards are insrerted into the CURRENT weapon only
@@ -12370,7 +12372,7 @@ void status_defaults(void) {
 	status->current_equip_card_id = 0;    //To prevent card-stacking (from jA) [Skotlex]
 
 	// These macros are used instead of a sum of sizeof(), to ensure that padding won't interfere with our size, and code won't rot when adding more fields
-	memset(ZEROED_BLOCK_POS(status), 0, ZEROED_BLOCK_SIZE(status));
+	memset(ZEROED_BLOCK_POS(status->dbs), 0, ZEROED_BLOCK_SIZE(status->dbs));
 
 	status->data_ers = NULL;
 	memset(&status->dummy, 0, sizeof(status->dummy));
diff --git a/src/map/status.h b/src/map/status.h
index 4bda57fa9..9143df6ae 100644
--- a/src/map/status.h
+++ b/src/map/status.h
@@ -1928,17 +1928,7 @@ struct s_refine_info {
 	int randombonus_max[MAX_REFINE]; // cumulative maximum random bonus damage
 };
 
-/*=====================================
-* Interface : status.h
-* Generated by HerculesInterfaceMaker
-* created by Susu
-*-------------------------------------*/
-struct status_interface {
-
-	/* vars */
-	int current_equip_item_index;
-	int current_equip_card_id;
-
+struct s_status_dbs {
 BEGIN_ZEROED_BLOCK; /* Everything within this block will be memset to 0 when status_defaults() is executed */
 	int max_weight_base[CLASS_COUNT];
 	int HP_table[CLASS_COUNT][MAX_LEVEL + 1];
@@ -1957,6 +1947,20 @@ BEGIN_ZEROED_BLOCK; /* Everything within this block will be memset to 0 when sta
 	char job_bonus[CLASS_COUNT][MAX_LEVEL];
 	sc_conf_type sc_conf[SC_MAX];
 END_ZEROED_BLOCK; /* End */
+};
+
+/*=====================================
+* Interface : status.h
+* Generated by HerculesInterfaceMaker
+* created by Susu
+*-------------------------------------*/
+struct status_interface {
+
+	/* vars */
+	int current_equip_item_index;
+	int current_equip_card_id;
+
+	struct s_status_dbs *dbs;
 
 	struct eri *data_ers; //For sc_data entries
 	struct status_data dummy;