- Undid r16968: SVN Replaced with source:/trunk/src/@16966 (tid:74924).

[16969:16991/trunk/src/] will be re-committed in the next 24 hours.

git-svn-id: https://rathena.svn.sourceforge.net/svnroot/rathena/trunk@16992 54d463be-8e91-2dee-dedb-b68131a5f0ec

1 files changed, 465 insertions, 457 deletions

diff --git a/src/map/storage.c b/src/map/storage.c
index e75891608..c66f12852 100644
--- a/src/map/storage.c
+++ b/src/map/storage.c
@@ -24,33 +24,34 @@
 #include <string.h>
 
 
-static DBMap *guild_storage_db; // int guild_id -> struct guild_storage*
+static DBMap* guild_storage_db; // int guild_id -> struct guild_storage*
 
 /*==========================================
  * Sort items in the warehouse
  *------------------------------------------*/
 static int storage_comp_item(const void *_i1, const void *_i2)
 {
-    struct item *i1 = (struct item *)_i1;
-    struct item *i2 = (struct item *)_i2;
-
-    if (i1->nameid == i2->nameid)
-        return 0;
-    else if (!(i1->nameid) || !(i1->amount))
-        return 1;
-    else if (!(i2->nameid) || !(i2->amount))
-        return -1;
-    return i1->nameid - i2->nameid;
+	struct item *i1 = (struct item *)_i1;
+	struct item *i2 = (struct item *)_i2;
+
+	if (i1->nameid == i2->nameid)
+		return 0;
+	else if (!(i1->nameid) || !(i1->amount))
+		return 1;
+	else if (!(i2->nameid) || !(i2->amount))
+		return -1;
+	return i1->nameid - i2->nameid;
 }
 
 //Sort item by storage_comp_item (nameid)
-static void storage_sortitem(struct item *items, unsigned int size)
+static void storage_sortitem(struct item* items, unsigned int size)
 {
-    nullpo_retv(items);
+	nullpo_retv(items);
 
-    if (battle_config.client_sort_storage) {
-        qsort(items, size, sizeof(struct item), storage_comp_item);
-    }
+	if( battle_config.client_sort_storage )
+	{
+		qsort(items, size, sizeof(struct item), storage_comp_item);
+	}
 }
 
 /*==========================================
@@ -58,12 +59,12 @@ static void storage_sortitem(struct item *items, unsigned int size)
  *------------------------------------------*/
 int do_init_storage(void) // Called from map.c::do_init()
 {
-    guild_storage_db=idb_alloc(DB_OPT_RELEASE_DATA);
-    return 1;
+	guild_storage_db=idb_alloc(DB_OPT_RELEASE_DATA);
+	return 1;
 }
 void do_final_storage(void) // by [MC Cameri]
 {
-    guild_storage_db->destroy(guild_storage_db,NULL);
+	guild_storage_db->destroy(guild_storage_db,NULL);
 }
 
 /**
@@ -72,17 +73,17 @@ void do_final_storage(void) // by [MC Cameri]
  */
 static int storage_reconnect_sub(DBKey key, DBData *data, va_list ap)
 {
-    struct guild_storage *stor = db_data2ptr(data);
-    if (stor->dirty && stor->storage_status == 0) //Save closed storages.
-        storage_guild_storagesave(0, stor->guild_id,0);
+	struct guild_storage *stor = db_data2ptr(data);
+	if (stor->dirty && stor->storage_status == 0) //Save closed storages.
+		storage_guild_storagesave(0, stor->guild_id,0);
 
-    return 0;
+	return 0;
 }
 
 //Function to be invoked upon server reconnection to char. To save all 'dirty' storages [Skotlex]
 void do_reconnect_storage(void)
 {
-    guild_storage_db->foreach(guild_storage_db, storage_reconnect_sub);
+	guild_storage_db->foreach(guild_storage_db, storage_reconnect_sub);
 }
 
 /*==========================================
@@ -92,22 +93,22 @@ void do_reconnect_storage(void)
  *------------------------------------------*/
 int storage_storageopen(struct map_session_data *sd)
 {
-    nullpo_ret(sd);
-
-    if (sd->state.storage_flag)
-        return 1; //Already open?
-
-    if (!pc_can_give_items(sd)) {
-        //check is this GM level is allowed to put items to storage
-        clif_displaymessage(sd->fd, msg_txt(246));
-        return 1;
-    }
-
-    sd->state.storage_flag = 1;
-    storage_sortitem(sd->status.storage.items, ARRAYLENGTH(sd->status.storage.items));
-    clif_storagelist(sd, sd->status.storage.items, ARRAYLENGTH(sd->status.storage.items));
-    clif_updatestorageamount(sd, sd->status.storage.storage_amount, MAX_STORAGE);
-    return 0;
+	nullpo_ret(sd);
+
+	if(sd->state.storage_flag)
+		return 1; //Already open?
+	
+	if( !pc_can_give_items(sd) )
+  	{ //check is this GM level is allowed to put items to storage
+		clif_displaymessage(sd->fd, msg_txt(246));
+		return 1;
+	}
+	
+	sd->state.storage_flag = 1;
+	storage_sortitem(sd->status.storage.items, ARRAYLENGTH(sd->status.storage.items));
+	clif_storagelist(sd, sd->status.storage.items, ARRAYLENGTH(sd->status.storage.items));
+	clif_updatestorageamount(sd, sd->status.storage.storage_amount, MAX_STORAGE);
+	return 0;
 }
 
 /* helper function
@@ -115,229 +116,232 @@ int storage_storageopen(struct map_session_data *sd)
  */
 int compare_item(struct item *a, struct item *b)
 {
-    if (a->nameid == b->nameid &&
-        a->identify == b->identify &&
-        a->refine == b->refine &&
-        a->attribute == b->attribute &&
-        a->expire_time == b->expire_time) {
-        int i;
-        for (i = 0; i < MAX_SLOTS && (a->card[i] == b->card[i]); i++);
-        return (i == MAX_SLOTS);
-    }
-    return 0;
+	if( a->nameid == b->nameid &&
+		a->identify == b->identify &&
+		a->refine == b->refine &&
+		a->attribute == b->attribute &&
+		a->expire_time == b->expire_time )
+	{
+		int i;
+		for (i = 0; i < MAX_SLOTS && (a->card[i] == b->card[i]); i++);
+		return (i == MAX_SLOTS);
+	}
+	return 0;
 }
 
 /*==========================================
  * Internal add-item function.
  *------------------------------------------*/
