Merge pull request #2446 from hemagx/refinery_ui_update

Implement Refinery ui and Refine code refactor

24 files changed, 1252 insertions, 266 deletions

diff --git a/src/map/HPMmap.c b/src/map/HPMmap.c
index cbfa8e8c4..e89f47c12 100644
--- a/src/map/HPMmap.c
+++ b/src/map/HPMmap.c
@@ -81,6 +81,8 @@
 #include "map/pet.h"
 #include "map/quest.h"
 #include "map/rodex.h"
+#include "map/refine.h"
+#include "map/refine.p.h"
 #include "map/script.h"
 #include "map/searchstore.h"
 #include "map/skill.h"
diff --git a/src/map/Makefile.in b/src/map/Makefile.in
index edb3fdaad..f851de756 100644
--- a/src/map/Makefile.in
+++ b/src/map/Makefile.in
@@ -44,7 +44,7 @@ MAP_C = achievement.c atcommand.c battle.c battleground.c buyingstore.c channel.
         chrif.c clan.c clif.c date.c duel.c elemental.c guild.c homunculus.c HPMmap.c \
         instance.c intif.c irc-bot.c itemdb.c log.c mail.c map.c mapreg_sql.c \
         mercenary.c mob.c npc.c npc_chat.c party.c path.c pc.c pc_groups.c \
-        pet.c quest.c rodex.c script.c searchstore.c skill.c status.c storage.c \
+        pet.c quest.c refine.c rodex.c script.c searchstore.c skill.c status.c storage.c \
         stylist.c trade.c unit.c vending.c
 MAP_OBJ = $(addprefix obj_sql/, $(patsubst %c,%o,$(MAP_C)))
 MAP_H = achievement.h atcommand.h battle.h battleground.h buyingstore.h channel.h chat.h \
@@ -54,9 +54,9 @@ MAP_H = achievement.h atcommand.h battle.h battleground.h buyingstore.h channel.
         messages_sak.h messages_zero.h mob.h npc.h packets.h packets_keys_main.h \
         packets_keys_zero.h packets_shuffle_main.h packets_shuffle_re.h \
         packets_shuffle_zero.h packets_struct.h party.h path.h pc.h pc_groups.h \
-        pet.h quest.h rodex.h script.h searchstore.h skill.h status.h storage.h \
+        pet.h quest.h refine.h rodex.h script.h searchstore.h skill.h status.h storage.h \
         stylist.h trade.h unit.h vending.h
-MAP_PH =
+MAP_PH = refine.p.h
 
 HAVE_MYSQL=@HAVE_MYSQL@
 ifeq ($(HAVE_MYSQL),yes)
diff --git a/src/map/atcommand.c b/src/map/atcommand.c
index 8bca17fa1..09303912b 100644
--- a/src/map/atcommand.c
+++ b/src/map/atcommand.c
@@ -48,6 +48,7 @@
 #include "map/pc_groups.h" // groupid2name
 #include "map/pet.h"
 #include "map/quest.h"
+#include "map/refine.h"
 #include "map/script.h"
 #include "map/searchstore.h"
 #include "map/skill.h"
@@ -1270,20 +1271,20 @@ ACMD(item2)
 	struct item_data *item_data;
 	char item_name[100];
 	int item_id, number = 0, bound = 0;
