public void CraftButton()
{
if (this.CraftingItemContainer.CanCraft())
{
foreach (IItemInstance item in this.CraftingItemContainer.Contents)
{
this.Player.AddContents(item.Contents);
}
this.Player.RemoveContents(this.CraftingItemContainer.Contents);
List <IItemInstance> newItems = new List <IItemInstance>();
IRecipe recipe = this.CraftingItemContainer.InferRecipeFromIngredients();
if (recipe is null)
{
return;
}
foreach (BaseItemType itemType in recipe.CraftingResults)
{
IItemInstance item = this.ItemFactory.CreateFromTemplate(
itemType,
true);
newItems.Add(item);
GlobalConstants.GameManager.ItemHandler.Add(item);
}
this.Player.AddContents(newItems);
this.PlayerInventory.Display();
this.CraftingItemContainer.RemoveAllItems();
}
}
public static IvnSubPacket GenerateIvnSubPacket([CanBeNull] this IItemInstance itemInstance, PocketType type,
short slot)
{
if (itemInstance == null)
{
return(new IvnSubPacket
{
Slot = slot,
VNum = -1,
RareAmount = 0,
UpgradeDesign = 0,
SecondUpgrade = 0
});
}
return(new IvnSubPacket
{
Slot = slot,
VNum = itemInstance.ItemVNum,
RareAmount =
type != PocketType.Equipment ? itemInstance.Amount
: itemInstance.Rare,
UpgradeDesign = itemInstance.Upgrade,
SecondUpgrade = 0
});
}
public void Setup()
{
_vendorCollection = new Collection <IVendorProduct <IItemInstance> >(10);
_vendorCurrencies = new CurrencyCollection();
_gold = new Currency(Guid.NewGuid(), "Gold", "GOLD", 2, 999f);
_vendor = new Vendor <IItemInstance>(new VendorConfig(), _vendorCollection, _vendorCurrencies);
_customerCollection = new Collection <IItemInstance>(10);
_customerCurrencies = new CurrencyCollection();
_customer = new Customer <IItemInstance>(Guid.NewGuid(), null, new CollectionGroup <IItemInstance>(new []
{
new CollectionGroup <IItemInstance> .Slot(_customerCollection),
}), new CurrencyCollectionGroup <ICurrency>(_customerCurrencies));
_item1 = new ItemInstance(Guid.NewGuid(), new ItemDefinition(Guid.NewGuid())
{
maxStackSize = 5, buyPrice = new[] { new CurrencyDecorator <double>(_gold, 1d) }, sellPrice = new[] { new CurrencyDecorator <double>(_gold, 0.6d) }
});
_item2 = new ItemInstance(Guid.NewGuid(), new ItemDefinition(Guid.NewGuid())
{
maxStackSize = 5, buyPrice = new[] { new CurrencyDecorator <double>(_gold, 2d) }, sellPrice = new[] { new CurrencyDecorator <double>(_gold, 1.6d) }
});
_product1 = new VendorProduct <IItemInstance>(_item1, _item1.itemDefinition.buyPrice, _item1.itemDefinition.sellPrice);
_product2 = new VendorProduct <IItemInstance>(_item2, _item2.itemDefinition.buyPrice, _item2.itemDefinition.sellPrice);
}
protected override bool StackOrAdd(
IItemInstance item,
IEnumerable <JoyItemSlot> slots = null,
bool takeFilledSlots = false)
{
if (item is null)
{
return(true);
}
if (this.ContainerOwner is null)
{
return(false);
}
if (this.GetSlotsForItem(item).Any())
{
return(true);
}
var requiredSlots = this.GetRequiredSlots(item, takeFilledSlots, slots);
if (requiredSlots.Count == item.ItemType.Slots.Count())
{
foreach (JoyItemSlot slot in requiredSlots)
{
slot.Item = item;
}
return(true);
}
//this.OnAddItem?.Invoke(this.ContainerOwner, item);
return(false);
}
public void Setup()
{
UnityEngine.Assertions.Assert.raiseExceptions = true;
_col0 = new Collection <IItemInstance>(5)
{
};
_col1 = new Collection <IItemInstance>(5)
{
};
_group = new CollectionGroup <IItemInstance, Collection <IItemInstance> >(new []
{
new CollectionGroup <IItemInstance, Collection <IItemInstance> > .Slot(_col0),
new CollectionGroup <IItemInstance, Collection <IItemInstance> > .Slot(_col1, new CollectionPriority <IItemInstance>(60, 60, 60)),
});
// Arrange
_itemDef = new ItemDefinition(Guid.NewGuid())
{
maxStackSize = 10
};
_itemDef2 = new ItemDefinition(Guid.NewGuid())
{
maxStackSize = 10
};
_item = new ItemInstance(Guid.NewGuid(), _itemDef);
_item2 = new ItemInstance(Guid.NewGuid(), _itemDef);
_item3 = new ItemInstance(Guid.NewGuid(), _itemDef2);
}
public virtual bool RemoveContents(IItemInstance actor)
{
if (actor is null)
{
return(true);
}
if (this.CanRemoveContents(actor) == false)
{
return(false);
}
if (this.m_Slots.All(s => actor.Guid.Equals(s.Item2) == false))
{
return(false);
}
List <Tuple <string, Guid> > slots = this.m_Slots.Where(s => actor.Guid.Equals(s.Item2)).ToList();
if (slots.Any() == false)
{
return(false);
}
foreach (Tuple <string, Guid> slot in slots)
{
int index = this.m_Slots.IndexOf(slot);
this.m_Slots[index] = new Tuple <string, Guid>(slot.Item1, Guid.Empty);
}
this.ItemRemoved?.Invoke(this, actor);
return(true);
}
public bool TryAddItemInstance(IItemInstance itemInstance)
{
ItemBatch queriedBatch = itemBatches.
FirstOrDefault(
b =>
b.item == itemInstance.data &&
b.fillLevel <= maxBatchSize - b.item.stackWeight);
if (queriedBatch != default(ItemBatch))
{
if (queriedBatch.TryAdd(itemInstance))
{
ItemAdded?.Invoke(itemInstance);
return(true);
}
return(false);
}
else
{
if (!slotToItemBatch.Any(s => s.Value == null))
{
return(false);
}
CreateNewItemBatch(itemInstance.data, itemInstance);
ItemAdded?.Invoke(itemInstance);
return(true);
}
}
public static void Register(System.Guid guid, IItemInstance val)
{
if (val != null)
{
_dict[guid] = val;
}
}
public bool Destroy(Guid key)
{
if (this.LiveItems.ContainsKey(key))
{
IItemInstance item = this.LiveItems[key];
//Erase any targets that match this item
//This is a really quick hack to fix a persistent problem
//TODO: Find a better way to reference AI targets
IEnumerable <IEntity> targeting =
GlobalConstants.GameManager.Player.MyWorld.Entities.Where(entity =>
entity.CurrentTarget.Target == item);
foreach (IEntity entity in targeting)
{
entity.CurrentTarget = new NeedAIData();
}
//this.LiveItems[key].Dispose();
this.LiveItems[key] = null;
this.LiveItems.Remove(key);
item = null;
return(true);
}
return(false);
}
public bool TryAddItem(Item item)
{
ItemBatch queriedBatch = itemBatches.FirstOrDefault(
b =>
b.item == item &&
b.fillLevel <= maxBatchSize - item.stackWeight);
IItemInstance itemInstance = default;
if (queriedBatch != default(ItemBatch))
{
itemInstance = queriedBatch.AddNew(1)[0];
ItemAdded?.Invoke(itemInstance);
return(true);
}
else
{
if (!slotToItemBatch.Any(s => s.Value == null))
{
return(false);
}
itemInstance = ItemManager.CreateItemInstance(item, null);
CreateNewItemBatch(item, itemInstance);
UpdateEmptyBatches();
ItemAdded?.Invoke(itemInstance);
return(true);
}
}
public override void Execute(DepositPacket depositPacket, ClientSession clientSession)
{
IItemInstance itemInstance = null;
short slot = 0;
var warehouseItems = _warehouseHttpClient.DepositItem(clientSession.Character.CharacterId,
WarehouseType.Warehouse, itemInstance, slot);
}
public override IQuestAction Create(
IEntity questor,
IEntity provider,
IWorldInstance overworld,
IEnumerable <string> tags)
{
this.ItemFactory ??= GlobalConstants.GameManager.ItemFactory;
IItemInstance deliveryItem = null;
List <IItemInstance> backpack = provider.Contents.ToList();
if (backpack.Count > 0)
{
int result = this.Roller.Roll(0, backpack.Count);
deliveryItem = backpack[result];
}
IEntity endPoint = overworld.GetRandomSentientWorldWide();
deliveryItem ??= this.ItemFactory.CreateRandomWeightedItem();
deliveryItem.SetOwner(endPoint.Guid);
List <string> myTags = new List <string>(tags);
return(new DeliverQuestAction(
new List <Guid> {
deliveryItem.Guid
},
new List <Guid> {
endPoint.Guid
},
new List <Guid>(),
myTags));
}
public IEnumerator TestTakeItemInstance()
{
yield return(null);
IItemInstance inst1 = ItemManager.CreateItemInstance(item1);
IItemInstance inst2 = ItemManager.CreateItemInstance(item1);
IItemInstance inst3 = ItemManager.CreateItemInstance(item2);
Assert.True(inventory.TryAddItemInstance(inst1));
//cant take item instances if not in inventory but same data in inventory
Assert.False(inventory.TryTakeItemInstance(inst2));
Assert.False(inventory.TryTakeItemInstance(inst3));
//can take item instance if in inventory
Assert.True(inventory.TryTakeItemInstance(inst1));
//cant take item instance twice
Assert.False(inventory.TryTakeItemInstance(inst1));
//cant take item instance after it has been taken but another instance of the same data is in inventory
Assert.True(inventory.TryAddItemInstance(inst1));
Assert.True(inventory.TryAddItemInstance(inst2));
Assert.True(inventory.TryTakeItemInstance(inst1));
Assert.False(inventory.TryTakeItemInstance(inst1));
//can take item instance if other item instance of same data has been just taken successfully
Assert.True(inventory.TryTakeItemInstance(inst2));
}
public MapItem PutItem(short amount, IItemInstance inv, ClientSession session)
{
Guid random2 = Guid.NewGuid();
MapItem droppedItem = null;
List <MapCell> possibilities = new List <MapCell>();
for (short x = -2; x < 3; x++)
{
for (short y = -2; y < 3; y++)
{
possibilities.Add(new MapCell {
X = x, Y = y
});
}
}
short mapX = 0;
short mapY = 0;
var niceSpot = false;
var orderedPossibilities = possibilities.OrderBy(_ => RandomFactory.Instance.RandomNumber()).ToList();
for (var i = 0; i < orderedPossibilities.Count && !niceSpot; i++)
{
mapX = (short)(session.Character.PositionX + orderedPossibilities[i].X);
mapY = (short)(session.Character.PositionY + orderedPossibilities[i].Y);
if (Map.IsBlockedZone(session.Character.PositionX, session.Character.PositionY, mapX, mapY))
{
continue;
}
niceSpot = true;
}
if (!niceSpot)
{
return(null);
}
if (amount <= 0 || amount > inv.Amount)
{
return(null);
}
var newItemInstance = (IItemInstance)inv.Clone();
newItemInstance.Id = random2;
newItemInstance.Amount = amount;
droppedItem = new MapItem
{
MapInstance = this, ItemInstance = newItemInstance, PositionX = mapX, PositionY = mapY
};
DroppedList[droppedItem.VisualId] = droppedItem;
inv.Amount -= amount;
if (inv.Amount == 0)
{
session.Character.Inventory.DeleteById(inv.Id);
}
return(droppedItem);
}
/// <summary>
/// Register a new item
/// </summary>
/// <param name="guid"></param>
/// <param name="val"></param>
public static void Register(System.Guid guid, IItemInstance val)
{
if (val != null)
{
_dict[guid] = val;
OnAddedItem?.Invoke(guid, val);
}
}
public static IItemInstance CreateItemInstance(Item item, Vector3 position, bool active = false)
{
IItemInstance createdInstance = CreateItemInstance(item);
createdInstance.gameObject.transform.position = position;
createdInstance.gameObject.SetActive(true);
return(createdInstance);
}
public virtual bool Equals(IItemInstance other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
return(itemDefinition.Equals(other.itemDefinition));
}
public bool RemoveItemFromWorld(IItemInstance item)
{
if (!this.LiveItems.ContainsKey(item.Guid))
{
return(false);
}
return(item.MyWorld.RemoveObject(item.WorldPosition, item));
}
public bool CanAddContents(IItemInstance actor)
{
if (actor is null)
{
return(true);
}
return(this.Guid != actor.Guid && !this.Contains(actor));
}
public IItemInstance CreateNewInstanceLike(IItemInstance item, IInventory inventory, int count)
{
var newItem = DefLoader.CreateInstanct <IItemInstance>(item.ItemDef, this, inventory);
(newItem as BaseItem).SetCount(count);
_items.Add(newItem.Id, newItem);
(inventory as BaseInventory).AddItemInstance(newItem);
return(newItem);
}
public virtual bool Contains(IItemInstance actor)
{
if (actor is null)
{
return(false);
}
return(this.m_Slots.Any(tuple => actor.Guid.Equals(tuple.Item2)));
}
public bool CanRemoveContents(IItemInstance actor)
{
if (actor is null)
{
return(true);
}
return(this.Contains(actor));
}
private static void ShowingDefaultItemData(IItemInstance itemInstance)
{
Console.WriteLine("1. 공통 정보 ----------------------");
Console.WriteLine(GetStringAppend("아이디: ", itemInstance.ClassId.ToString()));
Console.WriteLine(GetStringAppend("섬네일 이름: ", itemInstance.Thumb));
Console.WriteLine(GetStringAppend("이름: ", itemInstance.Name));
Console.WriteLine(GetStringAppend("설명: ", itemInstance.Desc));
Console.WriteLine(GetStringAppend("보유 여부: ", itemInstance.IsHave.ToString()));
Console.WriteLine(GetStringAppend("보유 갯수: ", itemInstance.HaveCount.ToString(), "\n"));
}
public IEnumerator TestHasItemInstance()
{
IItemInstance inst = ItemManager.CreateItemInstance(item1);
inventory.TryAddItemInstance(inst);
Assert.True(inventory.HasItemInstance(inst));
inventory.TryTakeItemInstance(inst);
Assert.False(inventory.HasItemInstance(inst));
yield return(null);
}
public bool DepositItem(long characterId, WarehouseType warehouse, IItemInstance itemInstance, short slot)
{
return(Post <bool>(new WareHouseDepositRequest
{
OwnerId = characterId,
WarehouseType = warehouse,
ItemInstance = itemInstance.Adapt <ItemInstanceDto>(),
Slot = slot
}));
}
public MapItem?PutItem(short amount, IItemInstance inv, ClientSession session)
{
var random2 = Guid.NewGuid();
MapItem?droppedItem;
var possibilities = new List <(short X, short Y)>();
for (short x = -1; x < 2; x++)
{
for (short y = -1; y < 2; y++)
{
possibilities.Add((x, y));
}
}
short mapX = 0;
short mapY = 0;
var niceSpot = false;
var orderedPossibilities = possibilities.OrderBy(_ => RandomHelper.Instance.RandomNumber()).ToList();
for (var i = 0; (i < orderedPossibilities.Count) && !niceSpot; i++)
{
mapX = (short)(session.Character.PositionX + orderedPossibilities[i].X);
mapY = (short)(session.Character.PositionY + orderedPossibilities[i].Y);
if (Map.IsBlockedZone(session.Character.PositionX, session.Character.PositionY, mapX, mapY))
{
continue;
}
niceSpot = true;
}
if (!niceSpot)
{
return(null);
}
if ((amount <= 0) || (amount > inv.Amount))
{
return(null);
}
var newItemInstance = (IItemInstance)inv.Clone();
newItemInstance.Id = random2;
newItemInstance.Amount = amount;
droppedItem = _mapItemGenerationService.Create(this, newItemInstance, mapX, mapY);
MapItems[droppedItem.VisualId] = droppedItem;
inv.Amount -= amount;
if (inv.Amount == 0)
{
session.Character.InventoryService !.DeleteById(inv.Id);
}
return(droppedItem);
}
public IEnumerable <IInventory> FindHaulDestinationForItem(IItemInstance item)
{
//TODO: Item filters and priority
foreach (var inventory in _inventories.Values.OrderBy(x => x.Config.Priority))
{
if (inventory.CanAcceptItem(item))
{
yield return(inventory);
}
}
}
/// <summary>
/// u_i packet
/// </summary>
/// <param name="useItemPacket"></param>
public void UseItem(UseItemPacket useItemPacket)
{
IItemInstance inv = Session.Character.Inventory.LoadBySlotAndType <IItemInstance>(useItemPacket.Slot, useItemPacket.Type);
if (inv?.Requests == null)
{
return;
}
inv.Requests.OnNext(new RequestData <Tuple <IItemInstance, UseItemPacket> >(Session, new Tuple <IItemInstance, UseItemPacket>(inv, useItemPacket)));
}
public virtual bool AddContents(IItemInstance actor)
{
if (!this.CanAddContents(actor))
{
return(false);
}
IEnumerable <string> slots = this.GetRequiredSlots(actor);
return(this.AddContents(actor, slots));
}
public IItemInstance Convert(IItemInstanceDto k)
{
IItemInstance item =
k.Adapt <BoxInstance>() ??
k.Adapt <SpecialistInstance>() ??
k.Adapt <WearableInstance>() ??
k.Adapt <UsableInstance>() ??
(IItemInstance)k.Adapt <ItemInstance>();
item.Item = _items.Find(s => s.VNum == k.ItemVNum);
return(item);
}