-static int storage_additem(struct map_session_data *sd, struct item *item_data, int amount)
+static int storage_additem(struct map_session_data* sd, struct item* item_data, int amount)
 {
-    struct storage_data *stor = &sd->status.storage;
-    struct item_data *data;
-    int i;
-
-    if (item_data->nameid <= 0 || amount <= 0)
-        return 1;
-
-    data = itemdb_search(item_data->nameid);
-
-    if (data->stack.storage && amount > data->stack.amount) {
-        // item stack limitation
-        return 1;
-    }
-
-    if (!itemdb_canstore(item_data, pc_get_group_level(sd))) {
-        //Check if item is storable. [Skotlex]
-        clif_displaymessage(sd->fd, msg_txt(264));
-        return 1;
-    }
-
-    if (itemdb_isstackable2(data)) {
-        //Stackable
-        for (i = 0; i < MAX_STORAGE; i++) {
-            if (compare_item(&stor->items[i], item_data)) {
-                // existing items found, stack them
-                if (amount > MAX_AMOUNT - stor->items[i].amount || (data->stack.storage && amount > data->stack.amount - stor->items[i].amount))
-                    return 1;
-                stor->items[i].amount += amount;
-                clif_storageitemadded(sd,&stor->items[i],i,amount);
-                return 0;
-            }
-        }
-    }
-
-    // find free slot
-    ARR_FIND(0, MAX_STORAGE, i, stor->items[i].nameid == 0);
-    if (i >= MAX_STORAGE)
-        return 1;
-
-    // add item to slot
-    memcpy(&stor->items[i],item_data,sizeof(stor->items[0]));
-    stor->storage_amount++;
-    stor->items[i].amount = amount;
-    clif_storageitemadded(sd,&stor->items[i],i,amount);
-    clif_updatestorageamount(sd, stor->storage_amount, MAX_STORAGE);
-
-    return 0;
+	struct storage_data* stor = &sd->status.storage;
+	struct item_data *data;
+	int i;
+
+	if( item_data->nameid <= 0 || amount <= 0 )
+		return 1;
+	
+	data = itemdb_search(item_data->nameid);
+
+	if( data->stack.storage && amount > data->stack.amount )
+	{// item stack limitation
+		return 1;
+	}
+
+	if( !itemdb_canstore(item_data, pc_get_group_level(sd)) )
+	{	//Check if item is storable. [Skotlex]
+		clif_displaymessage (sd->fd, msg_txt(264));
+		return 1;
+	}
+	
+	if( itemdb_isstackable2(data) )
+	{//Stackable
+		for( i = 0; i < MAX_STORAGE; i++ )
+		{
+			if( compare_item(&stor->items[i], item_data) )
+			{// existing items found, stack them
+				if( amount > MAX_AMOUNT - stor->items[i].amount || ( data->stack.storage && amount > data->stack.amount - stor->items[i].amount ) )
+					return 1;
+				stor->items[i].amount += amount;
+				clif_storageitemadded(sd,&stor->items[i],i,amount);
+				return 0;
+			}
+		}
+	}
+
+	// find free slot
+	ARR_FIND( 0, MAX_STORAGE, i, stor->items[i].nameid == 0 );
+	if( i >= MAX_STORAGE )
+		return 1;
+
+	// add item to slot
+	memcpy(&stor->items[i],item_data,sizeof(stor->items[0]));
+	stor->storage_amount++;
+	stor->items[i].amount = amount;
+	clif_storageitemadded(sd,&stor->items[i],i,amount);
+	clif_updatestorageamount(sd, stor->storage_amount, MAX_STORAGE);
+
+	return 0;
 }
 
 /*==========================================
  * Internal del-item function
  *------------------------------------------*/
