Ejemplo n.º 1
0
 public void AddItemEvent(OwnedItemInformation item, bool isSave)
 {
     if (AddedItem != null)
     {
         AddedItem(item, isSave);
     }
 }
Ejemplo n.º 2
0
 public int Contains(OwnedItemInformation modified)
 {
     foreach (OwnedItemInformation item in containerItems)
     {
         if (item.IsSameItemAs(modified))
         {
             return item.Amount;
         }
     }
     return 0;
 }
 void ModifiedItem(OwnedItemInformation data, bool isSave)
 {
     if (isSave == true)
     {
         ItemManipulationServices.MoveItem(new MoveItemsRequest(new MoveItemsRequest.MoveOrder( data.StackLocationId,data.Amount, Location)), x =>
         {
             data.StackLocationId = x.UpdatedStackIds[0].StackId;
             data.IsLocked = false;
         });
     }
 }
 public ItemDataDisplay FindDisplayMatch(OwnedItemInformation item)
 {
     foreach (ItemDataDisplay itemDisplay in currentDisplayObjects)
     {
         if (itemDisplay.itemObject.itemData == item)
         {
             return itemDisplay;
         }
     }
     return null;
 }
 public virtual void AddedItem(OwnedItemInformation itemData, bool isSaving)
 {
     GameObject newItem = GameObject.Instantiate(CloudGoodsSettings.DefaultUIItem) as GameObject;
     ItemDataDisplay newDisplay = newItem.GetComponent<ItemDataDisplay>();
     newDisplay.itemObject = newItem.GetComponent<ItemDataComponent>();
     newItem.GetComponent<ItemDataComponent>().itemData = itemData;
     newItem.name = itemData.Information.Name;
     newItem.transform.SetParent(ChildTarget);
     newItem.transform.localPosition = Vector3.zero;
     newItem.transform.localScale = Vector3.one;
     currentDisplayObjects.Add(newDisplay);
 }
Ejemplo n.º 6
0
        public ContainerMoveState GetContainerAddState(OwnedItemInformation itemData)
        {
            if (ContainerAddRestrictions.Count > 0)
            {
                foreach (IContainerRestriction newRestriction in ContainerAddRestrictions)
                {
                    if (newRestriction.IsRestricted(ContainerAction.add, itemData))
                        return new ContainerMoveState(ContainerMoveState.ActionState.No);
                }
            }

            return MyContainerAddState(itemData);
        }
        public static ContainerMoveState.ActionState MoveItem(OwnedItemInformation movingItemData, ItemContainer targetContainer)
        {
            try
            {
                if (movingItemData.IsLocked)
                    return ContainerMoveState.ActionState.No;

                if (movingItemData == null)
                    throw new Exception("Can Not Move null item");

                if (targetContainer == null)
                    throw new Exception("Can not move item to null container");

                ContainerMoveState targetAddState = targetContainer.GetContainerAddState(movingItemData);

                switch (targetAddState.ContainerActionState)
                {
                    case ContainerMoveState.ActionState.Add:

                        OwnedItemInformation newItemData = new OwnedItemInformation();
                        newItemData.Amount = movingItemData.Amount;
                        newItemData.Information = movingItemData.Information;
                        newItemData.OwnerContainer = movingItemData.OwnerContainer;
                        newItemData.StackLocationId = movingItemData.StackLocationId;
                        newItemData.Location = movingItemData.Location;

                        if (movingItemData.OwnerContainer != null)
                        {
                            if (RemoveItem(movingItemData, movingItemData.OwnerContainer) == ContainerMoveState.ActionState.No)
                                return ContainerMoveState.ActionState.No;
                        }

                        targetContainer.Add(newItemData, targetAddState.PossibleAddAmount);

                        break;
                    case ContainerMoveState.ActionState.No:
                        break;
                    default:
                        break;
                }

                return targetAddState.ContainerActionState;
            }
            catch (Exception e)
            {
                Debug.LogError(e.Message);

                return ContainerMoveState.ActionState.No;
            }
        }
        public void AddItem(OwnedItemInformation addItem, int amount, bool isSave)
        {
            if (IsSwapNeeded())
            {
                //Should only swap single item in container (first item in container items list)
                OwnedItemInformation swapItem = itemContainer.containerItems[swapIndex];

                ItemContainerManager.MoveItem(swapItem, addItem.OwnerContainer);
                AddItemToContainer(addItem, amount, isSave);
            }
            else
            {
                AddItemToContainer(addItem, amount, isSave);
            }
        }
        private bool AddToExistingStack(OwnedItemInformation data, int amount, bool isSave)
        {
            foreach (OwnedItemInformation item in ItemContainer.containerItems)
            {

                if (item.Information.Id.Equals(data.Information.Id))
                {

                    ItemContainer.ModifiedItemEvent(data, isSave);

                    item.Amount = item.Amount + amount;
                    data.Amount -= amount;

                    return true;
                }
            }

            return false;
        }
