d13956c142
- Likely fixed opening guild storage. git-svn-id: https://svn.code.sf.net/p/rathena/svn/trunk@5146 54d463be-8e91-2dee-dedb-b68131a5f0ec
691 lines
19 KiB
C
691 lines
19 KiB
C
// Copyright (c) Athena Dev Teams - Licensed under GNU GPL
|
|
// For more information, see LICENCE in the main folder
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "../common/nullpo.h"
|
|
#include "../common/malloc.h"
|
|
#include "../common/showmsg.h"
|
|
|
|
#include "storage.h"
|
|
#include "chrif.h"
|
|
#include "itemdb.h"
|
|
#include "clif.h"
|
|
#include "intif.h"
|
|
#include "pc.h"
|
|
#include "guild.h"
|
|
#include "battle.h"
|
|
#include "atcommand.h"
|
|
|
|
static struct dbt *storage_db;
|
|
static struct dbt *guild_storage_db;
|
|
|
|
/*==========================================
|
|
* 倉庫内アイテムソート
|
|
*------------------------------------------
|
|
*/
|
|
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;
|
|
}
|
|
|
|
void sortage_sortitem (struct storage *stor)
|
|
{
|
|
nullpo_retv(stor);
|
|
qsort(stor->storage_, MAX_STORAGE, sizeof(struct item), storage_comp_item);
|
|
}
|
|
|
|
void sortage_gsortitem (struct guild_storage* gstor)
|
|
{
|
|
nullpo_retv(gstor);
|
|
qsort(gstor->storage_, MAX_GUILD_STORAGE, sizeof(struct item), storage_comp_item);
|
|
}
|
|
|
|
/*==========================================
|
|
* 初期化とか
|
|
*------------------------------------------
|
|
*/
|
|
int do_init_storage(void) // map.c::do_init()から呼ばれる
|
|
{
|
|
storage_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
|
|
guild_storage_db=db_alloc(__FILE__,__LINE__,DB_INT,DB_OPT_RELEASE_DATA,sizeof(int));
|
|
return 1;
|
|
}
|
|
void do_final_storage(void) // by [MC Cameri]
|
|
{
|
|
storage_db->destroy(storage_db,NULL);
|
|
guild_storage_db->destroy(guild_storage_db,NULL);
|
|
}
|
|
|
|
|
|
static int storage_reconnect_sub(DBKey key,void *data,va_list ap)
|
|
{ //Parses storage and saves 'dirty' ones upon reconnect. [Skotlex]
|
|
int type = va_arg(ap, int);
|
|
if (type)
|
|
{ //Guild Storage
|
|
struct guild_storage* stor = (struct guild_storage*) data;
|
|
if (stor->dirty && stor->storage_status == 0) //Save closed storages.
|
|
storage_guild_storagesave(0, stor->guild_id);
|
|
}
|
|
else
|
|
{ //Account Storage
|
|
struct storage* stor = (struct storage*) data;
|
|
if (stor->dirty && stor->storage_status == 0) //Save closed storages.
|
|
storage_storage_save(stor->account_id);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Function to be invoked upon server reconnection to char. To save all 'dirty' storages [Skotlex
|
|
void do_reconnect_storage(void)
|
|
{
|
|
storage_db->foreach(storage_db, storage_reconnect_sub, 0);
|
|
guild_storage_db->foreach(guild_storage_db, storage_reconnect_sub, 1);
|
|
}
|
|
|
|
static void* create_storage(DBKey key, va_list args) {
|
|
struct storage *stor;
|
|
stor = (struct storage *) aCallocA (sizeof(struct storage), 1);
|
|
stor->account_id = key.i;
|
|
return stor;
|
|
}
|
|
struct storage *account2storage(int account_id)
|
|
{
|
|
return idb_ensure(storage_db,account_id,create_storage);
|
|
}
|
|
|
|
// Just to ask storage, without creation
|
|
struct storage *account2storage2(int account_id)
|
|
{
|
|
return idb_get(storage_db, account_id);
|
|
}
|
|
|
|
int storage_delete(int account_id)
|
|
{
|
|
idb_remove(storage_db,account_id);
|
|
return 0;
|
|
}
|
|
|
|
/*==========================================
|
|
* カプラ倉庫を開く
|
|
*------------------------------------------
|
|
*/
|
|
int storage_storageopen(struct map_session_data *sd)
|
|
{
|
|
//#ifdef TXT_ONLY
|
|
struct storage *stor;
|
|
//#endif
|
|
nullpo_retr(0, sd);
|
|
|
|
if(sd->state.finalsave) //Refuse to open storage when you had your last save done.
|
|
return 1;
|
|
|
|
if( pc_can_give_items(pc_isGM(sd)) ) { //check is this GM level is allowed to put items to storage
|
|
clif_displaymessage(sd->fd, msg_txt(246));
|
|
return 1;
|
|
}
|
|
//Storage loading always from sql idea from Komurka [Skotlex] - removed as it opens exploits when server lags.
|
|
//#ifdef TXT_ONLY
|
|
if((stor = idb_get(storage_db,sd->status.account_id)) != NULL) {
|
|
if (stor->storage_status == 0 && sd->state.storage_flag == 0) {
|
|
stor->storage_status = 1;
|
|
sd->state.storage_flag = 1;
|
|
clif_storageitemlist(sd,stor);
|
|
clif_storageequiplist(sd,stor);
|
|
clif_updatestorageamount(sd,stor);
|
|
return 0;
|
|
}
|
|
} else
|
|
//#endif
|
|
intif_request_storage(sd->status.account_id);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*==========================================
|
|
* カプラ倉庫へアイテム追加
|
|
*------------------------------------------
|
|
*/
|
|
int storage_additem(struct map_session_data *sd,struct 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;
|
|
nullpo_retr(1, data = itemdb_search(item_data->nameid));
|
|
|
|
if (!itemdb_canstore(item_data->nameid, pc_isGM(sd)))
|
|
{ //Check if item is storable. [Skotlex]
|
|
clif_displaymessage (sd->fd, msg_txt(264));
|
|
return 1;
|
|
}
|
|
|
|
i=MAX_STORAGE;
|
|
if(!itemdb_isequip2(data)){
|
|
// 装備品ではないので、既所有品なら個数のみ変化させる
|
|
for(i=0;i<MAX_STORAGE;i++){
|
|
if( compare_item (&stor->storage_[i], item_data)) {
|
|
if(stor->storage_[i].amount+amount > MAX_AMOUNT)
|
|
return 1;
|
|
stor->storage_[i].amount+=amount;
|
|
clif_storageitemadded(sd,stor,i,amount);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(i>=MAX_STORAGE){
|
|
// 装備品か未所有品だったので空き欄へ追加
|
|
for(i=0;i<MAX_STORAGE;i++){
|
|
if(stor->storage_[i].nameid==0){
|
|
memcpy(&stor->storage_[i],item_data,sizeof(stor->storage_[0]));
|
|
stor->storage_[i].amount=amount;
|
|
stor->storage_amount++;
|
|
clif_storageitemadded(sd,stor,i,amount);
|
|
clif_updatestorageamount(sd,stor);
|
|
break;
|
|
}
|
|
}
|
|
if(i>=MAX_STORAGE)
|
|
return 1;
|
|
}
|
|
|
|
stor->dirty = 1;
|
|
return 0;
|
|
}
|
|
/*==========================================
|
|
* カプラ倉庫アイテムを減らす
|
|
*------------------------------------------
|
|
*/
|
|
int storage_delitem(struct map_session_data *sd,struct storage *stor,int n,int amount)
|
|
{
|
|
nullpo_retr(1, sd);
|
|
nullpo_retr(1, stor);
|
|
|
|
if(stor->storage_[n].nameid==0 || stor->storage_[n].amount<amount)
|
|
return 1;
|
|
|
|
stor->storage_[n].amount-=amount;
|
|
if(stor->storage_[n].amount==0){
|
|
memset(&stor->storage_[n],0,sizeof(stor->storage_[0]));
|
|
stor->storage_amount--;
|
|
clif_updatestorageamount(sd,stor);
|
|
}
|
|
clif_storageitemremoved(sd,n,amount);
|
|
|
|
stor->dirty = 1;
|
|
return 0;
|
|
}
|
|
/*==========================================
|
|
* カプラ倉庫へ入れる
|
|
*------------------------------------------
|
|
*/
|
|
int storage_storageadd(struct map_session_data *sd,int index,int amount)
|
|
{
|
|
struct storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
nullpo_retr(0, stor=account2storage2(sd->status.account_id));
|
|
|
|
if( (stor->storage_amount <= MAX_STORAGE) && (stor->storage_status == 1) ) { // storage not full & storage open
|
|
if(index>=0 && index<MAX_INVENTORY) { // valid index
|
|
if( (amount <= sd->status.inventory[index].amount) && (amount > 0) ) { //valid amount
|
|
// log_tostorage(sd, index, 0);
|
|
if(storage_additem(sd,stor,&sd->status.inventory[index],amount)==0)
|
|
// remove item from inventory
|
|
pc_delitem(sd,index,amount,0);
|
|
} // valid amount
|
|
}// valid index
|
|
}// storage not full & storage open
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*==========================================
|
|
* カプラ倉庫から出す
|
|
*------------------------------------------
|
|
*/
|
|
int storage_storageget(struct map_session_data *sd,int index,int amount)
|
|
{
|
|
struct storage *stor;
|
|
int flag;
|
|
|
|
nullpo_retr(0, sd);
|
|
nullpo_retr(0, stor=account2storage2(sd->status.account_id));
|
|
|
|
if(stor->storage_status == 1) { // storage open
|
|
if(index>=0 && index<MAX_STORAGE) { // valid index
|
|
if( (amount <= stor->storage_[index].amount) && (amount > 0) ) { //valid amount
|
|
if((flag = pc_additem(sd,&stor->storage_[index],amount)) == 0)
|
|
storage_delitem(sd,stor,index,amount);
|
|
//else //taken out because it can dupe items if the above fails somehow :) [Kevin]
|
|
//clif_additem(sd,0,0,flag);
|
|
// log_fromstorage(sd, index, 0);
|
|
} // valid amount
|
|
}// valid index
|
|
}// storage open
|
|
|
|
return 0;
|
|
}
|
|
/*==========================================
|
|
* カプラ倉庫へカートから入れる
|
|
*------------------------------------------
|
|
*/
|
|
int storage_storageaddfromcart(struct map_session_data *sd,int index,int amount)
|
|
{
|
|
struct storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
nullpo_retr(0, stor=account2storage2(sd->status.account_id));
|
|
|
|
if( (stor->storage_amount <= MAX_STORAGE) && (stor->storage_status == 1) ) { // storage not full & storage open
|
|
if(index>=0 && index<MAX_INVENTORY) { // valid index
|
|
if( (amount <= sd->status.cart[index].amount) && (amount > 0) ) { //valid amount
|
|
if(storage_additem(sd,stor,&sd->status.cart[index],amount)==0)
|
|
pc_cart_delitem(sd,index,amount,0);
|
|
} // valid amount
|
|
}// valid index
|
|
}// storage not full & storage open
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*==========================================
|
|
* カプラ倉庫からカートへ出す
|
|
*------------------------------------------
|
|
*/
|
|
int storage_storagegettocart(struct map_session_data *sd,int index,int amount)
|
|
{
|
|
struct storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
nullpo_retr(0, stor=account2storage2(sd->status.account_id));
|
|
|
|
if(stor->storage_status == 1) { // storage open
|
|
if(index>=0 && index<MAX_STORAGE) { // valid index
|
|
if( (amount <= stor->storage_[index].amount) && (amount > 0) ) { //valid amount
|
|
if(pc_cart_additem(sd,&stor->storage_[index],amount)==0){
|
|
storage_delitem(sd,stor,index,amount);
|
|
}
|
|
} // valid amount
|
|
}// valid index
|
|
}// storage open
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*==========================================
|
|
* Modified By Valaris to save upon closing [massdriller]
|
|
*------------------------------------------
|
|
*/
|
|
int storage_storageclose(struct map_session_data *sd)
|
|
{
|
|
struct storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
nullpo_retr(0, stor=account2storage2(sd->status.account_id));
|
|
|
|
clif_storageclose(sd);
|
|
chrif_save(sd, 0); //This will invoke the storage save function as well. [Skotlex]
|
|
|
|
stor->storage_status=0;
|
|
sd->state.storage_flag = 0;
|
|
return 0;
|
|
}
|
|
|
|
/*==========================================
|
|
* ログアウト時開いているカプラ倉庫の保存
|
|
*------------------------------------------
|
|
*/
|
|
int storage_storage_quit(struct map_session_data *sd, int flag)
|
|
{
|
|
struct storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
|
|
stor = account2storage2(sd->status.account_id);
|
|
if(stor) {
|
|
chrif_save(sd, flag); //Invokes the storage saving as well.
|
|
stor->storage_status = 0;
|
|
sd->state.storage_flag = 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void storage_storage_dirty(struct map_session_data *sd)
|
|
{
|
|
struct storage *stor;
|
|
|
|
stor=account2storage2(sd->status.account_id);
|
|
|
|
if(stor)
|
|
stor->dirty = 1;
|
|
}
|
|
|
|
int storage_storage_save(int account_id)
|
|
{
|
|
struct storage *stor;
|
|
|
|
stor=account2storage2(account_id);
|
|
if(stor && stor->dirty)
|
|
{
|
|
intif_send_storage(stor);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//Ack from Char-server indicating the storage was saved. [Skotlex]
|
|
int storage_storage_saved(int account_id)
|
|
{
|
|
struct storage *stor;
|
|
|
|
if((stor=account2storage2(account_id)) != NULL)
|
|
{ //Only mark it clean if it's not in use. [Skotlex]
|
|
if (stor->dirty && stor->storage_status == 0)
|
|
{
|
|
stor->dirty = 0;
|
|
sortage_sortitem(stor);
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void* create_guildstorage(DBKey key, va_list args) {
|
|
struct guild_storage *gs = NULL;
|
|
gs = (struct guild_storage *) aCallocA(sizeof(struct guild_storage), 1);
|
|
gs->guild_id=key.i;
|
|
return gs;
|
|
}
|
|
struct guild_storage *guild2storage(int guild_id)
|
|
{
|
|
struct guild_storage *gs = NULL;
|
|
if(guild_search(guild_id) != NULL)
|
|
gs=(struct guild_storage *) idb_ensure(guild_storage_db,guild_id,create_guildstorage);
|
|
return gs;
|
|
}
|
|
|
|
struct guild_storage *guild2storage2(int guild_id)
|
|
{ //For just locating a storage without creating one. [Skotlex]
|
|
return idb_get(guild_storage_db,guild_id);
|
|
}
|
|
|
|
int guild_storage_delete(int guild_id)
|
|
{
|
|
idb_remove(guild_storage_db,guild_id);
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storageopen(struct map_session_data *sd)
|
|
{
|
|
struct guild_storage *gstor;
|
|
|
|
nullpo_retr(0, sd);
|
|
|
|
if(sd->status.guild_id <= 0)
|
|
return 2;
|
|
|
|
if(sd->state.finalsave) //Refuse to open storage when you had your last save done.
|
|
return 1;
|
|
|
|
if( pc_can_give_items(pc_isGM(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) {
|
|
if(gstor->storage_status)
|
|
return 1;
|
|
if(sd->state.storage_flag)
|
|
return 1; //Can't open both storages at a time.
|
|
gstor->storage_status = 1;
|
|
sd->state.storage_flag = 2;
|
|
clif_guildstorageitemlist(sd,gstor);
|
|
clif_guildstorageequiplist(sd,gstor);
|
|
clif_updateguildstorageamount(sd,gstor);
|
|
return 0;
|
|
}
|
|
else
|
|
intif_request_guild_storage(sd->status.account_id,sd->status.guild_id);
|
|
|
|
return 0;
|
|
}
|
|
|
|
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);
|
|
nullpo_retr(1, data = itemdb_search(item_data->nameid));
|
|
|
|
if(item_data->nameid <= 0 || amount <= 0)
|
|
return 1;
|
|
|
|
if (!itemdb_canguildstore(item_data->nameid, pc_isGM(sd)))
|
|
{ //Check if item is storable. [Skotlex]
|
|
clif_displaymessage (sd->fd, msg_txt(264));
|
|
return 1;
|
|
}
|
|
|
|
i=MAX_GUILD_STORAGE;
|
|
if(!itemdb_isequip2(data)){
|
|
// 装備品ではないので、既所有品なら個数のみ変化させる
|
|
for(i=0;i<MAX_GUILD_STORAGE;i++){
|
|
if(compare_item(&stor->storage_[i], item_data)) {
|
|
if(stor->storage_[i].amount+amount > MAX_AMOUNT)
|
|
return 1;
|
|
stor->storage_[i].amount+=amount;
|
|
clif_guildstorageitemadded(sd,stor,i,amount);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(i>=MAX_GUILD_STORAGE){
|
|
// 装備品か未所有品だったので空き欄へ追加
|
|
for(i=0;i<MAX_GUILD_STORAGE;i++){
|
|
if(stor->storage_[i].nameid==0){
|
|
memcpy(&stor->storage_[i],item_data,sizeof(stor->storage_[0]));
|
|
stor->storage_[i].amount=amount;
|
|
stor->storage_amount++;
|
|
clif_guildstorageitemadded(sd,stor,i,amount);
|
|
clif_updateguildstorageamount(sd,stor);
|
|
break;
|
|
}
|
|
}
|
|
if(i>=MAX_GUILD_STORAGE)
|
|
return 1;
|
|
}
|
|
stor->dirty = 1;
|
|
return 0;
|
|
}
|
|
|
|
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->storage_[n].nameid==0 || stor->storage_[n].amount<amount)
|
|
return 1;
|
|
|
|
stor->storage_[n].amount-=amount;
|
|
if(stor->storage_[n].amount==0){
|
|
memset(&stor->storage_[n],0,sizeof(stor->storage_[0]));
|
|
stor->storage_amount--;
|
|
clif_updateguildstorageamount(sd,stor);
|
|
}
|
|
clif_storageitemremoved(sd,n,amount);
|
|
stor->dirty = 1;
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storageadd(struct map_session_data *sd,int index,int amount)
|
|
{
|
|
struct guild_storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
|
|
if((stor=guild2storage2(sd->status.guild_id)) != NULL) {
|
|
if( (stor->storage_amount <= MAX_GUILD_STORAGE) && (stor->storage_status == 1) ) { // storage not full & storage open
|
|
if(index>=0 && index<MAX_INVENTORY) { // valid index
|
|
if( (amount <= sd->status.inventory[index].amount) && (amount > 0) ) { //valid amount
|
|
// log_tostorage(sd, index, 1);
|
|
if(guild_storage_additem(sd,stor,&sd->status.inventory[index],amount)==0)
|
|
// remove item from inventory
|
|
pc_delitem(sd,index,amount,0);
|
|
} // valid amount
|
|
}// valid index
|
|
}// storage not full & storage open
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storageget(struct map_session_data *sd,int index,int amount)
|
|
{
|
|
struct guild_storage *stor;
|
|
int flag;
|
|
|
|
nullpo_retr(0, sd);
|
|
|
|
if((stor=guild2storage2(sd->status.guild_id)) != NULL) {
|
|
if(stor->storage_status == 1) { // storage open
|
|
if(index>=0 && index<MAX_GUILD_STORAGE) { // valid index
|
|
if( (amount <= stor->storage_[index].amount) && (amount > 0) ) { //valid amount
|
|
if((flag = pc_additem(sd,&stor->storage_[index],amount)) == 0)
|
|
guild_storage_delitem(sd,stor,index,amount);
|
|
else
|
|
clif_additem(sd,0,0,flag);
|
|
// log_fromstorage(sd, index, 1);
|
|
} // valid amount
|
|
}// valid index
|
|
}// storage open
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storageaddfromcart(struct map_session_data *sd,int index,int amount)
|
|
{
|
|
struct guild_storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
|
|
if((stor=guild2storage2(sd->status.guild_id)) != NULL) {
|
|
if( (stor->storage_amount <= MAX_GUILD_STORAGE) && (stor->storage_status == 1) ) { // storage not full & storage open
|
|
if(index>=0 && index<MAX_INVENTORY) { // valid index
|
|
if( (amount <= sd->status.cart[index].amount) && (amount > 0) ) { //valid amount
|
|
if(guild_storage_additem(sd,stor,&sd->status.cart[index],amount)==0)
|
|
pc_cart_delitem(sd,index,amount,0);
|
|
} // valid amount
|
|
}// valid index
|
|
}// storage not full & storage open
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storagegettocart(struct map_session_data *sd,int index,int amount)
|
|
{
|
|
struct guild_storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
|
|
if((stor=guild2storage2(sd->status.guild_id)) != NULL) {
|
|
if(stor->storage_status == 1) { // storage open
|
|
if(index>=0 && index<MAX_GUILD_STORAGE) { // valid index
|
|
if( (amount <= stor->storage_[index].amount) && (amount > 0) ) { //valid amount
|
|
if(pc_cart_additem(sd,&stor->storage_[index],amount)==0){
|
|
guild_storage_delitem(sd,stor,index,amount);
|
|
}
|
|
} // valid amount
|
|
}// valid index
|
|
}// storage open
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storagesave(int account_id, int guild_id)
|
|
{
|
|
struct guild_storage *stor = guild2storage2(guild_id);
|
|
|
|
if(stor && stor->dirty)
|
|
{
|
|
intif_send_guild_storage(account_id,stor);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storagesaved(int account_id, 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;
|
|
sortage_gsortitem(stor);
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storageclose(struct map_session_data *sd)
|
|
{
|
|
struct guild_storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
nullpo_retr(0, stor=guild2storage2(sd->status.guild_id));
|
|
|
|
clif_storageclose(sd);
|
|
chrif_save(sd, 0); //This one also saves the storage. [Skotlex]
|
|
|
|
stor->storage_status=0;
|
|
sd->state.storage_flag = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int storage_guild_storage_quit(struct map_session_data *sd,int flag)
|
|
{
|
|
struct guild_storage *stor;
|
|
|
|
nullpo_retr(0, sd);
|
|
nullpo_retr(0, stor=guild2storage2(sd->status.guild_id));
|
|
|
|
sd->state.storage_flag = 0;
|
|
stor->storage_status = 0;
|
|
|
|
chrif_save(sd,flag);
|
|
if(!flag) //Only during a guild break flag is 1.
|
|
storage_guild_storagesave(sd->status.account_id,sd->status.guild_id);
|
|
else //When the guild was broken, close the storage of he who has it open.
|
|
clif_storageclose(sd);
|
|
|
|
return 0;
|
|
}
|