-int storage_delitem(struct map_session_data *sd, int n, int amount)
+int storage_delitem(struct map_session_data* sd, int n, int amount)
 {
-    if (sd->status.storage.items[n].nameid == 0 || sd->status.storage.items[n].amount < amount)
-        return 1;
-
-    sd->status.storage.items[n].amount -= amount;
-    if (sd->status.storage.items[n].amount == 0) {
-        memset(&sd->status.storage.items[n],0,sizeof(sd->status.storage.items[0]));
-        sd->status.storage.storage_amount--;
-        if (sd->state.storage_flag == 1) clif_updatestorageamount(sd, sd->status.storage.storage_amount, MAX_STORAGE);
-    }
-    if (sd->state.storage_flag == 1) clif_storageitemremoved(sd,n,amount);
-    return 0;
+	if( sd->status.storage.items[n].nameid == 0 || sd->status.storage.items[n].amount < amount )
+		return 1;
+
+	sd->status.storage.items[n].amount -= amount;
+	if( sd->status.storage.items[n].amount == 0 )
+	{
+		memset(&sd->status.storage.items[n],0,sizeof(sd->status.storage.items[0]));
+		sd->status.storage.storage_amount--;
+		if( sd->state.storage_flag == 1 ) clif_updatestorageamount(sd, sd->status.storage.storage_amount, MAX_STORAGE);
+	}
+	if( sd->state.storage_flag == 1 ) clif_storageitemremoved(sd,n,amount);
+	return 0;
 }
 
 /*==========================================
  * Add an item to the storage from the inventory.
  * @index : inventory idx
  * return
- *  0 : fail
- *  1 : success
+ *	0 : fail
+ *	1 : success
  *------------------------------------------*/
-int storage_storageadd(struct map_session_data *sd, int index, int amount)
+int storage_storageadd(struct map_session_data* sd, int index, int amount)
 {
-    nullpo_ret(sd);
+	nullpo_ret(sd);
 
-    if (sd->status.storage.storage_amount > MAX_STORAGE)
-        return 0; // storage full
+	if( sd->status.storage.storage_amount > MAX_STORAGE )
+		return 0; // storage full
 
-    if (index < 0 || index >= MAX_INVENTORY)
-        return 0;
+	if( index < 0 || index >= MAX_INVENTORY )
+		return 0;
 
-    if (sd->status.inventory[index].nameid <= 0)
-        return 0; // No item on that spot
+	if( sd->status.inventory[index].nameid <= 0 )
+		return 0; // No item on that spot
 
-    if (amount < 1 || amount > sd->status.inventory[index].amount)
-        return 0;
+	if( amount < 1 || amount > sd->status.inventory[index].amount )
+  		return 0;
 
-    if (storage_additem(sd,&sd->status.inventory[index],amount) == 0)
-        pc_delitem(sd,index,amount,0,4,LOG_TYPE_STORAGE);
+	if( storage_additem(sd,&sd->status.inventory[index],amount) == 0 )
+		pc_delitem(sd,index,amount,0,4,LOG_TYPE_STORAGE);
 
-    return 1;
+	return 1;
 }
 
 /*==========================================
  * Retrieve an item from the storage into inventory
  * @index : storage idx
  * return
- *  0 : fail
- *  1 : success
+ *	0 : fail
+ *	1 : success
  *------------------------------------------*/
-int storage_storageget(struct map_session_data *sd, int index, int amount)
+int storage_storageget(struct map_session_data* sd, int index, int amount)
 {
-    int flag;
+	int flag;
 
-    if (index < 0 || index >= MAX_STORAGE)
-        return 0;
+	if( index < 0 || index >= MAX_STORAGE )
+		return 0;
 
-    if (sd->status.storage.items[index].nameid <= 0)
-        return 0; //Nothing there
+	if( sd->status.storage.items[index].nameid <= 0 )
+		return 0; //Nothing there
+	
+	if( amount < 1 || amount > sd->status.storage.items[index].amount )
+		return 0;
 
-    if (amount < 1 || amount > sd->status.storage.items[index].amount)
-        return 0;
+	if( (flag = pc_additem(sd,&sd->status.storage.items[index],amount,LOG_TYPE_STORAGE)) == 0 )
+		storage_delitem(sd,index,amount);
+	else
+		clif_additem(sd,0,0,flag);
 
-    if ((flag = pc_additem(sd,&sd->status.storage.items[index],amount,LOG_TYPE_STORAGE)) == 0)
-        storage_delitem(sd,index,amount);
-    else
-        clif_additem(sd,0,0,flag);
-
-    return 1;
+	return 1;
 }
 
 /*==========================================
  * Move an item from cart to storage.
  * @index : cart inventory index
  * return
- *  0 : fail
- *  1 : success
+ *	0 : fail
+ *	1 : success
  *------------------------------------------*/
