private static void MoveToBank(int place, int toplace, PlayerInventory bag, PlayerInventory bank, ItemInfo item)
{
if (bag != null && item != null && bag != null)
{
ItemInfo toitem = bank.GetItemAt(toplace);
if (toitem != null)
{
if (item.CanStackedTo(toitem) && item.Count + toitem.Count <= item.Template.MaxCount)
{
if (bank.AddCountToStack(toitem, item.Count))
{
bag.RemoveItem(item, eItemRemoveType.Stack);
}
}
else
{
if (toitem.Template.BagType == (eBageType)bag.BagType)
{
bag.TakeOutItem(item);
bank.TakeOutItem(toitem);
bag.AddItemTo(toitem, place);
bank.AddItemTo(item, toplace);
}
}
}
else
{
if (bank.AddItemTo(item, toplace))
{
bag.TakeOutItem(item);
}
}
}
}
protected virtual bool StackItems(int fromSlot, int toSlot, int itemCount)
{
ItemInfo fromItem = m_items[fromSlot] as ItemInfo;
ItemInfo toItem = m_items[toSlot] as ItemInfo;
if (itemCount == 0)
{
if (fromItem.Count > 0)
{
itemCount = fromItem.Count;
}
else
{
itemCount = 1;
}
}
if (toItem != null && toItem.TemplateID == fromItem.TemplateID && toItem.CanStackedTo(fromItem))
{
if (fromItem.Count + toItem.Count > fromItem.Template.MaxCount)
{
fromItem.Count -= (toItem.Template.MaxCount - toItem.Count);
toItem.Count = toItem.Template.MaxCount;
}
else
{
toItem.Count += itemCount;
RemoveItem(fromItem);
}
return(true);
}
else if (toItem == null && fromItem.Count > itemCount)
{
ItemInfo newItem = (ItemInfo)fromItem.Clone();
newItem.Count = itemCount;
if (AddItemTo(newItem, toSlot))
{
fromItem.Count -= itemCount;
return(true);
}
else
{
return(false);
}
}
return(false);
}
protected virtual bool StackItems(int fromSlot, int toSlot, int itemCount)
{
ItemInfo itemInfo = this.m_items[fromSlot];
ItemInfo itemInfo2 = this.m_items[toSlot];
if (itemCount == 0)
{
if (itemInfo.Count > 0)
{
itemCount = itemInfo.Count;
}
else
{
itemCount = 1;
}
}
if (itemInfo2 != null && itemInfo2.TemplateID == itemInfo.TemplateID && itemInfo2.CanStackedTo(itemInfo))
{
if (itemInfo.Count + itemInfo2.Count > itemInfo.Template.MaxCount)
{
itemInfo.Count -= itemInfo2.Template.MaxCount - itemInfo2.Count;
itemInfo2.Count = itemInfo2.Template.MaxCount;
}
else
{
itemInfo2.Count += itemCount;
this.RemoveItem(itemInfo);
}
return(true);
}
if (itemInfo2 != null || itemInfo.Count <= itemCount)
{
return(false);
}
ItemInfo itemInfo3 = itemInfo.Clone();
itemInfo3.Count = itemCount;
if (this.AddItemTo(itemInfo3, toSlot))
{
itemInfo.Count -= itemCount;
return(true);
}
return(false);
}
private static void MoveFromBank(GamePlayer player, int place, int toplace, PlayerInventory bag, PlayerInventory tobag, ItemInfo item)
{
if (item != null)
{
PlayerInventory tb = player.GetItemInventory(item.Template);
if (tb == tobag)
{
ItemInfo toitem = tb.GetItemAt(toplace);
if (toitem == null)
{
if (tb.AddItemTo(item, toplace))
{
bag.TakeOutItem(item);
}
}
else
{
if (item.CanStackedTo(toitem) && item.Count + toitem.Count <= item.Template.MaxCount)
{
if (tb.AddCountToStack(toitem, item.Count))
{
bag.RemoveItem(item, eItemRemoveType.Stack);
}
}
else
{
tb.TakeOutItem(toitem);
bag.TakeOutItem(item);
tb.AddItemTo(item, toplace);
bag.AddItemTo(toitem, place);
}
}
}
else
{
if (tb.AddItem(item))
{
bag.TakeOutItem(item);
}
}
}
}
private static void MoveFromBank(GameClient client, int place, int toplace, PlayerInventory bag, PlayerInventory tobag, ItemInfo item)
{
if (item != null)
{
PlayerInventory itemInventory = client.Player.GetItemInventory(item.Template);
if (itemInventory == tobag)
{
ItemInfo itemAt = itemInventory.GetItemAt(toplace);
if (itemAt == null)
{
if (itemInventory.AddItemTo(item, toplace))
{
bag.TakeOutItem(item);
return;
}
}
else
{
if (!item.CanStackedTo(itemAt) || item.Count + itemAt.Count > item.Template.MaxCount)
{
itemInventory.TakeOutItem(itemAt);
bag.TakeOutItem(item);
itemInventory.AddItemTo(item, toplace);
bag.AddItemTo(itemAt, place);
return;
}
if (itemInventory.AddCountToStack(itemAt, item.Count))
{
bag.RemoveItem(item, eItemRemoveType.Stack);
return;
}
}
}
else
{
if (itemInventory.AddItem(item))
{
bag.TakeOutItem(item);
}
}
}
}
public bool StackItemToAnother(ItemInfo item)
{
object @lock;
Monitor.Enter(@lock = this.m_lock);
try
{
for (int i = this.m_capalility - 1; i >= 0; i--)
{
if (item != null && this.m_items[i] != null && this.m_items[i] != item && item.CanStackedTo(this.m_items[i]) && this.m_items[i].Count + item.Count <= item.Template.MaxCount)
{
ItemInfo itemInfo = this.m_items[i];
itemInfo.Count += item.Count;
item.IsExist = false;
item.RemoveType = 26;
this.UpdateItem(this.m_items[i]);
return(true);
}
}
}
finally
{
Monitor.Exit(@lock);
}
return(false);
}
public virtual bool AddTemplate(ItemInfo cloneItem, int count, int minSlot, int maxSlot)
{
if (cloneItem == null)
{
return(false);
}
ItemTemplateInfo template = cloneItem.Template;
if (template == null)
{
return(false);
}
if (count <= 0)
{
return(false);
}
if (minSlot < this.m_beginSlot || minSlot > this.m_capalility - 1)
{
return(false);
}
if (maxSlot < this.m_beginSlot || maxSlot > this.m_capalility - 1)
{
return(false);
}
if (minSlot > maxSlot)
{
return(false);
}
object @lock;
Monitor.Enter(@lock = this.m_lock);
bool result;
try
{
List <int> list = new List <int>();
int num = count;
for (int i = minSlot; i <= maxSlot; i++)
{
ItemInfo itemInfo = this.m_items[i];
if (itemInfo == null)
{
num -= template.MaxCount;
list.Add(i);
}
else
{
if (this.m_autoStack && cloneItem.CanStackedTo(itemInfo))
{
num -= template.MaxCount - itemInfo.Count;
list.Add(i);
}
}
if (num <= 0)
{
break;
}
}
if (num <= 0)
{
this.BeginChanges();
try
{
num = count;
foreach (int current in list)
{
ItemInfo itemInfo2 = this.m_items[current];
if (itemInfo2 == null)
{
itemInfo2 = cloneItem.Clone();
itemInfo2.Count = ((num < template.MaxCount) ? num : template.MaxCount);
num -= itemInfo2.Count;
this.AddItemTo(itemInfo2, current);
}
else
{
if (itemInfo2.TemplateID == template.TemplateID)
{
int num2 = (itemInfo2.Count + num < template.MaxCount) ? num : (template.MaxCount - itemInfo2.Count);
itemInfo2.Count += num2;
num -= num2;
this.OnPlaceChanged(current);
}
else
{
AbstractInventory.log.Error("Add template erro: select slot's TemplateId not equest templateId");
}
}
}
if (num != 0)
{
AbstractInventory.log.Error("Add template error: last count not equal Zero.");
}
}
finally
{
this.CommitChanges();
}
result = true;
}
else
{
result = false;
}
}
finally
{
Monitor.Exit(@lock);
}
return(result);
}
public virtual bool AddTemplate(ItemInfo cloneItem, int count, int minSlot, int maxSlot)
{
if (cloneItem == null)
{
return(false);
}
ItemTemplateInfo template = cloneItem.Template;
if (template == null)
{
return(false);
}
if (count <= 0)
{
return(false);
}
if (minSlot < m_beginSlot || minSlot > m_capalility - 1)
{
return(false);
}
if (maxSlot < m_beginSlot || maxSlot > m_capalility - 1)
{
return(false);
}
if (minSlot > maxSlot)
{
return(false);
}
lock (m_lock)
{
List <int> changedSlot = new List <int>();
int itemcount = count;
for (int i = minSlot; i <= maxSlot; i++)
{
ItemInfo item = m_items[i];
if (item == null)
{
itemcount -= template.MaxCount;
changedSlot.Add(i);
}
else if (m_autoStack && cloneItem.CanStackedTo(item))
{
itemcount -= (template.MaxCount - item.Count);
changedSlot.Add(i);
}
if (itemcount <= 0)
{
break;
}
}
if (itemcount <= 0)
{
BeginChanges();
try
{
itemcount = count;
foreach (int i in changedSlot)
{
ItemInfo item = m_items[i];
if (item == null)
{
item = cloneItem.Clone();
item.Count = itemcount < template.MaxCount ? itemcount : template.MaxCount;
itemcount -= item.Count;
AddItemTo(item, i);
}
else
{
if (item.TemplateID == template.TemplateID)
{
int add = (item.Count + itemcount < template.MaxCount ? itemcount : template.MaxCount - item.Count);
item.Count += add;
itemcount -= add;
OnPlaceChanged(i);
}
else
{
log.Error("Add template erro: select slot's TemplateId not equest templateId");
}
}
}
if (itemcount != 0)
{
log.Error("Add template error: last count not equal Zero.");
}
}
finally
{
CommitChanges();
}
return(true);
}
else
{
return(false);
}
}
}
public void MoveToHide(GamePlayer player, PlayerInventory bag, ItemInfo item, int toSlot, PlayerInventory hideBag, int count)
{
if (player != null && bag != null && item != null && hideBag != null)
{
int oldplace = item.Place;
ItemInfo toItem = hideBag.GetItemAt(toSlot);
if (toItem != null)
{
if (toItem.CanStackedTo(item))
{
return;
}
if (item.Count == 1 && item.BagType == toItem.BagType)
{
bag.TakeOutItem(item);
hideBag.TakeOutItem(toItem);
bag.AddItemTo(toItem, oldplace);
hideBag.AddItemTo(item, toSlot);
return;
}
string key = string.Format("temp_place_{0}", toItem.ItemID);
PlayerInventory tb = player.GetItemInventory(toItem.Template);
if (player.TempProperties.ContainsKey(key) && tb.BagType == 0)
{
int tempSlot = (int)player.TempProperties[key];
player.TempProperties.Remove(key);
if (tb.AddItemTo(toItem, tempSlot))
{
hideBag.TakeOutItem(toItem);
}
}
else
{
if (tb.StackItemToAnother(toItem))
{
hideBag.RemoveItem(toItem, eItemRemoveType.Stack);
}
else
{
if (tb.AddItem(toItem))
{
hideBag.TakeOutItem(toItem);
}
else
{
player.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("UserChangeItemPlaceHandler.full", new object[0]));
}
}
}
}
if (hideBag.IsEmpty(toSlot))
{
if (item.Count == 1)
{
if (hideBag.AddItemTo(item, toSlot))
{
bag.TakeOutItem(item);
if (item.Template.BagType == eBageType.MainBag)
{
string key = string.Format("temp_place_{0}", item.ItemID);
if (player.TempProperties.ContainsKey(key))
{
player.TempProperties[key] = oldplace;
}
else
{
player.TempProperties.Add(key, oldplace);
}
}
}
}
else
{
ItemInfo newItem = item.Clone();
newItem.Count = 1;
if (bag.RemoveCountFromStack(item, 1, eItemRemoveType.Stack))
{
if (!hideBag.AddItemTo(newItem, toSlot))
{
bag.AddCountToStack(item, 1);
}
}
}
}
}
}
public void MoveToStore(GameClient client, PlayerInventory bag, ItemInfo item, int toSlot, PlayerInventory storeBag, int count)
{
if (client.Player != null && bag != null && item != null && storeBag != null)
{
int place = item.Place;
ItemInfo itemAt = storeBag.GetItemAt(toSlot);
if (itemAt != null)
{
if (itemAt.CanStackedTo(item))
{
return;
}
if (item.Count == 1 && item.BagType == itemAt.BagType)
{
bag.TakeOutItem(item);
storeBag.TakeOutItem(itemAt);
bag.AddItemTo(itemAt, place);
storeBag.AddItemTo(item, toSlot);
return;
}
string key = string.Format("temp_place_{0}", itemAt.ItemID);
PlayerInventory itemInventory = client.Player.GetItemInventory(itemAt.Template);
if (client.Player.TempProperties.ContainsKey(key) && itemInventory.BagType == 0)
{
int place2 = (int)client.Player.TempProperties[key];
client.Player.TempProperties.Remove(key);
if (itemInventory.AddItemTo(itemAt, place2))
{
storeBag.TakeOutItem(itemAt);
}
}
else
{
if (itemInventory.StackItemToAnother(itemAt))
{
storeBag.RemoveItem(itemAt, eItemRemoveType.Stack);
}
else
{
if (itemInventory.AddItem(itemAt))
{
storeBag.TakeOutItem(itemAt);
}
else
{
client.Player.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("UserChangeItemPlaceHandler.full", new object[0]));
}
}
}
}
if (storeBag.IsEmpty(toSlot))
{
if (item.Count == 1)
{
if (storeBag.AddItemTo(item, toSlot))
{
bag.TakeOutItem(item);
if (item.Template.BagType == eBageType.MainBag && place < 31)
{
string key = string.Format("temp_place_{0}", item.ItemID);
if (client.Player.TempProperties.ContainsKey(key))
{
client.Player.TempProperties[key] = place;
return;
}
client.Player.TempProperties.Add(key, place);
return;
}
}
}
else
{
ItemInfo itemInfo = item.Clone();
itemInfo.Count = count;
if (bag.RemoveCountFromStack(item, count, eItemRemoveType.Stack) && !storeBag.AddItemTo(itemInfo, toSlot))
{
bag.AddCountToStack(item, count);
}
}
}
}
}
protected virtual bool StackItems(int fromSlot, int toSlot, int itemCount)
{
bool result;
if (fromSlot == toSlot)
{
result = false;
}
else
{
ItemInfo fromItem = this.m_items[fromSlot];
ItemInfo toItem = this.m_items[toSlot];
if (fromItem == null)
{
result = false;
}
else
{
if (itemCount < 0)
{
result = false;
}
else
{
if (itemCount == 0)
{
if (fromItem.Count > 0)
{
itemCount = fromItem.Count;
}
else
{
itemCount = 1;
}
}
if (fromItem.Count < itemCount)
{
result = false;
}
else
{
if (toItem != null && toItem.TemplateID == fromItem.TemplateID && toItem.CanStackedTo(fromItem))
{
if (itemCount + toItem.Count > fromItem.Template.MaxCount)
{
fromItem.Count -= toItem.Template.MaxCount - toItem.Count;
toItem.Count = toItem.Template.MaxCount;
}
else
{
toItem.Count += itemCount;
if (itemCount == fromItem.Count)
{
this.RemoveItem(fromItem, eItemRemoveType.Stack);
}
else
{
fromItem.Count -= itemCount;
this.UpdateItem(fromItem);
}
}
result = true;
}
else
{
if (toItem == null && fromItem.Count > itemCount)
{
ItemInfo newItem = fromItem.Clone();
newItem.Count = itemCount;
if (this.AddItemTo(newItem, toSlot))
{
fromItem.Count -= itemCount;
result = true;
}
else
{
result = false;
}
}
else
{
result = false;
}
}
}
}
}
}
return(result);
}
public virtual bool AddTemplate(ItemInfo cloneItem, int count, int minSlot, int maxSlot)
{
bool result;
if (cloneItem == null)
{
result = false;
}
else
{
ItemTemplateInfo template = cloneItem.Template;
if (template == null)
{
result = false;
}
else
{
if (count <= 0)
{
result = false;
}
else
{
if (minSlot < this.m_beginSlot || minSlot > this.m_capalility - 1)
{
result = false;
}
else
{
if (maxSlot < this.m_beginSlot || maxSlot > this.m_capalility - 1)
{
result = false;
}
else
{
if (minSlot > maxSlot)
{
result = false;
}
else
{
object @lock;
Monitor.Enter(@lock = this.m_lock);
try
{
List <int> changedSlot = new List <int>();
int itemcount = count;
for (int i = minSlot; i <= maxSlot; i++)
{
ItemInfo item = this.m_items[i];
if (item == null)
{
itemcount -= template.MaxCount;
changedSlot.Add(i);
}
else
{
if (this.m_autoStack && cloneItem.CanStackedTo(item))
{
itemcount -= template.MaxCount - item.Count;
changedSlot.Add(i);
}
}
if (itemcount <= 0)
{
break;
}
}
if (itemcount <= 0)
{
this.BeginChanges();
try
{
itemcount = count;
foreach (int i in changedSlot)
{
ItemInfo item = this.m_items[i];
if (item == null)
{
item = cloneItem.Clone();
item.Count = ((itemcount < template.MaxCount) ? itemcount : template.MaxCount);
itemcount -= item.Count;
this.AddItemTo(item, i);
}
else
{
if (item.TemplateID == template.TemplateID)
{
int add = (item.Count + itemcount < template.MaxCount) ? itemcount : (template.MaxCount - item.Count);
item.Count += add;
itemcount -= add;
this.OnPlaceChanged(i);
}
else
{
AbstractInventory.log.Error("Add template erro: select slot's TemplateId not equest templateId");
}
}
}
if (itemcount != 0)
{
AbstractInventory.log.Error("Add template error: last count not equal Zero.");
}
}
finally
{
this.CommitChanges();
}
result = true;
}
else
{
result = false;
}
}
finally
{
Monitor.Exit(@lock);
}
}
}
}
}
}
}
return(result);
}
