public static InvPayload Create(InventoryType type, params UInt256[] hashes)
{
return new InvPayload
{
Inventories = hashes.Select(p => new InventoryVector { Type = type, Hash = p }).ToArray()
};
}
internal InventoryPage(InventoryType type, StorageType storage, byte size, Item bag = null)
{
_type = type;
_storage = storage;
Size = size;
Bag = bag;
}
/// <summary>
/// Creates a notecard in the objects folder and specify an item id.
/// </summary>
/// <param name="scene"></param>
/// <param name="itemName"></param>
/// <param name="itemId"></param>
/// <param name="assetId"></param>
/// <param name="userId"></param>
/// <param name="type">Type of item to create</param>
/// <returns></returns>
public static InventoryItemBase CreateInventoryItem(
Scene scene, string itemName, UUID itemId, UUID assetId, UUID userId, InventoryType type)
{
AssetBase asset = null;
if (type == InventoryType.Notecard)
asset = AssetHelpers.CreateAsset(scene, userId);
else if (type == InventoryType.Object)
asset = AssetHelpers.CreateAsset(assetId, SceneHelpers.CreateSceneObject(1, userId));
else
throw new Exception(string.Format("Inventory type {0} not supported", type));
scene.AssetService.Store(asset);
InventoryItemBase item = new InventoryItemBase();
item.Name = itemName;
item.AssetID = asset.FullID;
item.ID = itemId;
item.Owner = userId;
item.AssetType = asset.Type;
item.InvType = (int)type;
InventoryFolderBase folder = scene.InventoryService.GetFolderForType(userId, AssetType.Notecard);
item.Folder = folder.ID;
scene.AddInventoryItem(item);
return item;
}
public InventoryPouch(InventoryType type, ushort[] legal, int maxcount, int offset, int size = -1)
{
Type = type;
LegalItems = legal;
MaxCount = maxcount;
Offset = offset;
PouchDataSize = size > -1 ? size : legal.Length;
}
public InventoryItem (ushort iD, byte index, uint count, uint flag, uint price, ushort extra, InventoryType loc)
{
ID = iD;
Index = index;
Count = count;
Flag = flag;
Price = price;
Extra = extra;
Location = loc;
}
public Inventory(Character pOwner, InventoryType invtype, byte slotLimit = 96)
{
Items = new Dictionary<byte, Item>(slotLimit);
Equips = new Dictionary<short, Equip>();
if ((int)invtype >= 2 || (int)invtype <= 5)
ItemAmounts = new Dictionary<int, short>();
SlotLimit = slotLimit;
InventoryType = invtype;
Owner = pOwner;
}
public virtual InventoryFolderBase GetFolderForType(UUID principalID, InventoryType invType, AssetType type)
{
Dictionary<string,object> ret = MakeRequest("GETFOLDERFORTYPE",
new Dictionary<string,object> {
{ "PRINCIPAL", principalID.ToString() },
{ "TYPE", ((int)type).ToString() },
{ "INVTYPE", ((int)invType).ToString() }
});
if (ret == null)
return null;
if (ret.Count == 0)
return null;
return BuildFolder((Dictionary<string, object>)ret["folder"]);
}
/// <summary>
/// Creates a notecard in the objects folder and specify an item id.
/// </summary>
/// <param name="scene"></param>
/// <param name="itemName"></param>
/// <param name="itemId"></param>
/// <param name="itemType"></param>
/// <param name="asset">The serialized asset for this item</param>
/// <param name="userId"></param>
/// <returns></returns>
private static InventoryItemBase AddInventoryItem(
Scene scene, string itemName, UUID itemId, InventoryType itemType, AssetBase asset, UUID userId)
{
scene.AssetService.Store(asset);
InventoryItemBase item = new InventoryItemBase();
item.Name = itemName;
item.AssetID = asset.FullID;
item.ID = itemId;
item.Owner = userId;
item.AssetType = asset.Type;
item.InvType = (int)itemType;
InventoryFolderBase folder = scene.InventoryService.GetFolderForType(userId, (AssetType)asset.Type);
item.Folder = folder.ID;
scene.AddInventoryItem(item);
return item;
}
public static InventoryItem CreateInventoryItem(InventoryType type, UUID id)
{
switch (type)
{
case InventoryType.Texture: return new InventoryTexture(id);
case InventoryType.Sound: return new InventorySound(id);
case InventoryType.CallingCard: return new InventoryCallingCard(id);
case InventoryType.Landmark: return new InventoryLandmark(id);
case InventoryType.Object: return new InventoryObject(id);
case InventoryType.Notecard: return new InventoryNotecard(id);
case InventoryType.Category: return new InventoryCategory(id);
case InventoryType.LSL: return new InventoryLSL(id);
case InventoryType.Snapshot: return new InventorySnapshot(id);
case InventoryType.Attachment: return new InventoryAttachment(id);
case InventoryType.Wearable: return new InventoryWearable(id);
case InventoryType.Animation: return new InventoryAnimation(id);
case InventoryType.Gesture: return new InventoryGesture(id);
default: return new InventoryItem(type, id);
}
}
public Inventory(Int32 x, Int32 y, Int32 numPages)
{
_map = null;
_gridSpace = null;
_inventoryType = InventoryType.None;
_owner = null;
_doubleCheckBlock = false;
_dirty = false;
_x = x;
_y = y;
_numPages = numPages;
if (_x <= 0)
_x = 1;
if (_y <= 0)
_y = 1;
if (_numPages <= 0)
_numPages = 1;
CreateGridSpace();
}
/// <summary>
/// Create an inventory item and upload asset data
/// </summary>
/// <param name="data">Asset data</param>
/// <param name="name">Inventory item name</param>
/// <param name="description">Inventory item description</param>
/// <param name="assetType">Asset type</param>
/// <param name="invType">Inventory type</param>
/// <param name="folderID">Put newly created inventory in this folder</param>
/// <param name="permissions">Permission of the newly created item
/// (EveryoneMask, GroupMask, and NextOwnerMask of Permissions struct are supported)</param>
/// <param name="callback">Delegate that will receive feedback on success or failure</param>
public void RequestCreateItemFromAsset(byte[] data, string name, string description, AssetType assetType,
InventoryType invType, UUID folderID, Permissions permissions, ItemCreatedFromAssetCallback callback)
{
if (Client.Network.CurrentSim == null || Client.Network.CurrentSim.Caps == null)
throw new Exception("NewFileAgentInventory capability is not currently available");
Uri url = Client.Network.CurrentSim.Caps.CapabilityURI("NewFileAgentInventory");
if (url != null)
{
OSDMap query = new OSDMap();
query.Add("folder_id", OSD.FromUUID(folderID));
query.Add("asset_type", OSD.FromString(Utils.AssetTypeToString(assetType)));
query.Add("inventory_type", OSD.FromString(Utils.InventoryTypeToString(invType)));
query.Add("name", OSD.FromString(name));
query.Add("description", OSD.FromString(description));
query.Add("everyone_mask", OSD.FromInteger((int)permissions.EveryoneMask));
query.Add("group_mask", OSD.FromInteger((int)permissions.GroupMask));
query.Add("next_owner_mask", OSD.FromInteger((int)permissions.NextOwnerMask));
query.Add("expected_upload_cost", OSD.FromInteger(Client.Settings.UPLOAD_COST));
// Make the request
CapsClient request = new CapsClient(url);
request.OnComplete += CreateItemFromAssetResponse;
request.UserData = new object[] { callback, data, Client.Settings.CAPS_TIMEOUT, query };
request.BeginGetResponse(query, OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT);
}
else
{
throw new Exception("NewFileAgentInventory capability is not currently available");
}
}
public int CountItemInAnInventory(InventoryType inv)
{
return(GetAllItems().Count(s => s.Type == inv));
}
public InventorySlotId(InventoryType type, ushort id, ItemSlotId slot)
{
Id = new InventoryId(type, id);
Slot = slot;
}
public ItemInstance AddIntoBazaarInventory(InventoryType inventory, byte slot, byte amount)
{
ItemInstance inv = LoadBySlotAndType(slot, inventory);
if (inv == null || amount > inv.Amount)
{
return(null);
}
ItemInstance invcopy = inv.DeepCopy();
invcopy.Id = Guid.NewGuid();
if (inv.Item.Type == InventoryType.Equipment)
{
for (short i = 0; i < 255; i++)
{
if (LoadBySlotAndType <ItemInstance>(i, InventoryType.Bazaar) == null)
{
invcopy.Type = InventoryType.Bazaar;
invcopy.Slot = i;
invcopy.CharacterId = Owner.CharacterId;
DeleteFromSlotAndType(inv.Slot, inv.Type);
PutItem(invcopy);
break;
}
}
Owner.Session.SendPacket(UserInterfaceHelper.Instance.GenerateInventoryRemove(inventory, slot));
return(invcopy);
}
if (amount >= inv.Amount)
{
for (short i = 0; i < 255; i++)
{
if (LoadBySlotAndType <ItemInstance>(i, InventoryType.Bazaar) == null)
{
invcopy.Type = InventoryType.Bazaar;
invcopy.Slot = i;
invcopy.CharacterId = Owner.CharacterId;
DeleteFromSlotAndType(inv.Slot, inv.Type);
PutItem(invcopy);
break;
}
}
Owner.Session.SendPacket(UserInterfaceHelper.Instance.GenerateInventoryRemove(inventory, slot));
return(invcopy);
}
invcopy.Amount = amount;
inv.Amount -= amount;
for (short i = 0; i < 255; i++)
{
if (LoadBySlotAndType <ItemInstance>(i, InventoryType.Bazaar) == null)
{
invcopy.Type = InventoryType.Bazaar;
invcopy.Slot = i;
invcopy.CharacterId = Owner.CharacterId;
PutItem(invcopy);
break;
}
}
Owner.Session.SendPacket(inv.GenerateInventoryAdd());
return(invcopy);
}
public void MoveItem(InventoryType sourcetype, InventoryType desttype, short sourceSlot, byte amount, short destinationSlot, out ItemInstance sourceInventory, out ItemInstance destinationInventory)
{
Logger.Debug(Owner.Session.GenerateIdentity(), $"type: {sourcetype} sourceSlot: {sourceSlot} amount: {amount} destinationSlot: {destinationSlot}");
// load source and destination slots
sourceInventory = LoadBySlotAndType(sourceSlot, sourcetype);
destinationInventory = LoadBySlotAndType(destinationSlot, desttype);
if (sourceInventory != null && amount <= sourceInventory.Amount)
{
if (destinationInventory == null)
{
if (sourceInventory.Amount == amount)
{
sourceInventory.Slot = destinationSlot;
sourceInventory.Type = desttype;
}
else
{
ItemInstance itemDest = sourceInventory.DeepCopy();
sourceInventory.Amount -= amount;
itemDest.Amount = amount;
itemDest.Type = desttype;
itemDest.Id = Guid.NewGuid();
AddToInventoryWithSlotAndType(itemDest, desttype, destinationSlot);
}
}
else
{
if (destinationInventory.ItemVNum == sourceInventory.ItemVNum && (byte)sourceInventory.Item.Type != 0)
{
if (destinationInventory.Amount + amount > MAX_ITEM_AMOUNT)
{
int saveItemCount = destinationInventory.Amount;
destinationInventory.Amount = MAX_ITEM_AMOUNT;
sourceInventory.Amount = (byte)(saveItemCount + sourceInventory.Amount - MAX_ITEM_AMOUNT);
}
else
{
destinationInventory.Amount += amount;
sourceInventory.Amount -= amount;
// item with amount of 0 should be removed
if (sourceInventory.Amount == 0)
{
DeleteFromSlotAndType(sourceInventory.Slot, sourceInventory.Type);
}
}
}
else
{
// add and remove save inventory
destinationInventory = TakeItem(destinationInventory.Slot, destinationInventory.Type);
if (destinationInventory == null)
{
return;
}
destinationInventory.Slot = sourceSlot;
destinationInventory.Type = sourcetype;
sourceInventory = TakeItem(sourceInventory.Slot, sourceInventory.Type);
if (sourceInventory == null)
{
return;
}
sourceInventory.Slot = destinationSlot;
sourceInventory.Type = desttype;
PutItem(destinationInventory);
PutItem(sourceInventory);
}
}
}
sourceInventory = LoadBySlotAndType(sourceSlot, sourcetype);
destinationInventory = LoadBySlotAndType(destinationSlot, desttype);
}
public void RequestCreateItemFromAsset(byte[] data, string name, string description, AssetType assetType,
InventoryType invType, LLUUID folderID, ItemCreatedFromAssetCallback callback)
{
if (_Client.Network.CurrentSim == null || _Client.Network.CurrentSim.Caps == null)
throw new Exception("NewFileAgentInventory capability is not currently available");
Uri url = _Client.Network.CurrentSim.Caps.CapabilityURI("NewFileAgentInventory");
if (url != null)
{
LLSDMap query = new LLSDMap();
query.Add("folder_id", LLSD.FromUUID(folderID));
query.Add("asset_type", LLSD.FromString(AssetTypeToString(assetType)));
query.Add("inventory_type", LLSD.FromString(InventoryTypeToString(invType)));
query.Add("name", LLSD.FromString(name));
query.Add("description", LLSD.FromString(description));
byte[] postData = StructuredData.LLSDParser.SerializeXmlBytes(query);
// Make the request
CapsClient request = new CapsClient(url);
request.OnComplete += new CapsClient.CompleteCallback(CreateItemFromAssetResponse);
request.UserData = new KeyValuePair<ItemCreatedFromAssetCallback, byte[]>(callback, data);
request.StartRequest(postData);
}
else
{
throw new Exception("NewFileAgentInventory capability is not currently available");
}
}
public bool CanAddItem(short itemVnum)
{
InventoryType type = ServerManager.Instance.GetItem(itemVnum).Type;
return(CanAddItem(type));
}
public void changeRoomInventory(Room room, InventoryType inventory)
{
roomsRepository.changeRoomInventory(room, inventory);
}
public InventoryVector(InventoryType type, uint256 hash)
{
this.Type = type;
this.Hash = hash;
}
public override void Use(ClientSession session, ref ItemInstance inv, byte option = 0, string[] packetsplit = null)
{
switch (Effect)
{
default:
bool delay = false;
if (option == 255)
{
delay = true;
option = 0;
}
Mate mate = null;
if (option != 0)
{
mate = session.Character.Mates.FirstOrDefault(s => s.MateType == MateType.Partner && s.PetId == (option - 1));
}
short slot = inv.Slot;
InventoryType equipment = InventoryType.Wear;
switch (option)
{
case 1:
equipment = InventoryType.FirstPartnerInventory;
break;
case 2:
equipment = InventoryType.SecondPartnerInventory;
break;
case 3:
equipment = InventoryType.ThirdPartnerInventory;
break;
}
InventoryType itemToWearType = inv.Type;
if (inv == null)
{
return;
}
if (ItemValidTime > 0 && inv.IsBound)
{
inv.ItemDeleteTime = DateTime.Now.AddSeconds(ItemValidTime);
}
if (!inv.IsBound)
{
if (!delay && (EquipmentSlot == EquipmentType.Fairy && (MaxElementRate == 70 || MaxElementRate == 80) || EquipmentSlot == EquipmentType.CostumeHat || EquipmentSlot == EquipmentType.CostumeSuit || EquipmentSlot == EquipmentType.WeaponSkin))
{
session.SendPacket($"qna #u_i^1^{session.Character.CharacterId}^{(byte)itemToWearType}^{slot}^1 {Language.Instance.GetMessageFromKey("ASK_BIND")}");
return;
}
if (delay)
{
inv.BoundCharacterId = session.Character.CharacterId;
}
}
double timeSpanSinceLastSpUsage = (DateTime.Now - Process.GetCurrentProcess().StartTime.AddSeconds(-50)).TotalSeconds - session.Character.LastSp;
if (EquipmentSlot == EquipmentType.Sp && inv.Rare == -2)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("CANT_EQUIP_DESTROYED_SP"), 0));
return;
}
if (option == 0)
{
if (EquipmentSlot == EquipmentType.Sp && timeSpanSinceLastSpUsage <= session.Character.SpCooldown && session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>((byte)EquipmentType.Sp, InventoryType.Specialist) != null)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("SP_INLOADING"), session.Character.SpCooldown - (int)Math.Round(timeSpanSinceLastSpUsage)), 0));
return;
}
if (ItemType != ItemType.Weapon && ItemType != ItemType.Armor && ItemType != ItemType.Fashion && ItemType != ItemType.Jewelery && ItemType != ItemType.Specialist ||
LevelMinimum > (IsHeroic ? session.Character.HeroLevel : session.Character.Level) || Sex != 0 && Sex != (byte)session.Character.Gender + 1 ||
ItemType != ItemType.Jewelery && EquipmentSlot != EquipmentType.Boots && EquipmentSlot != EquipmentType.Gloves && ((Class >> (byte)session.Character.Class) & 1) != 1)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
if (session.Character.UseSp)
{
SpecialistInstance sp = session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>((byte)EquipmentType.Sp, equipment);
if (sp != null && sp.Item.Element != 0 && EquipmentSlot == EquipmentType.Fairy && Element != sp.Item.Element && Element != sp.Item.SecondaryElement)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("BAD_FAIRY"), 0));
return;
}
}
if (session.Character.UseSp && EquipmentSlot == EquipmentType.Sp)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SP_BLOCKED"), 10));
return;
}
if (session.Character.JobLevel < LevelJobMinimum)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("LOW_JOB_LVL"), 10));
return;
}
}
else if (mate != null)
{
if (mate.Level < LevelMinimum)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
switch (EquipmentSlot)
{
case EquipmentType.Armor:
if (ItemSubType == 4)
{
mate.ArmorInstance = inv;
break;
}
else
{
goto default;
}
case EquipmentType.MainWeapon:
if (ItemSubType == 12)
{
mate.WeaponInstance = inv;
break;
}
else
{
goto default;
}
case EquipmentType.Gloves:
mate.GlovesInstance = inv;
break;
case EquipmentType.Boots:
mate.BootsInstance = inv;
break;
case EquipmentType.Sp:
if (ItemSubType == 4)
{
mate.SpInstance = inv;
break;
}
else
{
goto default;
}
default:
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
}
ItemInstance currentlyEquippedItem = session.Character.Inventory.LoadBySlotAndType((short)EquipmentSlot, equipment);
if (currentlyEquippedItem == null)
{
// move from equipment to wear
session.Character.Inventory.MoveInInventory(inv.Slot, itemToWearType, equipment);
session.SendPacket(UserInterfaceHelper.Instance.GenerateInventoryRemove(itemToWearType, slot));
}
else
{
// move from wear to equipment and back
session.Character.Inventory.MoveInInventory(currentlyEquippedItem.Slot, equipment, itemToWearType, inv.Slot);
session.SendPacket(currentlyEquippedItem.GenerateInventoryAdd());
session.Character.EquipmentBCards = session.Character.EquipmentBCards.Where(o => o.ItemVNum != currentlyEquippedItem.ItemVNum);
switch (currentlyEquippedItem.Slot)
{
case (byte)EquipmentType.Armor:
session.Character.Inventory.Armor = null;
break;
case (byte)EquipmentType.MainWeapon:
session.Character.Inventory.PrimaryWeapon = null;
break;
case (byte)EquipmentType.SecondaryWeapon:
session.Character.Inventory.SecondaryWeapon = null;
break;
}
}
inv.Item.BCards.ForEach(s => session.Character.EquipmentBCards.Add(s));
if (inv is WearableInstance wearableInstance)
{
if (wearableInstance.EquipmentOptions != null)
{
switch (wearableInstance.Item.ItemType)
{
case ItemType.Armor:
case ItemType.Weapon:
switch (wearableInstance.Slot)
{
case (byte)EquipmentType.Armor:
session.Character.Inventory.Armor = wearableInstance;
break;
case (byte)EquipmentType.MainWeapon:
session.Character.Inventory.PrimaryWeapon = wearableInstance;
break;
case (byte)EquipmentType.SecondaryWeapon:
session.Character.Inventory.SecondaryWeapon = wearableInstance;
break;
}
EquipmentOptionHelper.Instance.ShellToBCards(wearableInstance.EquipmentOptions, wearableInstance.ItemVNum).ForEach(s => session.Character.EquipmentBCards.Add(s));
break;
case ItemType.Jewelery:
EquipmentOptionHelper.Instance.CellonToBCards(wearableInstance.EquipmentOptions, wearableInstance.ItemVNum).ForEach(s => session.Character.EquipmentBCards.Add(s));
break;
}
}
}
if (option == 0)
{
session.SendPacket(session.Character.GenerateStatChar());
session.CurrentMapInstance?.Broadcast(session.Character.GenerateEq());
session.SendPacket(session.Character.GenerateEquipment());
session.CurrentMapInstance?.Broadcast(session.Character.GeneratePairy());
switch (EquipmentSlot)
{
case EquipmentType.Fairy:
WearableInstance fairy = session.Character.Inventory.LoadBySlotAndType <WearableInstance>((byte)EquipmentType.Fairy, equipment);
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("FAIRYSTATS"), fairy.XP, CharacterHelper.LoadFairyXpData(fairy.ElementRate + fairy.Item.ElementRate)), 10));
break;
case EquipmentType.Amulet:
session.SendPacket(session.Character.GenerateEff(39));
inv.BoundCharacterId = session.Character.CharacterId;
break;
}
}
else if (mate != null)
{
session.SendPacket(mate.GenerateScPacket());
}
break;
}
}
/// <summary>
/// Creates an item of the given type with an accompanying asset.
/// </summary>
/// <param name="scene"></param>
/// <param name="itemName"></param>
/// <param name="itemId"></param>
/// <param name="userId"></param>
/// <param name="type">Type of item to create</param>
/// <returns></returns>
public static InventoryItemBase CreateInventoryItem(
Scene scene, string itemName, UUID userId, InventoryType type)
{
return(CreateInventoryItem(scene, itemName, UUID.Random(), UUID.Random(), userId, type));
}
/// <summary>
/// sell packet
/// </summary>
/// <param name="sellPacket"></param>
public void SellShop(SellPacket sellPacket)
{
if (Session.Character.ExchangeInfo != null && Session.Character.ExchangeInfo.ExchangeList.Any() || Session.Character.IsShopping)
{
return;
}
if (sellPacket.Amount.HasValue && sellPacket.Slot.HasValue)
{
InventoryType type = (InventoryType)sellPacket.Data;
byte amount = sellPacket.Amount.Value, slot = sellPacket.Slot.Value;
if (type == InventoryType.Bazaar)
{
return;
}
ItemInstance inv = Session.Character.Inventory.LoadBySlotAndType(slot, type);
if (inv == null || amount > inv.Amount)
{
return;
}
if (Session.Character.MapInstance.MapDesignObjects.Any(s => s.ItemInstanceId == inv.Id))
{
return;
}
if (!inv.Item.IsSoldable)
{
Session.SendPacket(UserInterfaceHelper.Instance.GenerateShopMemo(2, string.Format(Language.Instance.GetMessageFromKey("ITEM_NOT_SOLDABLE"))));
return;
}
long price = inv.Item.ItemType == ItemType.Sell ? inv.Item.Price : inv.Item.Price / 20;
if (Session.Character.Gold + price * amount > ServerManager.Instance.MaxGold)
{
string message = UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("MAX_GOLD"), 0);
Session.SendPacket(message);
return;
}
Session.Character.Gold += price * amount;
Session.SendPacket(UserInterfaceHelper.Instance.GenerateShopMemo(1, string.Format(Language.Instance.GetMessageFromKey("SELL_ITEM_VALIDE"), inv.Item.Name, amount)));
Session.Character.Inventory.RemoveItemAmountFromInventory(amount, inv.Id);
Session.SendPacket(Session.Character.GenerateGold());
}
else
{
short vnum = sellPacket.Data;
CharacterSkill skill = Session.Character.Skills[vnum];
if (skill == null || vnum == 200 + 20 * (byte)Session.Character.Class || vnum == 201 + 20 * (byte)Session.Character.Class)
{
return;
}
Session.Character.Gold -= skill.Skill.Price;
Session.SendPacket(Session.Character.GenerateGold());
foreach (CharacterSkill loadedSkill in Session.Character.Skills.Select(s => s.Value))
{
if (skill.Skill.SkillVNum == loadedSkill.Skill.UpgradeSkill)
{
Session.Character.Skills.TryRemove(loadedSkill.SkillVNum, out CharacterSkill characterSkill);
}
}
Session.Character.Skills.TryRemove(skill.SkillVNum, out CharacterSkill CharacterSkill);
Session.SendPacket(Session.Character.GenerateSki());
Session.SendPackets(Session.Character.GenerateQuicklist());
Session.SendPacket(Session.Character.GenerateLev());
}
}
public void CreateShop(string packet)
{
string[] packetsplit = packet.Split(' ');
InventoryType[] type = new InventoryType[20];
long[] gold = new long[20];
short[] slot = new short[20];
byte[] qty = new byte[20];
string shopname = string.Empty;
if (packetsplit.Length <= 2)
{
return;
}
if (!short.TryParse(packetsplit[2], out short typePacket))
{
return;
}
if (Session.Character.HasShopOpened && typePacket != 1 || !Session.HasCurrentMapInstance || Session.Character.IsExchanging || Session.Character.ExchangeInfo != null)
{
return;
}
if (Session.CurrentMapInstance.Portals.Any(por => Session.Character.PositionX < por.SourceX + 6 && Session.Character.PositionX > por.SourceX - 6 && Session.Character.PositionY < por.SourceY + 6 && Session.Character.PositionY > por.SourceY - 6))
{
Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SHOP_NEAR_PORTAL"), 0));
return;
}
if (Session.Character.Group != null && Session.Character.Group?.GroupType != GroupType.Group)
{
Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SHOP_NOT_ALLOWED_IN_RAID"), 0));
return;
}
if (!Session.CurrentMapInstance.ShopAllowed)
{
Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SHOP_NOT_ALLOWED"), 0));
return;
}
if (typePacket == 2)
{
Session.SendPacket("ishop");
}
else if (typePacket == 0)
{
if (Session.CurrentMapInstance.UserShops.Count(s => s.Value.OwnerId == Session.Character.CharacterId) != 0)
{
return;
}
MapShop myShop = new MapShop();
if (packetsplit.Length > 82)
{
short shopSlot = 0;
for (short j = 3, i = 0; j < 82; j += 4, i++)
{
Enum.TryParse(packetsplit[j], out type[i]);
short.TryParse(packetsplit[j + 1], out slot[i]);
byte.TryParse(packetsplit[j + 2], out qty[i]);
long.TryParse(packetsplit[j + 3], out gold[i]);
if (gold[i] < 0)
{
return;
}
if (qty[i] <= 0)
{
continue;
}
ItemInstance inv = Session.Character.Inventory.LoadBySlotAndType(slot[i], type[i]);
if (inv == null)
{
continue;
}
if (inv.Amount < qty[i])
{
return;
}
if (!inv.Item.IsTradable || inv.IsBound)
{
Session.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SHOP_ONLY_TRADABLE_ITEMS"), 10));
Session.SendPacket("shop_end 0");
return;
}
PersonalShopItem personalshopitem = new PersonalShopItem
{
ShopSlot = shopSlot,
Price = gold[i],
ItemInstance = inv,
SellAmount = qty[i]
};
myShop.Items.Add(personalshopitem);
shopSlot++;
}
}
if (myShop.Items.Count != 0)
{
if (!myShop.Items.Any(s => !s.ItemInstance.Item.IsSoldable || s.ItemInstance.IsBound))
{
for (int i = 83; i < packetsplit.Length; i++)
{
shopname += $"{packetsplit[i]} ";
}
// trim shopname
shopname = shopname.TrimEnd(' ');
// create default shopname if it's empty
if (string.IsNullOrWhiteSpace(shopname) || string.IsNullOrEmpty(shopname))
{
shopname = Language.Instance.GetMessageFromKey("SHOP_PRIVATE_SHOP");
}
// truncate the string to a max-length of 20
shopname = shopname.Truncate(20);
myShop.OwnerId = Session.Character.CharacterId;
myShop.Name = shopname;
Session.CurrentMapInstance.UserShops.Add(Session.CurrentMapInstance.LastUserShopId++, myShop);
Session.Character.HasShopOpened = true;
Session.CurrentMapInstance?.Broadcast(Session, Session.Character.GeneratePlayerFlag(Session.CurrentMapInstance.LastUserShopId), ReceiverType.AllExceptMe);
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateShop(shopname));
Session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("SHOP_OPEN")));
Session.Character.IsSitting = true;
Session.Character.IsShopping = true;
Session.Character.LoadSpeed();
Session.SendPacket(Session.Character.GenerateCond());
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateRest());
}
else
{
Session.SendPacket("shop_end 0");
Session.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ITEM_NOT_SOLDABLE"), 10));
}
}
else
{
Session.SendPacket("shop_end 0");
Session.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SHOP_EMPTY"), 10));
}
}
else if (typePacket == 1)
{
Session.Character.CloseShop();
}
}
public string GenerateInventoryRemove(InventoryType type, short slot) => $"ivn {(byte)type} {GenerateRemovePacket(slot)}";
/// <summary>
///
/// </summary>
/// <returns></returns>
public InventoryItem(SerializationInfo info, StreamingContext ctxt)
: base(info, ctxt)
{
AssetUUID = (UUID)info.GetValue("AssetUUID", typeof(UUID));
Permissions = (Permissions)info.GetValue("Permissions", typeof(Permissions));
AssetType = (AssetType)info.GetValue("AssetType", typeof(AssetType));
InventoryType = (InventoryType)info.GetValue("InventoryType", typeof(InventoryType));
CreatorID = (UUID)info.GetValue("CreatorID", typeof(UUID));
Description = (string)info.GetValue("Description", typeof(string));
GroupID = (UUID)info.GetValue("GroupID", typeof(UUID));
GroupOwned = (bool)info.GetValue("GroupOwned", typeof(bool));
SalePrice = (int)info.GetValue("SalePrice", typeof(int));
SaleType = (SaleType)info.GetValue("SaleType", typeof(SaleType));
Flags = (uint)info.GetValue("Flags", typeof(uint));
CreationDate = (DateTime)info.GetValue("CreationDate", typeof(DateTime));
LastOwnerID = (UUID)info.GetValue("LastOwnerID", typeof(UUID));
}
private void RefreshInventoryUI()
{
if (this._toggleElements.IsNullOrEmpty <ToggleElement>())
{
return;
}
int index1 = -1;
for (int index2 = 0; index2 < this._toggleElements.Count; ++index2)
{
Toggle toggle = this._toggleElements.GetElement <ToggleElement>(index2)?.Toggle;
if (Object.op_Inequality((Object)toggle, (Object)null) && toggle.get_isOn())
{
index1 = index2;
break;
}
}
if (!this._vieweres.IsNullOrEmpty <RecyclingInventoryFacadeViewer>())
{
WorldData worldData = !Singleton <Game> .IsInstance() ? (WorldData)null : Singleton <Game> .Instance.WorldData;
if (worldData != null)
{
for (int index2 = 0; index2 < this._vieweres.Length; ++index2)
{
RecyclingInventoryFacadeViewer element = this._vieweres.GetElement <RecyclingInventoryFacadeViewer>(index2);
if (element != null)
{
InventoryType inventoryType = (InventoryType)index2;
int num = 0;
switch (inventoryType)
{
case InventoryType.Pouch:
PlayerData playerData = worldData.PlayerData;
int? nullable1;
int? nullable2;
if (playerData == null)
{
nullable1 = new int?();
nullable2 = nullable1;
}
else
{
nullable2 = new int?(playerData.InventorySlotMax);
}
nullable1 = nullable2;
num = !nullable1.HasValue ? 0 : nullable1.Value;
break;
case InventoryType.Chest:
num = !Singleton <Resources> .IsInstance() ? 0 : Singleton <Resources> .Instance.DefinePack.ItemBoxCapacityDefines.StorageCapacity;
break;
}
element.slotCounter.y = num;
element.ItemListNodeCreate();
}
}
}
}
if (this.RecyclingData != null)
{
this._decidedItemSlotUI.SettingUI(this.RecyclingData.DecidedItemList);
this._createItemStockUI.SettingUI(this.RecyclingData.CreatedItemList);
}
this.ChangedSelecteInventory(index1);
}
public void RequestCreateItem(LLUUID parentFolder, string name, string description, AssetType type,
InventoryType invType, PermissionMask nextOwnerMask, ItemCreatedCallback callback)
{
// Even though WearableType 0 is Shape, in this context it is treated as NOT_WEARABLE
RequestCreateItem(parentFolder, name, description, type, invType, (WearableType)0, nextOwnerMask,
callback);
}
} // @ public int GetItemIDByIndex(byte index, InventoryType location)
/// <summary>
/// The amount of items matching iD that you have in your inventory
/// </summary>
/// <param name="iD">ID of the item to count</param>
/// <param name="location">InventoryType of the location(s) to search.</param>
/// <returns>Total count of all items matching ID in the location(s) passed.</returns>
public uint GetItemCount (int iD, InventoryType location)
{
// Don't even bother to do range checks here.
// We're doing the looping ourselves.
// DoRangeChecks(1, location);
// Check to ensure iD passed isn't 0
if (iD <= 0)
return 0;
if (IsSet(location, InventoryType.None))
return 0;
System.Collections.Generic.List<InventoryItem> list = GetItemList(iD, location);
if (list.Count <= 0)
return 0;
uint count = 0;
for (int i = 0; i < list.Count; i++)
{
count += list[i].Count;
}
return count;
} // @ public uint GetItemCount(ushort iD, InventoryType location)
public static string InventoryTypeToString(InventoryType type)
{
return _InventoryTypeNames[(int)type];
}
public void LoadInventory(METAboltInstance instance, UUID folderID)
{
this.instance = instance;
this.client = this.instance.Client;
InventoryFolder rootFolder = this.client.Inventory.Store.RootFolder;
List <InventoryBase> contents = this.client.Inventory.Store.GetContents(folderID);
if (folderID != this.client.Inventory.Store.RootFolder.UUID)
{
if (this.TreeView.Nodes != null)
{
TreeNode[] array = this.TreeView.Nodes.Find(folderID.ToString(), true);
if (array.Length > 0)
{
TreeNodeCollection nodes = array[0].Nodes;
nodes.Clear();
if (contents.Count == 0)
{
nodes.Add(UUID.Zero.ToString(), "(empty)");
nodes[UUID.Zero.ToString()].Tag = "empty";
nodes[UUID.Zero.ToString()].ForeColor = Color.FromKnownColor(KnownColor.GrayText);
}
else
{
List <Primitive> list = this.client.Network.CurrentSim.ObjectsPrimitives.FindAll(delegate(Primitive prim)
{
bool result;
try
{
result = (prim.ParentID == instance.Client.Self.LocalID);
}
catch
{
result = false;
}
return(result);
});
foreach (InventoryBase current in contents)
{
string key = current.UUID.ToString();
bool flag = current is InventoryFolder;
try
{
string text = string.Empty;
if (!flag)
{
InventoryItem inventoryItem = (InventoryItem)current;
WearableType wearableType = this.client.Appearance.IsItemWorn(inventoryItem);
if (wearableType != WearableType.Invalid)
{
text = " (WORN)";
}
UUID lhs = UUID.Zero;
foreach (Primitive current2 in list)
{
if (current2.NameValues != null)
{
for (int i = 0; i < current2.NameValues.Length; i++)
{
if (current2.NameValues[i].Name == "AttachItemID")
{
lhs = (UUID)current2.NameValues[i].Value.ToString();
if (lhs == inventoryItem.UUID)
{
text = " (WORN)";
break;
}
}
}
}
}
nodes.Add(key, current.Name + text);
nodes[key].Tag = current;
if (text == " (WORN)")
{
nodes[key].ForeColor = Color.RoyalBlue;
}
string empty = string.Empty;
InventoryType inventoryType = inventoryItem.InventoryType;
switch (inventoryType)
{
case InventoryType.Texture:
nodes[key].ImageKey = "Texture";
continue;
case InventoryType.Sound:
case (InventoryType)4:
case (InventoryType)5:
case InventoryType.Category:
case InventoryType.RootCategory:
break;
case InventoryType.CallingCard:
nodes[key].ImageKey = "CallingCard";
continue;
case InventoryType.Landmark:
nodes[key].ImageKey = "LM";
continue;
case InventoryType.Object:
nodes[key].ImageKey = "Objects";
continue;
case InventoryType.Notecard:
nodes[key].ImageKey = "Notecard";
continue;
case InventoryType.LSL:
nodes[key].ImageKey = "Script";
continue;
default:
if (inventoryType == InventoryType.Snapshot)
{
nodes[key].ImageKey = "Snapshots";
continue;
}
if (inventoryType == InventoryType.Wearable)
{
nodes[key].ImageKey = "Wearable";
continue;
}
break;
}
nodes[key].ImageKey = "Gear";
}
else
{
nodes.Add(key, current.Name);
nodes[key].Tag = current;
nodes[key].ImageKey = "ClosedFolder";
nodes[key].Nodes.Add(null, "(loading...)").ForeColor = Color.FromKnownColor(KnownColor.GrayText);
}
}
catch (Exception var_16_4C6)
{
}
}
}
}
}
}
else
{
this.TreeView.Nodes.Clear();
TreeNode treeNode = this.TreeView.Nodes.Add(rootFolder.UUID.ToString(), "My Inventory");
treeNode.Tag = rootFolder;
treeNode.ImageKey = "OpenFolder";
if (contents.Count == 0)
{
treeNode.Nodes.Add(UUID.Zero.ToString(), "(empty)");
treeNode.Nodes[UUID.Zero.ToString()].Tag = "empty";
treeNode.Nodes[UUID.Zero.ToString()].ForeColor = Color.FromKnownColor(KnownColor.GrayText);
}
else
{
List <Primitive> list = this.client.Network.CurrentSim.ObjectsPrimitives.FindAll(delegate(Primitive prim)
{
bool result;
try
{
result = (prim.ParentID == instance.Client.Self.LocalID);
}
catch
{
result = false;
}
return(result);
});
foreach (InventoryBase current in contents)
{
string key = current.UUID.ToString();
bool flag = current is InventoryFolder;
try
{
string text = string.Empty;
if (!flag)
{
InventoryItem inventoryItem = (InventoryItem)current;
WearableType wearableType = this.client.Appearance.IsItemWorn(inventoryItem);
if (wearableType != WearableType.Invalid)
{
text = " (WORN)";
}
UUID lhs = UUID.Zero;
foreach (Primitive current2 in list)
{
if (current2.NameValues != null)
{
for (int i = 0; i < current2.NameValues.Length; i++)
{
if (current2.NameValues[i].Name == "AttachItemID")
{
lhs = (UUID)current2.NameValues[i].Value.ToString();
if (lhs == inventoryItem.UUID)
{
text = " (WORN)";
break;
}
}
}
}
}
treeNode.Nodes.Add(key, current.Name + text);
treeNode.Nodes[key].Tag = current;
if (text == " (WORN)")
{
treeNode.Nodes[key].ForeColor = Color.RoyalBlue;
}
string empty = string.Empty;
InventoryType inventoryType = inventoryItem.InventoryType;
switch (inventoryType)
{
case InventoryType.Texture:
treeNode.Nodes[key].ImageKey = "Texture";
continue;
case InventoryType.Sound:
case (InventoryType)4:
case (InventoryType)5:
case InventoryType.Category:
case InventoryType.RootCategory:
break;
case InventoryType.CallingCard:
treeNode.Nodes[key].ImageKey = "CallingCard";
continue;
case InventoryType.Landmark:
treeNode.Nodes[key].ImageKey = "LM";
continue;
case InventoryType.Object:
treeNode.Nodes[key].ImageKey = "Objects";
continue;
case InventoryType.Notecard:
treeNode.Nodes[key].ImageKey = "Notecard";
continue;
case InventoryType.LSL:
treeNode.Nodes[key].ImageKey = "Script";
continue;
default:
if (inventoryType == InventoryType.Snapshot)
{
treeNode.Nodes[key].ImageKey = "Snapshots";
continue;
}
if (inventoryType == InventoryType.Wearable)
{
treeNode.Nodes[key].ImageKey = "Wearable";
continue;
}
break;
}
treeNode.Nodes[key].ImageKey = "Gear";
}
else
{
treeNode.Nodes.Add(key, current.Name);
treeNode.Nodes[key].Tag = current;
treeNode.Nodes[key].ImageKey = "ClosedFolder";
treeNode.Nodes[key].Nodes.Add(null, "(loading...)").ForeColor = Color.FromKnownColor(KnownColor.GrayText);
}
}
catch (Exception var_16_4C6)
{
}
}
treeNode.Expand();
}
}
}
void ISerializable.Deserialize(BinaryReader reader)
{
this.Type = (InventoryType)reader.ReadUInt32();
this.Hash = reader.ReadSerializable <UInt256>();
}
void Inventory_OnTaskItemReceived(UUID itemID, UUID folderID, UUID creatorID, UUID assetID, InventoryType type)
{
Console.Write("\nOn Task Item Recieved\n");
}
private bool CanAddItem(InventoryType type)
{
return(Owner != null && GetFreeSlot(type, Owner.HaveBackpack() ? 1 : 0).HasValue);
}
public static IEnumerable<EquipSlot> GetInventorySlotsByEquipSlot(InventoryType type)
{
switch (type)
{
case InventoryType.Head:
yield return EquipSlot.Head;
break;
case InventoryType.Neck:
yield return EquipSlot.Neck;
break;
case InventoryType.Shoulders:
yield return EquipSlot.Shoulders;
break;
case InventoryType.Body:
yield return EquipSlot.Body;
break;
case InventoryType.Chest:
case InventoryType.Robe:
yield return EquipSlot.Chest;
break;
case InventoryType.Waist:
yield return EquipSlot.Waist;
break;
case InventoryType.Legs:
yield return EquipSlot.Legs;
break;
case InventoryType.Feet:
yield return EquipSlot.Feet;
break;
case InventoryType.Wrists:
yield return EquipSlot.Wrists;
break;
case InventoryType.Hands:
yield return EquipSlot.Hands;
break;
case InventoryType.Finger:
yield return EquipSlot.Finger1;
yield return EquipSlot.Finger2;
break;
case InventoryType.Trinket:
yield return EquipSlot.Trinket1;
yield return EquipSlot.Trinket2;
break;
case InventoryType.Weapon:
yield return EquipSlot.MainHand;
yield return EquipSlot.OffHand;
break;
case InventoryType.Shield:
case InventoryType.WeaponOffHand:
case InventoryType.Holdable:
yield return EquipSlot.OffHand;
break;
case InventoryType.Ranged:
case InventoryType.Thrown:
case InventoryType.RangedRight:
case InventoryType.Relic:
yield return EquipSlot.Ranged;
break;
case InventoryType.Cloak:
yield return EquipSlot.Back;
break;
case InventoryType.TwoHandedWeapon:
{
yield return EquipSlot.MainHand;
// TODO: Check for titan's grip
//bool flag = Manager.LocalPlayer.Class == WoWClass.Warrior && WoWScript.Execute<int>(InventoryManager.#a(61464), 4u) > 0;
//var mainHand = Manager.LocalPlayer.GetEquippedItem(EquipSlot.MainHand);
//if (flag && mainHand != null && mainHand.ItemInfo.InventoryType == InventoryType.TwoHandedWeapon)
//{
// yield return EquipSlot.OffHand;
//}
break;
}
case InventoryType.Bag:
case InventoryType.Quiver:
yield return EquipSlot.Bag1;
yield return EquipSlot.Bag2;
yield return EquipSlot.Bag3;
yield return EquipSlot.Bag4;
break;
case InventoryType.Tabard:
yield return EquipSlot.Tabard;
break;
case InventoryType.WeaponMainHand:
yield return EquipSlot.MainHand;
break;
}
}
/// <summary>
/// Moves one item from one Inventory to another. Example: Equipment <-> Wear,
/// Equipment <-> Costume, Equipment <-> Specialist
/// </summary>
/// <param name="sourceSlot"></param>
/// <param name="sourceType"></param>
/// <param name="targetType"></param>
/// <param name="targetSlot"></param>
/// <param name="wear"></param>
public ItemInstance MoveInInventory(short sourceSlot, InventoryType sourceType, InventoryType targetType, short?targetSlot = null, bool wear = true)
{
var sourceInstance = LoadBySlotAndType(sourceSlot, sourceType);
if (sourceInstance == null && wear)
{
Logger.Error(new InvalidOperationException("SourceInstance to move does not exist."));
return(null);
}
if (Owner != null && sourceInstance != null)
{
if (targetSlot.HasValue)
{
if (wear)
{
// swap
var targetInstance = LoadBySlotAndType(targetSlot.Value, targetType);
sourceInstance.Slot = targetSlot.Value;
sourceInstance.Type = targetType;
targetInstance.Slot = sourceSlot;
targetInstance.Type = sourceType;
}
else
{
// move source to target
short?freeTargetSlot = GetFreeSlot(targetType, Owner.HaveBackpack() ? 1 : 0);
if (freeTargetSlot.HasValue)
{
sourceInstance.Slot = freeTargetSlot.Value;
sourceInstance.Type = targetType;
}
}
return(sourceInstance);
}
// check for free target slot
short?nextFreeSlot;
switch (targetType)
{
case InventoryType.FirstPartnerInventory:
case InventoryType.SecondPartnerInventory:
case InventoryType.ThirdPartnerInventory:
case InventoryType.Wear:
nextFreeSlot = (LoadBySlotAndType((short)sourceInstance.Item.EquipmentSlot, targetType) == null
? (short)sourceInstance.Item.EquipmentSlot
: (short)-1);
break;
default:
nextFreeSlot = GetFreeSlot(targetType, Owner.HaveBackpack() ? 1 : 0);
break;
}
if (nextFreeSlot.HasValue)
{
sourceInstance.Type = targetType;
sourceInstance.Slot = nextFreeSlot.Value;
}
else
{
return(null);
}
}
else
{
return(null);
}
return(sourceInstance);
}
public InventoryVector(InventoryType type, uint256 hash)
{
Type = type;
Hash = hash;
}
public static bool IsPhone(InventoryType i)
{
return(i == InventoryType.SmartPhone1 || i == InventoryType.SmartPhone2 || i == InventoryType.SmartPhone3 || i == InventoryType.SmartPhone4 ||
i == InventoryType.SmartPhone5 || i == InventoryType.BrickPhone1 || i == InventoryType.BrickPhone2);
}
public InventoryId(InventoryType type, ushort id)
{
Type = type;
Id = id;
}
} // @ public uint GetItemCountByIndex(byte index, InventoryType location)
/// <summary>
/// Will get an item ID by index in the passed location
/// </summary>
/// <param name="index">Index of the item in your inventory</param>
/// <param name="location">InventoryType of the location to search (SINGLE LOCATION)</param>
public int GetItemIDByIndex (int index, InventoryType location)
{
if (IsSet(location, InventoryType.None))
return 0;
DoRangeChecks(index, location);
InventoryItem item = GetItem(index, location);
if (item != null)
return item.ID;
return 0;
} // @ public int GetItemIDByIndex(byte index, InventoryType location)
public VendingMachineEjectMessage(InventoryType type, string id)
{
Type = type;
ID = id;
}
/// <summary>
/// Gets information about an item from your inventory
/// </summary>
/// <param name="index">Index of the item</param>
/// <param name="location">Location to check (SINGLE LOCATION)</param>
/// <returns>InventoryItem filled with data about item, null if no item or error.</returns>
public InventoryItem GetItem (int index, InventoryType location)
{
if (IsSet(location, InventoryType.None))
return null;
DoRangeChecks(index, location);
// done this way because INVENTORYITEM is a private structure
FFACEGetItem func = null;
if (IsSet(location, InventoryType.Inventory))
{
func = FFACE.GetInventoryItem;
location = InventoryType.Inventory;
}
else if (IsSet(location, InventoryType.Locker))
{
func = FFACE.GetLockerItem;
location = InventoryType.Locker;
}
else if (IsSet(location, InventoryType.Sack))
{
func = FFACE.GetSackItem;
location = InventoryType.Sack;
}
else if (IsSet(location, InventoryType.Safe))
{
func = FFACE.GetSafeItem;
location = InventoryType.Safe;
}
else if (IsSet(location, InventoryType.Case))
{
func = FFACE.GetCaseItem;
location = InventoryType.Case;
}
else if (IsSet(location, InventoryType.Satchel))
{
func = FFACE.GetSatchelItem;
location = InventoryType.Satchel;
}
else if (IsSet(location, InventoryType.Storage))
{
func = FFACE.GetStorageItem;
location = InventoryType.Storage;
}
else if (IsSet(location, InventoryType.Temp))
{
func = FFACE.GetTempItem;
location = InventoryType.Temp;
}
else if (IsSet(location, InventoryType.Wardrobe))
{
func = FFACE.GetWardrobeItem;
location = InventoryType.Wardrobe;
}
if (func == null)
return null;
INVENTORYITEM item = func(_InstanceID, index);
if (item.ID <= 0)
{
return null;
}
return new InventoryItem(item.ID, item.Index, item.Count, item.Flag, item.Price, item.Extra, location);
} // @ public InventoryItem GetItem(int index, InventoryType location)
public VendingMachineInventoryEntry(InventoryType type, string id, uint amount)
{
Type = type;
ID = id;
Amount = amount;
}
} // @ public InventoryItem GetItem(int index, InventoryType location)
/// <summary>
/// Returns a list of all inventory items matching ID
/// </summary>
/// <param name="iD">ID of item to get list of.</param>
/// <returns></returns>
public System.Collections.Generic.List<InventoryItem> GetItemList (int iD, InventoryType location)
{
var retList = new System.Collections.Generic.List<InventoryItem>();
if (IsSet(location, InventoryType.None))
{
return retList;
}
if (location != InventoryType.None)
{
int start = 0;
bool inventory = IsSet(location, InventoryType.Inventory),
locker = IsSet(location, InventoryType.Locker),
sack = IsSet(location, InventoryType.Sack),
_case = IsSet(location, InventoryType.Case),
wardrobe = IsSet(location, InventoryType.Wardrobe),
safe = IsSet(location, InventoryType.Safe),
satchel = IsSet(location, InventoryType.Satchel),
storage = IsSet(location, InventoryType.Storage),
temp = IsSet(location, InventoryType.Temp);
// if inventory is not set at all, just skip the 0
if (!inventory)
start = 1;
// Check all bags in parallel
for (int i = start; i <= 80; i++)
{
// inventory index is allowed to be 0
InventoryItem item;
if (inventory)
{
item = GetItem(i, InventoryType.Inventory);
if (( item != null ) && ( item.ID == iD ))
retList.Add(item);
}
// Inventory is only one allowed to start at 0
if (i == 0)
continue;
if (locker)
{
item = GetItem(i, InventoryType.Locker);
if (( item != null ) && ( item.ID == iD ))
retList.Add(item);
}
if (sack)
{
item = GetItem(i, InventoryType.Sack);
if (( item != null ) && ( item.ID == iD ))
retList.Add(item);
}
if (_case)
{
item = GetItem(i, InventoryType.Case);
if (( item != null ) && ( item.ID == iD ))
retList.Add(item);
}
if (safe)
{
item = GetItem(i, InventoryType.Safe);
if (( item != null ) && ( item.ID == iD ))
retList.Add(item);
}
if (satchel)
{
item = GetItem(i, InventoryType.Satchel);
if (( item != null ) && ( item.ID == iD ))
retList.Add(item);
}
if (storage)
{
item = GetItem(i, InventoryType.Storage);
if (( item != null ) && ( item.ID == iD ))
retList.Add(item);
}
if (temp)
{
item = GetItem(i, InventoryType.Temp);
if (( item != null ) && ( item.ID == iD ))
retList.Add(item);
}
if (wardrobe)
{
item = GetItem(i, InventoryType.Wardrobe);
if ((item != null) && (item.ID == iD))
retList.Add(item);
}
}
}
return retList;
}
public static void SkillLevelUp_Req(InPacket lea, Client gc)
{
byte Type = lea.ReadByte();
byte Slot = lea.ReadByte();
var chr = gc.Character;
if (chr.SkillBonus < 1)
{
return;
}
List <Skill> s = chr.Skills.getSkills();
Skill sl = null;
foreach (Skill skill in s)
{
if (skill.Type == Type && skill.Slot == Slot)
{
sl = skill;
break;
}
}
if (sl == null || (sl.SkillID == 1 && sl.SkillLevel + 1 > 5) ||
(sl.SkillID == 2 && sl.SkillLevel + 1 > 10) || (sl.SkillID == 3 && sl.SkillLevel + 1 > 20) ||
(sl.SkillID == 4 && sl.SkillLevel + 1 > 20) || sl.SkillLevel + 1 > 20)
{
return;
}
chr.SkillBonus--;
sl.SkillLevel++;
if (sl.SkillID == 10101 || sl.SkillID == 10201 || sl.SkillID == 10301 || sl.SkillID == 10401 ||
sl.SkillID == 10501 || sl.SkillID == 10102 || sl.SkillID == 10202 || sl.SkillID == 10302 ||
sl.SkillID == 10402 || sl.SkillID == 10502)
{
if (chr.Items[InventoryType.ItemType.Equip, (byte)InventoryType.EquipType.Weapon] != null)
{
int ItemID = chr.Items[InventoryType.ItemType.Equip, (byte)InventoryType.EquipType.Weapon].ItemID;
int MaxAttack = 5;
int Attack = 3;
int MaxMagic = 4;
int Magic = 4;
MaxAttack += ((chr.Str - 3) * 2 + chr.Str / 5);
MaxAttack += ((chr.Dex - 3) * 2 + chr.Dex / 5);
Attack += ((chr.Dex - 3) * 1 + chr.Dex / 5);
MaxMagic += ((chr.Int - 3) * 2 + chr.Int / 5);
Magic += ((chr.Int - 3) * 2 + chr.Int / 5);
// 技能攻擊力+、魔攻力+
if (InventoryType.Is劍(ItemID) && sl.SkillID == 10101)
{
chr.MaxAttack -= (short)(MaxAttack * 0.02 * (sl.SkillLevel - 1));
chr.Attack -= (short)(Attack * 0.02 * (sl.SkillLevel - 1));
chr.MaxAttack += (short)(MaxAttack * 0.02 * sl.SkillLevel);
chr.Attack += (short)(Attack * 0.02 * sl.SkillLevel);
}
if (InventoryType.Is刀(ItemID) && sl.SkillID == 10102)
{
chr.MaxAttack -= (short)(MaxAttack * 0.03 * (sl.SkillLevel - 1));
chr.Attack -= (short)(Attack * 0.03 * (sl.SkillLevel - 1));
chr.MaxAttack += (short)(MaxAttack * 0.03 * sl.SkillLevel);
chr.Attack += (short)(Attack * 0.03 * sl.SkillLevel);
}
if (InventoryType.Is手套(ItemID) && sl.SkillID == 10201)
{
chr.MaxAttack -= (short)(MaxAttack * 0.02 * (sl.SkillLevel - 1));
chr.Attack -= (short)(Attack * 0.02 * (sl.SkillLevel - 1));
chr.MaxAttack += (short)(MaxAttack * 0.02 * sl.SkillLevel);
chr.Attack += (short)(Attack * 0.02 * sl.SkillLevel);
}
if (InventoryType.Is爪(ItemID) && sl.SkillID == 10202)
{
chr.MaxAttack -= (short)(MaxAttack * 0.03 * (sl.SkillLevel - 1));
chr.Attack -= (short)(Attack * 0.03 * (sl.SkillLevel - 1));
chr.MaxAttack += (short)(MaxAttack * 0.03 * sl.SkillLevel);
chr.Attack += (short)(Attack * 0.03 * sl.SkillLevel);
}
if (InventoryType.Is扇(ItemID) && sl.SkillID == 10301)
{
chr.MaxMagic -= (short)(MaxMagic * 0.02 * (sl.SkillLevel - 1));
chr.Magic -= (short)(Magic * 0.02 * (sl.SkillLevel - 1));
chr.MaxMagic += (short)(MaxMagic * 0.02 * sl.SkillLevel);
chr.Magic += (short)(Magic * 0.02 * sl.SkillLevel);
}
if (InventoryType.Is杖(ItemID) && sl.SkillID == 10302)
{
chr.MaxMagic -= (short)(MaxMagic * 0.03 * (sl.SkillLevel - 1));
chr.Magic -= (short)(Magic * 0.03 * (sl.SkillLevel - 1));
chr.MaxMagic += (short)(MaxMagic * 0.03 * sl.SkillLevel);
chr.Magic += (short)(Magic * 0.03 * sl.SkillLevel);
}
if (InventoryType.Is斧(ItemID) && sl.SkillID == 10401)
{
chr.MaxAttack -= (short)(MaxAttack * 0.02 * (sl.SkillLevel - 1));
chr.Attack -= (short)(Attack * 0.02 * (sl.SkillLevel - 1));
chr.MaxAttack += (short)(MaxAttack * 0.02 * sl.SkillLevel);
chr.Attack += (short)(Attack * 0.02 * sl.SkillLevel);
}
if (InventoryType.Is輪(ItemID) && sl.SkillID == 10402)
{
chr.MaxAttack -= (short)(MaxAttack * 0.03 * (sl.SkillLevel - 1));
chr.Attack -= (short)(Attack * 0.03 * (sl.SkillLevel - 1));
chr.MaxAttack += (short)(MaxAttack * 0.03 * sl.SkillLevel);
chr.Attack += (short)(Attack * 0.03 * sl.SkillLevel);
}
//if (Skill.ContainsKey(10501) && InventoryType.Is(chr.Items[InventoryType.ItemType.Equip, (byte)InventoryType.EquipType.Weapon].ItemID))
//{
//}
//if (Skill.ContainsKey(10502) && InventoryType.Is(chr.Items[InventoryType.ItemType.Equip, (byte)InventoryType.EquipType.Weapon].ItemID))
//{
//}
StatusPacket.UpdateStat(gc);
}
}
SkillPacket.updateSkillLevel(gc, chr.SkillBonus, Type, Slot, sl.SkillLevel);
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
FolderID = map["folder_id"].AsUUID();
AssetType = Utils.StringToAssetType(map["asset_type"].AsString());
InventoryType = Utils.StringToInventoryType(map["inventory_type"].AsString());
Name = map["name"].AsString();
Description = map["description"].AsString();
EveryoneMask = (PermissionMask)map["everyone_mask"].AsInteger();
GroupMask = (PermissionMask)map["group_mask"].AsInteger();
NextOwnerMask = (PermissionMask)map["next_owner_mask"].AsInteger();
}
// This class executes 1 queue item when called upon
public static void run()
{
Queue X = Queue.Instance;
// Get first queued item
Queue.Instance.invItem = null;
if (X.ActualQueue.Count == 0)
{
return;
}
KeyValuePair <UUID, List <Queue.QueueType> > kvp = X.ActualQueue.First();
InventoryManager inv = BotSession.Instance.grid.Inventory;
UUID GitOwnerFolder = UUID.Zero;
UUID Branch = UUID.Zero;
UUID Recipient = kvp.Key;
UUID Container = UUID.Zero;
UUID ParentFolder = inv.FindFolderForType(AssetType.Folder);
Queue.QueueType QT = kvp.Value.First();
InventoryBase GitOwnerFolderBase = null;
try
{
GitOwnerFolderBase = inv.LocalFind(ParentFolder, new[] { QT.GitOwner }, 0, false).First();
GitOwnerFolder = GitOwnerFolderBase.UUID;
} catch (Exception e)
{
}
if (GitOwnerFolder == UUID.Zero || GitOwnerFolder == ParentFolder)
{
GitOwnerFolder = inv.CreateFolder(ParentFolder, QT.GitOwner);
}
InventoryBase GitBranchBase = null;
try
{
GitBranchBase = inv.LocalFind(GitOwnerFolder, new[] { QT.GitBranch }, 0, false).First();
Branch = GitBranchBase.UUID;
}
catch (Exception e) { }
if (Branch == UUID.Zero || Branch == ParentFolder)
{
Branch = inv.CreateFolder(GitOwnerFolder, QT.GitBranch);
}
InventoryBase GitContainer = null;
try
{
GitContainer = inv.LocalFind(Branch, new[] { QT.Container }, 0, false).First();
Container = GitContainer.UUID;
}catch (Exception e) { }
if (Container == UUID.Zero || Container == ParentFolder)
{
Container = inv.CreateFolder(Branch, QT.Container);
}
Queue.FinalQueueData Finals = new Queue.FinalQueueData();
Dictionary <UUID, Queue.FinalQueueData> FQI = Queue.Instance.FinalQueue;
if (FQI.ContainsKey(Recipient))
{
Finals = FQI[Recipient];
if (Finals.Folders.ContainsKey(QT.Container))
{
// do nothing
}
else
{
Finals.Folders.Add(QT.Container, Container);
}
FQI[Recipient] = Finals;
Queue.Instance.FinalQueue = FQI;
}
Console.WriteLine("Git Owner Folder: " + GitOwnerFolder.ToString());
Console.WriteLine("Branch: " + Branch.ToString());
Console.WriteLine("Container: " + Container.ToString());
// Locate the Script or Notecard
InventoryBase importedItem = null;
UUID ItemID = UUID.Zero;
try
{
if (QT.ItemType == "script")
{
importedItem = inv.LocalFind(Container, new[] { QT.Name }, 1, true).First();
}
else if (QT.ItemType == "notecard")
{
importedItem = inv.LocalFind(Container, new[] { QT.Name + QT.FileExt }, 1, false).First();
}
ItemID = importedItem.UUID;
}
catch (Exception e) { }
if (ItemID == UUID.Zero || ItemID == null)
{
Queue.Instance.invItem = null;
}
else
{
Queue.Instance.ARE = new AutoResetEvent(false);
inv.ItemReceived += Inv_ItemReceived;
while (!Queue.Instance.ARE.WaitOne(TimeSpan.FromMinutes(1)))
{
Queue.Instance.ARE.Reset();
inv.RequestFetchInventory(ItemID, importedItem.OwnerID);
}
}
// Check that invItem is instantiated
AssetType itemType = AssetType.Folder;
InventoryType InvType = InventoryType.Animation;
if (QT.ItemType == "notecard")
{
InvType = InventoryType.Notecard;
itemType = AssetType.Notecard;
}
else if (QT.ItemType == "script")
{
InvType = InventoryType.LSL;
itemType = AssetType.LSLText;
}
if (Queue.Instance.invItem == null)
{
// We can safely create the inventory item now
string FinalName = QT.Name;
if (InvType == InventoryType.Notecard)
{
FinalName += QT.FileExt;
}
UUID Transaction = UUID.Random();
inv.RequestCreateItem(Container, FinalName, QT.Hash, itemType, Transaction, InvType, PermissionMask.All, delegate(bool success, InventoryItem ii)
{
if (success)
{
Queue.Instance.invItem = ii;
Queue.Instance.ARE.Set();
}
});
Queue.Instance.ARE.WaitOne(TimeSpan.FromSeconds(10));
InventoryItem actualItem = Queue.Instance.invItem;
if (itemType == AssetType.LSLText)
{
inv.RequestUpdateScriptAgentInventory(EncodeScript(QT.Text), actualItem.UUID, true, delegate(bool uploaded, string uploadstatus, bool compileSuccess, List <string> msgs, UUID itemID, UUID assetID)
{
Queue.Instance.compileMessages = msgs;
Queue.Instance.CompileSuccess = compileSuccess;
Queue.Instance.UploadSuccess = uploaded;
Queue.Instance.ARE.Set();
});
Queue.Instance.ARE.WaitOne(TimeSpan.FromSeconds(20));
if (Queue.Instance.UploadSuccess)
{
if (Queue.Instance.CompileSuccess)
{
// Remove this from future queues
kvp.Value.Remove(QT);
// quickly check whether KVP.Value is empty
if (kvp.Value.Count == 0)
{
// Send the container folder, and remove this from queue
//inv.GiveFolder(Branch, GitBranchBase.Name, Recipient, false);
//List<InventoryBase> folders = inv.FolderContents(Branch, BotSession.Instance.grid.Self.AgentID, true, false, InventorySortOrder.ByName, TimeSpan.FromSeconds(30).Milliseconds);
if (Recipient != UUID.Zero)
{
foreach (KeyValuePair <string, UUID> kvpx in Finals.Folders)
{
inv.GiveFolder(kvpx.Value, kvpx.Key, Recipient, false);
MH(Destinations.DEST_AGENT, Recipient, "Sending : " + kvpx.Key);
}
Queue.Instance.FinalQueue.Remove(Recipient);
}
X.ActualQueue.Remove(Recipient);
}
else
{
X.ActualQueue[Recipient] = kvp.Value;
}
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item '" + QT.Name + "' finished processing");
}
}
}
else
{
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item: " + QT.Name + QT.FileExt + " failed!");
}
}
}
else if (itemType == AssetType.Notecard)
{
inv.RequestUploadNotecardAsset(Encoding.UTF8.GetBytes(QT.Text), actualItem.UUID, delegate(bool success, string status, UUID itemID, UUID assetID)
{
if (success)
{
Queue.Instance.UploadSuccess = success;
Queue.Instance.ARE.Set();
}
});
if (Queue.Instance.UploadSuccess)
{
kvp.Value.Remove(QT);
if (kvp.Value.Count == 0)
{
X.ActualQueue.Remove(Recipient);
// inv.GiveFolder(Branch, GitBranchBase.Name, Recipient, false);
if (Recipient != UUID.Zero)
{
foreach (KeyValuePair <string, UUID> kvpx in Finals.Folders)
{
inv.GiveFolder(kvpx.Value, kvpx.Key, Recipient, false);
MH(Destinations.DEST_AGENT, Recipient, "Sending : " + kvpx.Key);
}
Queue.Instance.FinalQueue.Remove(Recipient);
}
}
else
{
X.ActualQueue[Recipient] = kvp.Value;
}
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item '" + QT.Name + "' finished processing");
}
}
else
{
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item: " + QT.Name + QT.FileExt + " failed!");
}
}
}
}
else
{
// Item exists, verify hash data!
if (itemType == AssetType.LSLText)
{
if (Queue.Instance.invItem.Description == QT.Hash)
{
// remove from queue
kvp.Value.Remove(QT);
if (kvp.Value.Count == 0)
{
if (Recipient != UUID.Zero)
{
foreach (KeyValuePair <string, UUID> kvpx in Finals.Folders)
{
inv.GiveFolder(kvpx.Value, kvpx.Key, Recipient, false);
MH(Destinations.DEST_AGENT, Recipient, "Sending : " + kvpx.Key);
}
Queue.Instance.FinalQueue.Remove(Recipient);
}
X.ActualQueue.Remove(Recipient);
//inv.GiveFolder(Branch, GitBranchBase.Name, Recipient, false);
}
else
{
X.ActualQueue[Recipient] = kvp.Value;
}
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item '" + QT.Name + "' finished processing - no changes needed");
}
}
else
{
// update the script now
inv.RequestUpdateScriptAgentInventory(EncodeScript(QT.Text), Queue.Instance.invItem.UUID, true, delegate(bool uploaded, string uploadstatus, bool compileSuccess, List <string> msgs, UUID itemID, UUID assetID)
{
Queue.Instance.compileMessages = msgs;
Queue.Instance.CompileSuccess = compileSuccess;
Queue.Instance.UploadSuccess = uploaded;
Queue.Instance.ARE.Set();
});
Queue.Instance.ARE.WaitOne(TimeSpan.FromSeconds(15));
if (Queue.Instance.UploadSuccess)
{
if (Queue.Instance.CompileSuccess)
{
X.invItem.Description = QT.Hash;
kvp.Value.Remove(QT);
if (kvp.Value.Count == 0)
{
if (Recipient != UUID.Zero)
{
foreach (KeyValuePair <string, UUID> kvpx in Finals.Folders)
{
inv.GiveFolder(kvpx.Value, kvpx.Key, Recipient, false);
MH(Destinations.DEST_AGENT, Recipient, "Sending : " + kvpx.Key);
}
Queue.Instance.FinalQueue.Remove(Recipient);
}
X.ActualQueue.Remove(Recipient);
//inv.GiveFolder(Branch, GitBranchBase.Name, Recipient, false);
}
else
{
X.ActualQueue[Recipient] = kvp.Value;
}
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item '" + QT.Name + "' finished processing");
}
}
}
else
{
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item: " + QT.Name + QT.FileExt + " failed!");
}
}
}
}
else if (itemType == AssetType.Notecard)
{
if (Queue.Instance.invItem.Description == QT.Hash)
{
kvp.Value.Remove(QT);
if (kvp.Value.Count == 0)
{
if (Recipient != UUID.Zero)
{
foreach (KeyValuePair <string, UUID> kvpx in Finals.Folders)
{
inv.GiveFolder(kvpx.Value, kvpx.Key, Recipient, false);
MH(Destinations.DEST_AGENT, Recipient, "Sending : " + kvpx.Key);
}
Queue.Instance.FinalQueue.Remove(Recipient);
}
X.ActualQueue.Remove(Recipient);
//inv.GiveFolder(Branch, GitBranchBase.Name, Recipient, false);
}
else
{
X.ActualQueue[Recipient] = kvp.Value;
}
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item '" + QT.Name + "' finished processing - no changes needed");
}
}
else
{
inv.RequestUploadNotecardAsset(EncodeScript(QT.Text), Queue.Instance.invItem.UUID, delegate(bool success, string status, UUID itemID, UUID assetID)
{
Queue.Instance.UploadSuccess = success;
Queue.Instance.ARE.Set();
});
Queue.Instance.ARE.WaitOne(TimeSpan.FromSeconds(15));
if (Queue.Instance.UploadSuccess)
{
// Notecard updated
kvp.Value.Remove(QT);
if (kvp.Value.Count == 0)
{
if (Recipient != UUID.Zero)
{
foreach (KeyValuePair <string, UUID> kvpx in Finals.Folders)
{
inv.GiveFolder(kvpx.Value, kvpx.Key, Recipient, false);
MH(Destinations.DEST_AGENT, Recipient, "Sending : " + kvpx.Key);
}
Queue.Instance.FinalQueue.Remove(Recipient);
}
X.ActualQueue.Remove(Recipient);
//inv.GiveFolder(Branch, GitBranchBase.Name, Recipient, false);
}
else
{
X.ActualQueue[Recipient] = kvp.Value;
}
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item '" + QT.Name + "' finished processing");
}
}
else
{
if (Recipient != UUID.Zero)
{
MH(Destinations.DEST_AGENT, Recipient, "Item: " + QT.Name + QT.FileExt + " failed!");
}
}
}
}
}
X.ARE = new AutoResetEvent(false);
X.compileMessages = new List <string>();
X.CompileSuccess = false;
X.invItem = null;
X.UploadSuccess = false;
}
public override InventoryFolderBase GetFolderForType(UUID principalID, InventoryType invType, AssetType type)
{
InventoryFolderBase invFolder = GetRootFolder (principalID);
switch (type)
{
case AssetType.Object:
InventoryFolderBase objFolder = GetFolderType (principalID, invFolder.ID, type);
if (objFolder == null)
objFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Object, "Foreign Objects");
return objFolder;
case AssetType.LSLText:
InventoryFolderBase lslFolder = GetFolderType (principalID, invFolder.ID, type);
if (lslFolder == null)
lslFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.LSLText, "Foreign Scripts");
return lslFolder;
case AssetType.Notecard:
InventoryFolderBase ncFolder = GetFolderType (principalID, invFolder.ID, type);
if (ncFolder == null)
ncFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Notecard, "Foreign Notecards");
return ncFolder;
case AssetType.Animation:
InventoryFolderBase aniFolder = GetFolderType (principalID, invFolder.ID, type);
if (aniFolder == null)
aniFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Notecard, "Foreign Animiations");
return aniFolder;
case AssetType.Bodypart:
case AssetType.Clothing:
InventoryFolderBase clothingFolder = GetFolderType (principalID, invFolder.ID, AssetType.Clothing);
if (clothingFolder == null)
clothingFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Clothing, "Foreign Clothing");
return clothingFolder;
case AssetType.Gesture:
InventoryFolderBase gestureFolder = GetFolderType (principalID, invFolder.ID, type);
if (gestureFolder == null)
gestureFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Gesture, "Foreign Gestures");
return gestureFolder;
case AssetType.Landmark:
InventoryFolderBase lmFolder = GetFolderType (principalID, invFolder.ID, type);
if (lmFolder == null)
lmFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Landmark, "Foreign Landmarks");
return lmFolder;
case AssetType.SnapshotFolder:
case AssetType.Texture:
InventoryFolderBase textureFolder = GetFolderType (principalID, invFolder.ID, type);
if (textureFolder == null)
textureFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Landmark, "Foreign Textures");
return textureFolder;
case AssetType.Sound:
InventoryFolderBase soundFolder = GetFolderType (principalID, invFolder.ID, type);
if (soundFolder == null)
soundFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Landmark, "Foreign Sounds");
return soundFolder;
default:
return invFolder;
}
}
void InventoryCreate()
{
Debug.LogWarning("InventoryCreate: ListInventoryPoint.Count = " + ListInventoryPoint.Count);
if (ListInventoryPoint.Count > MAX_INVENTORY_NUM)
{
Debug.LogError("InventoryCreate: incorrect ListInventoryPoint.Count = " + ListInventoryPoint.Count);
return;
}
ListInventory.Clear();
GameObject InventoryObject = GameObject.Find("InventoryObject");
if (GameManager.s_gameSingleMultiType == GameSingleMultiType.SingleGame)
{
for (int i = 0; i < ListInventoryPoint.Count; i++)
{
if (ListInventoryPoint[i] != null)
{
int index = Random.Range(0, 100) % m_inventoryName.Length;
GameObject loadObj = Resources.Load("Player/Prefabs/Invenrtory/" + m_inventoryName[index]) as GameObject;
GameObject temp = Instantiate(loadObj);
temp.transform.SetParent(InventoryObject.transform, false);
temp.transform.position = ListInventoryPoint[i].transform.position;
temp.name = m_inventoryName[index];
InventoryObjItem item = new InventoryObjItem();
item.id = (byte)i;
item.obj = temp;
item.bUsed = false;
item.bTaked = false;
ListInventory.Add(item);
}
}
}
else if (GameManager.s_gameSingleMultiType == GameSingleMultiType.MultiGame_WangHu)
{
GlobalUserInfo pGlobalUserInfo = GlobalUserInfo.GetInstance();
tagGlobalUserData pGlobalUserData = pGlobalUserInfo.GetGlobalUserData();
MersenneTwister.MT19937.Seed((ulong)pGlobalUserData.wRandseedForInventory);
for (int i = 0; i < ListInventoryPoint.Count; i++)
{
InventoryType inventoryType = (InventoryType)pGlobalUserData.sInventoryList[i].cbType;
if (ListInventoryPoint[i] != null && pGlobalUserData.sInventoryList[i].cbUsed == 0)
{
//Debug.LogWarning("InventoryCreate: inventoryType=" + inventoryType + " i=" + i);
if (inventoryType >= InventoryType.Inventory_Type_Num)
{
Debug.LogError("InventoryCreate: incorrect inventoryType=" + inventoryType + " i=" + i);
}
int index = (int)inventoryType;// (int)(MersenneTwister.MT19937.Int63() % m_inventoryName.Length);
GameObject loadObj = Resources.Load("Player/Prefabs/Invenrtory/" + m_inventoryName[index]) as GameObject;
GameObject temp = Instantiate(loadObj);
temp.transform.SetParent(InventoryObject.transform, false);
temp.transform.position = ListInventoryPoint[i].transform.position;
temp.name = m_inventoryName[index];
InventoryObjItem item = new InventoryObjItem();
item.id = (byte)i;
item.obj = temp;
item.bUsed = false;
item.bTaked = false;
ListInventory.Add(item);
}
}
}
}
/// <summary>
/// Create an inventory item and upload asset data
/// </summary>
/// <param name="data">Asset data</param>
/// <param name="name">Inventory item name</param>
/// <param name="description">Inventory item description</param>
/// <param name="assetType">Asset type</param>
/// <param name="invType">Inventory type</param>
/// <param name="folderID">Put newly created inventory in this folder</param>
/// <param name="callback">Delegate that will receive feedback on success or failure</param>
public void RequestCreateItemFromAsset(byte[] data, string name, string description, AssetType assetType,
InventoryType invType, UUID folderID, ItemCreatedFromAssetCallback callback)
{
Permissions permissions = new Permissions();
permissions.EveryoneMask = PermissionMask.None;
permissions.GroupMask = PermissionMask.None;
permissions.NextOwnerMask = PermissionMask.All;
RequestCreateItemFromAsset(data, name, description, assetType, invType, folderID, permissions, callback);
}
/// <summary>
/// Construct a new InventoryItem object of a specific Type
/// </summary>
/// <param name="type">The type of item from <seealso cref="T:OpenMetaverse.InventoryType" /></param>
/// <param name="itemID"><seealso cref="T:OpenMetaverse.UUID" /> of the item</param>
public InventoryItem(InventoryType type, UUID itemID) : base(itemID)
{
InventoryType = type;
}
/// <summary>
/// Creates inventory link to another inventory item or folder
/// </summary>
/// <param name="folderID">Put newly created link in folder with this UUID</param>
/// <param name="itemID">Original item's UUID</param>
/// <param name="name">Name</param>
/// <param name="description">Description</param>
/// <param name="assetType">Asset Type</param>
/// <param name="invType">Inventory Type</param>
/// <param name="transactionID">Transaction UUID</param>
/// <param name="callback">Method to call upon creation of the link</param>
public void CreateLink(UUID folderID, UUID itemID, string name, string description, AssetType assetType, InventoryType invType, UUID transactionID, ItemCreatedCallback callback)
{
LinkInventoryItemPacket create = new LinkInventoryItemPacket();
create.AgentData.AgentID = Client.Self.AgentID;
create.AgentData.SessionID = Client.Self.SessionID;
create.InventoryBlock.CallbackID = RegisterItemCreatedCallback(callback);
create.InventoryBlock.FolderID = folderID;
create.InventoryBlock.TransactionID = transactionID;
create.InventoryBlock.OldItemID = itemID;
create.InventoryBlock.Type = (sbyte)assetType;
create.InventoryBlock.InvType = (sbyte)invType;
create.InventoryBlock.Name = Utils.StringToBytes(name);
create.InventoryBlock.Description = Utils.StringToBytes(description);
Client.Network.SendPacket(create);
}
private void CreateCharacterItem(MySqlConnection connection, MySqlTransaction transaction, int idx, string characterId, InventoryType inventoryType, CharacterItem characterItem)
{
if (string.IsNullOrEmpty(characterItem.id))
{
return;
}
ExecuteNonQuerySync(connection, transaction, "INSERT INTO characteritem (id, idx, inventoryType, characterId, dataId, level, amount, equipSlotIndex, durability, exp, lockRemainsDuration, expireTime, randomSeed, ammo, sockets) VALUES (@id, @idx, @inventoryType, @characterId, @dataId, @level, @amount, @equipSlotIndex, @durability, @exp, @lockRemainsDuration, @expireTime, @randomSeed, @ammo, @sockets)",
new MySqlParameter("@id", characterItem.id),
new MySqlParameter("@idx", idx),
new MySqlParameter("@inventoryType", (byte)inventoryType),
new MySqlParameter("@characterId", characterId),
new MySqlParameter("@dataId", characterItem.dataId),
new MySqlParameter("@level", characterItem.level),
new MySqlParameter("@amount", characterItem.amount),
new MySqlParameter("@equipSlotIndex", characterItem.equipSlotIndex),
new MySqlParameter("@durability", characterItem.durability),
new MySqlParameter("@exp", characterItem.exp),
new MySqlParameter("@lockRemainsDuration", characterItem.lockRemainsDuration),
new MySqlParameter("@expireTime", characterItem.expireTime),
new MySqlParameter("@randomSeed", characterItem.randomSeed),
new MySqlParameter("@ammo", characterItem.ammo),
new MySqlParameter("@sockets", characterItem.WriteSockets()));
}
public TaskItemReceivedEventArgs(UUID itemID, UUID folderID, UUID creatorID, UUID assetID, InventoryType type)
{
this.m_ItemID = itemID;
this.m_FolderID = folderID;
this.m_CreatorID = creatorID;
this.m_AssetID = assetID;
this.m_Type = type;
}
public override void Use(ClientSession session, ref ItemInstance inv, byte Option = 0, string[] packetsplit = null)
{
switch (Effect)
{
default:
bool delay = false;
if (Option == 255)
{
delay = true;
Option = 0;
}
Mate mate = null;
if (Option != 0)
{
mate = session.Character.Mates.Find(s => s.MateType == MateType.Partner && s.PetId == Option - 1);
}
short slot = inv.Slot;
InventoryType equipment = InventoryType.Wear;
switch (Option)
{
case 1:
equipment = InventoryType.FirstPartnerInventory;
break;
case 2:
equipment = InventoryType.SecondPartnerInventory;
break;
case 3:
equipment = InventoryType.ThirdPartnerInventory;
break;
}
InventoryType itemToWearType = inv.Type;
if (inv == null)
{
return;
}
if (ItemValidTime > 0 && !inv.IsBound)
{
inv.ItemDeleteTime = DateTime.Now.AddSeconds(ItemValidTime);
}
if (!inv.IsBound)
{
if (!delay && ((EquipmentSlot == EquipmentType.Fairy && (MaxElementRate == 70 || MaxElementRate == 80)) || EquipmentSlot == EquipmentType.CostumeHat || EquipmentSlot == EquipmentType.CostumeSuit || EquipmentSlot == EquipmentType.WeaponSkin || EquipmentSlot == EquipmentType.Wings))
{
session.SendPacket($"qna #u_i^1^{session.Character.CharacterId}^{(byte)itemToWearType}^{slot}^1 {Language.Instance.GetMessageFromKey("ASK_BIND")}");
return;
}
if (delay)
{
inv.BoundCharacterId = session.Character.CharacterId;
}
}
double timeSpanSinceLastSpUsage = (DateTime.Now - Process.GetCurrentProcess().StartTime.AddSeconds(-50)).TotalSeconds - session.Character.LastSp;
if (EquipmentSlot == EquipmentType.Sp && inv.Rare == -2)
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("CANT_EQUIP_DESTROYED_SP"), 0));
return;
}
if (Option == 0)
{
if (EquipmentSlot == EquipmentType.Sp && timeSpanSinceLastSpUsage <= session.Character.SpCooldown && session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.Sp, InventoryType.Specialist) != null)
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("SP_INLOADING"), session.Character.SpCooldown - (int)Math.Round(timeSpanSinceLastSpUsage)), 0));
return;
}
if ((ItemType != ItemType.Weapon &&
ItemType != ItemType.Armor &&
ItemType != ItemType.Fashion &&
ItemType != ItemType.Jewelery &&
ItemType != ItemType.Specialist) ||
LevelMinimum > (IsHeroic ? session.Character.HeroLevel : session.Character.Level) || (Sex != 0 && Sex != (byte)session.Character.Gender + 1) ||
(ItemType != ItemType.Jewelery && EquipmentSlot != EquipmentType.Boots && EquipmentSlot != EquipmentType.Gloves && ((Class >> (byte)session.Character.Class) & 1) != 1))
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
if (session.Character.UseSp)
{
if (session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.Sp, equipment) is ItemInstance sp && sp.Item.Element != 0 && EquipmentSlot == EquipmentType.Fairy && Element != sp.Item.Element && Element != sp.Item.SecondaryElement)
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("BAD_FAIRY"), 0));
return;
}
}
if (session.Character.UseSp && EquipmentSlot == EquipmentType.Sp)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SP_BLOCKED"), 10));
return;
}
if (session.Character.JobLevel < LevelJobMinimum)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("LOW_JOB_LVL"), 10));
return;
}
}
else if (mate != null)
{
if (mate.Level < LevelMinimum)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
switch (EquipmentSlot)
{
case EquipmentType.Armor:
if (ItemSubType == 4)
{
mate.ArmorInstance = inv;
break;
}
else
{
goto default;
}
case EquipmentType.MainWeapon:
if (ItemSubType == 12)
{
mate.WeaponInstance = inv;
break;
}
else
{
goto default;
}
case EquipmentType.Gloves:
mate.GlovesInstance = inv;
break;
case EquipmentType.Boots:
mate.BootsInstance = inv;
break;
case EquipmentType.Sp:
if (ItemSubType == 4)
{
mate.SpInstance = inv;
break;
}
else
{
goto default;
}
default:
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
}
ItemInstance currentlyEquippedItem = session.Character.Inventory.LoadBySlotAndType((short)EquipmentSlot, equipment);
if (currentlyEquippedItem == null)
{
// move from equipment to wear
session.Character.Inventory.MoveInInventory(inv.Slot, itemToWearType, equipment);
session.SendPacket(UserInterfaceHelper.Instance.GenerateInventoryRemove(itemToWearType, slot));
}
else
{
Logger.LogUserEvent("EQUIPMENT_TAKEOFF", session.GenerateIdentity(), $"IIId: {currentlyEquippedItem.Id} ItemVnum: {currentlyEquippedItem.ItemVNum} Upgrade: {currentlyEquippedItem.Upgrade} Rare: {currentlyEquippedItem.Rare}");
// move from wear to equipment and back
session.Character.Inventory.MoveInInventory(currentlyEquippedItem.Slot, equipment, itemToWearType, inv.Slot);
session.SendPacket(currentlyEquippedItem.GenerateInventoryAdd());
session.Character.EquipmentBCards.RemoveAll(o => o.ItemVNum == currentlyEquippedItem.ItemVNum);
}
Logger.LogUserEvent("EQUIPMENT_WEAR", session.GenerateIdentity(), $"IIId: {inv.Id} ItemVnum: {inv.ItemVNum} Upgrade: {inv.Upgrade} Rare: {inv.Rare}");
session.Character.EquipmentBCards.AddRange(inv.Item.BCards);
switch (inv.Item.ItemType)
{
case ItemType.Armor:
session.Character.ShellEffectArmor.Clear();
foreach (ShellEffectDTO dto in inv.ShellEffects)
{
session.Character.ShellEffectArmor.Add(dto);
}
break;
case ItemType.Weapon:
switch (inv.Item.EquipmentSlot)
{
case EquipmentType.MainWeapon:
session.Character.ShellEffectMain.Clear();
foreach (ShellEffectDTO dto in inv.ShellEffects)
{
session.Character.ShellEffectMain.Add(dto);
}
break;
case EquipmentType.SecondaryWeapon:
session.Character.ShellEffectSecondary.Clear();
foreach (ShellEffectDTO dto in inv.ShellEffects)
{
session.Character.ShellEffectSecondary.Add(dto);
}
break;
}
break;
}
if (Option == 0)
{
session.SendPacket(session.Character.GenerateStatChar());
session.CurrentMapInstance?.Broadcast(session.Character.GenerateEq());
session.SendPacket(session.Character.GenerateEquipment());
session.CurrentMapInstance?.Broadcast(session.Character.GeneratePairy());
if (EquipmentSlot == EquipmentType.Fairy)
{
ItemInstance fairy = session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.Fairy, equipment);
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("FAIRYSTATS"), fairy.XP, CharacterHelper.LoadFairyXPData(fairy.ElementRate + fairy.Item.ElementRate)), 10));
}
if (EquipmentSlot == EquipmentType.Amulet)
{
session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player, session.Character.CharacterId, 39));
inv.BoundCharacterId = session.Character.CharacterId;
}
}
else if (mate != null)
{
session.SendPacket(mate.GenerateScPacket());
}
break;
}
}
public void RequestCreateItem(LLUUID parentFolder, string name, string description, AssetType type,
InventoryType invType, WearableType wearableType, PermissionMask nextOwnerMask,
ItemCreatedCallback callback)
{
CreateInventoryItemPacket create = new CreateInventoryItemPacket();
create.AgentData.AgentID = _Client.Self.AgentID;
create.AgentData.SessionID = _Client.Self.SessionID;
create.InventoryBlock.CallbackID = RegisterItemCreatedCallback(callback);
create.InventoryBlock.FolderID = parentFolder;
create.InventoryBlock.TransactionID = LLUUID.Random();
create.InventoryBlock.NextOwnerMask = (uint)nextOwnerMask;
create.InventoryBlock.Type = (sbyte)type;
create.InventoryBlock.InvType = (sbyte)invType;
create.InventoryBlock.WearableType = (byte)wearableType;
create.InventoryBlock.Name = Helpers.StringToField(name);
create.InventoryBlock.Description = Helpers.StringToField(description);
_Client.Network.SendPacket(create);
}
private InventoryType GetInvType()
{
if (_cacheInventoryType != InventoryType.InvalidInventory)
{
return(_cacheInventoryType);
}
if (Address == 0)
{
return(InventoryType.InvalidInventory);
}
// For Poe MemoryLeak bug where ChildCount of PlayerInventory keep
// Increasing on Area/Map Change. Ref:
// http://www.ownedcore.com/forums/mmo/path-of-exile/poe-bots-programs/511580-poehud-overlay-updated-362.html#post3718876
// Orriginal Value of ChildCount should be 0x18
for (var j = 1; j < InventoryList.InventoryCount; j++)
{
if (TheGame.IngameState.IngameUi.InventoryPanel[(InventoryIndex)j].Address == Address)
{
_cacheInventoryType = InventoryType.PlayerInventory;
return(_cacheInventoryType);
}
}
var parentChildCount = AsObject <Element>().Parent.ChildCount;
switch (parentChildCount)
{
case 0x6f:
_cacheInventoryType = InventoryType.EssenceStash;
break;
case 0x48:
_cacheInventoryType = InventoryType.CurrencyStash;
break;
case 0x5A:
_cacheInventoryType = InventoryType.FragmentStash;
break;
case 0x5:
_cacheInventoryType = InventoryType.DivinationStash;
break;
case 0x6:
if (AsObject <Element>().Parent.Children[0].ChildCount == 9)
{
_cacheInventoryType = InventoryType.MapStash;
break;
}
_cacheInventoryType = InventoryType.InvalidInventory;
break;
case 0x01:
// Normal Stash and Quad Stash is same.
if (TotalBoxesInInventoryRow == 24)
{
_cacheInventoryType = InventoryType.QuadStash;
}
_cacheInventoryType = InventoryType.NormalStash;
break;
case 0x23:
_cacheInventoryType = InventoryType.DelveStash;
break;
case 0x50:
_cacheInventoryType = InventoryType.BlightStash;
break;
case 0x1c:
_cacheInventoryType = InventoryType.DeliriumStash;
break;
case 0xe:
_cacheInventoryType = InventoryType.MetamorphStash;
break;
case 0x9:
_cacheInventoryType = InventoryType.UniqueStash;
break;
default:
_cacheInventoryType = InventoryType.InvalidInventory;
break;
}
return(_cacheInventoryType);
}
public InventoryItem(InventoryType type, LLUUID itemID) : base(itemID) { InventoryType = type; }
public InvPayload(InventoryType type, params uint256[] hashes)
: this(hashes.Select(h => new InventoryVector(type, h)).ToArray())
{
}
private InventoryItem SafeCreateInventoryItem(InventoryType InvType, LLUUID ItemID)
{
InventoryItem ret = null;
if (_Store.Contains(ItemID))
ret = _Store[ItemID] as InventoryItem;
if (ret == null)
ret = CreateInventoryItem(InvType, ItemID);
return ret;
}
/// <summary>
/// Convert an InventoryType to a string
/// </summary>
/// <param name="type">The <seealso cref="T:InventoryType"/> to convert</param>
/// <returns>A string representation of the source</returns>
public static string InventoryTypeToString(InventoryType type)
{
return(_InventoryTypeNames[(int)type]);
}