Ejemplo n.º 10
0
        void AddItemToContainer(OwnedItemInformation addItem, int amount, bool isSave)
        {
            if (amount == -1)
            {
                amount = addItem.Amount;
                addItem.OwnerContainer = itemContainer;

                itemContainer.containerItems.Add(addItem);
                itemContainer.AddItemEvent(addItem, isSave);

            }
            else
            {
                addItem.Amount = amount;
                addItem.OwnerContainer = itemContainer;

                itemContainer.containerItems.Add(addItem);
                itemContainer.AddItemEvent(addItem, isSave);
            }
        }
        public static ContainerMoveState.ActionState AddItem(OwnedItemInformation addItem, ItemContainer targetContainer)
        {
            if (addItem.IsLocked)
                return ContainerMoveState.ActionState.No;

            ContainerMoveState targetAddState = targetContainer.GetContainerAddState(addItem);

            switch (targetAddState.ContainerActionState)
            {
                case ContainerMoveState.ActionState.Add:

                    targetContainer.Add(addItem, targetAddState.PossibleAddAmount);

                    break;
                case ContainerMoveState.ActionState.No:
                    break;
                default:
                    break;
            }

            return targetAddState.ContainerActionState;
        }
Ejemplo n.º 12
0
        public void AddItem(OwnedItemInformation addItem, int amount, bool isSave)
        {
            if (amount == -1 || amount > addItem.Amount)
            {
                amount = addItem.Amount;
                addItem.OwnerContainer = ItemContainer;

                if (!AddToExistingStack(addItem, addItem.Amount, isSave))
                {
                    ItemContainer.containerItems.Add(addItem);
                    ItemContainer.AddItemEvent(addItem, isSave);
                }
            }
            else
            {
                addItem.OwnerContainer = ItemContainer;
                if (!AddToExistingStack(addItem, amount, isSave))
                {
                    addItem.Amount = amount;
                    ItemContainer.containerItems.Add(addItem);
                    ItemContainer.AddItemEvent(addItem, isSave);
                }
            }
        }
 public virtual void ModifiedItem(OwnedItemInformation itemData, bool isSaving)
 {
     foreach (ItemDataDisplay display in currentDisplayObjects)
     {
         if (display.itemObject.itemData.IsSameItemAs(itemData))
         {
             display.SetAmountText(display.itemObject.itemData.Amount.ToString());
             return;
         }
     }
 }
        public string Setup()
        {
            item = GetComponent<ItemDataComponent>().itemData;
            string formated = "";

            foreach (DisaplyOption selectedOption in displayOptions)
            {
                switch (selectedOption)
                {
                    case DisaplyOption.name:
                        if (isQualityColorUsed)
                        {
                            formated += item.Information.Name;//.ToRichColor(ItemQuailityColorSelector.GetColorForItem(item));
                        }
                        else
                        {
                            formated += item.Information.Name;
                        }
                        break;
                    case DisaplyOption.stats:
                        //foreach (KeyValuePair<string, string> pair in item.Information.)
                        //{
                        //    if (pair.Key == "Not Available") continue;

                        //    formated = string.Format("{0}\n{1}: {2}", formated, pair.Key, pair.Value.ToString()/*.ToRichColor(Color.yellow)*/);
                        //}
                        //break;
                    case DisaplyOption.quantity:
                        formated = string.Format("{0}\n{1}", formated, item.Amount);
                        break;
                    case DisaplyOption.description:
                        if (!string.IsNullOrEmpty(item.Information.Description))
                        {
                            formated = string.Format("{0}\n{1}", formated, item.Information.Description);
                        }
                        break;

                    case DisaplyOption.tag:

                        string tags = "";
                        foreach (ItemInformation.Tag tg in item.Information.Tags)
                        {
                            if (string.IsNullOrEmpty(tags))
                            {
                                tags = tg.Name;
                            }
                            else
                            {
                                tags = string.Format("{0}, {1}", tags, tg);
                            }
                        }
                        if (item.Information.Tags.Count == 0)
                        {
                            if (ShowBlankLineForEmptySelection)
                                formated = string.Format("{0}\n");
                        }
                        else
                        {
                            formated = string.Format("{0}\n{1}", formated, tags);
                        }
                        break;
                    case DisaplyOption.behaviour:

                        foreach (ItemInformation.Behaviour behaviour in item.Information.Behaviours)
                        {
                            formated = string.Format("{0}\n{1}", formated, behaviour.Name);
                        }

                        if (item.Information.Behaviours.Count == 0 && ShowBlankLineForEmptySelection)
                        {
                            formated = string.Format("{0}\n", formated);
                        }
                        break;
                    case DisaplyOption.behaviourWithDescription:
                        foreach (ItemInformation.Behaviour behaviour in item.Information.Behaviours)
                        {
                            formated = string.Format("{0}\n{1}: {2}", formated, behaviour.Name/*.ToRichColor(Color.white)*/, behaviour.Id/*.ToRichColor(Color.grey)*/);
                        }
                        if (item.Information.Behaviours.Count == 0 && ShowBlankLineForEmptySelection)
                        {
                            formated = string.Format("{0}\n", formated);
                        }
                        break;
                    case DisaplyOption.space:
                        formated = string.Format("{0}\n", formated);
                        break;
                    case DisaplyOption.varianceID:
                        formated = string.Format("{0}\n{1}", formated, item.Information.Id);
                        break;
                    case DisaplyOption.itemID:
                        formated = string.Format("{0}\n{1}", formated, item.Information.CollectionId);
                        break;
                    case DisaplyOption.classID:
                        formated = string.Format("{0}\n{1}", formated, item.Information.ClassId);
                        break;
                    case DisaplyOption.energy:
                        formated = string.Format("{0}\n{1}", formated, item.Information.Energy);
                        break;
                    case DisaplyOption.stackID:
                        formated = string.Format("{0}\n{1}", formated, item.StackLocationId.ToString());
                        break;

                    default: break;
                }
            }
            return formated;
        }