-int storage_storageaddfromcart(struct map_session_data *sd, int index, int amount)
+int storage_storageaddfromcart(struct map_session_data* sd, int index, int amount)
 {
-    nullpo_ret(sd);
-
-    if (sd->status.storage.storage_amount > MAX_STORAGE)
-        return 0; // storage full / storage closed
+	nullpo_ret(sd);
 
-    if (index < 0 || index >= MAX_CART)
-        return 0;
+	if( sd->status.storage.storage_amount > MAX_STORAGE )
+  		return 0; // storage full / storage closed
 
-    if (sd->status.cart[index].nameid <= 0)
-        return 0; //No item there.
+	if( index < 0 || index >= MAX_CART )
+  		return 0;
 
-    if (amount < 1 || amount > sd->status.cart[index].amount)
-        return 0;
+	if( sd->status.cart[index].nameid <= 0 )
+		return 0; //No item there.
+	
+	if( amount < 1 || amount > sd->status.cart[index].amount )
+		return 0;
 
-    if (storage_additem(sd,&sd->status.cart[index],amount) == 0)
-        pc_cart_delitem(sd,index,amount,0,LOG_TYPE_STORAGE);
+	if( storage_additem(sd,&sd->status.cart[index],amount) == 0 )
+		pc_cart_delitem(sd,index,amount,0,LOG_TYPE_STORAGE);
 
-    return 1;
+	return 1;
 }
 
 /*==========================================
  * Get from Storage to the Cart inventory
  * @index : storage index
  * return
- *  0 : fail
- *  1 : success
+ *	0 : fail
+ *	1 : success
  *------------------------------------------*/
-int storage_storagegettocart(struct map_session_data *sd, int index, int amount)
+int storage_storagegettocart(struct map_session_data* sd, int index, int amount)
 {
-    nullpo_ret(sd);
-
-    if (index < 0 || index >= MAX_STORAGE)
-        return 0;
-
-    if (sd->status.storage.items[index].nameid <= 0)
-        return 0; //Nothing there.
-
-    if (amount < 1 || amount > sd->status.storage.items[index].amount)
-        return 0;
-
-    if (pc_cart_additem(sd,&sd->status.storage.items[index],amount,LOG_TYPE_STORAGE) == 0)
-        storage_delitem(sd,index,amount);
-
-    return 1;
+	nullpo_ret(sd);
+
+	if( index < 0 || index >= MAX_STORAGE )
+		return 0;
+	
+	if( sd->status.storage.items[index].nameid <= 0 )
+		return 0; //Nothing there.
+	
+	if( amount < 1 || amount > sd->status.storage.items[index].amount )
+		return 0;
+	
+	if( pc_cart_additem(sd,&sd->status.storage.items[index],amount,LOG_TYPE_STORAGE) == 0 )
+		storage_delitem(sd,index,amount);
+
+	return 1;
 }
 
 
 /*==========================================
  * Modified By Valaris to save upon closing [massdriller]
  *------------------------------------------*/
-void storage_storageclose(struct map_session_data *sd)
+void storage_storageclose(struct map_session_data* sd)
 {
-    nullpo_retv(sd);
+	nullpo_retv(sd);
 
-    clif_storageclose(sd);
+	clif_storageclose(sd);
 
-    if (save_settings&4)
-        chrif_save(sd,0); //Invokes the storage saving as well.
+	if( save_settings&4 )
+		chrif_save(sd,0); //Invokes the storage saving as well.
 
-    sd->state.storage_flag = 0;
+	sd->state.storage_flag = 0;
 }
 
 /*==========================================
  * When quitting the game.
  *------------------------------------------*/
-void storage_storage_quit(struct map_session_data *sd, int flag)
+void storage_storage_quit(struct map_session_data* sd, int flag)
 {
-    nullpo_retv(sd);
+	nullpo_retv(sd);
+	
+	if (save_settings&4)
+		chrif_save(sd, flag); //Invokes the storage saving as well.
 
-    if (save_settings&4)
-        chrif_save(sd, flag); //Invokes the storage saving as well.
-
-    sd->state.storage_flag = 0;
+	sd->state.storage_flag = 0;
 }
 
 /**
@@ -345,370 +349,374 @@ void storage_storage_quit(struct map_session_data *sd, int flag)
  */
 static DBData create_guildstorage(DBKey key, va_list args)
 {
-    struct guild_storage *gs = NULL;
-    gs = (struct guild_storage *) aCalloc(sizeof(struct guild_storage), 1);
-    gs->guild_id=key.i;
-    return db_ptr2data(gs);
+	struct guild_storage *gs = NULL;
+	gs = (struct guild_storage *) aCalloc(sizeof(struct guild_storage), 1);
+	gs->guild_id=key.i;
+	return db_ptr2data(gs);
 }
 
