public override bool Remove(ItemSurrogate newItem)
{
for (int i = 0; i < Items.Count; i++)
{
ItemSlot slot = Items[i];
if (slot.Item == newItem)
{
slot.Item.RemoveAllReferenceSlots();
slot.Item = null;
if (OnSlotRemoved != null)
{
OnSlotRemoved(slot);
}
Items.Remove(slot);
return(true);
}
}
return(false);
}
public List <ItemSurrogate> Select()
{
if (cachedGeneratedItems == null)
{
cachedGeneratedItems = new List <ItemSurrogate> ();
}
cachedGeneratedItems.Clear();
for (int i = 0; i < TableRolls.Length; i++)
{
ItemGenerator itemGenerator = TableRolls[i].Select();
if (itemGenerator == null)
{
continue;
}
if (itemGenerator.RewardTemplate != null)
{
ItemSurrogate generatedItem = itemGenerator.Generate();
cachedGeneratedItems.Add(generatedItem);
}
}
return(cachedGeneratedItems);
}
public void ItemTooltip(RectTransform target, ItemSurrogate item)
{
currentTransform = target;
// fade.Value = 0.0f;
RenderTarget <ItemSurrogate> (item);
}
/// <summary>
/// Check if an item is valid in this slot
/// </summary>
/// <returns><c>true</c> if the item is valid in this slot; otherwise, <c>false</c>.</returns>
/// <param name="newItem">The item to compare.</param>
public bool IsValid (ItemSurrogate newItem)
{
if (Conditions == null)
return true;
return Conditions.IsValid (newItem);
}
public static void DropItem(Vector3 position, ItemSurrogate item)
{
ItemDrop drop = Instantiate(instance.DropPrefab) as ItemDrop;
drop.transform.position = position;
drop.SetItem(item);
}
private void SetTargetSlot(ItemSurrogate item)
{
if (item != null)
{
item.AddReferenceSlot(this);
item.OnReferenceChanged += DetachListener;
}
}
private void ActivateSlot()
{
ItemSurrogate item = manager.slot.Item;
if (item != null)
{
item.TryUse();
}
}
private void RemoveTargetSlot(ItemSurrogate item)
{
if (item != null)
{
item.OnReferenceChanged -= DetachListener;
item.RemoveReferenceSlot(this);
}
}
public void SetItem(ItemSurrogate _item)
{
item = _item;
GameObject render = Instantiate(item.Template.RenderPrefab, transform) as GameObject;
render.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
render.transform.position = transform.position;
}
/// <summary>
/// Check if an item is valid in this slot
/// </summary>
/// <returns><c>true</c> if the item is valid in this slot; otherwise, <c>false</c>.</returns>
/// <param name="newItem">The item to compare.</param>
public bool IsValid(ItemSurrogate newItem)
{
if (Conditions == null)
{
return(true);
}
return(Conditions.IsValid(newItem));
}
public void CheatItem(int index)
{
if (index >= CheatItems.Length)
{
throw new System.ArgumentOutOfRangeException("index", "The index provided is out of range.");
}
ItemGenerator generator = CheatItems[index];
ItemSurrogate item = generator.Generate();
Character.inventory.Add(item);
}
public static void DropItem(Vector3 position, ItemSurrogate item)
{
if (instance == null)
{
Debug.LogError("There is no ItemDropper in the world.");
return;
}
var drop = Instantiate(instance.DropPrefab) as ItemDrop;
drop.transform.position = position;
drop.SetItem(item);
}
public override void Swap(ItemSlot other)
{
// other is the start slot
// this is the end slot
if (other == null)
{
Return();
return;
}
if (!IsValid(other.Item))
{
return;
}
if (!other.IsValid(Item))
{
return;
}
if (other.Item == null)
{
ItemSurrogate swapItem = Item;
Item = null;
other.Item = swapItem;
return;
}
ItemSurrogate tempItem = other.Item;
other.Item = null;
AddResult result = Add(tempItem);
if (result == AddResult.None)
{
ItemSurrogate tempBItem = Item;
Item = null;
other.Item = tempBItem;
Item = tempItem;
}
else if (result == AddResult.Partial || result == AddResult.Referenced)
{
other.Item = tempItem;
}
}
public override bool IsValid(ItemSurrogate item)
{
if (item == null)
{
return(true);
}
for (int i = 0; i < slotTypes.Length; i++)
{
if (item.EquiptableSlot == slotTypes[i])
{
return(true);
}
}
return(false);
}
public static bool IsValid(this IEnumerable <ItemCondition> conditions, ItemSurrogate item)
{
if (conditions == null)
{
return(true);
}
foreach (ItemCondition condition in conditions)
{
if (!condition.IsValid(item))
{
return(false);
}
}
return(true);
}
public void RenderItem(ItemSurrogate item)
{
if (item == null)
{
RenderEmpty();
return;
}
lastItem = item;
lastTemplate = item.template;
if (rectTransform == null)
{
rectTransform = GetComponent <RectTransform> ();
}
if (Hovered && DisplayTooltip)
{
TooltipManager.instance.ItemTooltip(rectTransform, lastSlot);
}
RenderTemplate(item.Template);
if (quantityText != null)
{
if (HideQuantityOnOne && item.Quantity == 1)
{
quantityText.gameObject.SetActive(false);
}
else
{
quantityText.gameObject.SetActive(true);
quantityText.text = item.Quantity.ToString();
}
}
if (nameText != null)
{
nameText.gameObject.SetActive(true);
nameText.text = item.BaseName;
}
Faded = true;
}
public override AddResult Add(ItemSurrogate newItem)
{
if (Item == newItem)
{
return(AddResult.None);
}
if (!IsValid(newItem))
{
return(AddResult.None);
}
RemoveTargetSlot(Item);
SetTargetSlot(newItem);
Item = newItem;
return(AddResult.Referenced);
}
public void RenderEmpty()
{
if (slotImage != null)
{
slotImage.sprite = defaultSlotSprite;
}
iconImage.gameObject.SetActive(false);
if (currentObject != null)
{
Destroy(currentObject);
}
if (quantityText != null)
{
quantityText.gameObject.SetActive(false);
}
if (nameText != null)
{
nameText.gameObject.SetActive(false);
}
if (slotDecoration != null)
{
slotDecoration.gameObject.SetActive(false);
}
Faded = false;
if (Hovered)
{
TooltipManager.instance.Hide();
}
LastSlot = null;
lastItem = null;
lastTemplate = null;
}
public List <ItemSurrogate> SelectMultiple()
{
if (cachedGeneratedItems == null)
{
cachedGeneratedItems = new List <ItemSurrogate> ();
}
cachedGeneratedItems.Clear();
for (int i = 0; i < TableRolls.Length; i++)
{
ItemGenerator[] itemGenerator = TableRolls[i].SelectMultiple();
for (int x = 0; x < itemGenerator.Length; x++)
{
if (itemGenerator[x].RewardTemplate)
{
ItemSurrogate generatedItem = itemGenerator[x].Generate();
cachedGeneratedItems.Add(generatedItem);
}
}
}
return(cachedGeneratedItems);
}
public abstract bool IsValid(ItemSurrogate item);
public ItemReferenceSlot(RPGCharacter owner, ItemSlotBehaviour[] behaviours = null, ItemCondition[] conditions = null,
ItemSurrogate _defaultItem = null)
: base(owner, behaviours, conditions)
{
defaultItem = _defaultItem;
}
public void ItemTooltip(RectTransform target, ItemSurrogate item)
{
currentTransform = target;
RenderTarget(item);
}
public override AddResult Add(ItemSurrogate newItem)
{
List <ItemSlot> emptySlots = new List <ItemSlot> (Items.Count);
bool partiallyComplete = false;
for (int i = 0; i < Items.Count; i++)
{
ItemSlot slot = Items[i];
if (slot.Item == null)
{
emptySlots.Add(slot);
continue;
}
AddResult result = slot.Add(newItem);
if (result == AddResult.Complete)
{
if (OnAddItem != null)
{
OnAddItem();
}
return(AddResult.Complete);
}
else if (result == AddResult.Partial)
{
partiallyComplete = true;
}
}
for (int i = 0; i < emptySlots.Count; i++)
{
ItemSlot slot = emptySlots[i];
AddResult result = slot.Add(newItem);
if (result == AddResult.Complete)
{
if (OnAddItem != null)
{
OnAddItem();
}
return(AddResult.Complete);
}
else if (result == AddResult.Partial)
{
partiallyComplete = true;
}
}
if (partiallyComplete)
{
if (OnAddItem != null)
{
OnAddItem();
}
return(AddResult.Partial);
}
else
{
return(AddResult.None);
}
}
public override AddResult Add(ItemSurrogate newItem)
{
return(currentSlot.Add(newItem));
}
private void Start()
{
ItemSurrogate item = generator.Generate();
drop.SetItem(item);
}
/// <summary> /// Add an item to the slot. /// </summary> /// <param name="newItem">The new item to add.</param> public abstract AddResult Add (ItemSurrogate newItem);
public abstract bool Remove(ItemSurrogate newItem);
public override bool IsValid(ItemSurrogate item)
{
return(item != null);
}
public override AddResult Add(ItemSurrogate newItem)
{
List <ItemSlot> emptySlots = new List <ItemSlot> (Items.Count);
//bool partiallyComplete = false;
for (int i = 0; i < Items.Count; i++)
{
ItemSlot slot = Items[i];
if (slot.Item == null)
{
emptySlots.Add(slot);
continue;
}
AddResult result = slot.Add(newItem);
if (result == AddResult.Complete)
{
if (OnAddItem != null)
{
OnAddItem();
}
return(AddResult.Complete);
}
//else if (result == AddResult.Partial)
// partiallyComplete = true;
}
/*for (int i = 0; i < emptySlots.Count; i++)
* {
* ItemSlot slot = emptySlots [i];
*
* AddResult result = slot.Add (newItem);
*
* if (result == AddResult.Complete)
* {
* if (OnAddItem != null)
* OnAddItem ();
*
* return AddResult.Complete;
* }
* else if (result == AddResult.Partial)
* partiallyComplete = true;
* }*/
AddResult lastAddResult = AddResult.None;
while (lastAddResult != AddResult.Complete)
{
ItemSlot newSlot = AddSlot();
lastAddResult = newSlot.Add(newItem);
if (OnAddItem != null)
{
OnAddItem();
}
}
return(AddResult.Complete);
/*if (partiallyComplete)
* {
* if (OnAddItem != null)
* OnAddItem ();
*
* return AddResult.Partial;
* }
* else
* return AddResult.None;*/
}
public override AddResult Add(ItemSurrogate newItem)
{
if (!IsValid(newItem))
{
return(AddResult.None);
}
if (Item == null)
{
int amountCanAdd = Mathf.Min(newItem.template.StackSize, newItem.Quantity);
if (amountCanAdd == newItem.Quantity)
{
Item = newItem;
return(AddResult.Complete);
}
else if (amountCanAdd != 0)
{
newItem.Quantity -= amountCanAdd;
Item = newItem.Template.GenerateItem();
Item.Quantity += amountCanAdd - 1;
return(AddResult.Partial);
}
else
{
Item = newItem;
return(AddResult.Complete);
}
}
if (Item.template == newItem.template)
{
if (Item.template.StackSize == 0)
{
Item.Quantity += newItem.Quantity;
newItem.Quantity = 0;
return(AddResult.Complete);
}
int amountCanAdd = Mathf.Min(Item.template.StackSize - Item.Quantity, newItem.Quantity);
if (amountCanAdd != 0)
{
newItem.Quantity -= amountCanAdd;
Item.Quantity += amountCanAdd;
if (newItem.Quantity == 0)
{
return(AddResult.Complete);
}
else
{
return(AddResult.Partial);
}
}
else
{
return(AddResult.None);
}
}
//Check if stackable with previous stack
//Add item to slot
return(AddResult.None);
}