Ejemplo n.º 15
0
 public void ModifiedItemEvent(OwnedItemInformation item, bool isSave)
 {
     if (ModifiedItem != null)
     {
         ModifiedItem(item, isSave);
     }
 }
 public virtual void RemovedItem(OwnedItemInformation itemData, int amount, bool arg3)
 {
     ItemDataDisplay selected = FindDisplayMatch(itemData);
     if (selected != null)
     {
         if (itemData.Amount <= 0)
         {
             currentDisplayObjects.Remove(selected);
             Destroy(selected.gameObject);
         }
     }
 }
Ejemplo n.º 17
0
        public void Remove(OwnedItemInformation itemData, bool isMoving, int amount = -1)
        {
            if (ItemContainerStackRestrictor.Restrictor != null)
            {
                if (restriction.IsRestricted(ContainerAction.remove))
                {
                    return;
                }
            }

            RemoveItem(itemData, isMoving, amount);
        }
Ejemplo n.º 18
0
 public void RemoveItemEvent(OwnedItemInformation item, int amount, bool isMoving)
 {
     if (RemovedItem != null)
     {
         RemovedItem(item, amount, isMoving);
     }
 }
        public static ContainerMoveState.ActionState RemoveItem(OwnedItemInformation RemoveItemData, ItemContainer TargetContainer)
        {
            if (RemoveItemData.IsLocked)
                return ContainerMoveState.ActionState.No;

            if (TargetContainer.GetContainerRemoveState(RemoveItemData).ContainerActionState == ContainerMoveState.ActionState.Remove)
            {
                TargetContainer.Remove(RemoveItemData, false, RemoveItemData.Amount);
                return ContainerMoveState.ActionState.Remove;
            }

            return ContainerMoveState.ActionState.No;
        }
Ejemplo n.º 20
0
 public virtual void SetData(OwnedItemInformation itemData)
 {
 }
Ejemplo n.º 21
0
        protected ContainerMoveState MyContainerAddState(OwnedItemInformation modified)
        {
            int addAbleAmount = modified.Amount;

            if (IsItemQuantityLimited == true)
            {
                foreach (OwnedItemInformation item in containerItems)
                {
                    if (item.IsSameItemAs(modified))
                    {
                        return new ContainerMoveState(ContainerMoveState.ActionState.No, 0);
                    }
                }

                if (addAbleAmount >= ItemQuantityLimit)
                    addAbleAmount = ItemQuantityLimit;
            }

            return new ContainerMoveState(ContainerMoveState.ActionState.Add, addAbleAmount);
        }
Ejemplo n.º 22
0
        protected void RemoveItem(OwnedItemInformation modified, bool isMoving, int amount = -1)
        {
            foreach (OwnedItemInformation item in containerItems)
            {
                if (item.IsSameItemAs(modified))
                {
                    if (amount == -1 || item.Amount <= amount)
                        containerItems.Remove(item);

                    modified.Amount -= amount;

                    RemoveItemEvent(item, amount, isMoving);
                    return;
                }
            }
            return;
        }
Ejemplo n.º 23
0
 public void Add(OwnedItemInformation itemData, int amount = -1, bool isSave = true)
 {
     ContainerAddAction.AddItem(itemData, amount, isSave);
 }