-	int identify = 0, refine = 0, attr = 0;
+	int identify = 0, refine_level = 0, attr = 0;
 	int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
 
 	memset(item_name, '\0', sizeof(item_name));
 
 	if (!strcmpi(info->command,"itembound2") && (!*message || (
-		sscanf(message, "\"%99[^\"]\" %12d %12d %12d %12d %12d %12d %12d %12d %12d", item_name, &number, &identify, &refine, &attr, &c1, &c2, &c3, &c4, &bound) < 10 &&
-		sscanf(message, "%99s %12d %12d %12d %12d %12d %12d %12d %12d %12d", item_name, &number, &identify, &refine, &attr, &c1, &c2, &c3, &c4, &bound) < 10 ))) {
+		sscanf(message, "\"%99[^\"]\" %12d %12d %12d %12d %12d %12d %12d %12d %12d", item_name, &number, &identify, &refine_level, &attr, &c1, &c2, &c3, &c4, &bound) < 10 &&
+		sscanf(message, "%99s %12d %12d %12d %12d %12d %12d %12d %12d %12d", item_name, &number, &identify, &refine_level, &attr, &c1, &c2, &c3, &c4, &bound) < 10 ))) {
 		clif->message(fd, msg_fd(fd,296)); // Please enter all parameters (usage: @itembound2 <item name/ID> <quantity>
 		clif->message(fd, msg_fd(fd,297)); //   <identify_flag> <refine> <attribute> <card1> <card2> <card3> <card4> <bound_type>).
 		return false;
 	} else if (!*message
-	         || ( sscanf(message, "\"%99[^\"]\" %12d %12d %12d %12d %12d %12d %12d %12d", item_name, &number, &identify, &refine, &attr, &c1, &c2, &c3, &c4) < 9
-	           && sscanf(message, "%99s %12d %12d %12d %12d %12d %12d %12d %12d", item_name, &number, &identify, &refine, &attr, &c1, &c2, &c3, &c4) < 9
+	         || ( sscanf(message, "\"%99[^\"]\" %12d %12d %12d %12d %12d %12d %12d %12d", item_name, &number, &identify, &refine_level, &attr, &c1, &c2, &c3, &c4) < 9
+	           && sscanf(message, "%99s %12d %12d %12d %12d %12d %12d %12d %12d", item_name, &number, &identify, &refine_level, &attr, &c1, &c2, &c3, &c4) < 9
 	)) {
 		clif->message(fd, msg_fd(fd,984)); // Please enter all parameters (usage: @item2 <item name/ID> <quantity>
 		clif->message(fd, msg_fd(fd,985)); //   <identify_flag> <refine> <attribute> <card1> <card2> <card3> <card4>).
@@ -1319,20 +1320,20 @@ ACMD(item2)
 			get_count = 1;
 			if (item_data->type == IT_PETEGG) {
 				identify = 1;
-				refine = 0;
+				refine_level = 0;
 			}
 			if (item_data->type == IT_PETARMOR)
-				refine = 0;
+				refine_level = 0;
 		} else {
 			identify = 1;
-			refine = attr = 0;
+			refine_level = attr = 0;
 		}
-		refine = cap_value(refine, 0, MAX_REFINE);
+		refine_level = cap_value(refine_level, 0, MAX_REFINE);
 		for (i = 0; i < loop; i++) {
 			memset(&item_tmp, 0, sizeof(item_tmp));
 			item_tmp.nameid = item_id;
 			item_tmp.identify = identify;
-			item_tmp.refine = refine;
+			item_tmp.refine = refine_level;
 			item_tmp.attribute = attr;
 			item_tmp.bound = (unsigned char)bound;
 			item_tmp.card[0] = c1;
@@ -2215,12 +2216,12 @@ ACMD(killmonster)
  *------------------------------------------*/
 ACMD(refine)
 {
-	int j, position = 0, refine = 0, current_position, final_refine;
+	int j, position = 0, refine_level = 0, current_position, final_refine;
 	int count;
 
 	memset(atcmd_output, '\0', sizeof(atcmd_output));
 
-	if (!*message || sscanf(message, "%12d %12d", &position, &refine) < 2) {
+	if (!*message || sscanf(message, "%12d %12d", &position, &refine_level) < 2) {
 		clif->message(fd, msg_fd(fd,996)); // Please enter a position and an amount (usage: @refine <equip position> <+/- amount>).
 		safesnprintf(atcmd_output, sizeof(atcmd_output), msg_fd(fd,997), EQP_HEAD_LOW); // %d: Lower Headgear
 		clif->message(fd, atcmd_output);
@@ -2245,7 +2246,7 @@ ACMD(refine)
 		return false;
 	}
 
-	refine = cap_value(refine, -MAX_REFINE, MAX_REFINE);
+	refine_level = cap_value(refine_level, -MAX_REFINE, MAX_REFINE);
 
 	count = 0;
 	for (j = 0; j < EQI_MAX; j++) {
@@ -2263,7 +2264,7 @@ ACMD(refine)
 		if(position && !(sd->status.inventory[idx].equip & position))
 			continue;
 
-		final_refine = cap_value(sd->status.inventory[idx].refine + refine, 0, MAX_REFINE);
+		final_refine = cap_value(sd->status.inventory[idx].refine + refine_level, 0, MAX_REFINE);
 		if (sd->status.inventory[idx].refine != final_refine) {
 			sd->status.inventory[idx].refine = final_refine;
 			current_position = sd->status.inventory[idx].equip;
@@ -9828,6 +9829,22 @@ ACMD(camerainfo)
 	return true;
 }
 
+ACMD(refineryui)
+{
+#if PACKETVER_MAIN_NUM >= 20161005 || PACKETVER_RE_NUM >= 20161005 || defined(PACKETVER_ZERO)
+	if (battle_config.enable_refinery_ui == 0) {
+		clif->message(fd, msg_fd(fd, 453));
+		return false;
+	}
+
+	clif->OpenRefineryUI(sd);
+	return true;
+#else
+	clif->message(fd, msg_fd(fd, 453));
+	return false;
+#endif
+}
+
 /**
  * Fills the reference of available commands in atcommand DBMap
  **/
@@ -10111,6 +10128,7 @@ static void atcommand_basecommands(void)
 		ACMD_DEF(reloadclans),
 		ACMD_DEF(setzone),
 		ACMD_DEF(camerainfo),
+		ACMD_DEF(refineryui),
 	};
 	int i;
 
diff --git a/src/map/battle.c b/src/map/battle.c
index b06de267d..2f33e2ea9 100644
--- a/src/map/battle.c
+++ b/src/map/battle.c
@@ -7419,6 +7419,8 @@ static const struct battle_data {
 	{ "ping_time",                          &battle_config.ping_time,                       20,     0,      99999999,       },
 	{ "option_drop_max_loop",               &battle_config.option_drop_max_loop,            10,     1,      100000,         },
 	{ "drop_connection_on_quit",            &battle_config.drop_connection_on_quit,         0,      0,      1,              },
+	{"features/enable_refinery_ui",         &battle_config.enable_refinery_ui,              1,      0,      1,              },
+	{"features/replace_refine_npcs",        &battle_config.replace_refine_npcs,             1,      0,      1,              },
 };
 
 static bool battle_set_value_sub(int index, int value)
@@ -7544,6 +7546,18 @@ static void battle_adjust_conf(void)
 	}
 #endif
 
+#if !(PACKETVER_MAIN_NUM >= 20161130 || PACKETVER_RE_NUM >= 20161109 || defined(PACKETVER_ZERO))
+	if (battle_config.enable_refinery_ui == 1) {
+		ShowWarning("conf/map/battle/feature.conf refinery ui is enabled but it requires PACKETVER 2016-11-09 RagexeRE/2016-11-30 Ragexe or newer, disabling...\n");
+		battle_config.enable_refinery_ui = 0;
+	}
+
+	if (battle_config.replace_refine_npcs == 1) {
+		ShowWarning("conf/map/battle/feature.conf replace refine npcs is enabled but it requires PACKETVER 2016-11-09 RagexeRE/2016-11-30 Ragexe or newer, disabling...\n");
+		battle_config.replace_refine_npcs = 0;
+	}
+#endif
+
 #ifndef CELL_NOSTACK
 	if (battle_config.custom_cell_stack_limit != 1)
 		ShowWarning("Battle setting 'custom_cell_stack_limit' takes no effect as this server was compiled without Cell Stack Limit support.\n");
diff --git a/src/map/battle.h b/src/map/battle.h
index 8743274ee..1640a4e7f 100644
--- a/src/map/battle.h
+++ b/src/map/battle.h
@@ -587,6 +587,8 @@ struct Battle_Config {
 	int option_drop_max_loop;
 
 	int drop_connection_on_quit;
+	int enable_refinery_ui;
+	int replace_refine_npcs;
 };
 
 /* criteria for battle_config.idletime_critera */
diff --git a/src/map/clif.c b/src/map/clif.c
index 299c69a1c..462991510 100644
--- a/src/map/clif.c
+++ b/src/map/clif.c
@@ -49,6 +49,7 @@
 #include "map/pet.h"
 #include "map/quest.h"
 #include "map/rodex.h"
+#include "map/refine.h"
 #include "map/script.h"
 #include "map/skill.h"
 #include "map/status.h"
@@ -22492,6 +22493,104 @@ static void clif_parse_ResetCooldown(int fd, struct map_session_data *sd)
 	atcommand->exec(fd, sd, cmd, true);
 }
 
+static void clif_OpenRefineryUI(struct map_session_data *sd)
+{
+#if PACKETVER_MAIN_NUM >= 20161130 || PACKETVER_RE_NUM >= 20161109 || defined(PACKETVER_ZERO)
+	nullpo_retv(sd);
+
+	if (battle_config.enable_refinery_ui == 0)
+		return;
+
+	struct PACKET_ZC_REFINE_OPEN_WINDOW p;
+	p.packetType = HEADER_ZC_REFINE_OPEN_WINDOW;
+	clif->send(&p, sizeof(p), &sd->bl, SELF);
+
+	sd->state.refine_ui = 1;
+#endif
+}
+
+static void clif_parse_AddItemRefineryUI(int fd, struct map_session_data *sd) __attribute__((nonnull(2)));
+static void clif_parse_AddItemRefineryUI(int fd, struct map_session_data *sd)
+{
+#if PACKETVER_MAIN_NUM >= 20161005 || PACKETVER_RE_NUM >= 20161005 || defined(PACKETVER_ZERO)
+	if (battle_config.enable_refinery_ui == 0)
+		return;
+
+	const struct PACKET_CZ_REFINE_ADD_ITEM *p = RFIFO2PTR(fd);
+	refine->refinery_add_item(sd, p->index - 2);
+#endif
+}
+
+static void clif_AddItemRefineryUIAck(struct map_session_data *sd, int item_index, struct s_refine_requirement *req)
+{
+#if PACKETVER_MAIN_NUM >= 20161130 || PACKETVER_RE_NUM >= 20161109 || defined(PACKETVER_ZERO)
+	nullpo_retv(sd);
+	nullpo_retv(req);
+	Assert_retv(item_index >= 0 && item_index < sd->status.inventorySize);
+
+	if (battle_config.enable_refinery_ui == 0)
+		return;
+
+	char buf[sizeof(struct PACKET_ZC_REFINE_ADD_ITEM) + sizeof(struct PACKET_ZC_REFINE_ADD_ITEM_SUB) * MAX_REFINE_REQUIREMENTS];
+	struct PACKET_ZC_REFINE_ADD_ITEM *p = (struct PACKET_ZC_REFINE_ADD_ITEM *)buf;
+
+	p->packetType = HEADER_ZC_REFINE_ADD_ITEM;
+	p->packtLength = sizeof(*p) + sizeof(p->req[0]) * req->req_count;
+	p->itemIndex = item_index + 2;
+	p->blacksmithBlessing = req->blacksmith_blessing;
+
+	int weapon_level = itemdb_wlv(sd->status.inventory[item_index].nameid);
+	for (int i = 0; i < req->req_count; ++i) {
+		p->req[i].chance = refine->get_refine_chance(weapon_level, sd->status.inventory[item_index].refine, req->req[i].type);
+		p->req[i].itemId = req->req[i].nameid;
+		p->req[i].zeny = req->req[i].cost;
+	}
+
+	clif->send(p, p->packtLength, &sd->bl, SELF);
+#endif
+}
+
+static void clif_parse_RefineryUIRefine(int fd, struct map_session_data *sd) __attribute__((nonnull(2)));
+static void clif_parse_RefineryUIRefine(int fd, struct map_session_data *sd)
+{
+#if PACKETVER_MAIN_NUM >= 20161005 || PACKETVER_RE_NUM >= 20161005 || defined(PACKETVER_ZERO)
+	if (battle_config.enable_refinery_ui == 0)
+		return;
+
+	const struct PACKET_CZ_REFINE_ITEM_REQUEST *p = RFIFO2PTR(fd);
+	refine->refinery_refine_request(sd, p->index - 2, p->itemId, (p->blacksmithBlessing == 1) ? true : false);
+#endif
+}
+
+static void clif_parse_RefineryUIClose(int fd, struct map_session_data *sd) __attribute__((nonnull(2)));
+static void clif_parse_RefineryUIClose(int fd, struct map_session_data *sd)
+{
+#if PACKETVER_MAIN_NUM >= 20161130 || PACKETVER_RE_NUM >= 20161109 || defined(PACKETVER_ZERO)
+	if (battle_config.enable_refinery_ui == 0)
+		return;
+
+	sd->state.refine_ui = 0;
+	return;
+#endif
+}
+
+static void clif_announce_refine_status(struct map_session_data *sd, int item_id, int refine_level, bool success, enum send_target target)
+{
+#if PACKETVER_MAIN_NUM >= 20170906 || PACKETVER_RE_NUM >= 20170830 || defined(PACKETVER_ZERO)
+	nullpo_retv(sd);
+
+	Assert_retv(refine_level > 0 && refine_level <= INT8_MAX);
+
+	struct PACKET_ZC_REFINE_STATUS p;
+	p.packetType = HEADER_ZC_REFINE_STATUS;
+	safestrncpy(p.name, sd->status.name, NAME_LENGTH);
+	p.itemId = item_id;
+	p.refine_level = refine_level;
+	p.status = (success) ? true : false;
+	clif->send(&p, sizeof(p), &sd->bl, target);
+#endif
+}
+
 /*==========================================
  * Main client packet processing function
  *------------------------------------------*/
@@ -23705,4 +23804,10 @@ void clif_defaults(void)
 	clif->pResetCooldown = clif_parse_ResetCooldown;
 	clif->loadConfirm = clif_loadConfirm;
 	clif->send_selforarea = clif_send_selforarea;
+	clif->OpenRefineryUI = clif_OpenRefineryUI;
+	clif->pAddItemRefineryUI = clif_parse_AddItemRefineryUI;
+	clif->AddItemRefineryUIAck = clif_AddItemRefineryUIAck;
+	clif->pRefineryUIClose = clif_parse_RefineryUIClose;
+	clif->pRefineryUIRefine = clif_parse_RefineryUIRefine;
+	clif->announce_refine_status = clif_announce_refine_status;
 }
diff --git a/src/map/clif.h b/src/map/clif.h
index aaf053274..19c321ed3 100644
--- a/src/map/clif.h
+++ b/src/map/clif.h
@@ -55,6 +55,7 @@ struct skill_unit;
 struct unit_data;
 struct view_data;
 struct achievement_data; // map/achievement.h
+struct s_refine_requirement;
 
 enum clif_messages;
 enum rodex_add_item;
@@ -1611,6 +1612,12 @@ struct clif_interface {
 	void (*pResetCooldown) (int fd, struct map_session_data *sd);
 	void (*loadConfirm) (struct map_session_data *sd);
 	void (*send_selforarea) (int fd, struct block_list *bl, const void *buf, int len);
+	void (*OpenRefineryUI) (struct map_session_data *sd);
+	void (*pAddItemRefineryUI) (int fd, struct map_session_data *sd);
+	void (*AddItemRefineryUIAck) (struct map_session_data *sd, int item_index, struct s_refine_requirement *req);
+	void (*pRefineryUIClose) (int fd, struct map_session_data *sd);
+	void (*pRefineryUIRefine) (int fd, struct map_session_data *sd);
+	void (*announce_refine_status) (struct map_session_data *sd, int item_id, int refine_level, bool success, enum send_target target);
 };
 
 #ifdef HERCULES_CORE
diff --git a/src/map/itemdb.c b/src/map/itemdb.c
index a61bbd008..11d778f8a 100644
--- a/src/map/itemdb.c
+++ b/src/map/itemdb.c
@@ -27,6 +27,7 @@
 #include "map/map.h"
 #include "map/mob.h"    // MAX_MOB_DB
 #include "map/pc.h"     // W_MUSICAL, W_WHIP
+#include "map/refine.h"
 #include "map/script.h" // item script processing
 #include "common/HPM.h"
 #include "common/conf.h"
diff --git a/src/map/itemdb.h b/src/map/itemdb.h
index 315787993..e032def0c 100644
--- a/src/map/itemdb.h
+++ b/src/map/itemdb.h
@@ -130,6 +130,7 @@ enum item_itemid {
 	ITEMID_INDIGO_PTS            = 6361,
 	ITEMID_YELLOW_WISH_PTS       = 6362,
 	ITEMID_LIME_GREEN_PTS        = 6363,
+	ITEMID_BLACKSMITH_BLESSING   = 6635,
 	ITEMID_STONE                 = 7049,
 	ITEMID_FIRE_BOTTLE           = 7135,
 	ITEMID_ACID_BOTTLE           = 7136,
diff --git a/src/map/log.c b/src/map/log.c
index efb7fefbc..5bbca02a9 100644
--- a/src/map/log.c
+++ b/src/map/log.c
@@ -106,7 +106,7 @@ static char log_chattype2char(e_log_chat_type type)
 }
 
 /// check if this item should be logged according the settings
-static bool should_log_item(int nameid, int amount, int refine, struct item_data *id)
+static bool should_log_item(int nameid, int amount, int refine_level, struct item_data *id)
 {
 	int filter = logs->config.filter;
 
@@ -123,7 +123,7 @@ static bool should_log_item(int nameid, int amount, int refine, struct item_data
 		( filter&LOG_FILTER_PETITEM && ( id->type == IT_PETEGG || id->type == IT_PETARMOR ) ) ||
 		( filter&LOG_FILTER_PRICE && id->value_buy >= logs->config.price_items_log ) ||
 		( filter&LOG_FILTER_AMOUNT && abs(amount) >= logs->config.amount_items_log ) ||
-		( filter&LOG_FILTER_REFINE && refine >= logs->config.refine_items_log ) ||
+		( filter&LOG_FILTER_REFINE && refine_level >= logs->config.refine_items_log ) ||
 		( filter&LOG_FILTER_CHANCE && ( ( id->maxchance != -1 && id->maxchance <= logs->config.rare_items_log ) || id->nameid == ITEMID_EMPERIUM ) )
 	)
 		return true;
diff --git a/src/map/log.h b/src/map/log.h
index db802575d..116d99bfd 100644
--- a/src/map/log.h
+++ b/src/map/log.h
@@ -155,7 +155,7 @@ struct log_interface {
 
 	char (*picktype2char) (e_log_pick_type type);
 	char (*chattype2char) (e_log_chat_type type);
-	bool (*should_log_item) (int nameid, int amount, int refine, struct item_data *id);
+	bool (*should_log_item) (int nameid, int amount, int refine_level, struct item_data *id);
 };
 
 #ifdef HERCULES_CORE
diff --git a/src/map/map.c b/src/map/map.c
index 7d2cc87d4..2b95ec27a 100644
--- a/src/map/map.c
+++ b/src/map/map.c
@@ -58,6 +58,7 @@
 #include "map/storage.h"
 #include "map/stylist.h"
 #include "map/rodex.h"
+#include "map/refine.h"
 #include "map/trade.h"
 #include "map/unit.h"
 #include "map/achievement.h"
@@ -6190,6 +6191,7 @@ int do_final(void)
 	atcommand->final_msg();
 	skill->final();
 	status->final();
+	refine->final();
 	unit->final();
 	bg->final();
 	duel->final();
@@ -6407,6 +6409,7 @@ static void map_load_defaults(void)
 	npc_chat_defaults();
 	rodex_defaults();
 	stylist_defaults();
+	refine_defaults();
 }
 /**
  * --run-once handler
@@ -6711,6 +6714,7 @@ int do_init(int argc, char *argv[])
 		map->read_zone_db();/* read after item and skill initialization */
 	mob->init(minimal);
 	pc->init(minimal);
+	refine->init(minimal);
 	status->init(minimal);
 	party->init(minimal);
 	guild->init(minimal);
diff --git a/src/map/packets.h b/src/map/packets.h
index 99404cbe3..bffec4f43 100644
--- a/src/map/packets.h
+++ b/src/map/packets.h
@@ -1805,6 +1805,12 @@ packet(0x96e,clif->ackmergeitems);
 	packet(0x0a88,clif->pResetCooldown);
 #endif
 
+#if PACKETVER_MAIN_NUM >= 20161130 || PACKETVER_RE_NUM >= 20161109 || defined(PACKETVER_ZERO)
+	packet(0x0aa1, clif->pAddItemRefineryUI);
+	packet(0x0aa3, clif->pRefineryUIRefine);
+	packet(0x0aa4, clif->pRefineryUIClose);
+#endif
+
 // 2017-02-28aRagexeRE
 #if PACKETVER >= 20170228
 // new packets
diff --git a/src/map/packets_struct.h b/src/map/packets_struct.h
index 45683596f..33b7759ce 100644
--- a/src/map/packets_struct.h
+++ b/src/map/packets_struct.h
@@ -3319,6 +3319,76 @@ struct PACKET_ZC_SE_PC_BUY_CASHITEM_RESULT {
 DEFINE_PACKET_HEADER(ZC_SE_PC_BUY_CASHITEM_RESULT, 0x0849);
 #endif
 
+#if PACKETVER_MAIN_NUM >= 20161130 || PACKETVER_RE_NUM >= 20161109 || defined(PACKETVER_ZERO)
+struct PACKET_ZC_REFINE_OPEN_WINDOW {
+	int16 packetType;
+} __attribute__((packed));
+DEFINE_PACKET_HEADER(ZC_REFINE_OPEN_WINDOW, 0x0aa0);
+#endif
+
+#if PACKETVER_MAIN_NUM >= 20161005 || PACKETVER_RE_NUM >= 20161005 || defined(PACKETVER_ZERO)
+struct PACKET_CZ_REFINE_ADD_ITEM {
+	int16 packetType;
+	int16 index;
+};
+DEFINE_PACKET_HEADER(CZ_REFINE_ADD_ITEM, 0x0aa1);
+#endif
+
+#if PACKETVER_MAIN_NUM >= 20161130 || PACKETVER_RE_NUM >= 20161109 || defined(PACKETVER_ZERO)
+struct PACKET_ZC_REFINE_ADD_ITEM_SUB {
+#if PACKETVER_MAIN_NUM >= 20181121 || PACKETVER_RE_NUM >= 20180704 || PACKETVER_ZERO_NUM >= 20181114
+	uint32 itemId;
+#else
+	uint16 itemId;
+#endif
+	int8 chance;
+	int32 zeny;
+} __attribute__((packed));
+
+struct PACKET_ZC_REFINE_ADD_ITEM {
+	int16 packetType;
+	int16 packtLength;
+	int16 itemIndex;
+	int8 blacksmithBlessing;
+	struct PACKET_ZC_REFINE_ADD_ITEM_SUB req[];
+} __attribute__((packed));
+DEFINE_PACKET_HEADER(ZC_REFINE_ADD_ITEM, 0x0aa2);
+#endif
+
+#if PACKETVER_MAIN_NUM >= 20161005 || PACKETVER_RE_NUM >= 20161005 || defined(PACKETVER_ZERO)
+struct PACKET_CZ_REFINE_ITEM_REQUEST {
+	int16 packetType;
+	int16 index;
+#if PACKETVER_MAIN_NUM >= 20181121 || PACKETVER_RE_NUM >= 20180704 || PACKETVER_ZERO_NUM >= 20181114
+	uint32 itemId;
+#else
+	uint16 itemId;
+#endif
+	int8 blacksmithBlessing;
+} __attribute__((packed));
+DEFINE_PACKET_HEADER(CZ_REFINE_ITEM_REQUEST, 0x0aa3);
+
+struct PACKET_CZ_REFINE_WINDOW_CLOSE {
+	int16 packetType;
+} __attribute__((packed));
+DEFINE_PACKET_HEADER(CZ_REFINE_WINDOW_CLOSE, 0x0aa4);
+#endif
+
+#if PACKETVER_MAIN_NUM >= 20170906 || PACKETVER_RE_NUM >= 20170830 || defined(PACKETVER_ZERO)
+struct PACKET_ZC_REFINE_STATUS {
+	int16 packetType;
+	char name[NAME_LENGTH];
+#if PACKETVER_MAIN_NUM >= 20181121 || PACKETVER_RE_NUM >= 20180704 || PACKETVER_ZERO_NUM >= 20181114
+	uint32 itemId;
+#else
+	uint16 itemId;
+#endif
+	int8 refine_level;
+	int8 status;
+} __attribute__((packed));
+DEFINE_PACKET_HEADER(ZC_REFINE_STATUS, 0x0ada);
+#endif
+
 #if !defined(sun) && (!defined(__NETBSD__) || __NetBSD_Version__ >= 600000000) // NetBSD 5 and Solaris don't like pragma pack but accept the packed attribute
 #pragma pack(pop)
 #endif // not NetBSD < 6 / Solaris
diff --git a/src/map/pc.h b/src/map/pc.h
index b2069d4df..42c9d204e 100644
--- a/src/map/pc.h
+++ b/src/map/pc.h
@@ -237,6 +237,7 @@ struct map_session_data {
 		unsigned int standalone : 1;/* [Ind/Hercules <3] */
 		unsigned int loggingout : 1;
 		unsigned int warp_clean : 1;
+		unsigned int refine_ui : 1;
 	} state;
 	struct {
 		unsigned char no_weapon_damage, no_magic_damage, no_misc_damage;
@@ -660,10 +661,10 @@ END_ZEROED_BLOCK;
 #define pc_issit(sd)          ( (sd)->vd.dead_sit == 2 )
 #define pc_isidle(sd)         ( (sd)->chat_id != 0 || (sd)->state.vending || (sd)->state.buyingstore || DIFF_TICK(sockt->last_tick, (sd)->idletime) >= battle->bc->idle_no_share )
 #define pc_istrading(sd)      ( (sd)->npc_id || (sd)->state.vending || (sd)->state.buyingstore || (sd)->state.trading )
-#define pc_cant_act(sd)       ( (sd)->npc_id || (sd)->state.vending || (sd)->state.buyingstore || (sd)->chat_id != 0 || ((sd)->sc.opt1 && (sd)->sc.opt1 != OPT1_BURNING) || (sd)->state.trading || (sd)->state.storage_flag || (sd)->state.prevend )
+#define pc_cant_act(sd)       ( (sd)->npc_id || (sd)->state.vending || (sd)->state.buyingstore || (sd)->chat_id != 0 || ((sd)->sc.opt1 && (sd)->sc.opt1 != OPT1_BURNING) || (sd)->state.trading || (sd)->state.storage_flag || (sd)->state.prevend || (sd)->state.refine_ui == 1)
 
 /* equals pc_cant_act except it doesn't check for chat rooms */
-#define pc_cant_act2(sd)       ( (sd)->npc_id || (sd)->state.buyingstore || ((sd)->sc.opt1 && (sd)->sc.opt1 != OPT1_BURNING) || (sd)->state.trading || (sd)->state.storage_flag || (sd)->state.prevend )
+#define pc_cant_act2(sd)       ( (sd)->npc_id || (sd)->state.buyingstore || ((sd)->sc.opt1 && (sd)->sc.opt1 != OPT1_BURNING) || (sd)->state.trading || (sd)->state.storage_flag || (sd)->state.prevend || (sd)->state.refine_ui == 1)
 
 #define pc_setdir(sd,b,h)     ( (sd)->ud.dir = (b) ,(sd)->head_dir = (h) )
 #define pc_setchatid(sd,n)    ( (sd)->chat_id = (n) )
diff --git a/src/map/refine.c b/src/map/refine.c
new file mode 100644
index 000000000..1ff893c56
--- /dev/null
+++ b/src/map/refine.c
@@ -0,0 +1,669 @@
+/**
+* This file is part of Hercules.
+* http://herc.ws - http://github.com/HerculesWS/Hercules
+*
+* Copyright (C) 2019  Hercules Dev Team
+*
+* Hercules is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define HERCULES_CORE
+
+#include "refine.p.h"
+#include "common/cbasetypes.h"
+#include "common/nullpo.h"
+#include "common/random.h"
+#include "common/showmsg.h"
+#include "common/strlib.h"
+#include "common/utils.h"
+#include "map/itemdb.h"
+#include "map/map.h"
+#include "map/pc.h"
+#include "map/script.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/** @file
+* Implementation of the refine interface.
+*/
+
+static struct refine_interface refine_s;
+static struct refine_interface_private refine_p;
+static struct refine_interface_dbs refine_dbs;
+struct refine_interface *refine;
+
+/// @copydoc refine_interface::refinery_refine_request()
+static void refine_refinery_refine_request(struct map_session_data *sd, int item_index, int material_id, bool use_blacksmith_blessing)
+{
+	nullpo_retv(sd);
+
+	if (item_index < 0 || item_index >= sd->status.inventorySize)
+		return;
+
+	if (!refine->p->is_refinable(sd, item_index))
+		return;
+
+	int weapon_level = itemdb_wlv(sd->status.inventory[item_index].nameid);
+	int refine_level = sd->status.inventory[item_index].refine;
+	int i = 0;
+	const struct s_refine_requirement *req = &refine->p->dbs->refine_info[weapon_level].refine_requirements[refine_level];
+	ARR_FIND(0, req->req_count, i, req->req[i].nameid == material_id);
+
+	if (i == req->req_count)
+		return;
+
+	if (use_blacksmith_blessing && req->blacksmith_blessing == 0)
+		return;
+
+	if (sd->status.zeny < req->req[i].cost)
+		return;
+
+	if (use_blacksmith_blessing) {
+		int count = 0;
+		for (int k = 0; k < sd->status.inventorySize; ++k) {
+			if (sd->status.inventory[k].nameid == ITEMID_BLACKSMITH_BLESSING)
+				count += sd->status.inventory[k].amount;
+		}
+
+		if (count < req->blacksmith_blessing)
+			return;
+	}
+
+	int idx;
+	if ((idx = pc->search_inventory(sd, req->req[i].nameid)) == INDEX_NOT_FOUND)
+		return;
+
+	if (use_blacksmith_blessing) {
+		int amount = req->blacksmith_blessing;
+		for (int k = 0; k < sd->status.inventorySize; ++k) {
+			if (sd->status.inventory[k].nameid != ITEMID_BLACKSMITH_BLESSING)
+				continue;
+
+			int delamount = (amount < sd->status.inventory[k].amount) ? amount : sd->status.inventory[k].amount;
+			if (pc->delitem(sd, k, delamount, 0, DELITEM_NORMAL, LOG_TYPE_REFINE) != 0)
+				break;
+
+			amount -= delamount;
+			if (amount == 0)
+				break;
+		}
+	}
+
+	if (pc->delitem(sd, idx, 1, 0, DELITEM_NORMAL, LOG_TYPE_REFINE) != 0)
+		return;
+
+	if (pc->payzeny(sd, req->req[i].cost, LOG_TYPE_REFINE, NULL) != 0)
+		return;
+
+	int refine_chance = refine->get_refine_chance(weapon_level, refine_level, req->req[i].type);
+	if (rnd() % 100 >= refine_chance) {
+		clif->misceffect(&sd->bl, 2);
+
+		int failure_behabior = (use_blacksmith_blessing) ? REFINE_FAILURE_BEHAVIOR_KEEP : req->req[i].failure_behavior;
+		switch (failure_behabior) {
+		case REFINE_FAILURE_BEHAVIOR_KEEP:
+			clif->refine(sd->fd, 1, 0, sd->status.inventory[item_index].refine);
+			refine->refinery_add_item(sd, item_index);
+			break;
+		case REFINE_FAILURE_BEHAVIOR_DOWNGRADE:
+			sd->status.inventory[item_index].refine -= 1;
+			sd->status.inventory[item_index].refine = cap_value(sd->status.inventory[item_index].refine, 0, MAX_REFINE);
+			clif->refine(sd->fd, 2, item_index, sd->status.inventory[item_index].refine);
+			logs->pick_pc(sd, LOG_TYPE_REFINE, 1, &sd->status.inventory[item_index], sd->inventory_data[item_index]);
+			refine->refinery_add_item(sd, item_index);
+			break;
+		case REFINE_FAILURE_BEHAVIOR_DESTROY:
+		default:
+			clif->refine(sd->fd, 1, item_index, sd->status.inventory[item_index].refine);
+			pc->delitem(sd, item_index, 1, 0, DELITEM_FAILREFINE, LOG_TYPE_REFINE);
+			break;
+		}
+
+		if ((req->announce & REFINE_ANNOUNCE_FAILURE) != 0)
+			clif->announce_refine_status(sd, sd->status.inventory[item_index].nameid, sd->status.inventory[item_index].refine, false, ALL_CLIENT);
+	} else {
+		sd->status.inventory[item_index].refine += 1;
+		sd->status.inventory[item_index].refine = cap_value(sd->status.inventory[item_index].refine, 0, MAX_REFINE);
+
+		clif->misceffect(&sd->bl, 3);
+		clif->refine(sd->fd, 0, item_index, sd->status.inventory[item_index].refine);
+		logs->pick_pc(sd, LOG_TYPE_REFINE, 1, &sd->status.inventory[item_index], sd->inventory_data[item_index]);
+		refine->refinery_add_item(sd, item_index);
+
+		if ((req->announce & REFINE_ANNOUNCE_SUCCESS) != 0)
+			clif->announce_refine_status(sd, sd->status.inventory[item_index].nameid, sd->status.inventory[item_index].refine, true, ALL_CLIENT);
+	}
+}
+
+/// @copydoc refine_interface::refinery_add_item()
+static void refine_refinery_add_item(struct map_session_data *sd, int item_index)
+{
+	nullpo_retv(sd);
+
+	if (item_index < 0 || item_index >= sd->status.inventorySize)
+		return;
+
+	if (!refine->p->is_refinable(sd, item_index))
+		return;
+	
+	int weapon_level = itemdb_wlv(sd->status.inventory[item_index].nameid);
+	int refine_level = sd->status.inventory[item_index].refine;
+	clif->AddItemRefineryUIAck(sd, item_index, &refine->p->dbs->refine_info[weapon_level].refine_requirements[refine_level]);
+}
+
+/// @copydoc refine_interface_private::is_refinable()
+static bool refine_is_refinable(struct map_session_data *sd, int item_index)
+{
+	nullpo_retr(false, sd);
+	Assert_retr(false, item_index >= 0 && item_index < sd->status.inventorySize);
+
+	if (sd->status.inventory[item_index].nameid == 0)
+		return false;
+
+	struct item_data *itd = itemdb->search(sd->status.inventory[item_index].nameid);
+
+	if (itd == &itemdb->dummy)
+		return false;
+
+	if (itd->type != IT_WEAPON && itd->type != IT_ARMOR)
+		return false;
+
+	if (itd->flag.no_refine == 1)
+		return false;
+
+	if (sd->status.inventory[item_index].identify == 0)
+		return false;
+
+	if (sd->status.inventory[item_index].refine >= MAX_REFINE || sd->status.inventory[item_index].expire_time > 0)
+		return false;
+
+	if ((sd->status.inventory[item_index].attribute & ATTR_BROKEN) != 0)
+		return false;
+
+	return true;
+}
+
+/// @copydoc refine_interface::get_randombonus_max()
+static int refine_get_randombonus_max(enum refine_type equipment_type, int refine_level)
+{
+	Assert_ret((int)equipment_type >= REFINE_TYPE_ARMOR && equipment_type < REFINE_TYPE_MAX);
+	Assert_ret(refine_level > 0 && refine_level <= MAX_REFINE);
+
+	return refine->p->dbs->refine_info[equipment_type].randombonus_max[refine_level - 1];
+}
+
+/// @copydoc refine_interface::get_bonus()
+static int refine_get_bonus(enum refine_type equipment_type, int refine_level)
+{
+	Assert_ret((int)equipment_type >= REFINE_TYPE_ARMOR && equipment_type < REFINE_TYPE_MAX);
+	Assert_ret(refine_level > 0 && refine_level <= MAX_REFINE);
+
+	return refine->p->dbs->refine_info[equipment_type].bonus[refine_level - 1];
+}
+
+/// @copydoc refine_interface::get_refine_chance()
+static int refine_get_refine_chance(enum refine_type wlv, int refine_level, enum refine_chance_type type)
+{
+	Assert_ret((int)wlv >= REFINE_TYPE_ARMOR && wlv < REFINE_TYPE_MAX);
+
+	if (refine_level < 0 || refine_level >= MAX_REFINE)
+		return 0;
+
+	if (type >= REFINE_CHANCE_TYPE_MAX)
+		return 0;
+
+	return refine->p->dbs->refine_info[wlv].chance[type][refine_level];
+}
+
+/// @copydoc refine_interface_private::announce_behavior_string2enum()
+static bool refine_announce_behavior_string2enum(const char *str, unsigned int *result)
+{
+	nullpo_retr(false, str);
+	nullpo_retr(false, result);
+
+	if (strcasecmp(str, "Success") == 0)
+		*result = REFINE_ANNOUNCE_SUCCESS;
+	else if (strcasecmp(str, "Failure") == 0)
+		*result = REFINE_ANNOUNCE_FAILURE;
+	else if (strcasecmp(str, "Always") == 0)
+		*result = REFINE_ANNOUNCE_ALWAYS;
+	else
+		return false;
+
+	return true;
+}
+
+/// @copydoc refine_interface_private::failure_behavior_string2enum()
+static bool refine_failure_behavior_string2enum(const char *str, enum refine_ui_failure_behavior *result)
+{
+	nullpo_retr(false, str);
+	nullpo_retr(false, result);
+
+	if (strcasecmp(str, "Destroy") == 0)
+		*result = REFINE_FAILURE_BEHAVIOR_DESTROY;
+	else if (strcasecmp(str, "Keep") == 0)
+		*result = REFINE_FAILURE_BEHAVIOR_KEEP;
+	else if (strcasecmp(str, "Downgrade") == 0)
+		*result = REFINE_FAILURE_BEHAVIOR_DOWNGRADE;
+	else
+		return false;
+
+	return true;
+}
+
+/// @copydoc refine_interface_private::readdb_refinery_ui_settings_items()
+static bool refine_readdb_refinery_ui_settings_items(const struct config_setting_t *elem, struct s_refine_requirement *req, const char *name, const char *source)
+{
+	nullpo_retr(false, elem);
+	nullpo_retr(false, req);
+	nullpo_retr(false, name);
+	nullpo_retr(false, source);
+	Assert_retr(false, req->req_count < MAX_REFINE_REQUIREMENTS);
+
+	const char *aegis_name = config_setting_name(elem);
+	struct item_data *itd;
+
+	if ((itd = itemdb->search_name(aegis_name)) == NULL) {
+		ShowWarning("refine_readdb_requirements_items: Invalid item '%s' passed to requirements of '%s' in \"%s\" skipping...\n", aegis_name, name, source);
+		return false;
+	}
+
+	for (int i = 0; i < req->req_count; ++i) {
+		if (req->req[i].nameid == itd->nameid) {
+			ShowWarning("refine_readdb_requirements_items: Duplicated item '%s' passed to requirements of '%s' in \"%s\" skipping...\n", aegis_name, name, source);
+			return false;
+		}
+	}
+
+	const char *type_string = NULL;
+	if (libconfig->setting_lookup_string(elem, "Type", &type_string) == CONFIG_FALSE) {
+		ShowWarning("refine_readdb_requirements_items: no type passed to item '%s' of requirements of '%s' in \"%s\" skipping...\n", aegis_name, name, source);
+		return false;
+	}
+
+	int type;
+	if (!script->get_constant(type_string, &type)) {
+		ShowWarning("refine_readdb_requirements_items: invalid type '%s' passed to item '%s' of requirements of '%s' in \"%s\" skipping...\n", type_string, aegis_name, name, source);
+		return false;
+	}
+
+	int cost = 0;
+	if (libconfig->setting_lookup_int(elem, "Cost", &cost) == CONFIG_TRUE) {
+		if (cost < 1) {
+			ShowWarning("refine_readdb_requirements_items: invalid cost value %d passed to item '%s' of requirements of '%s' in \"%s\" defaulting to 0...\n", cost, aegis_name, name, source);
+			cost = 0;
+		}
+	}
+
+	enum refine_ui_failure_behavior behavior = REFINE_FAILURE_BEHAVIOR_DESTROY;
+	const char *behavior_string = NULL;
+	if (libconfig->setting_lookup_string(elem, "FailureBehavior", &behavior_string) != CONFIG_FALSE) {
+		if (!refine->p->failure_behavior_string2enum(behavior_string, &behavior)) {
+			ShowWarning("refine_readdb_requirements_items: invalid failure behavior value %s passed to item '%s' of requirements of '%s' in \"%s\" defaulting to 'Destroy'...\n", behavior_string, aegis_name, name, source);
+		}
+	}
+
+	req->req[req->req_count].nameid = itd->nameid;
+	req->req[req->req_count].type = type;
+	req->req[req->req_count].cost = cost;
+	req->req[req->req_count].failure_behavior = behavior;
+	req->req_count++;
+
+	return true;
+}
+
+/// @copydoc refine_interface_private::readdb_refinery_ui_settings_sub()
+static bool refine_readdb_refinery_ui_settings_sub(const struct config_setting_t *elem, int type, const char *name, const char *source)
+{
+	nullpo_retr(false, elem);
+	nullpo_retr(false, name);
+	nullpo_retr(false, source);
+	Assert_retr(0, type >= REFINE_TYPE_ARMOR && type < REFINE_TYPE_MAX);
+
+	struct config_setting_t *level_t;
+	bool levels[MAX_REFINE] = {0};
+
+	if ((level_t = libconfig->setting_get_member(elem, "Level")) == NULL) {
+		ShowWarning("refine_readdb_requirements_sub: a requirements element missing level field for entry '%s' in \"%s\" skipping...\n", name, source);
+		return false;
+	}
+
+	if (config_setting_is_scalar(level_t)) {
+		if (!config_setting_is_number(level_t)) {
+			ShowWarning("refine_readdb_requirements_sub: expected 'Level' field to be an integer '%s' in \"%s\" skipping...\n", name, source);
+			return false;
+		}
+
+		int refine_level = libconfig->setting_get_int(level_t);
+		if (refine_level < 1 || refine_level > MAX_REFINE) {
+			ShowWarning("refine_readdb_requirements_sub: Invalid 'Level' given value %d expected a value between %d and %d '%s' in \"%s\" skipping...\n", refine_level, 1, MAX_REFINE, name, source);
+			return false;
+		}
+
+		levels[refine_level - 1] = true;
+	} else if (config_setting_is_aggregate(level_t)) {
+		if (libconfig->setting_length(level_t) != 2) {
+			ShowWarning("refine_readdb_requirements_sub: invalid length for Level array, expected 2 found %d for entry '%s' in \"%s\" skipping...\n", libconfig->setting_length(level_t), name, source);
+			return false;
+		}
+
+		int levels_range[2];
+		const struct config_setting_t *level_entry = NULL;
+		int i = 0,
+			k = 0;
+		while ((level_entry = libconfig->setting_get_elem(level_t, i++)) != NULL) {
+			if (!config_setting_is_number(level_entry)) {
+				ShowWarning("refine_readdb_requirements_sub: expected 'Level' array field to be an integer '%s' in \"%s\" skipping...\n", name, source);
+				return false;
+			}
+
+			levels_range[k] = libconfig->setting_get_int(level_entry);
+			if (levels_range[k] < 1 || levels_range[k] > MAX_REFINE) {
+				ShowWarning("refine_readdb_requirements_sub: Invalid 'Level' given value %d expected a value between %d and %d in entry'%s' in \"%s\" skipping...\n", levels_range[k], 1, MAX_REFINE, name, source);
+				return false;
+			}
+
+			++k;
+		}
+
+		if (!(levels_range[0] < levels_range[1])) {
+			ShowWarning("refine_readdb_requirements_sub: Invalid 'Level' range was given low %d high %d in entry'%s' in \"%s\" skipping...\n", levels_range[0], levels_range[1], name, source);
+			return false;
+		}
+
+		for (i = levels_range[0] - 1; i < levels_range[1]; ++i) {
+			levels[i] = true;
+		}
+	}
+
+	struct s_refine_requirement req = {0};
+	if (libconfig->setting_lookup_int(elem, "BlacksmithBlessing", &req.blacksmith_blessing) == CONFIG_TRUE) {
+		if (req.blacksmith_blessing < 1 || req.blacksmith_blessing > INT8_MAX) {
+			ShowWarning("refine_readdb_requirements_sub: Invalid 'BlacksmithBlessing' amount was given value %d expected a value between %d and %d in entry'%s' in \"%s\" defaulting to 0...\n", req.blacksmith_blessing, 1, INT8_MAX, name, source);
+			req.blacksmith_blessing = 0;
+		}
+	}
+
+	req.announce = 0;
+	const char *announce_behavior = NULL;
+	if (libconfig->setting_lookup_string(elem, "Announce", &announce_behavior) != CONFIG_FALSE) {
+		if (!refine->p->announce_behavior_string2enum(announce_behavior, &req.announce)) {
+			ShowWarning("refine_readdb_requirements_sub: invalid announce behavior value '%s' in entry '%s' in \"%s\" defaulting to not announce...\n", announce_behavior, name, source);
+		}
+	}
+
+	struct config_setting_t *items_t;
+	if ((items_t = libconfig->setting_get_member(elem, "Items")) == NULL) {
+		ShowWarning("refine_readdb_requirements_sub: a requirements element missing Items element for entry '%s' in \"%s\" skipping...\n", name, source);
+		return false;
+	}
+
+	if (libconfig->setting_length(items_t) < 1) {
+		ShowWarning("refine_readdb_requirements_sub: an Items element containing no items passed for entry '%s' in \"%s\" skipping...\n", name, source);
+		return false;
+	}
+
+	int loaded_items = 0;
+	for (int i = 0; i < libconfig->setting_length(items_t); ++i) {
+		if (req.req_count >= MAX_REFINE_REQUIREMENTS) {
+			ShowWarning("refine_readdb_requirements_sub: Too many items passed to requirements maximum possible items is %d entry '%s' in \"%s\" skipping...\n", MAX_REFINE_REQUIREMENTS, name, source);
+			continue;
+		}
+
+		struct config_setting_t *item_t = libconfig->setting_get_elem(items_t, i);
+
+		if (!refine->p->readdb_refinery_ui_settings_items(item_t, &req, name, source))
+			continue;
+
+		loaded_items++;
+	}
+
+	if (loaded_items == 0) {
+		ShowWarning("refine_readdb_requirements_sub: no valid items for requirements is passed for entry '%s' in \"%s\" skipping...\n", name, source);
+		return false;
+	}
+
+	for (int i = 0; i < MAX_REFINE; ++i) {
+		if (!levels[i])
+			continue;
+
+		refine->p->dbs->refine_info[type].refine_requirements[i] = req;
+	}
+
+	return true;
+}
+
+/// @copydoc refine_interface_private::readdb_refinery_ui_settings()
+static int refine_readdb_refinery_ui_settings(const struct config_setting_t *r, int type, const char *name, const char *source)
+{
+	nullpo_retr(0, r);
+	nullpo_retr(0, name);
+	nullpo_retr(0, source);
+	Assert_retr(0, type >= REFINE_TYPE_ARMOR && type < REFINE_TYPE_MAX);
+
+	int i = 0;
+	const struct config_setting_t *elem = NULL;
+	while ((elem = libconfig->setting_get_elem(r, i++)) != NULL) {
+		refine->p->readdb_refinery_ui_settings_sub(elem, type, name, source);
+	}
+
+	int retval = 0;
+	for (i = 0; i < MAX_REFINE; ++i) {
+		if (refine->p->dbs->refine_info[type].refine_requirements[i].req_count > 0)
+			retval++;
+	}
+
+	return retval;
+}
+
+/// @copydoc refine_interface_private::readdb_refine_libconfig_sub()
+static int refine_readdb_refine_libconfig_sub(struct config_setting_t *r, const char *name, const char *source)
+{
+	struct config_setting_t *rate = NULL;
+	int type = REFINE_TYPE_ARMOR, bonus_per_level = 0, rnd_bonus_v = 0, rnd_bonus_lv = 0;
+	char lv[4];
+	nullpo_ret(r);
+	nullpo_ret(name);
+	nullpo_ret(source);
+
+	if (strncmp(name, "Armors", 6) == 0) {
+		type = REFINE_TYPE_ARMOR;
+	} else if (strncmp(name, "WeaponLevel", 11) != 0 || !strspn(&name[strlen(name)-1], "0123456789") || (type = atoi(strncpy(lv, name+11, 2))) == REFINE_TYPE_ARMOR) {
+		ShowError("status_readdb_refine_libconfig_sub: Invalid key name for entry '%s' in \"%s\", skipping.\n", name, source);
+		return 0;
+	}
+	if (type < REFINE_TYPE_ARMOR || type >= REFINE_TYPE_MAX) {
+		ShowError("status_readdb_refine_libconfig_sub: Out of range level for entry '%s' in \"%s\", skipping.\n", name, source);
+		return 0;
+	}
+
+	struct config_setting_t *refinery_ui_settings;
+	if ((refinery_ui_settings = libconfig->setting_get_member(r, "RefineryUISettings")) == NULL) {
+		ShowWarning("status_readdb_refine_libconfig_sub: Missing Requirements for entry '%s' in \"%s\", skipping.\n", name, source);
+		return 0;
+	}
+
+	if (refine->p->readdb_refinery_ui_settings(refinery_ui_settings, type, name, source) != MAX_REFINE) {
+		ShowWarning("status_readdb_refine_libconfig_sub: Not all refine levels have requrements entry for entry '%s' in \"%s\", skipping.\n", name, source);
+		return 0;
+	}
+
+	if (!libconfig->setting_lookup_int(r, "StatsPerLevel", &bonus_per_level)) {
+		ShowWarning("status_readdb_refine_libconfig_sub: Missing StatsPerLevel for entry '%s' in \"%s\", skipping.\n", name, source);
+		return 0;
+	}
+	if (!libconfig->setting_lookup_int(r, "RandomBonusStartLevel", &rnd_bonus_lv)) {
+		ShowWarning("status_readdb_refine_libconfig_sub: Missing RandomBonusStartLevel for entry '%s' in \"%s\", skipping.\n", name, source);
+		return 0;
+	}
+	if (!libconfig->setting_lookup_int(r, "RandomBonusValue", &rnd_bonus_v)) {
+		ShowWarning("status_readdb_refine_libconfig_sub: Missing RandomBonusValue for entry '%s' in \"%s\", skipping.\n", name, source);
+		return 0;
+	}
+
+	if ((rate=libconfig->setting_get_member(r, "Rates")) != NULL && config_setting_is_group(rate)) {
+		bool duplicate[MAX_REFINE];
+		int bonus[MAX_REFINE], rnd_bonus[MAX_REFINE];
+		int chance[REFINE_CHANCE_TYPE_MAX][MAX_REFINE];
+
+		memset(&duplicate, 0, sizeof(duplicate));
+		memset(&bonus, 0, sizeof(bonus));
+		memset(&rnd_bonus, 0, sizeof(rnd_bonus));
+
+		for (int i = 0; i < REFINE_CHANCE_TYPE_MAX; i++)
+			for (int j = 0; j < MAX_REFINE; j++)
+				chance[i][j] = 100; // default value for all rates.
+
+		struct config_setting_t *t = NULL;
+		for (int i = 0; (t = libconfig->setting_get_elem(rate, i++)) != NULL && config_setting_is_group(t); ++i) {
+			int level = 0, i32;
+			char *rlvl = config_setting_name(t);
+			memset(&lv, 0, sizeof(lv));
+
+			if (!strspn(&rlvl[strlen(rlvl) - 1], "0123456789") || (level = atoi(strncpy(lv, rlvl + 2, 3))) <= 0) {
+				ShowError("status_readdb_refine_libconfig_sub: Invalid refine level format '%s' for entry %s in \"%s\"... skipping.\n", rlvl, name, source);
+				continue;
+			}
+
+			if (level <= 0 || level > MAX_REFINE) {
+				ShowError("status_readdb_refine_libconfig_sub: Out of range refine level '%s' for entry %s in \"%s\"... skipping.\n", rlvl, name, source);
+				continue;
+			}
+
+			level--;
+
+			if (duplicate[level]) {
+				ShowWarning("status_readdb_refine_libconfig_sub: duplicate rate '%s' for entry %s in \"%s\", overwriting previous entry...\n", rlvl, name, source);
+			} else {
+				duplicate[level] = true;
+			}
+
+			if (libconfig->setting_lookup_int(t, "NormalChance", &i32) != 0)
+				chance[REFINE_CHANCE_TYPE_NORMAL][level] = i32;
+			else
+				chance[REFINE_CHANCE_TYPE_NORMAL][level] = 100;
+
+			if (libconfig->setting_lookup_int(t, "EnrichedChance", &i32) != 0)
+				chance[REFINE_CHANCE_TYPE_ENRICHED][level] = i32;
+			else
+				chance[REFINE_CHANCE_TYPE_ENRICHED][level] = level > 10 ? 0 : 100; // enriched ores up to +10 only.
+
+			if (libconfig->setting_lookup_int(t, "EventNormalChance", &i32) != 0)
+				chance[REFINE_CHANCE_TYPE_E_NORMAL][level] = i32;
+			else
+				chance[REFINE_CHANCE_TYPE_E_NORMAL][level] = 100;
+
+			if (libconfig->setting_lookup_int(t, "EventEnrichedChance", &i32) != 0)
+				chance[REFINE_CHANCE_TYPE_E_ENRICHED][level] = i32;
+			else
+				chance[REFINE_CHANCE_TYPE_E_ENRICHED][level] = level > 10 ? 0 : 100; // enriched ores up to +10 only.
+
+			if (libconfig->setting_lookup_int(t, "Bonus", &i32) != 0)
+				bonus[level] += i32;
+
+			if (level >= rnd_bonus_lv - 1)
+				rnd_bonus[level] = rnd_bonus_v * (level - rnd_bonus_lv + 2);
+		}
+		for (int i = 0; i < MAX_REFINE; i++) {
+			refine->p->dbs->refine_info[type].chance[REFINE_CHANCE_TYPE_NORMAL][i] = chance[REFINE_CHANCE_TYPE_NORMAL][i];
+			refine->p->dbs->refine_info[type].chance[REFINE_CHANCE_TYPE_E_NORMAL][i] = chance[REFINE_CHANCE_TYPE_E_NORMAL][i];
+			refine->p->dbs->refine_info[type].chance[REFINE_CHANCE_TYPE_ENRICHED][i] = chance[REFINE_CHANCE_TYPE_ENRICHED][i];
+			refine->p->dbs->refine_info[type].chance[REFINE_CHANCE_TYPE_E_ENRICHED][i] = chance[REFINE_CHANCE_TYPE_E_ENRICHED][i];
+			refine->p->dbs->refine_info[type].randombonus_max[i] = rnd_bonus[i];
+			bonus[i] += bonus_per_level + (i > 0 ? bonus[i - 1] : 0);
+			refine->p->dbs->refine_info[type].bonus[i] = bonus[i];
+		}
+	} else {
+		ShowWarning("status_readdb_refine_libconfig_sub: Missing refine rates for entry '%s' in \"%s\", skipping.\n", name, source);
+		return 0;
+	}
+
+	return type + 1;
+}
+
+/// @copydoc refine_interface_private::readdb_refine_libconfig()
+static int refine_readdb_refine_libconfig(const char *filename)
+{
+	nullpo_retr(0, filename);
+
+	bool duplicate[REFINE_TYPE_MAX];
+	struct config_t refine_db_conf;
+	struct config_setting_t *r;
+	char filepath[256];
+	int i = 0, count = 0;
+
+	safesnprintf(filepath, sizeof(filepath), "%s/%s", map->db_path, filename);
+	if (!libconfig->load_file(&refine_db_conf, filepath))
+		return 0;
+
+	memset(&duplicate, 0, sizeof(duplicate));
+
+	while((r = libconfig->setting_get_elem(refine_db_conf.root, i++))) {
+		char *name = config_setting_name(r);
+		int type = refine->p->readdb_refine_libconfig_sub(r, name, filename);
+		if (type != 0) {
+			if (duplicate[type - 1]) {
+				ShowWarning("status_readdb_refine_libconfig: duplicate entry for %s in \"%s\", overwriting previous entry...\n", name, filename);
+			} else {
+				duplicate[type - 1] = true;
+			}
+			count++;
+		}
+	}
+	libconfig->destroy(&refine_db_conf);
+	ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' entries in '"CL_WHITE"%s"CL_RESET"'.\n", count, filename);
+
+	return count;
+}
+
+/// @copydoc refine_interface::init()
+static int refine_init(bool minimal)
+{
+	if (minimal)
+		return 0;
+
+	refine->p->readdb_refine_libconfig(DBPATH"refine_db.conf");
+	return 0;
+}
+
+/// @copydoc refine_interface::final()
+static void refine_final(void)
+{
+}
+
+void refine_defaults(void)
+{
+	refine = &refine_s;
+	refine->p = &refine_p;
+	refine->p->dbs = &refine_dbs;
+
+	refine->p->readdb_refine_libconfig = refine_readdb_refine_libconfig;
+	refine->p->readdb_refine_libconfig_sub = refine_readdb_refine_libconfig_sub;
+	refine->p->announce_behavior_string2enum = refine_announce_behavior_string2enum;
+	refine->p->failure_behavior_string2enum = refine_failure_behavior_string2enum;
+	refine->p->readdb_refinery_ui_settings_items = refine_readdb_refinery_ui_settings_items;
+	refine->p->readdb_refinery_ui_settings_sub = refine_readdb_refinery_ui_settings_sub;
+	refine->p->readdb_refinery_ui_settings = refine_readdb_refinery_ui_settings;
+	refine->p->is_refinable = refine_is_refinable;
+
+	refine->init = refine_init;
+	refine->final = refine_final;
+	refine->refinery_refine_request = refine_refinery_refine_request;
+	refine->refinery_add_item = refine_refinery_add_item;
+	refine->get_refine_chance = refine_get_refine_chance;
+	refine->get_bonus = refine_get_bonus;
+	refine->get_randombonus_max = refine_get_randombonus_max;
+}
diff --git a/src/map/refine.h b/src/map/refine.h
new file mode 100644
index 000000000..410811e06
--- /dev/null
+++ b/src/map/refine.h
@@ -0,0 +1,148 @@
+/**
+* This file is part of Hercules.
+* http://herc.ws - http://github.com/HerculesWS/Hercules
+*
+* Copyright (C) 2019  Hercules Dev Team
+*
+* Hercules is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MAP_REFINE_H
+#define MAP_REFINE_H
+
+/** @file
+ * Refine Interface.
+ **/
+#include "common/hercules.h"
+#include "common/mmo.h"
+
+/* Defines */
+/**
+* Max Refine available to your server
+* Changing this limit requires edits to refine_db.conf
+**/
+#ifdef RENEWAL
+	#define MAX_REFINE 20
+#else
+	#define MAX_REFINE 10
+#endif
+
+/* Forward Declarations */
+struct refine_interface_private;
+
+/* Enums */
+enum refine_type {
+	REFINE_TYPE_ARMOR   = 0,
+	REFINE_TYPE_WEAPON1 = 1,
+	REFINE_TYPE_WEAPON2 = 2,
+	REFINE_TYPE_WEAPON3 = 3,
+	REFINE_TYPE_WEAPON4 = 4,
+#ifndef REFINE_TYPE_MAX
+	REFINE_TYPE_MAX     = 5
+#endif
+};
+
+enum refine_chance_type {
+	REFINE_CHANCE_TYPE_NORMAL     = 0, // Normal Chance
+	REFINE_CHANCE_TYPE_ENRICHED   = 1, // Enriched Ore Chance
+	REFINE_CHANCE_TYPE_E_NORMAL   = 2, // Event Normal Ore Chance
+	REFINE_CHANCE_TYPE_E_ENRICHED = 3, // Event Enriched Ore Chance
+	REFINE_CHANCE_TYPE_MAX
+};
+
+enum refine_ui_failure_behavior {
+	REFINE_FAILURE_BEHAVIOR_DESTROY,
+	REFINE_FAILURE_BEHAVIOR_KEEP,
+	REFINE_FAILURE_BEHAVIOR_DOWNGRADE
+};
+
+/* Structure */
+struct s_refine_requirement {
+	int blacksmith_blessing;
+	int req_count;
+	unsigned int announce;
+
+	struct {
+		int nameid;
+		int cost;
+		enum refine_chance_type type;
+		enum refine_ui_failure_behavior failure_behavior;
+	} req[MAX_REFINE_REQUIREMENTS];
+};
+
+/**
+ * Refine Interface
+ **/
+struct refine_interface {
+	struct refine_interface_private *p;
+
+	/**
+	 * Initialize refine system
+	 * @param minimal sets refine system to minimal mode in which it won't load or initialize itself
+	 * @return returns 0 in-case of success 1 otherwise
+	 **/
+	int (*init)(bool minimal);
+
+	/**
+	 * Finalize refine system
+	 **/
+	void (*final)(void);
+
+	/**
+	 * Get the chance to upgrade a piece of equipment.
+	 * @param wlv The weapon type of the item to refine (see see enum refine_type)
+	 * @param refine The target refine level
+	 * @return The chance to refine the item, in percent (0~100)
+	 **/
+	int (*get_refine_chance) (enum refine_type wlv, int refine_level, enum refine_chance_type type);
+
+	/**
+	 * Gets the attack/deffense bonus for the given equipment type and refine level
+	 * @param equipment_type the equipment type
+	 * @param refine_level the equipment refine level
+	 * @return returns the bonus from refine db
+	 **/
+	int (*get_bonus) (enum refine_type equipment_type, int refine_level);
+
+	/**
+	* Gets the maximum attack/deffense random bonus for the given equipment type and refine level
+	* @param equipment_type the equipment type
+	* @param refine_level the equipment refine level
+	* @return returns the bonus from refine db
+	**/
+	int(*get_randombonus_max) (enum refine_type equipment_type, int refine_level);
+
+	/**
+	 * Validates and send Item addition packet to the client for refinery UI
+	 * @param sd player session data.
+	 * @param item_index the requested item index in inventory.
+	 **/
+	void (*refinery_add_item) (struct map_session_data *sd, int item_index);
+
+	/**
+	 * Processes an refine request through Refinery UI
+	 * @param sd player session data
+	 * @param item_index the index of the requested item
+	 * @param material_id the refine material chosen by player
+	 * @param use_blacksmith_blessing sets either if blacksmith blessing is requested to be used or not
+	 **/
+	void (*refinery_refine_request) (struct map_session_data *sd, int item_index, int material_id, bool use_blacksmith_blessing);
+};
+
+#ifdef HERCULES_CORE
+void refine_defaults(void);
+#endif
+
+HPShared struct refine_interface *refine;
+#endif
diff --git a/src/map/refine.p.h b/src/map/refine.p.h
new file mode 100644
index 000000000..3247d15c9
--- /dev/null
+++ b/src/map/refine.p.h
@@ -0,0 +1,144 @@
+/**
+* This file is part of Hercules.
+* http://herc.ws - http://github.com/HerculesWS/Hercules
+*
+* Copyright (C) 2019  Hercules Dev Team
+*
+* Hercules is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MAP_REFINE_P_H
+#define MAP_REFINE_P_H
+
+/** @file
+ * Private header for the refine interface.
+ **/
+
+#include "refine.h"
+#include "common/conf.h"
+/* Enums */
+enum refine_announce_condition {
+	REFINE_ANNOUNCE_SUCCESS = 0x1,
+	REFINE_ANNOUNCE_FAILURE = 0x2,
+	REFINE_ANNOUNCE_ALWAYS = REFINE_ANNOUNCE_SUCCESS | REFINE_ANNOUNCE_FAILURE,
+};
+
+/* Structures */
+struct s_refine_info {
+	int chance[REFINE_CHANCE_TYPE_MAX][MAX_REFINE]; //< success chance
+	int bonus[MAX_REFINE];                          //< cumulative fixed bonus damage
+	int randombonus_max[MAX_REFINE];                //< cumulative maximum random bonus damage
+	struct s_refine_requirement refine_requirements[MAX_REFINE]; //< The requirements used for refinery UI
+};
+
+struct refine_interface_dbs {
+	struct s_refine_info refine_info[REFINE_TYPE_MAX];
+};
+
+/**
+ * Refine Private Interface
+ **/
+struct refine_interface_private {
+	struct refine_interface_dbs *dbs;
+
+	/**
+	 * Processes a refine_db.conf entry.
+	 *
+	 * @param r      Libconfig setting entry. It is expected to be valid and it
+	 *               won't be freed (it is care of the caller to do so if
+	 *               necessary)
+	 * @param n      Ordinal number of the entry, to be displayed in case of
+	 *               validation errors.
+	 * @param source Source of the entry (file name), to be displayed in case of
+	 *               validation errors.
+	 * @return # of the validated entry, or 0 in case of failure.
+	 **/
+	int (*readdb_refine_libconfig_sub) (struct config_setting_t *r, const char *name, const char *source);
+
+	/**
+	 * Reads from a libconfig-formatted refine_db.conf file.
+	 *
+	 * @param *filename File name, relative to the database path.
+	 * @return The number of found entries.
+	 **/
+	int (*readdb_refine_libconfig) (const char *filename);
+
+	/**
+	 * Converts refine database announce behvaior string to enum refine_announce_condition
+	 * @param str the string to convert
+	 * @param result pointer to where the converted value will be held
+	 * @return true on success, false otherwise.
+	**/
+	bool (*announce_behavior_string2enum) (const char *str, unsigned int *result);
+
+	/**
+	 * Converts refine database failure behvaior string to enum refine_ui_failure_behavior
+	 * @param str the string to convert
+	 * @param result pointer to where the converted value will be held
+	 * @return true on success, false otherwise.
+	 **/
+	bool (*failure_behavior_string2enum) (const char *str, enum refine_ui_failure_behavior *result);
+
+	/**
+	 * Processes a refine_db.conf RefineryUISettings items entry.
+	 *
+	 * @param elem   Libconfig setting entry. It is expected to be valid and it
+	 *               won't be freed (it is care of the caller to do so if
+	 *               necessary)
+	 * @param req    a pointer to requirements struct to fill with the item data
+	 * @param name   the current element name
+	 * @param source Source of the entry (file name), to be displayed in case of
+	 *               validation errors.
+	 * @return true on success, false otherwise.
+	 **/
+	bool (*readdb_refinery_ui_settings_items) (const struct config_setting_t *elem, struct s_refine_requirement *req, const char *name, const char *source);
+
+	/**
+	 * Processes a refine_db.conf RefineryUISettings entry.
+	 *
+	 * @param elem   Libconfig setting entry. It is expected to be valid and it
+	 *               won't be freed (it is care of the caller to do so if
+	 *               necessary)
+	 * @param type   the type index in refine database to fill the data
+	 * @param name   the current element name
+	 * @param source Source of the entry (file name), to be displayed in case of
+	 *               validation errors.
+	 * @return true on success, false otherwise.
+	 **/
+	bool (*readdb_refinery_ui_settings_sub) (const struct config_setting_t *elem, int type, const char *name, const char *source);
+
+	/**
+	 * Reads a refine_db.conf RefineryUISettings entry and sends it to be processed.
+	 *
+	 * @param r      Libconfig setting entry. It is expected to be valid and it
+	 *               won't be freed (it is care of the caller to do so if
+	 *               necessary)
+	 * @param type   the type index in refine database to fill the data
+	 * @param name   the current element name
+	 * @param source Source of the entry (file name), to be displayed in case of
+	 *               validation errors.
+	 * @return true on success, false otherwise.
+	 **/
+	int (*readdb_refinery_ui_settings) (const struct config_setting_t *r, int type, const char *name, const char *source);
+
+	/**
+	 * Checks if a given item in player's inventory is refineable.
+	 * @param sd player session data.
+	 * @param item_index the item index in player's inventory.
+	 * @return true if item is refineable, false otherwise.
+	 **/
+	bool (*is_refinable) (struct map_session_data *sd, int item_index);
+};
+
+#endif
diff --git a/src/map/script.c b/src/map/script.c
index 4fb24708b..5843ac292 100644
--- a/src/map/script.c
+++ b/src/map/script.c
@@ -52,6 +52,7 @@
 #include "map/pet.h"
 #include "map/pet.h"
 #include "map/quest.h"
+#include "map/refine.h"
 #include "map/skill.h"
 #include "map/status.h"
 #include "map/status.h"
@@ -9505,7 +9506,7 @@ static BUILDIN(getequippercentrefinery)
 
 	if (i >= 0 && sd->status.inventory[i].nameid != 0 && sd->status.inventory[i].refine < MAX_REFINE)
 		script_pushint(st,
-			status->get_refine_chance(itemdb_wlv(sd->status.inventory[i].nameid), (int) sd->status.inventory[i].refine, (enum refine_chance_type) type));
+			refine->get_refine_chance(itemdb_wlv(sd->status.inventory[i].nameid), (int) sd->status.inventory[i].refine, (enum refine_chance_type) type));
 	else
 		script_pushint(st, 0);
 
@@ -25285,6 +25286,25 @@ static BUILDIN(closeroulette)
 	return true;
 }
 
+static BUILDIN(openrefineryui)
+{
+	struct map_session_data *sd = script_rid2sd(st);
+
+	if (sd == NULL) {
+		script_pushint(st, 0);
+		return true;
+	}
+
+	if (battle_config.enable_refinery_ui == 0) {
+		script_pushint(st, 0);
+		return true;
+	}
+
+	clif->OpenRefineryUI(sd);
+	script_pushint(st, 1);
+	return true;
+}
+
 /**
  * Adds a built-in script function.
  *
@@ -26038,6 +26058,7 @@ static void script_parse_builtin(void)
 		BUILDIN_DEF(getInventorySize, ""),
 
 		BUILDIN_DEF(closeroulette, ""),
+		BUILDIN_DEF(openrefineryui, ""),
 	};
 	int i, len = ARRAYLENGTH(BUILDIN);
 	RECREATE(script->buildin, char *, script->buildin_count + len); // Pre-alloc to speed up
diff --git a/src/map/searchstore.c b/src/map/searchstore.c
index 0c6fa3555..c991e38c4 100644
--- a/src/map/searchstore.c
+++ b/src/map/searchstore.c
@@ -345,7 +345,7 @@ static void searchstore_clearremote(struct map_session_data *sd)
 }
 
 /// receives results from a store-specific callback
-static bool searchstore_result(struct map_session_data *sd, unsigned int store_id, int account_id, const char *store_name, int nameid, unsigned short amount, unsigned int price, const int *card, unsigned char refine, const struct item_option *option)
+static bool searchstore_result(struct map_session_data *sd, unsigned int store_id, int account_id, const char *store_name, int nameid, unsigned short amount, unsigned int price, const int *card, unsigned char refine_level, const struct item_option *option)
 {
 	struct s_search_store_info_item* ssitem;
 
@@ -364,7 +364,7 @@ static bool searchstore_result(struct map_session_data *sd, unsigned int store_i
 	ssitem->amount = amount;
 	ssitem->price = price;
 	memcpy(ssitem->card, card, sizeof(ssitem->card));
-	ssitem->refine = refine;
+	ssitem->refine = refine_level;
 	memcpy(ssitem->option, option, sizeof(ssitem->option));
 
 	return true;
diff --git a/src/map/searchstore.h b/src/map/searchstore.h
index e5ccfd300..71d562679 100644
--- a/src/map/searchstore.h
+++ b/src/map/searchstore.h
@@ -109,7 +109,7 @@ struct searchstore_interface {
 	void (*click) (struct map_session_data* sd, int account_id, int store_id, int nameid);
 	bool (*queryremote) (struct map_session_data* sd, int account_id);
 	void (*clearremote) (struct map_session_data* sd);
-	bool (*result) (struct map_session_data* sd, unsigned int store_id, int account_id, const char* store_name, int nameid, unsigned short amount, unsigned int price, const int* card, unsigned char refine, const struct item_option *option);
+	bool (*result) (struct map_session_data* sd, unsigned int store_id, int account_id, const char* store_name, int nameid, unsigned short amount, unsigned int price, const int* card, unsigned char refine_level, const struct item_option *option);
 };
 
 #ifdef HERCULES_CORE
diff --git a/src/map/skill.c b/src/map/skill.c
index 633a73d67..2b2c2b6f1 100644
--- a/src/map/skill.c
+++ b/src/map/skill.c
@@ -44,6 +44,7 @@
 #include "map/path.h"
 #include "map/pc.h"
 #include "map/pet.h"
+#include "map/refine.h"
 #include "map/script.h"
 #include "map/status.h"
 #include "map/unit.h"
@@ -16204,7 +16205,7 @@ static void skill_weaponrefine(struct map_session_data *sd, int idx)
 				return;
 			}
 
-			per = status->get_refine_chance(ditem->wlv, (int)item->refine, REFINE_CHANCE_TYPE_NORMAL) * 10;
+			per = refine->get_refine_chance(ditem->wlv, (int)item->refine, REFINE_CHANCE_TYPE_NORMAL) * 10;
 
 			// Aegis leaked formula. [malufett]
 			if (sd->status.class == JOB_MECHANIC_T)
diff --git a/src/map/status.c b/src/map/status.c
index f06bb0330..5300f65c4 100644
--- a/src/map/status.c
+++ b/src/map/status.c
@@ -38,6 +38,7 @@
 #include "map/path.h"
 #include "map/pc.h"
 #include "map/pet.h"
+#include "map/refine.h"
 #include "map/script.h"
 #include "map/skill.h"
 #include "map/skill.h"
@@ -2577,18 +2578,18 @@ static int status_calc_pc_(struct map_session_data *sd, enum e_status_calc_opt o
 				r = 0;
 
 			if (r)
-				wa->atk2 = status->dbs->refine_info[wlv].bonus[r-1] / 100;
+				wa->atk2 = refine->get_bonus(wlv, r) / 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->dbs->refine_info[wlv].bonus[r-1] / 100;
+				wa->matk += refine->get_bonus(wlv, r) / 100;
 #endif
 
 			//Overrefined bonus.
 			if (r)
-				wd->overrefine = status->dbs->refine_info[wlv].randombonus_max[r-1] / 100;
+				wd->overrefine = refine->get_randombonus_max(wlv, r) / 100;
 
 			wa->range += sd->inventory_data[index]->range;
 			if(sd->inventory_data[index]->script) {
@@ -2623,7 +2624,7 @@ static int status_calc_pc_(struct map_session_data *sd, enum e_status_calc_opt o
 				r = 0;
 
 			if (r)
-				refinedef += status->dbs->refine_info[REFINE_TYPE_ARMOR].bonus[r-1];
+				refinedef += refine->get_bonus(REFINE_TYPE_ARMOR, r);
 
 			if(sd->inventory_data[index]->script) {
 				if( i == EQI_HAND_L ) //Shield
@@ -12508,10 +12509,10 @@ static int status_get_weapon_atk(struct block_list *bl, struct weapon_atk *watk,
 
 	if ( bl->type == BL_PC && !(flag & 2) ) {
 		const struct map_session_data *sd = BL_UCCAST(BL_PC, bl);
-		short index = sd->equip_index[EQI_HAND_R], refine;
+		short index = sd->equip_index[EQI_HAND_R], refine_level;
 		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->dbs->refine_info[watk->wlv].randombonus_max[refine + (4 - watk->wlv)] / 100;
+			&& (refine_level = sd->status.inventory[index].refine) < 16 && refine_level) {
+			int r = refine->get_randombonus_max(watk->wlv, refine_level + (4 - watk->wlv) + 1) / 100;
 			if ( r )
 				max += (rnd() % 100) % r + 1;
 		}
@@ -12623,10 +12624,10 @@ static void status_get_matk_sub(struct block_list *bl, int flag, unsigned short
 
 #ifdef RENEWAL
 	if ( sd && !(flag & 2) ) {
-		short index = sd->equip_index[EQI_HAND_R], refine;
+		short index = sd->equip_index[EQI_HAND_R], refine_level;
 		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->dbs->refine_info[sd->inventory_data[index]->wlv].randombonus_max[refine + (4 - sd->inventory_data[index]->wlv)] / 100;
+			&& (refine_level = sd->status.inventory[index].refine) < 16 && refine_level) {
+			int r = refine->get_randombonus_max(sd->inventory_data[index]->wlv, refine_level + (4 - sd->inventory_data[index]->wlv) + 1) / 100;
 			if ( r )
 				*matk_max += (rnd() % 100) % r + 1;
 		}
@@ -13076,25 +13077,6 @@ static int status_natural_heal_timer(int tid, int64 tick, int id, intptr_t data)
 	return 0;
 }
 
-/**
- * Get the chance to upgrade a piece of equipment.
- * @param wlv The weapon type of the item to refine (see see enum refine_type)
- * @param refine The target refine level
- * @return The chance to refine the item, in percent (0~100)
- */
-static int status_get_refine_chance(enum refine_type wlv, int refine, enum refine_chance_type type)
-{
-	Assert_ret((int)wlv >= REFINE_TYPE_ARMOR && wlv < REFINE_TYPE_MAX);
-
-	if (refine < 0 || refine >= MAX_REFINE)
-		return 0;
-
-	if (type >= REFINE_CHANCE_TYPE_MAX)
-		return 0;
-
-	return status->dbs->refine_info[wlv].chance[type][refine];
-}
-
 static int status_get_sc_type(sc_type type)
 {
 
@@ -13405,171 +13387,6 @@ static bool status_readdb_sizefix(char *fields[], int columns, int current)
 	return true;
 }
 
-/**
- * Processes a refine_db.conf entry.
- *
- * @param r      Libconfig setting entry. It is expected to be valid and it
- *               won't be freed (it is care of the caller to do so if
- *               necessary)
- * @param n      Ordinal number of the entry, to be displayed in case of
- *               validation errors.
- * @param source Source of the entry (file name), to be displayed in case of
- *               validation errors.
- * @return # of the validated entry, or 0 in case of failure.
- */
-static int status_readdb_refine_libconfig_sub(struct config_setting_t *r, const char *name, const char *source)
-{
-	struct config_setting_t *rate = NULL;
-	int type = REFINE_TYPE_ARMOR, bonus_per_level = 0, rnd_bonus_v = 0, rnd_bonus_lv = 0;
-	char lv[4];
-	nullpo_ret(r);
-	nullpo_ret(name);
-	nullpo_ret(source);
-
-	if (strncmp(name, "Armors", 6) == 0) {
-		type = REFINE_TYPE_ARMOR;
-	} else if (strncmp(name, "WeaponLevel", 11) != 0 || !strspn(&name[strlen(name)-1], "0123456789") || (type = atoi(strncpy(lv, name+11, 2))) == REFINE_TYPE_ARMOR) {
-		ShowError("status_readdb_refine_libconfig_sub: Invalid key name for entry '%s' in \"%s\", skipping.\n", name, source);
-		return 0;
-	}
-	if (type < REFINE_TYPE_ARMOR || type >= REFINE_TYPE_MAX) {
-		ShowError("status_readdb_refine_libconfig_sub: Out of range level for entry '%s' in \"%s\", skipping.\n", name, source);
-		return 0;
-	}
-	if (!libconfig->setting_lookup_int(r, "StatsPerLevel", &bonus_per_level)) {
-		ShowWarning("status_readdb_refine_libconfig_sub: Missing StatsPerLevel for entry '%s' in \"%s\", skipping.\n", name, source);
-		return 0;
-	}
-	if (!libconfig->setting_lookup_int(r, "RandomBonusStartLevel", &rnd_bonus_lv)) {
-		ShowWarning("status_readdb_refine_libconfig_sub: Missing RandomBonusStartLevel for entry '%s' in \"%s\", skipping.\n", name, source);
-		return 0;
-	}
-	if (!libconfig->setting_lookup_int(r, "RandomBonusValue", &rnd_bonus_v)) {
-		ShowWarning("status_readdb_refine_libconfig_sub: Missing RandomBonusValue for entry '%s' in \"%s\", skipping.\n", name, source);
-		return 0;
-	}
-
-	if ((rate=libconfig->setting_get_member(r, "Rates")) != NULL && config_setting_is_group(rate)) {
-		struct config_setting_t *t = NULL;
-		bool duplicate[MAX_REFINE];
-		int bonus[MAX_REFINE], rnd_bonus[MAX_REFINE];
-		int chance[REFINE_CHANCE_TYPE_MAX][MAX_REFINE];
-		int i, j;
-
-		memset(&duplicate, 0, sizeof(duplicate));
-		memset(&bonus, 0, sizeof(bonus));
-		memset(&rnd_bonus, 0, sizeof(rnd_bonus));
-
-		for (i = 0; i < REFINE_CHANCE_TYPE_MAX; i++)
-			for (j = 0; j < MAX_REFINE; j++)
-				chance[i][j] = 100; // default value for all rates.
-
-		i = 0;
-		j = 0;
-		while ((t = libconfig->setting_get_elem(rate,i++)) != NULL && config_setting_is_group(t)) {
-			int level = 0, i32;
-			char *rlvl = config_setting_name(t);
-			memset(&lv, 0, sizeof(lv));
-
-			if (!strspn(&rlvl[strlen(rlvl) - 1], "0123456789") || (level = atoi(strncpy(lv, rlvl + 2, 3))) <= 0) {
-				ShowError("status_readdb_refine_libconfig_sub: Invalid refine level format '%s' for entry %s in \"%s\"... skipping.\n", rlvl, name, source);
-				continue;
-			}
-
-			if (level <= 0 || level > MAX_REFINE) {
-				ShowError("status_readdb_refine_libconfig_sub: Out of range refine level '%s' for entry %s in \"%s\"... skipping.\n", rlvl, name, source);
-				continue;
-			}
-
-			level--;
-
-			if (duplicate[level]) {
-				ShowWarning("status_readdb_refine_libconfig_sub: duplicate rate '%s' for entry %s in \"%s\", overwriting previous entry...\n", rlvl, name, source);
-			} else {
-				duplicate[level] = true;
-			}
-
-			if (libconfig->setting_lookup_int(t, "NormalChance", &i32) != 0)
-				chance[REFINE_CHANCE_TYPE_NORMAL][level] = i32;
-			else
-				chance[REFINE_CHANCE_TYPE_NORMAL][level] = 100;
-
-			if (libconfig->setting_lookup_int(t, "EnrichedChance", &i32) != 0)
-				chance[REFINE_CHANCE_TYPE_ENRICHED][level] = i32;
-			else
-				chance[REFINE_CHANCE_TYPE_ENRICHED][level] = level > 10 ? 0 : 100; // enriched ores up to +10 only.
-
-			if (libconfig->setting_lookup_int(t, "EventNormalChance", &i32) != 0)
-				chance[REFINE_CHANCE_TYPE_E_NORMAL][level] = i32;
-			else
-				chance[REFINE_CHANCE_TYPE_E_NORMAL][level] = 100;
-
-			if (libconfig->setting_lookup_int(t, "EventEnrichedChance", &i32) != 0)
-				chance[REFINE_CHANCE_TYPE_E_ENRICHED][level] = i32;
-			else
-				chance[REFINE_CHANCE_TYPE_E_ENRICHED][level] = level > 10 ? 0 : 100; // enriched ores up to +10 only.
-
-			if (libconfig->setting_lookup_int(t, "Bonus", &i32) != 0)
-				bonus[level] += i32;
-
-			if (level >= rnd_bonus_lv - 1)
-				rnd_bonus[level] = rnd_bonus_v * (level - rnd_bonus_lv + 2);
-		}
-		for (i = 0; i < MAX_REFINE; i++) {
-			status->dbs->refine_info[type].chance[REFINE_CHANCE_TYPE_NORMAL][i] = chance[REFINE_CHANCE_TYPE_NORMAL][i];
-			status->dbs->refine_info[type].chance[REFINE_CHANCE_TYPE_E_NORMAL][i] = chance[REFINE_CHANCE_TYPE_E_NORMAL][i];
-			status->dbs->refine_info[type].chance[REFINE_CHANCE_TYPE_ENRICHED][i] = chance[REFINE_CHANCE_TYPE_ENRICHED][i];
-			status->dbs->refine_info[type].chance[REFINE_CHANCE_TYPE_E_ENRICHED][i] = chance[REFINE_CHANCE_TYPE_E_ENRICHED][i];
-			status->dbs->refine_info[type].randombonus_max[i] = rnd_bonus[i];
-			bonus[i] += bonus_per_level + (i > 0 ? bonus[i - 1] : 0);
-			status->dbs->refine_info[type].bonus[i] = bonus[i];
-		}
-	} else {
-		ShowWarning("status_readdb_refine_libconfig_sub: Missing refine rates for entry '%s' in \"%s\", skipping.\n", name, source);
-		return 0;
-	}
-
-	return type + 1;
-}
-
-/**
- * Reads from a libconfig-formatted refine_db.conf file.
- *
- * @param *filename File name, relative to the database path.
- * @return The number of found entries.
- */
-static int status_readdb_refine_libconfig(const char *filename)
-{
-	bool duplicate[REFINE_TYPE_MAX];
-	struct config_t refine_db_conf;
-	struct config_setting_t *r;
-	char filepath[256];
-	int i = 0, count = 0;
-
-	safesnprintf(filepath, sizeof(filepath), "%s/%s", map->db_path, filename);
-	if (!libconfig->load_file(&refine_db_conf, filepath))
-		return 0;
-
-	memset(&duplicate,0,sizeof(duplicate));
-
-	while((r = libconfig->setting_get_elem(refine_db_conf.root,i++))) {
-		char *name = config_setting_name(r);
-		int type = status->readdb_refine_libconfig_sub(r, name, filename);
-		if (type != 0) {
-			if (duplicate[type-1]) {
-				ShowWarning("status_readdb_refine_libconfig: duplicate entry for %s in \"%s\", overwriting previous entry...\n", name, filename);
-			} else {
-				duplicate[type-1] = true;
-			}
-			count++;
-		}
-	}
-	libconfig->destroy(&refine_db_conf);
-	ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' entries in '"CL_WHITE"%s"CL_RESET"'.\n", count, filename);
-
-	return count;
-}
-
 static bool status_readdb_scconfig(char *fields[], int columns, int current)
 {
 	int val = 0;
@@ -13627,7 +13444,6 @@ static int status_readdb(void)
 	//
 	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_SINGLE_WEAPON_TYPE, MAX_SINGLE_WEAPON_TYPE, ARRAYLENGTH(status->dbs->atkmods), status->readdb_sizefix);
-	status->readdb_refine_libconfig(DBPATH"refine_db.conf");
 	sv->readdb(map->db_path, "sc_config.txt",       ',', 2,                 2,                 SC_MAX,                   status->readdb_scconfig);
 	status->read_job_db();
 
@@ -13685,7 +13501,6 @@ void status_defaults(void)
 	status->natural_heal_prev_tick = 0;
 	status->natural_heal_diff_tick = 0;
 	/* funcs */
-	status->get_refine_chance = status_get_refine_chance;
 	// for looking up associated data
 	status->skill2sc = status_skill2sc;
 	status->sc2skill = status_sc2skill;
@@ -13819,8 +13634,6 @@ void status_defaults(void)
 	status->natural_heal_timer = status_natural_heal_timer;
 	status->readdb_job2 = status_readdb_job2;
 	status->readdb_sizefix = status_readdb_sizefix;
-	status->readdb_refine_libconfig = status_readdb_refine_libconfig;
-	status->readdb_refine_libconfig_sub = status_readdb_refine_libconfig_sub;
 	status->readdb_scconfig = status_readdb_scconfig;
 	status->read_job_db = status_read_job_db;
 	status->read_job_db_sub = status_read_job_db_sub;
diff --git a/src/map/status.h b/src/map/status.h
index 17af22703..79aaca95f 100644
--- a/src/map/status.h
+++ b/src/map/status.h
@@ -49,27 +49,6 @@ struct pet_data;
 )
 
 /**
- * Max Refine available to your server
- * Changing this limit requires edits to refine_db.txt
- **/
-#ifdef RENEWAL
-	#define MAX_REFINE 20
-#else
-	#define MAX_REFINE 10
-#endif
-
-enum refine_type {
-	REFINE_TYPE_ARMOR   = 0,
-	REFINE_TYPE_WEAPON1 = 1,
-	REFINE_TYPE_WEAPON2 = 2,
-	REFINE_TYPE_WEAPON3 = 3,
-	REFINE_TYPE_WEAPON4 = 4,
-#ifndef REFINE_TYPE_MAX
-	REFINE_TYPE_MAX     = 5
-#endif
-};
-
-/**
  * SC configuration type
  * @see db/sc_config.txt for more information
  **/
