/// <summary>
/// Equip item in inventory.
/// </summary>
/// <param name="item"> Item is picked in Inventory.</param>
/// <returns></returns>
public bool AddToEquip(ItemResource item, Action reloadData = null)
{
var equipSlot = GetSlot(item);
if (equipSlot == null)
{
return(false);
}
if (equipSlot.itemResource != null)
{
playerInventory.RemoveEquipmentItem(currentCharacter.characterId, equipSlot.itemResource);
playerInventory.AddItem(equipSlot.itemResource);
}
equipSlot.SetupItem(item);
playerInventory.AddEquipmentItem(currentCharacter.characterId, equipSlot.itemResource);
playerInventory.RemoveItem(equipSlot.itemResource);
// reload data in Inventory
reloadData?.Invoke();
return(true);
}
public void InventoryEventsTest()
{
BaseItem herb = ItemDatabase.GetItemByName("Herb");
BaseItem coin = ItemDatabase.GetItemByName("Coin");
// Simple Inventory
simpleInventory = new SimpleInventory();
simpleInventory.OnItemAdded += new ItemAddedHandler(ItemAdded);
simpleInventory.OnItemRemoved += new ItemRemovedHandler(ItemRemoved);
simpleInventory.AddItem(herb.Id);
simpleInventory.AddItem(herb.Id);
simpleInventory.RemoveItem(herb.Id);
simpleInventory.RemoveItem(herb.Id);
simpleInventory.RemoveItem(herb.Id);
Assert.AreEqual(2, _itemAddedCalled);
Assert.AreEqual(2, _itemRemovedCalled);
// Player Inventory
playerInventory = new PlayerInventory();
playerInventory.OnItemAdded += new ItemAddedHandler(ItemAdded);
playerInventory.OnItemRemoved += new ItemRemovedHandler(ItemRemoved);
playerInventory.AddItem(herb.Id);
playerInventory.AddItem(herb.Id);
playerInventory.RemoveItem(herb.Id);
playerInventory.RemoveItem(herb.Id);
playerInventory.RemoveItem(herb.Id);
Assert.AreEqual(4, _itemAddedCalled);
Assert.AreEqual(4, _itemRemovedCalled);
}
public void PlayerInventoryTest()
{
playerInventory = new PlayerInventory();
Assert.AreEqual(0, playerInventory.ItemCount);
BaseItem herb = ItemDatabase.GetItemByName("Herb");
BaseItem coin = ItemDatabase.GetItemByName("Coin");
playerInventory.AddItem(herb.Id);
Assert.AreEqual(1, playerInventory.ItemCount);
playerInventory.AddItem(herb.Id, 9);
Assert.AreEqual(1, playerInventory.ItemCount);
Assert.AreEqual(10, playerInventory.GetQuantity(herb.Id));
playerInventory.RemoveItem(herb.Id, 9);
Assert.AreEqual(1, playerInventory.ItemCount);
playerInventory.RemoveItem(herb.Id, 100);
Assert.AreEqual(0, playerInventory.ItemCount);
Assert.AreEqual(0, playerInventory.GetQuantity(herb.Id));
// Set and check Items and Quantities
playerInventory.Items = new List <int>()
{
herb.Id, coin.Id
};
playerInventory.Quantities = new List <int>()
{
1, 2
};
Assert.AreEqual(2, playerInventory.Quantities.ToList <int>().Count);
Assert.AreEqual(2, playerInventory.Items.ToList <int>().Count);
// Test the pretty representation
playerInventory.ToString();
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.E) && playerInRange)
{
PlayerMovement.instance.canMove = false;
isPickingUp = true;
playerAnim.SetTrigger("pickUp");
}
if (isPickingUp)
{
animTimer += Time.deltaTime;
if (animTimer >= 0.4)
{
switch (itemType)
{
case ItemType.Stick:
inventory.AddItem(Item.ItemType.Stick, amountToPickup);
break;
case ItemType.Stone:
inventory.AddItem(Item.ItemType.Stone, amountToPickup);
break;
case ItemType.Axe:
inventory.AddItem(Item.ItemType.Axe, amountToPickup);
break;
}
Destroy(gameObject);
PlayerMovement.instance.canMove = true;
}
}
}
public void AddItem(Item item)
{
if (item != null && itemSlot.item != null)
{
playerInventory.AddItem(itemSlot.item);
}
itemSlot.Initialize(item, null);
LoadModifiers(item);
playerInventory.GetConnectedInventory(item.itemType).DeleteItem(item);
}
/// <summary>
/// Adds an Item to inventory at fist not full stack or call AddToEmptySlot
/// </summary>
/// <param name="item"></param>
/// <param name="count"></param>
private bool AddItem(Item item, int count = 1)
{
if (IsInventoryFull())
{
return(false);
}
count = count <= 0 ? 1 : count;
_playerInventory.AddItem(item, count);
RefreshInventoryItems();
return(true);
}
public void buyKey()
{
SoundManager.PlayeSound("Click");
playerInventory.coins -= 5;
RemoveFromInventory();
playerInventory.AddItem(thisItem);
//playerInventory.currentItem = thisItem;
AddItemToInventory();
//PlayerPrefs.SetInt("isKeySold", 1);
//keyPrice.text = "sold!";
//buyButton.gameObject.SetActive(false);
}
protected override void Collect(GameManager PlayerGameManager)
{
switch (PowerupID)
{
case PowerupsInfo.PowerupsIDs.GreenArrows:
Inventory.AddItem(PowerupsInfo.PowerupsIDs.GreenArrows);
break;
case PowerupsInfo.PowerupsIDs.Magnet:
Inventory.AddItem(PowerupsInfo.PowerupsIDs.Magnet);
break;
case PowerupsInfo.PowerupsIDs.PurpleHeart:
TheRunGameManager.Instance.GameData.Data.Profile.PurpleHearts++;
break;
case PowerupsInfo.PowerupsIDs.PurplePoison:
PlayerGameManager.CauseDamage(75f, false);
PlayerGameManager.CurrentMoney -= (int)(PlayerGameManager.CurrentMoney * 0.15f);
break;
case PowerupsInfo.PowerupsIDs.RedBomb:
case PowerupsInfo.PowerupsIDs.RedSkull:
PlayerGameManager.CauseDamage(50f, false);
PlayerGameManager.CurrentMoney -= (int)(PlayerGameManager.CurrentMoney * 0.2f);
break;
case PowerupsInfo.PowerupsIDs.RedMedipack:
Inventory.AddItem(PowerupsInfo.PowerupsIDs.RedMedipack);
break;
case PowerupsInfo.PowerupsIDs.RedStar:
TheRunGameManager.Instance.GameData.Data.Profile.RedStars++;
TheRunGameManager.Instance.GameData.Save();
break;
default:
Debug.LogError("Power-up not implemented yet: " + PowerupID.ToString());
break;
}
base.Collect(PlayerGameManager);
}
protected override void Start()
{
base.Start();
inventory.AddItem(new WeaponItem(10001));
inventory.AddItem(new Item(5001));
inventory.AddItem(new Item(5101));
inventory.AddItem(new Item(901), 999);
inventory.AddItem(new Item(9002), 1, PlayerInventory.bootsIndex);
if (admin)
{
inventory.AddAllItems();
}
}
public void Take(Transform target)
{
if (!pickedUp && playerInventory.HasSpace())
{
// GameObject.FindGameObjectWithTag("Player").GetComponent<PlayerMove>().health += .5f;
playerInventory.AddItem(item, gameObject);
gameObject.SetActive(false);
pickedUp = true;
}
// transform.parent = target;
// transform.position = new Vector3(target.position.x, target.position.y, -5f);
// transform.rotation = target.rotation;
/*
* if (GetComponent<Weapon>()) {
* GetComponent<Weapon>().enabled = true;
*
* if (target.GetComponent<PlayerMove>()) {
* target.GetComponent<PlayerMove>().weapon = GetComponent<Weapon>();
* }
*
* tag = target.tag;
* gameObject.layer = 0;
* transform.SetSiblingIndex(0);
*
* target.Find("Fist").gameObject.SetActive(false);
* }*/
}
void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
if (gameObject.tag != "NonIntoxicant" && gameObject.tag != "Intoxicant")
{
// create empty gameobject as item pick up audio source
GameObject soundObject = new GameObject();
soundObject.name = "Item Pickup Audio Source";
soundObject.transform.position = transform.position;
AudioSource audioSource = soundObject.AddComponent <AudioSource>();
soundObject.GetComponent <AudioSource>().PlayOneShot(pickupAudioClip);
objects--;
playerInventory.AddItem(gameObject.tag);
itemList = itemList + gameObject.tag;
Destroy(gameObject);
}
if (gameObject.tag == "NonIntoxicant" || gameObject.tag == "Intoxicant")
{
eChat.SetActive(true);
}
}
}
public void BuyItem()
{
if (selectedItem == -1)
{
return;
}
ItemShop item = myDetails.sellingItems[selectedItem];
switch (item.coinType)
{
case ShopCoin.Gold:
if (inventory.Gold < item.value)
{
return;
}
inventory.Gold -= item.value;
break;
case ShopCoin.Secret:
if (inventory.SecretGold < item.value)
{
return;
}
inventory.SecretGold -= item.value;
break;
}
item.sellingItem.OnBuy(GameManager.Player.gameObject);
inventory.AddItem(item.sellingItem);
RefreshShop();
}
private bool GetItem(GamePlayer player, ItemInfo item, ref string message, ref bool result)
{
bool result2;
if (item == null)
{
result2 = false;
}
else
{
PlayerInventory bag = player.GetItemInventory(item.Template);
if (bag.StackItemToAnother(item) || bag.AddItem(item))
{
result = true;
player.TempBag.TakeOutItem(item);
result2 = true;
}
else
{
result = false;
bag.UpdateChangedPlaces();
message = LanguageMgr.GetTranslation(item.GetBagName(), new object[0]) + LanguageMgr.GetTranslation("GameTakeTempItemsHandler.Msg", new object[0]);
result2 = false;
}
}
return(result2);
}
// Token: 0x060000DD RID: 221
public static void GiveItem(Item_Base item, int amount, Player p = null)
{
if (p == null)
{
p = UnityEngine.Object.FindObjectOfType <Player>();
}
FieldInfo field = Enumerable.FirstOrDefault <FieldInfo>(typeof(Player).GetFields((BindingFlags)36), (FieldInfo x) => x.Name == "playerInventory");
if (field == null)
{
RConsole.Log("Couldn't find playerInventory");
return;
}
PlayerInventory pi = (PlayerInventory)field.GetValue(p);
if (pi == null)
{
RConsole.Log("Couldn't get playerInventory");
return;
}
try
{
pi.AddItem(item.name, 1);
}
catch (Exception ex)
{
RConsole.Log(ex.ToString());
}
}
public void OnDrop(PointerEventData eventData)
{
var draggedObject = DragableItem.DraggedObject;
if (draggedObject == null)
{
return;
}
int?draggedID = DragableItem.StartingSlot.GetID();
var draggedType = gameItems.GetItemByID(draggedID).Type;
if (draggedType != type)
{
return;
}
if (draggedObject.GetComponent <PlayerEquipmentSlot>())
{
SwapItems(DragableItem.StartingSlot, draggedID);
sound.PlaySound(itemID);
return;
}
if (DragableItem.StartingSlot.GetComponent <PlayerInventorySlot>())
{
DragableItem.DraggedObject.GetComponent <DragableItem>().HideDraggedPrefab();
DragableItem.StartingSlot.GetComponent <PlayerInventorySlot>().DecrementCount();
if (itemID != null)
{
inventoryItems.AddItem((int)itemID);
}
}
FillFromID(draggedID);
sound.PlaySound(itemID);
}
private void OnTriggerStay2D(Collider2D other)
{
if (other.tag.Equals("Player") && Input.GetKey(KeyCode.E))
{
_playerInventory.AddItem(this, false);
}
}
public void BuyItem(ItemType item, int price, int quantity = 1)
{
int cost = price * quantity;
playerStats.Cash -= cost;
playerInventory.AddItem(item, quantity);
}
private void OnRequestSell([FromSource] Player source, string item, int itemAmount)
{
var playerSession = Server.Instances.Session.GetPlayer(source);
if (playerSession == null)
{
return;
}
var playerInv = new PlayerInventory(playerSession.GetGlobalData("Character.Inventory", ""), playerSession);
if (playerInv.HasItemWithAmount(item, itemAmount))
{
playerInv.AddItem(item, -itemAmount);
var animalData = item.Split('_');
var sellingPrice = sellingPrices[item] * itemAmount;
Server.Get <PaymentHandler>().UpdatePlayerCash(playerSession, sellingPrice, $"selling {itemAmount} {animalData[0].AddSpacesToCamelCase()} {animalData[1]}");
Log.ToClient("[Hunting]", $"You just sold {itemAmount} {animalData[0].AddSpacesToCamelCase()} {animalData[1]} for ${sellingPrice}", ConstantColours.Hunting, source);
}
else
{
Log.ToClient("[Hunting]", $"You don't have enough of this item to do that", ConstantColours.Hunting, source);
}
}
void FinishView()
{
canFinish = false;
isViewing = false;
UIManager.instance.SetBackImage(false);
if (currentItem.inventoryItem)
{
inventory.AddItem(currentItem);
audioPlayer.PlayAudio(writingSound);
currentInteractable.CollectItem.Invoke();
}
if (currentItem.grabbable)
{
currentInteractable.transform.rotation = originRotation;
StartCoroutine(MovingObject(currentInteractable, originPosition));
}
if (currentItem.requiredItem)
{
inventory.AddRequiredItens(currentItem);
}
OnFinishView.Invoke();
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.tag == "Item")
{
inventory.AddItem(other.GetComponent <Items>());
}
}
public static void ChangeWeapon(Item newWeapon)
{
PlayerInventory.AddItem(Weapon);
//TODO: дропать старое оружее если нет места в инвентаре
Weapon = newWeapon;
EquipmentChanged?.Invoke();
}
// @TODO Move to instanciated gameobject
public bool AddInventoryItem(Item item)
{
PlayerInventory inventory = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>();
// la funcion al ser bool puede devolver true/false al igual que AddItem
// del script Inventory
return(inventory.AddItem(item));
}
public override void AddItemToPlayerInventory()
{
ItemTypes myItem = ItemTypes.MaterialItem;
playerInv.AddItem(myItem);
playerInv.TestFunc();
Destroy(this.gameObject);
}
public void Sell(ItemData item)
{
if (PlayerInventory.GetItems().Contains(item))
{
PlayerInventory.AddItem(item, -1);
PlayerInventory.ChangeGold((int)(item.goldValue * sellMod));
}
}
public void Buy(ItemData item)
{
if (PlayerInventory.gold >= item.goldValue)
{
PlayerInventory.ChangeGold(-item.goldValue);
PlayerInventory.AddItem(item);
}
}
private void Start()
{
BuyMode();
//Place holder starting inventory
PlayerInventory.ChangeGold(500);
PlayerInventory.AddItem(startItem, 5);
}
private void InitPlayer()
{
playerInventory.Init(new InventoryOptions()
{
origin = ItemOrigin.PlayerInventory,
resources = _resources,
contentTransform = playerSlotsParent,
itemDragTransform = itemDragParent,
slotCount = 12,
allowInternalSwap = true
});
playerInventory.OnItemDroppedEvent += OnPlayerItemReceive;
playerInventory.AddItem(_resources.itemDatabase.definitions[0].DefId, 0);
playerInventory.AddItem(_resources.itemDatabase.definitions[1].DefId, 1);
playerInventory.AddItem(_resources.itemDatabase.definitions[2].DefId, 2);
_inventoryQuery = playerInventory;
}
private void AddItems(PlayerInventory inventory, Guid itemId, int totalItemAmount, int tickTimeMs)
{
for (var i = 0; i < totalItemAmount; ++i)
{
inventory.AddItem(itemId);
System.Threading.Thread.Sleep(tickTimeMs);
}
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.gameObject.CompareTag(otherTag.value) && !other.isTrigger)
{
PlayerInventory inventory = other.gameObject.GetComponent <PlayerInventory>();
inventory.AddItem(item);
Destroy(this.gameObject);
}
}
public void ModifyItem(Item item)
{
inventoryManager.AddItem(item);
if (item.itemType == Item.ITEM_TYPES.SWORD)
{
// react to sword collect
PlayerController.GetInstance().InterruptState(AbstractState.ACTION.SWORD_UP);
}
}