-struct guild_storage *guild2storage(int guild_id) {
-    struct guild_storage *gs = NULL;
-    if (guild_search(guild_id) != NULL)
-        gs = idb_ensure(guild_storage_db,guild_id,create_guildstorage);
-    return gs;
+struct guild_storage *guild2storage(int guild_id)
+{
+	struct guild_storage *gs = NULL;
+	if(guild_search(guild_id) != NULL)
+		gs = idb_ensure(guild_storage_db,guild_id,create_guildstorage);
+	return gs;
 }
 
 //For just locating a storage without creating one. [Skotlex]
-struct guild_storage *guild2storage2(int guild_id) {
-    return (struct guild_storage *)idb_get(guild_storage_db,guild_id);
+struct guild_storage *guild2storage2(int guild_id)
+{	
+	return (struct guild_storage*)idb_get(guild_storage_db,guild_id);
 }
 
 int guild_storage_delete(int guild_id)
 {
-    idb_remove(guild_storage_db,guild_id);
-    return 0;
+	idb_remove(guild_storage_db,guild_id);
+	return 0;
 }
 
 /*==========================================
 * Attempt to open guild storage for sd
 * return
-*   0 : success (open or req to create a new one)
-*   1 : fail
-*   2 : no guild for sd
+* 	0 : success (open or req to create a new one)
+* 	1 : fail
+*	2 : no guild for sd
  *------------------------------------------*/
-int storage_guild_storageopen(struct map_session_data *sd)
+int storage_guild_storageopen(struct map_session_data* sd)
 {
-    struct guild_storage *gstor;
-
-    nullpo_ret(sd);
-
-    if (sd->status.guild_id <= 0)
-        return 2;
-
-    if (sd->state.storage_flag)
-        return 1; //Can't open both storages at a time.
-
-    if (!pc_can_give_items(sd)) {  //check is this GM level can open guild storage and store items [Lupus]
-        clif_displaymessage(sd->fd, msg_txt(246));
-        return 1;
-    }
-
-    if ((gstor = guild2storage2(sd->status.guild_id)) == NULL) {
-        intif_request_guild_storage(sd->status.account_id,sd->status.guild_id);
-        return 0;
-    }
-    if (gstor->storage_status)
-        return 1;
-
-    gstor->storage_status = 1;
-    sd->state.storage_flag = 2;
-    storage_sortitem(gstor->items, ARRAYLENGTH(gstor->items));
-    clif_storagelist(sd, gstor->items, ARRAYLENGTH(gstor->items));
-    clif_updatestorageamount(sd, gstor->storage_amount, MAX_GUILD_STORAGE);
-    return 0;
+	struct guild_storage *gstor;
+
+	nullpo_ret(sd);
+
+	if(sd->status.guild_id <= 0)
+		return 2;
+
+	if(sd->state.storage_flag)
+		return 1; //Can't open both storages at a time.
+	
+	if( !pc_can_give_items(sd) ) { //check is this GM level can open guild storage and store items [Lupus]
+		clif_displaymessage(sd->fd, msg_txt(246));
+		return 1;
+	}
+
+	if((gstor = guild2storage2(sd->status.guild_id)) == NULL) {
+		intif_request_guild_storage(sd->status.account_id,sd->status.guild_id);
+		return 0;
+	}
+	if(gstor->storage_status)
+		return 1;
+	
+	gstor->storage_status = 1;
+	sd->state.storage_flag = 2;
+	storage_sortitem(gstor->items, ARRAYLENGTH(gstor->items));
+	clif_storagelist(sd, gstor->items, ARRAYLENGTH(gstor->items));
+	clif_updatestorageamount(sd, gstor->storage_amount, MAX_GUILD_STORAGE);
+	return 0;
 }
 
 /*==========================================
 * Attempt to add an item in guild storage, then refresh it
 * return
-*   0 : success
-*   1 : fail
+* 	0 : success
+* 	1 : fail
  *------------------------------------------*/
-int guild_storage_additem(struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int amount)
+int guild_storage_additem(struct map_session_data* sd, struct guild_storage* stor, struct item* item_data, int amount)
 {
-    struct item_data *data;
-    int i;
-
-    nullpo_retr(1, sd);
-    nullpo_retr(1, stor);
-    nullpo_retr(1, item_data);
-
-    if (item_data->nameid <= 0 || amount <= 0)
-        return 1;
-
-    data = itemdb_search(item_data->nameid);
-
-    if (data->stack.guildstorage && amount > data->stack.amount) {
-        // item stack limitation
-        return 1;
-    }
-
-    if (!itemdb_canguildstore(item_data, pc_get_group_level(sd)) || item_data->expire_time) {
-        //Check if item is storable. [Skotlex]
-        clif_displaymessage(sd->fd, msg_txt(264));
-        return 1;
-    }
-
-    if (itemdb_isstackable2(data)) { //Stackable
-        for (i=0; i<MAX_GUILD_STORAGE; i++) {
-            if (compare_item(&stor->items[i], item_data)) {
-                if (amount > MAX_AMOUNT - stor->items[i].amount || (data->stack.guildstorage && amount > data->stack.amount - stor->items[i].amount))
-                    return 1;
-                stor->items[i].amount+=amount;
-                clif_storageitemadded(sd,&stor->items[i],i,amount);
-                stor->dirty = 1;
-                return 0;
-            }
-        }
-    }
-    //Add item
-    for (i=0; i<MAX_GUILD_STORAGE && stor->items[i].nameid; i++);
-
-    if (i>=MAX_GUILD_STORAGE)
-        return 1;
-
-    memcpy(&stor->items[i],item_data,sizeof(stor->items[0]));
-    stor->items[i].amount=amount;
-    stor->storage_amount++;
-    clif_storageitemadded(sd,&stor->items[i],i,amount);
-    clif_updatestorageamount(sd, stor->storage_amount, MAX_GUILD_STORAGE);
-    stor->dirty = 1;
-    return 0;
+	struct item_data *data;
+	int i;
+
+	nullpo_retr(1, sd);
+	nullpo_retr(1, stor);
+	nullpo_retr(1, item_data);
+
+	if(item_data->nameid <= 0 || amount <= 0)
+		return 1;
+
+	data = itemdb_search(item_data->nameid);
+
+	if( data->stack.guildstorage && amount > data->stack.amount )
+	{// item stack limitation
+		return 1;
+	}
+
+	if( !itemdb_canguildstore(item_data, pc_get_group_level(sd)) || item_data->expire_time )
+	{	//Check if item is storable. [Skotlex]
+		clif_displaymessage (sd->fd, msg_txt(264));
+		return 1;
+	}
+
+	if(itemdb_isstackable2(data)){ //Stackable
+		for(i=0;i<MAX_GUILD_STORAGE;i++){
+			if(compare_item(&stor->items[i], item_data)) {
+				if( amount > MAX_AMOUNT - stor->items[i].amount || ( data->stack.guildstorage && amount > data->stack.amount - stor->items[i].amount ) )
+					return 1;
+				stor->items[i].amount+=amount;
+				clif_storageitemadded(sd,&stor->items[i],i,amount);
+				stor->dirty = 1;
+				return 0;
+			}
+		}
+	}
+	//Add item
+	for(i=0;i<MAX_GUILD_STORAGE && stor->items[i].nameid;i++);
+	
+	if(i>=MAX_GUILD_STORAGE)
+		return 1;
+	
+	memcpy(&stor->items[i],item_data,sizeof(stor->items[0]));
+	stor->items[i].amount=amount;
+	stor->storage_amount++;
+	clif_storageitemadded(sd,&stor->items[i],i,amount);
+	clif_updatestorageamount(sd, stor->storage_amount, MAX_GUILD_STORAGE);
+	stor->dirty = 1;
+	return 0;
 }
 
 /*==========================================
 * Attempt to delete an item in guild storage, then refresh it
 * return
-*   0 : success
-*   1 : fail
+* 	0 : success
+* 	1 : fail
  *------------------------------------------*/
-int guild_storage_delitem(struct map_session_data *sd, struct guild_storage *stor, int n, int amount)
+int guild_storage_delitem(struct map_session_data* sd, struct guild_storage* stor, int n, int amount)
 {
-    nullpo_retr(1, sd);
-    nullpo_retr(1, stor);
-
-    if (stor->items[n].nameid==0 || stor->items[n].amount<amount)
-        return 1;
-
-    stor->items[n].amount-=amount;
-    if (stor->items[n].amount==0) {
-        memset(&stor->items[n],0,sizeof(stor->items[0]));
-        stor->storage_amount--;
-        clif_updatestorageamount(sd, stor->storage_amount, MAX_GUILD_STORAGE);
-    }
-    clif_storageitemremoved(sd,n,amount);
-    stor->dirty = 1;
-    return 0;
+	nullpo_retr(1, sd);
+	nullpo_retr(1, stor);
+
+	if(stor->items[n].nameid==0 || stor->items[n].amount<amount)
+		return 1;
+
+	stor->items[n].amount-=amount;
+	if(stor->items[n].amount==0){
+		memset(&stor->items[n],0,sizeof(stor->items[0]));
+		stor->storage_amount--;
+		clif_updatestorageamount(sd, stor->storage_amount, MAX_GUILD_STORAGE);
+	}
+	clif_storageitemremoved(sd,n,amount);
+	stor->dirty = 1;
+	return 0;
 }
 
 /*==========================================
 * Attempt to add an item in guild storage from inventory, then refresh it
 * @index : inventory idx
 * return
-*   0 : fail
-*   1 : succes
+* 	0 : fail
+* 	1 : succes
  *------------------------------------------*/
-int storage_guild_storageadd(struct map_session_data *sd, int index, int amount)
+int storage_guild_storageadd(struct map_session_data* sd, int index, int amount)
 {
-    struct guild_storage *stor;
-
-    nullpo_ret(sd);
-    nullpo_ret(stor=guild2storage2(sd->status.guild_id));
-
-    if (!stor->storage_status || stor->storage_amount > MAX_GUILD_STORAGE)
-        return 0;
-
-    if (index<0 || index>=MAX_INVENTORY)
-        return 0;
-
-    if (sd->status.inventory[index].nameid <= 0)
-        return 0;
-
-    if (amount < 1 || amount > sd->status.inventory[index].amount)
-        return 0;
-
-    if (guild_storage_additem(sd,stor,&sd->status.inventory[index],amount)==0)
-        pc_delitem(sd,index,amount,0,4,LOG_TYPE_GSTORAGE);
-
-    return 1;
+	struct guild_storage *stor;
+
+	nullpo_ret(sd);
+	nullpo_ret(stor=guild2storage2(sd->status.guild_id));
+		
+	if( !stor->storage_status || stor->storage_amount > MAX_GUILD_STORAGE )
+		return 0;
+	
+	if( index<0 || index>=MAX_INVENTORY )
+		return 0;
+
+	if( sd->status.inventory[index].nameid <= 0 )
+		return 0;
+	
+	if( amount < 1 || amount > sd->status.inventory[index].amount )
+		return 0;
+
+	if(guild_storage_additem(sd,stor,&sd->status.inventory[index],amount)==0)
+		pc_delitem(sd,index,amount,0,4,LOG_TYPE_GSTORAGE);
+
+	return 1;
 }
 
 /*==========================================
 * Attempt to retrieve an item from guild storage to inventory, then refresh it
 * @index : storage idx
 * return
-*   0 : fail
-*   1 : succes
+* 	0 : fail
+* 	1 : succes
  *------------------------------------------*/
-int storage_guild_storageget(struct map_session_data *sd, int index, int amount)
+int storage_guild_storageget(struct map_session_data* sd, int index, int amount)
 {
-    struct guild_storage *stor;
-    int flag;
-
-    nullpo_ret(sd);
-    nullpo_ret(stor=guild2storage2(sd->status.guild_id));
-
-    if (!stor->storage_status)
-        return 0;
-
-    if (index<0 || index>=MAX_GUILD_STORAGE)
-        return 0;
-
-    if (stor->items[index].nameid <= 0)
-        return 0;
-
-    if (amount < 1 || amount > stor->items[index].amount)
-        return 0;
-
-    if ((flag = pc_additem(sd,&stor->items[index],amount,LOG_TYPE_GSTORAGE)) == 0)
-        guild_storage_delitem(sd,stor,index,amount);
-    else //inform fail
-        clif_additem(sd,0,0,flag);
-    //  log_fromstorage(sd, index, 1);
-
-    return 0;
+	struct guild_storage *stor;
+	int flag;
+
+	nullpo_ret(sd);
+	nullpo_ret(stor=guild2storage2(sd->status.guild_id));
+
+	if(!stor->storage_status)
+  		return 0;
+	
+	if(index<0 || index>=MAX_GUILD_STORAGE)
+		return 0;
+
+	if(stor->items[index].nameid <= 0)
+		return 0;
+	
+	if(amount < 1 || amount > stor->items[index].amount)
+	  	return 0;
+
+	if((flag = pc_additem(sd,&stor->items[index],amount,LOG_TYPE_GSTORAGE)) == 0)
+		guild_storage_delitem(sd,stor,index,amount);
+	else //inform fail
+		clif_additem(sd,0,0,flag);
+//	log_fromstorage(sd, index, 1);
+
+	return 0;
 }
 
 /*==========================================
 * Attempt to add an item in guild storage from cart, then refresh it
 * @index : cart inventory idx
 * return
-*   0 : fail
-*   1 : succes
+* 	0 : fail
+* 	1 : succes
  *------------------------------------------*/
-int storage_guild_storageaddfromcart(struct map_session_data *sd, int index, int amount)
+int storage_guild_storageaddfromcart(struct map_session_data* sd, int index, int amount)
 {
-    struct guild_storage *stor;
+	struct guild_storage *stor;
 
-    nullpo_ret(sd);
-    nullpo_ret(stor=guild2storage2(sd->status.guild_id));
+	nullpo_ret(sd);
+	nullpo_ret(stor=guild2storage2(sd->status.guild_id));
 
-    if (!stor->storage_status || stor->storage_amount > MAX_GUILD_STORAGE)
-        return 0;
+	if( !stor->storage_status || stor->storage_amount > MAX_GUILD_STORAGE )
+		return 0;
 
-    if (index < 0 || index >= MAX_CART)
-        return 0;
+	if( index < 0 || index >= MAX_CART )
+		return 0;
 
-    if (sd->status.cart[index].nameid <= 0)
-        return 0;
+	if( sd->status.cart[index].nameid <= 0 )
+		return 0;
+	
+	if( amount < 1 || amount > sd->status.cart[index].amount )
+		return 0;
 
-    if (amount < 1 || amount > sd->status.cart[index].amount)
-        return 0;
+	if(guild_storage_additem(sd,stor,&sd->status.cart[index],amount)==0)
+		pc_cart_delitem(sd,index,amount,0,LOG_TYPE_GSTORAGE);
 
-    if (guild_storage_additem(sd,stor,&sd->status.cart[index],amount)==0)
-        pc_cart_delitem(sd,index,amount,0,LOG_TYPE_GSTORAGE);
-
-    return 1;
+	return 1;
 }
 
 /*==========================================
 * Attempt to retrieve an item from guild storage to cart, then refresh it
 * @index : storage idx
 * return
-*   0 : fail
-*   1 : succes
+* 	0 : fail
+* 	1 : succes
  *------------------------------------------*/
-int storage_guild_storagegettocart(struct map_session_data *sd, int index, int amount)
+int storage_guild_storagegettocart(struct map_session_data* sd, int index, int amount)
 {
-    struct guild_storage *stor;
-
-    nullpo_ret(sd);
-    nullpo_ret(stor=guild2storage2(sd->status.guild_id));
-
-    if (!stor->storage_status)
-        return 0;
+	struct guild_storage *stor;
 
-    if (index<0 || index>=MAX_GUILD_STORAGE)
-        return 0;
+	nullpo_ret(sd);
+	nullpo_ret(stor=guild2storage2(sd->status.guild_id));
 
-    if (stor->items[index].nameid<=0)
-        return 0;
+	if(!stor->storage_status)
+	  	return 0;
 
-    if (amount < 1 || amount > stor->items[index].amount)
-        return 0;
+	if(index<0 || index>=MAX_GUILD_STORAGE)
+	  	return 0;
+	
+	if(stor->items[index].nameid<=0)
+		return 0;
+	
+	if(amount < 1 || amount > stor->items[index].amount)
+		return 0;
 
-    if (pc_cart_additem(sd,&stor->items[index],amount,LOG_TYPE_GSTORAGE)==0)
-        guild_storage_delitem(sd,stor,index,amount);
+	if(pc_cart_additem(sd,&stor->items[index],amount,LOG_TYPE_GSTORAGE)==0)
+		guild_storage_delitem(sd,stor,index,amount);
 
-    return 1;
+	return 1;
 }
 
 /*==========================================
 * Request to save guild storage
 * return
-*   0 : fail (no storage)
-*   1 : succes
+* 	0 : fail (no storage)
+* 	1 : succes
  *------------------------------------------*/
 int storage_guild_storagesave(int account_id, int guild_id, int flag)
 {
-    struct guild_storage *stor = guild2storage2(guild_id);
-
-    if (stor) {
-        if (flag) //Char quitting, close it.
-            stor->storage_status = 0;
-        if (stor->dirty)
-            intif_send_guild_storage(account_id,stor);
-        return 1;
-    }
-    return 0;
+	struct guild_storage *stor = guild2storage2(guild_id);
+
+	if(stor)
+	{
+		if (flag) //Char quitting, close it.
+			stor->storage_status = 0;
+	 	if (stor->dirty)
+			intif_send_guild_storage(account_id,stor);
+		return 1;
+	}
+	return 0;
 }
 
 /*==========================================
 * ACK save of guild storage
 * return
-*   0 : fail (no storage)
-*   1 : succes
+* 	0 : fail (no storage)
+* 	1 : succes
  *------------------------------------------*/
 int storage_guild_storagesaved(int guild_id)
 {
-    struct guild_storage *stor;
-
-    if ((stor=guild2storage2(guild_id)) != NULL) {
-        if (stor->dirty && stor->storage_status == 0) {
-            //Storage has been correctly saved.
-            stor->dirty = 0;
-        }
-        return 1;
-    }
-    return 0;
+	struct guild_storage *stor;
+
+	if((stor=guild2storage2(guild_id)) != NULL) {
+		if (stor->dirty && stor->storage_status == 0)
+		{	//Storage has been correctly saved.
+			stor->dirty = 0;
+		}
+		return 1;
+	}
+	return 0;
 }
 
 //Close storage for sd and save it
-int storage_guild_storageclose(struct map_session_data *sd)
+int storage_guild_storageclose(struct map_session_data* sd)
 {
-    struct guild_storage *stor;
-
-    nullpo_ret(sd);
-    nullpo_ret(stor=guild2storage2(sd->status.guild_id));
-
-    clif_storageclose(sd);
-    if (stor->storage_status) {
-        if (save_settings&4)
-            chrif_save(sd, 0); //This one also saves the storage. [Skotlex]
-        else
-            storage_guild_storagesave(sd->status.account_id, sd->status.guild_id,0);
-        stor->storage_status=0;
-    }
-    sd->state.storage_flag = 0;
-
-    return 0;
+	struct guild_storage *stor;
+
+	nullpo_ret(sd);
+	nullpo_ret(stor=guild2storage2(sd->status.guild_id));
+
+	clif_storageclose(sd);
+	if (stor->storage_status)
+	{
+		if (save_settings&4)
+			chrif_save(sd, 0); //This one also saves the storage. [Skotlex]
+		else
+			storage_guild_storagesave(sd->status.account_id, sd->status.guild_id,0);
+		stor->storage_status=0;
+	}
+	sd->state.storage_flag = 0;
+
+	return 0;
 }
 
-int storage_guild_storage_quit(struct map_session_data *sd, int flag)
+int storage_guild_storage_quit(struct map_session_data* sd, int flag)
 {
-    struct guild_storage *stor;
-
-    nullpo_ret(sd);
-    nullpo_ret(stor=guild2storage2(sd->status.guild_id));
-
-    if (flag) {
-        //Only during a guild break flag is 1 (don't save storage)
-        sd->state.storage_flag = 0;
-        stor->storage_status = 0;
-        clif_storageclose(sd);
-        if (save_settings&4)
-            chrif_save(sd,0);
-        return 0;
-    }
-
-    if (stor->storage_status) {
-        if (save_settings&4)
-            chrif_save(sd,0);
-        else
-            storage_guild_storagesave(sd->status.account_id,sd->status.guild_id,1);
-    }
-    sd->state.storage_flag = 0;
-    stor->storage_status = 0;
-
-    return 0;
+	struct guild_storage *stor;
+
+	nullpo_ret(sd);
+	nullpo_ret(stor=guild2storage2(sd->status.guild_id));
+	
+	if(flag)
+	{	//Only during a guild break flag is 1 (don't save storage)
+		sd->state.storage_flag = 0;
+		stor->storage_status = 0;
+		clif_storageclose(sd);
+		if (save_settings&4)
+			chrif_save(sd,0);
+		return 0;
+	}
+
+	if(stor->storage_status) {
+		if (save_settings&4)
+			chrif_save(sd,0);
+		else
+			storage_guild_storagesave(sd->status.account_id,sd->status.guild_id,1);
+	}
+	sd->state.storage_flag = 0;
+	stor->storage_status = 0;
+
+	return 0;
 }