public static IvnPacket GeneratePocketChange(this ItemInstance itemInstance, PocketType type, short slot)
{
if (itemInstance == null)
{
return(new IvnPacket
{
Type = type,
IvnSubPackets = new List <IvnSubPacket> {
new IvnSubPacket()
{
Slot = slot,
VNum = -1,
Rare = 0,
Upgrade = 0,
SecondUpgrade = 0
}
}
});
}
return(new IvnPacket
{
Type = type,
IvnSubPackets = new List <IvnSubPacket> {
new IvnSubPacket()
{
Slot = slot,
VNum = itemInstance.ItemVNum,
Rare = itemInstance.Type != PocketType.Equipment ? itemInstance.Amount : itemInstance.Rare,
Upgrade = itemInstance.Upgrade,
SecondUpgrade = 0
}
}
});
}
public T LoadBySlotAndType <T>(short slot, PocketType type) where T : IItemInstance
{
T retItem = default;
try
{
retItem = (T)this.Select(s => s.Value)
.SingleOrDefault(i => i is T && i.Slot == slot && i.Type == type);
}
catch (InvalidOperationException ioEx)
{
_logger.Error(ioEx.Message, ioEx);
var isFirstItem = true;
foreach (var item in this.Select(s => s.Value).Where(i => i is T && i.Slot == slot && i.Type == type))
{
if (isFirstItem)
{
retItem = (T)item;
isFirstItem = false;
continue;
}
var iteminstance = this.Select(s => s.Value).FirstOrDefault(i =>
i != null && i.GetType() == typeof(T) && i.Slot == slot && i.Type == type);
if (iteminstance != null)
{
TryRemove(iteminstance.Id, out var value);
}
}
}
return(retItem);
}
public float GetSpaceUsed(PocketType type)
{
return(Manifest.Samples
.Where(sample => sample.Type == type)
.Sum(sample => Manifest.GetQuantity(sample) *
Pocket.GetUnitSize(sample)));
}
public void Clear()
{
m_Type = PocketType.None;
punishmentObject.SetActive(false);
rewardObject.SetActive(false);
blockObject.SetActive(false);
}
public void SetAsBlock()
{
m_Type = PocketType.BlockOff;
punishmentObject.SetActive(false);
rewardObject.SetActive(false);
blockObject.SetActive(true);
}
public static IvnPacket GeneratePocketChange(this InventoryItemInstance?itemInstance,
PocketType type,
short slot)
{
if (itemInstance == null)
{
return(new IvnPacket
{
Type = type,
IvnSubPackets = new List <IvnSubPacket?> {
((IItemInstance?)null).GenerateIvnSubPacket(type, slot)
}
});
}
return(new IvnPacket
{
Type = type,
IvnSubPackets = new List <IvnSubPacket?>
{
new IvnSubPacket
{
Slot = slot,
VNum = itemInstance.ItemInstance !.ItemVNum,
RareAmount =
itemInstance.Type != NoscorePocketType.Equipment ? itemInstance.ItemInstance.Amount
: itemInstance.ItemInstance.Rare,
UpgradeDesign = itemInstance.ItemInstance.Upgrade,
SecondUpgrade = 0
}
}
});
/// <summary>
/// sell packet
/// </summary>
/// <param name="sellPacket"></param>
public void SellShop(SellPacket sellPacket)
{
if (Session.Character.InExchangeOrTrade)
{
//TODO log
return;
}
if (sellPacket.Amount.HasValue && sellPacket.Slot.HasValue)
{
PocketType type = (PocketType)sellPacket.Data;
var inv = Session.Character.Inventory.LoadBySlotAndType <IItemInstance>(sellPacket.Slot.Value, type);
if (inv == null || sellPacket.Amount.Value > inv.Amount)
{
//TODO log
return;
}
if (!inv.Item.IsSoldable)
{
Session.SendPacket(new SMemoPacket
{
Type = SMemoType.Error,
Message = Language.Instance.GetMessageFromKey(LanguageKey.ITEM_NOT_SOLDABLE, Session.Account.Language)
});
return;
}
long price = inv.Item.ItemType == ItemType.Sell ? inv.Item.Price : inv.Item.Price / 20;
if (Session.Character.Gold + price * sellPacket.Amount.Value > _worldConfiguration.MaxGoldAmount)
{
Session.SendPacket(new MsgPacket
{
Message = Language.Instance.GetMessageFromKey(LanguageKey.MAX_GOLD,
Session.Account.Language),
Type = 0
});
return;
}
Session.Character.Gold += price * sellPacket.Amount.Value;
Session.SendPacket(new SMemoPacket
{
Type = SMemoType.Success,
Message = string.Format(
Language.Instance.GetMessageFromKey(LanguageKey.SELL_ITEM_VALIDE, Session.Account.Language),
inv.Item.Name,
sellPacket.Amount.Value
)
});
Session.Character.Inventory.RemoveItemAmountFromInventory(sellPacket.Amount.Value, inv.Id);
Session.SendPacket(Session.Character.GenerateGold());
}
else
{
//TODO sell skill
}
}
public ItemEdit(string item, PocketType it, ushort quantity)
{
InitializeComponent();
isReady = false;
//Moja initalizacija
MyInitialize(it);
isReady = true;
//Kontrole
uxItems.Text = item;
uxQuantity.Text = quantity.ToString();
}
private short?GetFreeSlot(PocketType type)
{
var backPack = IsExpanded ? 1 : 0;
var itemInstanceSlotsByType = this.Select(s => s.Value).Where(i => i.Type == type).OrderBy(i => i.Slot).Select(i => (int)i.Slot);
IEnumerable <int> instanceSlotsByType = itemInstanceSlotsByType as int[] ?? itemInstanceSlotsByType.ToArray();
var nextFreeSlot = instanceSlotsByType.Any()
? Enumerable.Range(0, (type != PocketType.Miniland ? Configuration.BackpackSize + (backPack * 12) : 50) + 1).Except(instanceSlotsByType).FirstOrDefault()
: 0;
return((short?)nextFreeSlot < (type != PocketType.Miniland ? Configuration.BackpackSize + (backPack * 12) : 50) ? (short?)nextFreeSlot : null);
}
// public bool EnoughPlace(List<ItemInstance> itemInstances, int backPack)
// {
// var place = new Dictionary<PocketType, int>();
// foreach (var itemgroup in itemInstances.GroupBy(s => s.ItemVNum))
// {
// var type = itemgroup.First().Type;
// var listitem = this.Select(s => s.Value).Where(i => i.Type == type).ToList();
// if (!place.ContainsKey(type))
// {
// place.Add(type, (type != PocketType.Miniland ? Configuration.BackpackSize + backPack * 12 : 50) - listitem.Count);
// }
// var amount = itemgroup.Sum(s => s.Amount);
// var rest = amount % (type == PocketType.Equipment ? 1 : 99);
// var needanotherslot = listitem.Where(s => s.ItemVNum == itemgroup.Key).Sum(s => Configuration.MaxItemAmount - s.Amount) <= rest;
// place[type] -= (amount / (type == PocketType.Equipment ? 1 : 99)) + (needanotherslot ? 1 : 0);
// if (place[type] < 0)
// {
// return false;
// }
// }
// return true;
// }
// public IEnumerable<ItemInstance> RemoveItemAmount(int vnum, int amount = 1)
// {
// var remainingAmount = amount;
// foreach (var pocket in this.Select(s => s.Value).Where(s => s.ItemVNum == vnum && s.Type != PocketType.Wear && s.Type != PocketType.Bazaar && s.Type != PocketType.Warehouse && s.Type != PocketType.PetWarehouse && s.Type != PocketType.FamilyWareHouse).OrderBy(i => i.Slot))
// {
// if (remainingAmount > 0)
// {
// if (pocket.Amount > remainingAmount)
// {
// // amount completely removed
// pocket.Amount -= (short)remainingAmount;
// remainingAmount = 0;
// }
// else
// {
// // amount partly removed
// remainingAmount -= pocket.Amount;
// DeleteById(pocket.Id);
// }
// yield return pocket;
// }
// else
// {
// // amount to remove reached
// break;
// }
// }
// }
// public ItemInstance RemoveItemAmountFromPocket(short amount, Guid id)
// {
// var inv = this.Select(s => s.Value).FirstOrDefault(i => i.Id.Equals(id));
// if (inv == null)
// {
// return null;
// }
// inv.Amount -= amount;
// if (inv.Amount <= 0)
// {
// TryRemove(inv.Id, out _);
// }
// return inv;
// }
// public IEnumerable<ItemInstance> Reorder(ClientSession session, PocketType pocketType)
// {
// var itemsByPocketType = new List<ItemInstance>();
// switch (pocketType)
// {
// case PocketType.Costume:
// itemsByPocketType = this.Select(s => s.Value).Where(s => s.Type == PocketType.Costume).OrderBy(s => s.ItemVNum).ToList();
// break;
// case PocketType.Specialist:
// itemsByPocketType = this.Select(s => s.Value).Where(s => s.Type == PocketType.Specialist).OrderBy(s => s.Item.LevelJobMinimum).ToList();
// break;
// }
// short i = 0;
// foreach (var item in itemsByPocketType)
// {
// // remove item from pocket
// TryRemove(item.Id, out var value);
// yield return new ItemInstance(){Slot = item.Slot, Type = item.Type};
// // readd item to pocket
// item.Slot = i;
// yield return item;
// this[item.Id] = item;
// // increment slot
// i++;
// }
// }
//private ItemInstance GetFreeSlot(IEnumerable<ItemInstance> slotfree)
//{
// var pocketitemids = slotfree.Select(itemfree => itemfree.Id).ToList();
// return this.Select(s => s.Value).Where(i => pocketitemids.Contains(i.Id) && i.Type != PocketType.Wear && i.Type != PocketType.PetWarehouse && i.Type != PocketType.FamilyWareHouse && i.Type != PocketType.Warehouse && i.Type != PocketType.Bazaar).OrderBy(i => i.Slot).FirstOrDefault();
//}
private ItemInstance TakeItem(short slot, PocketType type)
{
var itemInstance = this.Select(s => s.Value).SingleOrDefault(i => i.Slot == slot && i.Type == type);
if (itemInstance == null)
{
return(null);
}
TryRemove(itemInstance.Id, out _);
return(itemInstance);
}
public ItemInstance DeleteFromTypeAndSlot(PocketType type, short slot)
{
var inv = this.Select(s => s.Value).FirstOrDefault(i => i.Slot.Equals(slot) && i.Type.Equals(type));
if (inv != null && type != PocketType.Bazaar)
{
TryRemove(inv.Id, out var value);
return(value);
}
Logger.Error(new InvalidOperationException("Expected item wasn't deleted, Type or Slot did not match!"));
return(null);
}
public static UseItemPacket GenerateUseItem(this IAliveEntity aliveEntity, PocketType type, short slot,
byte mode, byte parameter)
{
return(new UseItemPacket
{
VisualId = aliveEntity.VisualId,
VisualType = aliveEntity.VisualType,
Type = type,
Slot = slot,
Mode = mode,
Parameter = parameter
});
}
public MapItem PutItem(PocketType type, short slot, short amount, ref ItemInstance inv, ClientSession session)
{
Guid random2 = Guid.NewGuid();
MapItem droppedItem = null;
List <MapCell> possibilities = new List <MapCell>();
for (short x = -2; x < 3; x++)
{
for (short y = -2; y < 3; y++)
{
possibilities.Add(new MapCell {
X = x, Y = y
});
}
}
short mapX = 0;
short mapY = 0;
var niceSpot = false;
foreach (MapCell possibility in possibilities.OrderBy(s => ServerManager.Instance.RandomNumber()))
{
mapX = (short)(session.Character.PositionX + possibility.X);
mapY = (short)(session.Character.PositionY + possibility.Y);
if (!Map.IsWalkable(Map[mapX, mapY]))
{
continue;
}
niceSpot = true;
break;
}
if (!niceSpot)
{
return(null);
}
if (amount <= 0 || amount > inv.Amount)
{
return(null);
}
var newItemInstance = inv.Clone();
newItemInstance.Id = random2;
newItemInstance.Amount = amount;
droppedItem = new MapItem {
MapInstance = this, VNum = newItemInstance.ItemVNum, PositionX = mapX, PositionY = mapY, Amount = amount
};
DroppedList[droppedItem.VisualId] = droppedItem;
inv.Amount -= amount;
return(droppedItem);
}
public Pocket(Rect _rect, Texture2D _texture, GameObject _pocketGameObject, PocketIndexes _Index)
{
rect = _rect;
texture = _texture;
pocketGameObject = _pocketGameObject;
m_Index = _Index;
(punishmentObject = pocketGameObject.transform.FindChild("PunishmentSprite").gameObject).SetActive(false);
(rewardObject = pocketGameObject.transform.FindChild("RewardSprite").gameObject).SetActive(false);
(blockObject = pocketGameObject.transform.FindChild("BlockOff").gameObject).SetActive(false);
punishmentColor = Color.red;
rewardColor = Color.green;
blockColor = Color.white;
m_Type = PocketType.None;
}
private void MyInitialize(PocketType it)
{
//Postavljamo kolka kolicina moze bit
switch (it)
{
case PocketType.Items:
uxQuantity.NumberValueMax = 99;
break;
case PocketType.KeyItems:
uxQuantity.NumberValueMax = 1;
break;
case PocketType.PokeBalls:
uxQuantity.NumberValueMax = 99;
break;
case PocketType.TMsHMs:
uxQuantity.NumberValueMax = 99;
break;
case PocketType.Berries:
uxQuantity.NumberValueMax = 99;
break;
}
//Dohvacamo sve iteme koji su odredenog Pocket tipa
var items = from item in PokemonConstants.ItemTypes
where item.Value.PocketType == it
select item.Value;
List <string> itemStrings = new List <string>();
//Stavljamo mogucnost da napravimo prazan item
itemStrings.Add("000 Nothing");
foreach (var itm in items)
{
itemStrings.Add(String.Format("{0:D3}", itm.ItemID) + " " + itm.ItemName);
}
uxItems.DataSource = itemStrings;
}
public static IvnSubPacket GenerateIvnSubPacket(this IItemInstance?itemInstance, PocketType type,
short slot)
{
if (itemInstance == null)
{
return(new IvnSubPacket
{
Slot = slot,
VNum = -1,
RareAmount = 0,
UpgradeDesign = 0,
SecondUpgrade = 0
});
}
return(new IvnSubPacket
{
Slot = slot,
VNum = itemInstance.ItemVNum,
RareAmount =
type != PocketType.Equipment ? itemInstance.Amount
: itemInstance.Rare,
UpgradeDesign = itemInstance.Upgrade,
SecondUpgrade = 0
});
}
public IItemInstance MoveInPocket(short sourceSlot, PocketType sourceType, PocketType targetType, short?targetSlot) => MoveInPocket(sourceSlot, sourceType, targetType, targetSlot, true);
public int CountItemInAnPocket(PocketType inv)
{
return(this.Count(s => s.Value.Type == inv));
}
private void uxTrainerBagItems_MouseDoubleClick(object sender, MouseEventArgs e)
{
if (!isReady || uxTrainerBagItems.SelectedIndices == null)
{
return;
}
int index = uxTrainerBagItems.SelectedIndices[0];
Item itemToChange = new Item();
PocketType pocket = PocketType.Items;
string itemString;
switch (uxTrainerBagSlot.SelectedIndex)
{
case 0: //Items
itemToChange = playerBag.Items[index];
pocket = PocketType.Items;
break;
case 1: //KeyItems
itemToChange = playerBag.KeyItems[index];
pocket = PocketType.KeyItems;
break;
case 2: //PokeBalls
itemToChange = playerBag.PokeBalls[index];
pocket = PocketType.PokeBalls;
break;
case 3: //TMsHMs
itemToChange = playerBag.TMsHMs[index];
pocket = PocketType.TMsHMs;
break;
case 4: //Berries
itemToChange = playerBag.Berries[index];
pocket = PocketType.Berries;
break;
}
itemString = String.Format("{0:D3}", itemToChange.GetItemType.ItemID) + " " + itemToChange.GetItemType.ItemName;
ItemEdit ite;
//Ruby i Sapphire nemaju enkriptirano pa moramo pristupit direktno
if (pokemonVersion == PokemonVersion.RubyAndSapphire)
{
ite = new ItemEdit(itemString, pocket, itemToChange.Quantity);
}
else
{
ite = new ItemEdit(itemString, pocket, itemToChange.GetQuantityDecrypted);
}
if (ite.ShowDialog() == DialogResult.OK)
{
itemToChange.ItemType = ite.Item;
//Ruby i Sapphire nemaju enkriptirano pa moramo pristupit direktno
if (pokemonVersion == PokemonVersion.RubyAndSapphire)
{
itemToChange.Quantity = ite.Quantity;
}
else
{
itemToChange.SetQuantityEncrypted = ite.Quantity;
}
PokemonBagFill();
}
ite.Dispose();
}
public bool TryMoveItem(PocketType sourcetype, short sourceSlot, short amount, short destinationSlot,
out IItemInstance sourcePocket, out IItemInstance destinationPocket)
{
// load source and destination slots
sourcePocket = LoadBySlotAndType <IItemInstance>(sourceSlot, sourcetype);
destinationPocket = LoadBySlotAndType <IItemInstance>(destinationSlot, sourcetype);
if (sourceSlot == destinationSlot || amount == 0 ||
destinationSlot > Configuration.BackpackSize + ((IsExpanded ? 1 : 0) * 12))
{
return(false);
}
if (sourcePocket != null && amount <= sourcePocket.Amount)
{
switch (destinationPocket)
{
case null when sourcePocket.Amount == amount:
sourcePocket.Slot = destinationSlot;
break;
case null:
IItemInstance itemDest = (IItemInstance)sourcePocket.Clone();
sourcePocket.Amount -= amount;
itemDest.Amount = amount;
itemDest.Id = Guid.NewGuid();
AddItemToPocket(itemDest, sourcetype, destinationSlot);
break;
default:
if (destinationPocket.ItemVNum == sourcePocket.ItemVNum &&
(sourcePocket.Item.Type == PocketType.Main || sourcePocket.Item.Type == PocketType.Etc))
{
if (destinationPocket.Amount + amount > Configuration.MaxItemAmount)
{
var saveItemCount = destinationPocket.Amount;
destinationPocket.Amount = Configuration.MaxItemAmount;
sourcePocket.Amount =
(short)(saveItemCount + sourcePocket.Amount - Configuration.MaxItemAmount);
}
else
{
destinationPocket.Amount += amount;
sourcePocket.Amount -= amount;
// item with amount of 0 should be removed
if (sourcePocket.Amount == 0)
{
DeleteFromTypeAndSlot(sourcePocket.Type, sourcePocket.Slot);
}
}
}
else
{
// add and remove save pocket
destinationPocket = TakeItem(destinationPocket.Slot, destinationPocket.Type);
if (destinationPocket == null)
{
return(true);
}
destinationPocket.Slot = sourceSlot;
destinationPocket.Type = sourcetype;
sourcePocket = TakeItem(sourcePocket.Slot, sourcePocket.Type);
if (sourcePocket == null)
{
return(true);
}
sourcePocket.Slot = destinationSlot;
this[destinationPocket.Id] = destinationPocket;
this[sourcePocket.Id] = sourcePocket;
}
break;
}
}
sourcePocket = LoadBySlotAndType <IItemInstance>(sourceSlot, sourcetype);
destinationPocket = LoadBySlotAndType <IItemInstance>(destinationSlot, sourcetype);
return(true);
}
public Pocket(Rect _rect, Texture2D _texture, GameObject _pocketGameObject, PocketIndexes _Index)
{
rect = _rect;
texture = _texture;
pocketGameObject = _pocketGameObject;
m_Index = _Index;
(punishmentObject = pocketGameObject.transform.FindChild("PunishmentSprite").gameObject).SetActive(false);
(rewardObject = pocketGameObject.transform.FindChild("RewardSprite").gameObject).SetActive(false);
(blockObject = pocketGameObject.transform.FindChild("BlockOff").gameObject).SetActive(false);
punishmentColor = Color.red;
rewardColor = Color.green;
blockColor = Color.white;
m_Type = PocketType.None;
}
public IItemInstance MoveInPocket(short sourceSlot, PocketType sourceType, PocketType targetType) => MoveInPocket(sourceSlot, sourceType, targetType, null, false);
public IItemInstance MoveInPocket(short sourceSlot, PocketType sourceType, PocketType targetType,
short?targetSlot, bool swap)
{
if (sourceSlot == targetSlot && sourceType == targetType)
{
var e = new InvalidOperationException("SourceInstance can't be moved on the same spot");
_logger.Error(e.Message, e);
return(null);
}
var sourceInstance = LoadBySlotAndType <IItemInstance>(sourceSlot, sourceType);
if (!(sourceInstance is WearableInstance || sourceInstance is SpecialistInstance))
{
var e = new InvalidOperationException("SourceInstance can't be moved between pockets");
_logger.Error(e.Message, e);
return(null);
}
if (sourceInstance is WearableInstance && targetType != PocketType.Equipment &&
targetType != PocketType.Costume && targetType != PocketType.Wear)
{
var e = new InvalidOperationException("WearableInstance can't be move to this inventory");
_logger.Error(e.Message, e);
return(null);
}
if (sourceInstance is SpecialistInstance && targetType != PocketType.Equipment &&
targetType != PocketType.Specialist && targetType != PocketType.Wear)
{
var e = new InvalidOperationException("SpecialistInstance can't be move to this inventory");
_logger.Error(e.Message, e);
return(null);
}
if (targetSlot.HasValue)
{
var targetInstance = LoadBySlotAndType <IItemInstance>(targetSlot.Value, targetType);
if (swap && targetInstance != null)
{
// swap
sourceInstance.Slot = targetSlot.Value;
sourceInstance.Type = targetType;
targetInstance.Slot = sourceSlot;
targetInstance.Type = sourceType;
}
else if (targetInstance == null)
{
sourceInstance.Slot = targetSlot.Value;
sourceInstance.Type = targetType;
}
else
{
var e = new InvalidOperationException("Source can not be swapped");
_logger.Error(e.Message, e);
return(null);
}
return(sourceInstance);
}
// check for free target slot
short?nextFreeSlot;
if (targetType == PocketType.Wear)
{
nextFreeSlot =
LoadBySlotAndType <IItemInstance>((short)sourceInstance.Item.EquipmentSlot, targetType) == null
? (short)sourceInstance.Item.EquipmentSlot
: (short)-1;
}
else
{
nextFreeSlot = GetFreeSlot(targetType);
}
if (nextFreeSlot.HasValue)
{
sourceInstance.Type = targetType;
sourceInstance.Slot = nextFreeSlot.Value;
}
else
{
return(null);
}
return(sourceInstance);
}
public float GetSize(PocketType type)
{
return(Pockets
.Where(pocket => pocket.Type == type)
.Sum(pocket => pocket.Size * pocket.Item.Quantity));
}
public void SetAsReward()
{
m_Type = PocketType.Reward;
punishmentObject.SetActive(false);
rewardObject.SetActive(true);
blockObject.SetActive(false);
}
public ItemInstance MoveInPocket(short sourceSlot, PocketType sourceType, PocketType targetType,
short?targetSlot = null, bool wear = true)
{
if (sourceSlot == targetSlot && sourceType == targetType)
{
Logger.Error(new InvalidOperationException("SourceInstance can't be moved on the same spot"));
return(null);
}
var sourceInstance = LoadBySlotAndType <ItemInstance>(sourceSlot, sourceType);
if (!(sourceInstance is WearableInstance))
{
Logger.Error(new InvalidOperationException("SourceInstance can't be moved between pockets"));
return(null);
}
switch (sourceInstance?.Item.ItemType)
{
case ItemType.Fashion when targetType != PocketType.Main && targetType != PocketType.Costume:
case ItemType.Specialist when targetType != PocketType.Main && targetType != PocketType.Specialist:
Logger.Error(new InvalidOperationException("SourceInstance can't be moved to this Pocket"));
return(null);
}
if (targetSlot.HasValue)
{
if (wear)
{
// swap
var targetInstance = LoadBySlotAndType <ItemInstance>(targetSlot.Value, targetType);
sourceInstance.Slot = targetSlot.Value;
sourceInstance.Type = targetType;
targetInstance.Slot = sourceSlot;
targetInstance.Type = sourceType;
}
else
{
// move source to target
var freeTargetSlot = GetFreeSlot(targetType);
if (!freeTargetSlot.HasValue)
{
return(sourceInstance);
}
sourceInstance.Slot = freeTargetSlot.Value;
sourceInstance.Type = targetType;
}
return(sourceInstance);
}
// check for free target slot
short?nextFreeSlot;
if (targetType == PocketType.Wear)
{
nextFreeSlot =
LoadBySlotAndType <ItemInstance>((short)sourceInstance.Item.EquipmentSlot, targetType) == null
? (short)sourceInstance.Item.EquipmentSlot
: (short)-1;
}
else
{
nextFreeSlot = GetFreeSlot(targetType);
}
if (nextFreeSlot.HasValue)
{
sourceInstance.Type = targetType;
sourceInstance.Slot = nextFreeSlot.Value;
}
else
{
return(null);
}
return(sourceInstance);
}
public void Clear()
{
m_Type = PocketType.None;
punishmentObject.SetActive(false);
rewardObject.SetActive(false);
blockObject.SetActive(false);
}
public float GetSpaceAvailable(PocketType type)
{
return(GetSize(type) - GetSpaceUsed(type));
}