@@ -2249,21 +2228,6 @@ struct status_change {
 #define status_calc_elemental(ed, opt)  (status->calc_bl_(&(ed)->bl, SCB_ALL, (opt)))
 #define status_calc_npc(nd, opt)        (status->calc_bl_(&(nd)->bl, SCB_ALL, (opt)))
 
-enum refine_chance_type {
-	REFINE_CHANCE_TYPE_NORMAL     = 0, // Normal Chance
-	REFINE_CHANCE_TYPE_ENRICHED   = 1, // Enriched Ore Chance
-	REFINE_CHANCE_TYPE_E_NORMAL   = 2, // Event Normal Ore Chance
-	REFINE_CHANCE_TYPE_E_ENRICHED = 3, // Event Enriched Ore Chance
-	REFINE_CHANCE_TYPE_MAX
-};
-
-// bonus values and upgrade chances for refining equipment
-struct s_refine_info {
-	int chance[REFINE_CHANCE_TYPE_MAX][MAX_REFINE]; // success chance
-	int bonus[MAX_REFINE]; // cumulative fixed bonus damage
-	int randombonus_max[MAX_REFINE]; // cumulative maximum random bonus damage
-};
-
 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];
@@ -2277,8 +2241,6 @@ BEGIN_ZEROED_BLOCK; /* Everything within this block will be memset to 0 when sta
 	int RelevantBLTypes[SI_MAX];          // "icon" -> enum bl_type (for clif->status_change to identify for which bl types to send packets)
 	bool DisplayType[SC_MAX];
 	/* */
