/// <summary> /// Stacks the attached item onto the other item and returns true if it was stacked. /// </summary> /// <param name="other">The item that will act as the stack.</param> /// <returns>True if attached item was stacked onto other item, otherwise false.</returns> public bool AvoidSwap(ISwappable other) { // if the other swappable is an item if (other.GetType() == typeof(Item)) { // cast the swappable to an item Item otherItem = (Item)other; // if the item types are the same we can potentially stack them if (otherItem.itemType == itemType) { int remainder = stackItems(this, otherItem); if (remainder == 0) { UnityEngine.Object.Destroy(Icon.gameObject); return(true); } else { SubtractFromAmt(int.MaxValue); AddToAmt(remainder); return(true); } } return(false); } Debug.Log("Avoid"); return(true); }
public void DestroyAttachedSwappable() { if (attachedSwappable != null) { attachedSwappable.OnDestroy(); attachedSwappable = null; } }
public void SetSwap(ISwappable <T> swapUnit1, ISwappable <T> swapUnit2) { // swap if the new one is not the same as the current one if (swapUnit1 != swapUnit2) { T temp = swapUnit1.SwapData; swapUnit1.SwapData = swapUnit2.SwapData; swapUnit2.SwapData = temp; } }
public void SetAttachedSwappable(ISwappable _attachedSwappable) { attachedSwappable = _attachedSwappable; // set a new parent so it appears over all slots attachedSwappable.Icon.transform.SetParent(movementParent); // make sure it isn't clickable attachedSwappable.Icon.raycastTarget = false; }
public void Swap(ISwappable swapWith) { if (base.ContainsKey(swapWith.OldKey)) { base.Remove(swapWith.OldKey); this.Add(swapWith.AsNewPair()); } else { throw new KeyNotFoundException(string.Format(ERR_MSG, swapWith.OldKey)); } }
public void Swap(string newKey, StringComparison comparison = CASESENSITIVE) { if (this.TryGetKvp(newKey, comparison, out KeyValuePair <string, object> foundKvp)) { ISwappable iswap = DictionarySwap.New(newKey, foundKvp); this.Swap(iswap); } else { throw new KeyNotFoundException(string.Format(ERR_MSG, newKey)); } }
private void ReplaceParameters(ref SwappableDictionary swapd) { foreach (KeyValuePair <string, string> kvp in Opposites) { if (swapd.ContainsKey(kvp.Key)) { bool val = !((SwitchParameter)swapd[kvp.Key]).ToBool(); ISwappable swap = swapd.NewSwappable(kvp.Value, kvp.Key); swapd.Swap(swap); swapd[kvp.Value] = val; } } }
private bool CompareSwappables(ISwappable exp1, BinaryOperator exp2) { if ((exp1 as BinaryOperator).Left is ISwappable || (exp1 as BinaryOperator).Right is ISwappable) { return(SwappableCompareAlgorithem(exp1, exp2)); } else if (CompareSides(exp1 as BinaryOperator, exp2) || CompareSides(exp1.Swap().Reduce() as BinaryOperator, exp2)) { return(true); } return(false); }
private void OpenSellPanel() { // get the swappable attached to the mouse ISwappable swappable = swapManager.GetAttachedSwappable(); // if there is a swappable and its an item if (swappable != null && swappable.GetType() == typeof(Item)) { // open the sell panel with that item. Item item = (Item)swappable; Shop.OpenSellPanel(item); // return the attached item back to its slot swapManager.StopSwap(); } }
private bool SwappableCompareAlgorithem(ISwappable exp1, BinaryOperator exp2) { BinaryOperator modified = (exp1 as BinaryOperator).Clone() as BinaryOperator; if (modified.ToStringParent() == exp2.ToStringParent()) { return(true); } //Transforms modified until modified == exp2 or modified == exp1 //When modified == exp2 then exp1s result is the same as exp2, aka they are the same //When modified == exp1 then the loop is done, and it found no matching trees. do { //First, transform modified. modified = (modified as ISwappable).Transform(); if (modified.ToStringParent() == exp2.ToStringParent()) { return(true); } //Second, swap one of the swappable sides. if (modified.Left is ISwappable) { modified.Left = (modified.Left as ISwappable).Swap(); if (modified.ToStringParent() == exp2.ToStringParent()) { return(true); } } else if (modified.Right is ISwappable) { modified.Right = (modified.Right as ISwappable).Swap(); if (modified.ToStringParent() == exp2.ToStringParent()) { return(true); } } } while (!(modified.ToStringParent() == exp1.ToStringParent())); return(false); }
/// <summary> /// Swaps the positions of 1-2 item <see cref="Image"/>'s in the inventory UI. /// <para> /// If there is an empty slot that can hold an item, other is null and a slotHandler must be given. /// </para> /// </summary> /// <param name="otherSlotIndex">The slot index of the other item</param> /// <param name="other">The other item that will be swapped with the <see cref="attachedSwappable"/></param> /// <param name="slotHandler">Used to move the attached item to the correct empty slot</param> public void SwapPositions(int otherSlotIndex, ISwappable other, SlotsHandler slotHandler = null) { if (other != null) { if (attachedSwappable.AvoidSwap(other)) { return; } SlotsHandler attachedSlotHandler = attachedSwappable.SlotsHandler; // move other swappable to the attached swappables slot int temp_idx = attachedSwappable.SlotIndex; other.SlotIndex = attachedSwappable.SlotIndex; attachedSlotHandler.MoveImageToSlot(other.Icon.gameObject, temp_idx); // move attached swappable to the other swappables slot attachedSwappable.SlotIndex = otherSlotIndex; other.SlotsHandler.MoveImageToSlot(attachedSwappable.Icon.gameObject, otherSlotIndex); // swap which slot handler they will reference SlotsHandler temp_slots = attachedSlotHandler; attachedSwappable.SlotsHandler = other.SlotsHandler; other.SlotsHandler = temp_slots; } else { // move attached swappable to the empty slot attachedSwappable.SlotIndex = otherSlotIndex; slotHandler.MoveImageToSlot(attachedSwappable.Icon.gameObject, otherSlotIndex); // assign the slot handler of the empty slot to the attached swappable. attachedSwappable.SlotsHandler = slotHandler; } ResetAttachedSwappable(); }
public void SetSwappable(ISwappable swappable) => Swappable = swappable;
private void ResetAttachedSwappable() { // make it clickable again attachedSwappable.Icon.raycastTarget = true; attachedSwappable = null; }