/// <summary> /// Adds existing item. /// </summary> /// <returns>The item.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="limit">Limit.</param> public int AddExistingItem(StackItem stackItem, int limit) { int res = 0; if (stackItem != null) { // Init internal state (just in case it was not initted before) stackItem.Init(); StackGroup sourceStackGroup = AccessUtility.GetComponentInParent <StackGroup>(stackItem.transform); StackCell sourceStackCell = stackItem.GetStackCell(); StackGroupEventDescriptor desc = new StackGroupEventDescriptor(); // Try to distribute item inside group's items and cells DistributeResults distributeResults = DistributeAnywhere(stackItem, limit, null); res += distributeResults.amount; // Send stack event notification if (res > 0) { PlaySound(stackItem.sound); desc.sourceGroup = sourceStackGroup; desc.destinationGroup = this; desc.sourceCell = sourceStackCell; desc.destinationCells = distributeResults.cells; SendNotification(desc); } } return(res); }
/// <summary> /// Try to distribute item in similar items inside group. /// </summary> /// <returns>The in items.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="amount">Amount.</param> /// <param name="reservedStackCell">Reserved stack cell, excluded from calculation.</param> private int DistributeInItems(StackItem stackItem, int amount, StackCell reservedStackCell) { int res = 0; if (stackItem != null) { if (amount > 0) { foreach (StackCell stackCell in GetComponentsInChildren <StackCell>()) { if (stackCell != reservedStackCell) { if (amount > 0) { if (stackCell.HasSameItem(stackItem) == true) { int unitedPart = stackCell.UniteStack(stackItem, amount); res += unitedPart; amount -= unitedPart; } } else { break; } } } } } return(res); }
/// <summary> /// Swaps the stacks between cells. /// </summary> /// <returns><c>true</c>, if stacks was swaped, <c>false</c> otherwise.</returns> /// <param name="sourceStackCell">Source stack cell.</param> public bool SwapStacks(StackCell sourceStackCell) { print(6); bool res = false; if (sourceStackCell != null) { StackItem myStackItem = GetStackItem(); StackItem theirStackItem = sourceStackCell.GetStackItem(); if (myStackItem != null && theirStackItem != null) { if (SortCell.IsSortAllowed(gameObject, theirStackItem.gameObject) == true && SortCell.IsSortAllowed(sourceStackCell.gameObject, myStackItem.gameObject) == true) { if (cellStackLimit >= theirStackItem.GetStack() && sourceStackCell.cellStackLimit >= myStackItem.GetStack()) { DadCell.SwapItems(gameObject, sourceStackCell.gameObject); res = true; } } } } return(res); }
/// <summary> /// Try to distribute item in free cells inside group. /// </summary> /// <returns>The in cells.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="amount">Amount.</param> /// <param name="reservedStackCell">Reserved stack cell, excluded from calculation.</param> private int DistributeInCells(StackItem stackItem, int amount, StackCell reservedStackCell) { int res = 0; if (stackItem != null) { if (amount > 0) { foreach (StackCell emptyStackCell in GetFreeStackCells(stackItem)) { if (emptyStackCell != reservedStackCell) { int unitedPart = emptyStackCell.UniteStack(stackItem, amount); res += unitedPart; amount -= unitedPart; if (amount <= 0) { break; } } } } } return(res); }
/// <summary> /// On menu item select. /// </summary> static void Item() { StackCell res = null; if (Selection.activeGameObject != null) { res = AccessUtility.GetComponentInParent <StackCell>(Selection.activeGameObject.transform); } if (res != null) { // Create item from prefab string prefabName = "Demo/Item"; GameObject prefab = Resources.Load <GameObject>(prefabName); if (prefab != null) { GameObject go = Instantiate(prefab, res.transform); go.name = prefab.name; go.transform.SetAsFirstSibling(); } else { Debug.Log("Can't find needed prefab in Resources folder: " + prefabName); } } else { Debug.Log("Please choose any stack cell on scene before add this element"); } }
/// <summary> /// Try to distribute item in free cells inside group. /// </summary> /// <returns>Distribute result.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="amount">Amount.</param> /// <param name="reservedStackCell">Reserved stack cell, excluded from calculation.</param> private DistributeResults DistributeInCells(StackItem stackItem, int amount, StackCell reservedStackCell) { DistributeResults res = new DistributeResults(); if (stackItem != null) { if (amount > 0) { foreach (StackCell emptyStackCell in GetFreeStackCells(stackItem)) { if (emptyStackCell != reservedStackCell) { int unitedPart = emptyStackCell.UniteStack(stackItem, amount); if (unitedPart > 0) { res.amount += unitedPart; res.cells.Add(emptyStackCell); amount -= unitedPart; } if (amount <= 0) { break; } } } } } return(res); }
/// <summary> /// Try to distribute item in similar items inside group. /// </summary> /// <returns>Distribute result.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="amount">Amount.</param> /// <param name="reservedStackCell">Reserved stack cell, excluded from calculation.</param> private DistributeResults DistributeInItems(StackItem stackItem, int amount, StackCell reservedStackCell) { DistributeResults res = new DistributeResults(); if (stackItem != null) { if (amount > 0) { foreach (StackCell stackCell in GetComponentsInChildren <StackCell>(true)) { if (stackCell != reservedStackCell) { if (stackCell.HasSameItem(stackItem) == true) { int unitedPart = stackCell.UniteStack(stackItem, amount); if (unitedPart > 0) { res.amount += unitedPart; res.cells.Add(stackCell); amount -= unitedPart; } } if (amount <= 0) { break; } } } } } return(res); }
/// <summary> /// Calls the drag and drop event manually from script. /// </summary> /// <param name="sourceCell">Source cell.</param> /// <param name="destinationGroup">Destination group.</param> public void CallDadEventManually(StackCell sourceCell, StackGroup destinationGroup) { Init(); if (myState == MyState.WaitForRequest) { if (sourceCell != null && destinationGroup != null) { StackItem stackItem = sourceCell.GetStackItem(); StackCell destinationCell = null; if (stackItem != null) { List <StackCell> destinationCells = new List <StackCell>(); // Check for not full cells with same items foreach (StackItem similarStackItem in GetSimilarStackItems(stackItem)) { if (similarStackItem.name == stackItem.name) { StackCell similarStackCell = similarStackItem.GetStackCell(); if (similarStackCell.GetAllowedSpace() > 0) { destinationCell = similarStackCell; break; } } } if (destinationCell == null) { // Check for empty cells destinationCells = GetFreeStackCells(stackItem); if (destinationCells.Count > 0) { destinationCell = destinationCells[0]; } } if (destinationCell == null) { // Check for other cells with similar items foreach (StackItem similarStackItem in GetSimilarStackItems(stackItem)) { if (similarStackItem.name != stackItem.name) { destinationCell = similarStackItem.GetStackCell(); break; } } } if (destinationCell != null) { CallDadEventManually(sourceCell, destinationCell); } } } } }
/// <summary> /// Removes the item. /// </summary> /// <param name="stackCell">Stack cell.</param> /// <param name="limit">Limit.</param> public void RemoveItem(StackCell stackCell, int limit) { if (stackCell != null) { StackItem stackItem = stackCell.GetStackItem(); if (stackItem != null) { RemoveItem(stackItem, limit); } } }
/// <summary> /// Try to distribute between items than between free cells. /// </summary> /// <returns>The anywhere.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="amount">Amount.</param> /// <param name="reservedStackCell">Reserved stack cell, excluded from calculation.</param> private int DistributeAnywhere(StackItem stackItem, int amount, StackCell reservedStackCell) { int res = 0; res += DistributeInItems(stackItem, amount, reservedStackCell); amount -= res; if (amount > 0) { res += DistributeInCells(stackItem, amount, reservedStackCell); } return(res); }
/// <summary> /// Raises the item click event. /// </summary> /// <param name="item">Item.</param> public void OnItemUse(GameObject item) { if (destinationGroup != null && item != null) { StackItem stackItem = item.GetComponent <StackItem>(); if (stackItem != null) { StackCell sourceCell = stackItem.GetStackCell(); destinationGroup.CallDadEventManually(sourceCell, destinationGroup); } } }
/// <summary> /// Distribute destination item in source group than place source item in just vacated cell. /// </summary> /// <returns><c>true</c>, if item was replaced, <c>false</c> otherwise.</returns> /// <param name="sourceStackItem">Source stack item.</param> /// <param name="destinationStackItem">Destination stack item.</param> public bool ReplaceItems(StackItem sourceStackItem, StackItem destinationStackItem) { bool res = false; StackCell sourceStackCell = sourceStackItem.GetStackCell(); StackCell destinationStackCell = destinationStackItem.GetStackCell(); StackGroup sourceStackGroup = AccessUtility.GetComponentInParent <StackGroup>(sourceStackItem.transform); if (sourceStackItem != null && destinationStackItem != null && sourceStackCell != null && destinationStackCell != null && sourceStackGroup != null) { StackGroupEventDescriptor distributeDesc = new StackGroupEventDescriptor(); StackGroupEventDescriptor swapDesc = new StackGroupEventDescriptor(); // Try distribute item from destination cell into source group DistributeResults distributeResults = sourceStackGroup.DistributeAnywhere(destinationStackItem, destinationStackItem.GetStack(), null); if (distributeResults.amount > 0) { distributeDesc.sourceGroup = this; distributeDesc.destinationGroup = sourceStackGroup; distributeDesc.sourceCell = destinationStackCell; distributeDesc.destinationCells = distributeResults.cells; // If destination cell is empty now if (destinationStackCell.GetStackItem() == null) { // Place source item into it if (destinationStackCell.UniteStack(sourceStackItem, sourceStackItem.GetStack()) > 0) { PlaySound(sourceStackItem.sound); swapDesc.sourceGroup = sourceStackGroup; swapDesc.destinationGroup = this; swapDesc.sourceCell = sourceStackCell; swapDesc.destinationCells.Add(destinationStackCell); res = true; } } } if (distributeResults.amount > 0) { // Send distribute stack event notification SendNotification(distributeDesc); if (res == true) { // Send swap stack item event notification SendNotification(swapDesc); } } } return(res); }
/// <summary> /// Calls the drag and drop event manually from script. /// </summary> /// <param name="sourceCell">Source cell.</param> /// <param name="destinationCell">Destination cell.</param> public void CallDadEventManually(StackCell sourceCell, StackCell destinationCell) { if (myState == MyState.WaitForRequest) { if (sourceCell != null && destinationCell != null) { DadCell.DadEventDescriptor desc = new DadCell.DadEventDescriptor(); desc.sourceCell = sourceCell.GetComponent <DadCell>(); desc.destinationCell = destinationCell.GetComponent <DadCell>(); myState = MyState.Busy; // Operate item's drop eventHandkerCoroutine = coroutineContainer.StartCoroutine(EventHandler(desc)); } } }
/// <summary> /// Stack event handler. /// </summary> /// <returns>The handler.</returns> /// <param name="desc">Desc.</param> private IEnumerator EventHandler(DadCell.DadEventDescriptor desc) { StackGroup sourceStackGroup = desc.sourceCell.GetComponentInParent <StackGroup>(); StackGroup destStackGroup = desc.destinationCell.GetComponentInParent <StackGroup>(); StackCell myStackCell = desc.destinationCell.GetComponent <StackCell>(); StackCell theirStackCell = desc.sourceCell.GetComponent <StackCell>(); StackItem myStackItem = myStackCell.GetStackItem(); StackItem theirStackItem = theirStackCell.GetStackItem(); //AudioClip itemSound = theirStackItem.sound; // Item's SFX //int amount = theirStackItem.GetStack(); // Item's stack amount yield return(0); }
/// <summary> /// Removes the item. /// </summary> /// <param name="stackItem">Stack item.</param> /// <param name="limit">Limit.</param> public void RemoveItem(StackItem stackItem, int limit) { if (stackItem != null) { StackCell stackCell = stackItem.GetStackCell(); PlaySound(trashBinSound); stackItem.ReduceStack(limit); StackGroupEventDescriptor desc = new StackGroupEventDescriptor(); desc.sourceGroup = this; desc.destinationGroup = this; desc.sourceCell = stackCell; desc.destinationCells.Add(stackCell); SendNotification(desc); } }
/// <summary> /// Swap items between groups. /// </summary> /// <returns><c>true</c>, if item was replaced, <c>false</c> otherwise.</returns> /// <param name="currentStackItem">Current stack item.</param> /// <param name="sourceStackItem">Source stack item.</param> /// <param name="sourceStackGroup">Source stack group.</param> public bool ReplaceItems(StackItem currentStackItem, StackItem sourceStackItem, StackGroup sourceStackGroup) { bool res = false; if (currentStackItem != null && sourceStackItem != null && sourceStackGroup != null) { StackCell currentStackCell = currentStackItem.GetStackCell(); sourceStackGroup.DistributeAnywhere(currentStackItem, currentStackItem.GetStack(), null); if (currentStackCell.GetStackItem() == null) { currentStackCell.UniteStack(sourceStackItem, sourceStackItem.GetStack()); PlaySound(sourceStackItem.sound); res = true; } // Send stack event notification SendNotification(sourceStackGroup.gameObject, gameObject); } return(res); }
public void ClearInv() { print("ClearInv() =========="); printDadCells(); for (int i = 0; i < dadCells.Length; i++) { int stack = 0; StackCell stackCell = dadCells[i].GetComponentInParent <StackCell>(); DadItem dadItem = dadCells[i].GetComponentInChildren <DadItem>(); StackItem stackItem = dadCells[i].GetComponentInChildren <StackItem>(); if (dadItem != null) { stack = stackItem.GetStack(); print(i + " : removing in ClearInv() , " + stackItem + stack); stackGroup.RemoveItem(stackItem, stack); print(i + " : removed in ClearInv() , " + stackItem); } } }
/// <summary> /// Try to distribute between items than between free cells. /// </summary> /// <returns>Distribute result.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="amount">Amount.</param> /// <param name="reservedStackCell">Reserved stack cell, excluded from calculation.</param> private DistributeResults DistributeAnywhere(StackItem stackItem, int amount, StackCell reservedStackCell) { DistributeResults res = new DistributeResults(); res = DistributeInItems(stackItem, amount, reservedStackCell); amount -= res.amount; if (amount > 0) { DistributeResults distributeInCells = new DistributeResults(); distributeInCells = DistributeInCells(stackItem, amount, reservedStackCell); if (distributeInCells.amount > 0) { res.amount += distributeInCells.amount; foreach (StackCell cell in distributeInCells.cells) { res.cells.Add(cell); } } } return(res); }
/// <summary> /// Stack event handler. /// </summary> /// <returns>The handler.</returns> /// <param name="desc">Desc.</param> private IEnumerator EventHandler(DadCell.DadEventDescriptor desc) { StackGroup sourceStackGroup = desc.sourceCell.GetComponentInParent <StackGroup>(); StackGroup destStackGroup = desc.destinationCell.GetComponentInParent <StackGroup>(); StackCell myStackCell = desc.destinationCell.GetComponent <StackCell>(); StackCell theirStackCell = desc.sourceCell.GetComponent <StackCell>(); StackItem myStackItem = myStackCell.GetStackItem(); StackItem theirStackItem = theirStackCell.GetStackItem(); PriceItem priceItem = theirStackItem.GetComponent <PriceItem>(); PriceGroup buyer = desc.destinationCell.GetComponentInParent <PriceGroup>(); PriceGroup seller = desc.sourceCell.GetComponentInParent <PriceGroup>(); AudioClip itemSound = theirStackItem.sound; // Item's SFX int amount = theirStackItem.GetStack(); // Item's stack amount if ((globalSplit == true) || (sourceStackGroup != destStackGroup && (sourceStackGroup.splitOuter == true || destStackGroup.splitOuter == true))) { // Need to use split interface if (splitInterface != null) { if (priceItem != null && buyer != null && seller != null && buyer != seller) { // Split with prices splitInterface.ShowSplitter(theirStackItem, priceItem); } else { // Split without prices splitInterface.ShowSplitter(theirStackItem, null); } // Show split interface and wait while it is active while (splitInterface.gameObject.activeSelf == true) { yield return(new WaitForEndOfFrame()); } // Get splitted stack amount amount = splitInterface.GetRightAmount(); } } if (amount > 0) { if (sourceStackGroup != destStackGroup && (destStackGroup.arrangeMode == true || sourceStackGroup.arrangeMode == true)) { // Split ain arrange mode between different stack groups if (priceItem != null && buyer != null && seller != null && buyer != seller) { // Different price groups if (buyer.GetCash() > priceItem.GetPrice() * amount) { // Has anough cash int distributed = DistributeAnywhere(theirStackItem, amount, null); if (distributed > 0) { int totalPrice = priceItem.GetPrice() * distributed; seller.AddCash(totalPrice); buyer.SpendCash(totalPrice); buyer.UpdatePrices(); } } } else { // Same price group DistributeAnywhere(theirStackItem, amount, null); } } else { // Inside same stack group transactions disabled in arrange mode if (arrangeMode == false) { if (myStackItem != null) { // Check if items allowed for cells if (SortCell.IsSortAllowed(myStackCell.gameObject, theirStackItem.gameObject) == true && SortCell.IsSortAllowed(theirStackCell.gameObject, myStackItem.gameObject) == true) { // Destination cell already has item if (myStackCell.HasSameItem(theirStackItem) == true) { // Same item myStackCell.UniteStack(theirStackItem, amount); } else { // Different items. Try to swap items between cells if (myStackCell.SwapStacks(theirStackCell) == true) { // Swap successful theirStackItem = theirStackCell.GetStackItem(); if (theirStackItem != null) { // Distribute item after swap DistributeInItems(theirStackItem, theirStackItem.GetStack(), theirStackCell); } } else { // Swap unsuccessful. // Try to distribute item between other cells to make cell free DistributeAnywhere(myStackItem, myStackItem.GetStack(), myStackCell); myStackItem = myStackCell.GetStackItem(); if (myStackItem != null) { // Item still in cell. Try to place item in other group's cells sourceStackGroup.DistributeAnywhere(myStackItem, myStackItem.GetStack(), null); myStackItem = myStackCell.GetStackItem(); if (myStackItem == null) { // Item was placed into other cell and now this cell is free // Place item into destination cell myStackCell.UniteStack(theirStackItem, amount); } } else { // Item was placed into other cell and now this cell is free // Place item into destination cell myStackCell.UniteStack(theirStackItem, amount); } } } } } else { // Destination cell has no item // Place item into destination cell myStackCell.UniteStack(theirStackItem, amount); } } } } // Send stack event notification SendNotification(sourceStackGroup.gameObject, destStackGroup.gameObject); if (trashBinMode == true) { // In trash bin mode just destroy item desc.destinationCell.RemoveItem(); PlaySound(trashBinSound); } else { audioSource.PlayOneShot(itemSound); } myState = MyState.WaitForRequest; }
void Start() { stackCell = GetComponent <StackCell>(); }
/// <summary> /// Stack event handler. /// </summary> /// <returns>The handler.</returns> /// <param name="desc">Desc.</param> private IEnumerator EventHandler(DadCell.DadEventDescriptor dadDesc) { StackGroup sourceStackGroup = AccessUtility.GetComponentInParent <StackGroup>(dadDesc.sourceCell.transform); StackGroup destStackGroup = AccessUtility.GetComponentInParent <StackGroup>(dadDesc.destinationCell.transform); if (sourceStackGroup == null || destStackGroup == null) { dadDesc.groupPermission = false; myState = MyState.WaitForRequest; yield break; } StackCell destStackCell = dadDesc.destinationCell.GetComponent <StackCell>(); StackCell sourceStackCell = dadDesc.sourceCell.GetComponent <StackCell>(); if (destStackCell == null || sourceStackCell == null) { dadDesc.groupPermission = false; myState = MyState.WaitForRequest; yield break; } StackItem destStackItem = destStackCell.GetStackItem(); StackItem sourceStackItem = sourceStackCell.GetStackItem(); StackGroupEventDescriptor stackDescPrimary = new StackGroupEventDescriptor(); // Stack event info stackDescPrimary.sourceGroup = sourceStackGroup; stackDescPrimary.destinationGroup = destStackGroup; stackDescPrimary.sourceCell = sourceStackCell; StackGroupEventDescriptor stackDescSecondary = new StackGroupEventDescriptor(); // One more stack event info in case if destination cell is not empty and items were swapped stackDescSecondary.sourceGroup = destStackGroup; stackDescSecondary.destinationGroup = sourceStackGroup; stackDescSecondary.sourceCell = destStackCell; DistributeResults distributeResults = new DistributeResults(); // Info with results of stack item distribution in stack group PriceItem priceItem = sourceStackItem.GetComponent <PriceItem>(); PriceGroup buyer = AccessUtility.GetComponentInParent <PriceGroup>(dadDesc.destinationCell.transform); PriceGroup seller = AccessUtility.GetComponentInParent <PriceGroup>(dadDesc.sourceCell.transform); AudioClip itemSound = sourceStackItem.sound; // Item's SFX int amount = sourceStackItem.GetStack(); // Item's stack amount if (amount > 1) { // If item's stack > 1 try to use split interface if ((globalSplit == true) || (sourceStackGroup != destStackGroup && (sourceStackGroup.splitOuter == true || destStackGroup.splitOuter == true))) { // Need to use split interface if (splitInterface != null) { if (priceItem != null && buyer != null && seller != null && buyer != seller) { // Split with prices splitInterface.ShowSplitter(sourceStackItem, priceItem); } else { // Split without prices splitInterface.ShowSplitter(sourceStackItem, null); } // Show split interface and wait while it is active while (splitInterface.gameObject.activeSelf == true) { yield return(new WaitForEndOfFrame()); } // Get splitted stack amount amount = splitInterface.GetRightAmount(); } } } if (amount > 0) { if (sourceStackGroup != destStackGroup && (destStackGroup.arrangeMode == true || sourceStackGroup.arrangeMode == true)) { // Split in arrange mode between different stack groups if (priceItem != null && buyer != null && seller != null && buyer != seller) { // Different price groups if ((long)buyer.GetCash() >= (long)priceItem.GetPrice() * amount) { // Has anough cash distributeResults = DistributeAnywhere(sourceStackItem, amount, null); if (distributeResults.amount > 0) { stackDescPrimary.destinationCells = distributeResults.cells; int totalPrice = priceItem.GetPrice() * distributeResults.amount; seller.AddCash(totalPrice); buyer.SpendCash(totalPrice); buyer.UpdatePrices(); } } } else { // Same price group distributeResults = DistributeAnywhere(sourceStackItem, amount, null); if (distributeResults.amount > 0) { stackDescPrimary.destinationCells = distributeResults.cells; } } } else { // Inside same stack group transactions disabled in arrange mode if (arrangeMode == false) { if (destStackItem != null) { // Check if items allowed for destination cell if (SortCell.IsSortAllowed(destStackCell.gameObject, sourceStackItem.gameObject) == true) { // Destination cell already has same item if (destStackCell.HasSameItem(sourceStackItem) == true) { if (destStackCell.UniteStack(sourceStackItem, amount) > 0) { stackDescPrimary.destinationCells.Add(destStackCell); } } // Check if items allowed for source cell else if (SortCell.IsSortAllowed(sourceStackCell.gameObject, destStackItem.gameObject) == true) { // Different items. Try to swap items between cells if (destStackCell.SwapStacks(sourceStackCell) == true) { // Swap successful stackDescSecondary.destinationCells.Add(sourceStackCell); sourceStackItem = sourceStackCell.GetStackItem(); if (sourceStackItem != null) { // Distribute item after swap distributeResults = DistributeInItems(sourceStackItem, sourceStackItem.GetStack(), destStackCell); if (distributeResults.amount > 0) { stackDescPrimary.destinationCells = distributeResults.cells; } if (destStackCell.GetStackItem() != null) { // If stack item (or part of it) in destination cell stackDescPrimary.destinationCells.Add(destStackCell); } } } else { // Swap unsuccessful. // Try to distribute item between other cells to make cell free distributeResults = DistributeAnywhere(destStackItem, destStackItem.GetStack(), destStackCell); if (distributeResults.amount > 0) { stackDescSecondary.destinationCells = distributeResults.cells; } destStackItem = destStackCell.GetStackItem(); if (destStackItem != null) { // Item still in cell. Try to place item in other group's cells distributeResults = sourceStackGroup.DistributeAnywhere(destStackItem, destStackItem.GetStack(), null); if (distributeResults.amount > 0) { stackDescSecondary.destinationCells.AddRange(distributeResults.cells); } destStackItem = destStackCell.GetStackItem(); if (destStackItem == null) { // Item was placed into other cell and now this cell is free // Place item into destination cell if (destStackCell.UniteStack(sourceStackItem, amount) > 0) { stackDescPrimary.destinationCells.Add(destStackCell); } } } else { // Item was placed into other cell and now this cell is free // Place item into destination cell if (destStackCell.UniteStack(sourceStackItem, amount) > 0) { stackDescPrimary.destinationCells.Add(destStackCell); } } } } } } else { // Destination cell has no item // Place item into destination cell if (destStackCell.UniteStack(sourceStackItem, amount) > 0) { stackDescPrimary.destinationCells.Add(destStackCell); } } } } } // Send stack event notifications if (stackDescSecondary.destinationCells.Count > 0) { SendNotification(stackDescSecondary); } if (stackDescPrimary.destinationCells.Count > 0) { SendNotification(stackDescPrimary); if (trashBinMode == true) { // In trash bin mode just destroy item dadDesc.destinationCell.RemoveItem(); PlaySound(trashBinSound); } else { PlaySound(itemSound); } } myState = MyState.WaitForRequest; eventHandkerCoroutine = null; }