-	struct s_refine_info refine_info[REFINE_TYPE_MAX];
-	/* */
 	int atkmods[3][MAX_SINGLE_WEAPON_TYPE];//ATK weapon modification for size (size_fix.txt)
 	char job_bonus[CLASS_COUNT][MAX_LEVEL];
 	sc_conf_type sc_conf[SC_MAX];
@@ -2307,7 +2269,6 @@ struct status_interface {
 	int (*init) (bool minimal);
 	void (*final) (void);
 	/* funcs */
-	int (*get_refine_chance) (enum refine_type wlv, int refine, enum refine_chance_type type);
 	// for looking up associated data
 	sc_type (*skill2sc) (int skill_id);
 	int (*sc2skill) (sc_type sc);
@@ -2427,8 +2388,6 @@ struct status_interface {
 	int (*natural_heal_timer) (int tid, int64 tick, int id, intptr_t data);
 	bool (*readdb_job2) (char *fields[], int columns, int current);
 	bool (*readdb_sizefix) (char *fields[], int columns, int current);
-	int (*readdb_refine_libconfig) (const char *filename);
-	int (*readdb_refine_libconfig_sub) (struct config_setting_t *r, const char *name, const char *source);
 	bool (*readdb_scconfig) (char *fields[], int columns, int current);
 	void (*read_job_db) (void);
 	void (*read_job_db_sub) (int idx, const char *name, struct config_setting_t *jdb);