public override int TryPutInto(ItemSlot sinkSlot, ref ItemStackMoveOperation op) { if (!sinkSlot.CanTakeFrom(this) || !CanTake() || Itemstack == null) { return(0); } // Fill up sink slot if (op.ShiftDown) { if (Empty) { return(0); } int maxstacksize = Itemstack.Collectible.MaxStackSize; if (sinkSlot.Itemstack == null) { op.RequestedQuantity = maxstacksize; } else { op.RequestedQuantity = maxstacksize - sinkSlot.StackSize; } } // Fill the destination slot with as many items as we can if (sinkSlot.Itemstack == null) { sinkSlot.Itemstack = TakeOut(op.RequestedQuantity); sinkSlot.OnItemSlotModified(sinkSlot.Itemstack); op.MovedQuantity = sinkSlot.StackSize; return(op.MovedQuantity); } ItemStack ownStack = Itemstack.Clone(); ItemStackMergeOperation mergeop = op.ToMergeOperation(sinkSlot, this); op = mergeop; sinkSlot.Itemstack.Collectible.TryMergeStacks(mergeop); // Ignore any changes made to our slot Itemstack = ownStack; sinkSlot.OnItemSlotModified(sinkSlot.Itemstack); return(op.MovedQuantity); }
/// <summary> /// Returns the quantity of items that were not merged (left over in the source slot) /// </summary> /// <param name="sinkSlot"></param> /// <param name="op"></param> /// <returns>Amount of moved items</returns> public virtual int TryPutInto(ItemSlot sinkSlot, ref ItemStackMoveOperation op) { if (!sinkSlot.CanTakeFrom(this) || !CanTake() || itemstack == null) { return(0); } if (sinkSlot.inventory?.CanContain(sinkSlot, this) == false) { return(0); } // Fill the destination slot with as many items as we can if (sinkSlot.Itemstack == null) { int q = Math.Min(sinkSlot.GetRemainingSlotSpace(itemstack), op.RequestedQuantity); if (q > 0) { sinkSlot.Itemstack = TakeOut(q); // Has to be above the modified calls because e.g. when moving stuff into the ground slot this will eject the item // onto the ground and sinkSlot.StackSize is 0 right after op.MovedQuantity = op.MovableQuantity = Math.Min(sinkSlot.StackSize, q); sinkSlot.OnItemSlotModified(sinkSlot.Itemstack); OnItemSlotModified(sinkSlot.Itemstack); } return(op.MovedQuantity); } ItemStackMergeOperation mergeop = op.ToMergeOperation(sinkSlot, this); op = mergeop; int origRequestedQuantity = op.RequestedQuantity; op.RequestedQuantity = Math.Min(sinkSlot.GetRemainingSlotSpace(itemstack), op.RequestedQuantity); sinkSlot.Itemstack.Collectible.TryMergeStacks(mergeop); if (mergeop.MovedQuantity > 0) { sinkSlot.OnItemSlotModified(sinkSlot.Itemstack); OnItemSlotModified(sinkSlot.Itemstack); } op.RequestedQuantity = origRequestedQuantity; //ensures op.NotMovedQuantity will be correct in calling code if used with slots with limited slot maxStackSize, e.g. InventorySmelting with a cooking container has slots with maxStackSize == 6 return(mergeop.MovedQuantity); }
/// <summary> /// Activates the left click functions of the given slot. /// </summary> /// <param name="sourceSlot"></param> /// <param name="op"></param> protected virtual void ActivateSlotLeftClick(ItemSlot sourceSlot, ref ItemStackMoveOperation op) { // 1. Current slot empty: Take items if (Empty) { if (!CanHold(sourceSlot)) { return; } int q = Math.Min(sourceSlot.StackSize, MaxSlotStackSize); q = Math.Min(q, GetRemainingSlotSpace(sourceSlot.itemstack)); itemstack = sourceSlot.TakeOut(q); op.MovedQuantity = itemstack.StackSize; OnItemSlotModified(itemstack); return; } // 2. Current slot non empty, source slot empty: Put items if (sourceSlot.Empty) { op.RequestedQuantity = StackSize; TryPutInto(sourceSlot, ref op); return; } // 3. Both slots not empty, and they are stackable: Fill slot int maxq = itemstack.Collectible.GetMergableQuantity(itemstack, sourceSlot.itemstack, op.CurrentPriority); if (maxq > 0) { int origRequestedQuantity = op.RequestedQuantity; op.RequestedQuantity = GameMath.Min(maxq, sourceSlot.itemstack.StackSize, GetRemainingSlotSpace(sourceSlot.itemstack)); ItemStackMergeOperation mergeop = op.ToMergeOperation(this, sourceSlot); op = mergeop; itemstack.Collectible.TryMergeStacks(mergeop); sourceSlot.OnItemSlotModified(itemstack); OnItemSlotModified(itemstack); op.RequestedQuantity = origRequestedQuantity; //ensures op.NotMovedQuantity will be correct in calling code if used with slots with limited slot maxStackSize, e.g. InventorySmelting with a cooking container has slots with maxStackSize == 6 return; } // 4. Both slots not empty and not stackable: Exchange items TryFlipWith(sourceSlot); }
/// <summary> /// Activates the left click functions of the given slot. /// </summary> /// <param name="sourceSlot"></param> /// <param name="op"></param> protected virtual void ActivateSlotLeftClick(ItemSlot sourceSlot, ref ItemStackMoveOperation op) { // 1. Current slot empty: Take items if (Empty) { if (!CanHold(sourceSlot)) { return; } itemstack = sourceSlot.TakeOut(Math.Min(sourceSlot.StackSize, MaxSlotStackSize)); op.MovedQuantity = itemstack.StackSize; OnItemSlotModified(itemstack); return; } // 2. Current slot non empty, source slot empty: Put items if (sourceSlot.Empty) { op.RequestedQuantity = StackSize; TryPutInto(sourceSlot, ref op); return; } // 3. Both slots not empty, and they are stackable: Fill slot int maxq = itemstack.Collectible.GetMergableQuantity(itemstack, sourceSlot.itemstack, op.CurrentPriority); if (maxq > 0) { op.RequestedQuantity = GameMath.Min(maxq, sourceSlot.itemstack.StackSize, RemainingSlotSpace); ItemStackMergeOperation mergeop = op.ToMergeOperation(this, sourceSlot); op = mergeop; itemstack.Collectible.TryMergeStacks(mergeop); sourceSlot.OnItemSlotModified(itemstack); OnItemSlotModified(itemstack); return; } // 4. Both slots not empty and not stackable: Exchange items TryFlipWith(sourceSlot); }
/// <summary> /// Returns the quantity of items that were not merged (left over in the source slot) /// </summary> /// <param name="sinkSlot"></param> /// <param name="op"></param> /// <returns>Amount of moved items</returns> public virtual int TryPutInto(ItemSlot sinkSlot, ref ItemStackMoveOperation op) { if (!sinkSlot.CanTakeFrom(this) || !CanTake() || itemstack == null) { return(0); } // Fill the destination slot with as many items as we can if (sinkSlot.Itemstack == null) { int q = Math.Min(sinkSlot.RemainingSlotSpace, op.RequestedQuantity); if (q > 0) { sinkSlot.Itemstack = TakeOut(q); // Has to be above the modified calls because e.g. when moving stuff into the ground slot this will eject the item // onto the ground and sinkSlot.StackSize is 0 right after op.MovedQuantity = op.MovableQuantity = Math.Min(sinkSlot.StackSize, q); sinkSlot.OnItemSlotModified(sinkSlot.Itemstack); OnItemSlotModified(sinkSlot.Itemstack); } return(op.MovedQuantity); } ItemStackMergeOperation mergeop = op.ToMergeOperation(sinkSlot, this); op = mergeop; op.RequestedQuantity = Math.Min(sinkSlot.RemainingSlotSpace, op.RequestedQuantity); sinkSlot.Itemstack.Collectible.TryMergeStacks(mergeop); if (mergeop.MovedQuantity > 0) { sinkSlot.OnItemSlotModified(sinkSlot.Itemstack); OnItemSlotModified(sinkSlot.Itemstack); } return(mergeop.MovedQuantity); }
protected override void ActivateSlotLeftClick(ItemSlot sinkSlot, ref ItemStackMoveOperation op) { // 1. Current slot empty: Remove items if (Empty) { sinkSlot.TakeOutWhole(); return; } // 2. Current slot non empty, source slot empty: Put items if (sinkSlot.Empty) { op.RequestedQuantity = StackSize; TryPutInto(sinkSlot, ref op); return; } // 3. Both slots not empty, and they are stackable: Fill source slot int maxq = Itemstack.Collectible.GetMergableQuantity(sinkSlot.Itemstack, Itemstack, op.CurrentPriority); if (maxq > 0) { op.RequestedQuantity = 1; ItemStackMergeOperation mergeop = op.ToMergeOperation(sinkSlot, this); op = mergeop; ItemStack ownStack = Itemstack.Clone(); sinkSlot.Itemstack.Collectible.TryMergeStacks(mergeop); // Ignore any changes made to our slot Itemstack = ownStack; return; } // 4. Both slots not empty and not stackable: Remove items sinkSlot.TakeOutWhole(); }
protected override void ActivateSlotLeftClick(ItemSlot sinkSlot, ref ItemStackMoveOperation op) { // 1. Current slot empty: Remove items if (Empty) { sinkSlot.TakeOutWhole(); return; } // 2. Current slot non empty, source slot empty: Put items if (sinkSlot.Empty) { op.RequestedQuantity = StackSize; TryPutInto(sinkSlot, ref op); return; } // 3. Both slots not empty, and they are the same: Fill source slot if (sinkSlot.Itemstack.Equals(op.World, Itemstack, GlobalConstants.IgnoredStackAttributes)) { op.RequestedQuantity = 1; ItemStackMergeOperation mergeop = op.ToMergeOperation(sinkSlot, this); op = mergeop; ItemStack ownStack = Itemstack.Clone(); sinkSlot.Itemstack.Collectible.TryMergeStacks(mergeop); // Ignore any changes made to our slot Itemstack = ownStack; return; } // 4. Both slots not empty and not stackable: Remove items sinkSlot.TakeOutWhole(); }
public override int TryPutInto(ItemSlot sinkSlot, ref ItemStackMoveOperation op) { if (!sinkSlot.CanTakeFrom(this) || !CanTake() || Itemstack == null) { return(0); } if (sinkSlot.Inventory?.CanContain(sinkSlot, this) == false) { return(0); } // Fill up sink slot if (op.ShiftDown) { if (Empty) { return(0); } int maxstacksize = Itemstack.Collectible.MaxStackSize; if (sinkSlot.Itemstack == null) { op.RequestedQuantity = maxstacksize; } else { op.RequestedQuantity = maxstacksize - sinkSlot.StackSize; } } // Fill the destination slot with as many items as we can if (sinkSlot.Itemstack == null) { int q = Math.Min(sinkSlot.GetRemainingSlotSpace(itemstack), op.RequestedQuantity); sinkSlot.Itemstack = TakeOut(q); sinkSlot.OnItemSlotModified(sinkSlot.Itemstack); op.MovedQuantity = sinkSlot.StackSize; return(op.MovedQuantity); } ItemStack ownStack = Itemstack.Clone(); ItemStackMergeOperation mergeop = op.ToMergeOperation(sinkSlot, this); op = mergeop; int origRequestedQuantity = op.RequestedQuantity; op.RequestedQuantity = Math.Min(sinkSlot.GetRemainingSlotSpace(itemstack), op.RequestedQuantity); sinkSlot.Itemstack.Collectible.TryMergeStacks(mergeop); // Ignore any changes made to our slot Itemstack = ownStack; if (mergeop.MovedQuantity > 0) { sinkSlot.OnItemSlotModified(sinkSlot.Itemstack); } op.RequestedQuantity = origRequestedQuantity; //ensures op.NotMovedQuantity will be correct in calling code if used with slots with limited slot maxStackSize, e.g. InventorySmelting with a cooking container has slots with maxStackSize == 6 return(op.MovedQuantity); }