Sistema de inventario (2D?)

(Creio que não tenha muita diferença do inventario de um jogo 3D pro 2D mas, vai saber né)
Pretendo fazer um inventario para meu jogo e gostaria de saber se tem algum tutorial explicando como posso fazer, é muito complexo fazer um inventario ou da pra fazer um sem muito conhecimento ?

E Quase Mesma Coisa De Fazer em 3d

complexo

sem muito conhecimento e quase impossível mais se você sabe raciocinar com programação orientada a objeto você vai conseguir

o mais complicado talvez seja salvar os dados mais isso e o de menos

você precisa fazer classe para o slot classe para o inventario classe para item classe para player e ir gerando classes a partir das classes existentes usando o polimorfismo
e o mais importante lógica porque as classe de forma direta ou indireta vão ficar ligados um com outro 

e se envolver multiplayer ai fica mais complexo

Então, inventário é a ovelha negra dos tutoriais... Eh a coisa mais chata e complexa de se fazer, pois meio que tem que ser feito especificamente para o seu projeto, e é interessante utilizar banco de dados.

É um dos poucos assuntos que eu não pretendo trazer em tutorial por que é extremamente difícil eu fazer um sistema e ele se adaptar ao seu jogo de maneira correta sem gerar uma penca de problemas.

Bem, eu acho que encontrei uma maneira "menos complexa" de fazer meus inventários. ( Online ).

Basicamente eu tenho um conjunto de classes php que já tratam tudo (Adição, remoção, armazenamento...).

E eu simplesmente chamo a página com os parâmetros ( id do jogador, item, oque fazer com o item... ) e depois retorno um json e trato de volta no C#. É mais complexo de explicar do que fazer.


Como eu trabalho com servidor autoritário, o meu apache está configurado pra aceitar conexões somente do servidor, assim não corro o risco de manipulações indesejadas. 

Eu estou bem no meio de um projeto e pretendo UM DIA colocar isso no github pra facilitar a vida da galera.

Galera, não acho que fazer inventário seja tanto problema. Em quase todos os meus projetos eu crio um sistema desses. Encontrei uma forma simples, porém talvez não a mais correta, que é criar uma lista que armazene os meus objetos.

A lista seria algo assim: 

Código:

using UnityEngine;
using System.Collections.Generic;
using System;

public class Inventario : MonoBehaviour {

    public List<Itens> itens;

}

[Serializable]
public class Itens
{
    public string NomeDoItem; // na verdade, eu geralmente nao utilizo o nome do item, mas sim um ENUM que vai diferenciar um tipo de item do outro.
    public int Quantidade;
}


A partir disso, só precisamos criar funções para adicionar objetos a esta lista.

O real problema chega na hora de salvar, pois se não usarmos banco de dados, tudo isso deve ser gravado com playerprefs.

Uma forma que eu utilizo é salvar valor por valor (por isso disse que talvez não fosse a mais correta), salvando o item em diferentes partes, seguidas do index do item na lista para poder resgatar esse valor futuramente. Outra coisa interessante, é guardar também o número de itens que foram salvos para poder pegar todos os valores sem se preocupar com limite de inventário.

Um exemplo bem básico: 

Código:

using UnityEngine;
using System.Collections.Generic;
using System;

public class Inventario : MonoBehaviour {

    public List<Item> itens;


    void SalvarItens ()
    {
        int indexItens = 0;

        while (indexItens < itens.Count)
        {
            PlayerPrefs.SetString("NomeItem" + indexItens.ToString(), itens[indexItens].NomeDoItem);
            PlayerPrefs.SetInt("Quantidade" + indexItens.ToString(), itens[indexItens].Quantidade);
            PlayerPrefs.SetInt("NumeroDeItensSalvos", indexItens + 1);                             // salvar a quantidade de itens que foram salvos
            indexItens++;
        }
        PlayerPrefs.Save();
    }

    void ResgatarItens ()
    {
        itens.Clear();

        int numeroDeItens = PlayerPrefs.GetInt("NumeroDeItensSalvos");
        int indexItens = 0;

        while (numeroDeItens > indexItens)
        {
            itens.Add(new Item());
            itens[indexItens].NomeDoItem = PlayerPrefs.GetString("NomeItem" + indexItens.ToString());
            itens[indexItens].Quantidade = PlayerPrefs.GetInt("Quantidade" + indexItens.ToString());
            indexItens++;
        }
    }
}

[Serializable]
public class Item
{
    public string NomeDoItem;
    public int Quantidade;
}


Tenho que admitir que é trabalhoso, mas não difícil.

Tudo bem, é algo simples. Mas isso é só a ponta do iceberg. Ainda tem o sistema de interação com ele, interação com itens... tem gente que chega aqui no forum pedindo um inventário multiplayer ... ai vc ainda terá que criar todo o sistema ant bug, fraude, e de interação entre players, npcs. Por isso não basta apenas salvar itens, é preciso criar um sistema gigante e complexo que vai envolver praticamente todas as areas do jogo.
A não ser que o jogo não use inventario pra quase nada, e só pra salvar 3 itens.

Concordo com o meu chará Renan.
Não acho complicado, mas é muito particular e meio que impossível você ter uma coisa genérica.
Até sistema de interação e antifraude  a resposta de como fazer sempre será: Depende!

blz, pelo que vi é basicamente complexo de fazer um sistema de inventario, mas gostaria de saber onde vcs aprenderam a fazer, foi buscando pela net? tem algo na net que me ajuda a entender como posso fazer um futuramente ?

não tem muito o que fazer a não ser estudar o básico e ir pro avançado
a sim você pode implementar sua própria lógica eu já fiz um sistema de inventario a um tempo vou mostra o script do slot se vc entender ele você esta apto a fazer um inventario

ele esta incompleto falta fazer algumas funçõese e remover algumas gambiarras

Código:

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using UnityEngine.EventSystems;
using Items;

public class Slot : MonoBehaviour, IDragHandler, IEndDragHandler, IBeginDragHandler, IPointerClickHandler
{

    #region VARIAVEIS

    public Image iconItem;
    public Text amountItem;

    public Image dragIconItem;

    public Slider durabilitySlider;

    public bool UseTypeToRestriction;
    public ITEM_TYPE restrictionType;

    protected bool currentSlotIsEmpty = true;
    protected bool canDrag = false;
    protected ItemBase currentItemInSlot;
    protected Slot nextSlot = null;

    #endregion

    protected void Start()
    {
        canDrag = false;
    }
    
    protected void Update()
    {
        currentSlotIsEmpty = currentItemInSlot == null ? true : false;

        if (!currentSlotIsEmpty)
        {
            ItemValues();
            iconItem.sprite = currentItemInSlot.iconItem;
            iconItem.enabled = true;
        }
        else
        {
            amountItem.enabled = false;
            iconItem.enabled = false;
            durabilitySlider.gameObject.SetActive(false);
        }
    }
    
    protected void ItemValues()
    {
        if (currentItemInSlot.itemType == ITEM_TYPE.CONSUMABLES)
        {
            ConsumableItemBehaviour consumableItemBehaviour = currentItemInSlot.GetComponent<ConsumableItemBehaviour>();

            if (consumableItemBehaviour.typeComsumable == TYPE_CONSUMABLE.DRINK)
            {
                amountItem.enabled = true;
                float amount = consumableItemBehaviour.amount;
                amountItem.text = string.Format("{0}ML", amount);
            }
        }
        else if (currentItemInSlot.itemType == ITEM_TYPE.CLOTHING || currentItemInSlot.itemType == ITEM_TYPE.WEAPONS)
        {
            durabilitySlider.gameObject.SetActive(true);
            amountItem.enabled = false;
        }
        else
        {
            amountItem.text = string.Format("x{0}", currentItemInSlot.amountItem);
        }
    }

    #region Events

    public virtual void OnPointerClick(PointerEventData eventData)
    {

    }

    public virtual void OnBeginDrag(PointerEventData eventData)
    {
        if (currentItemInSlot == null)
            return;
        
        dragIconItem.sprite = currentItemInSlot.iconItem;
        dragIconItem.enabled = true;
        canDrag = true;
    }

    public virtual void OnDrag(PointerEventData eventData)
    {
        if (!canDrag)
            return;

        Vector2 mousePosition = eventData.position;
        dragIconItem.transform.position = mousePosition;
    }

    public virtual void OnEndDrag(PointerEventData eventData)
    {
        if (!canDrag)
            return;

        if (eventData.pointerEnter != null)
        {
            nextSlot = eventData.pointerEnter.GetComponent<Slot>();
        }

        if (nextSlot != null)
        {
            if (nextSlot.IsEmpty())
            {
                ChangeToSlot(nextSlot);
            }
            else
            {
                if (nextSlot.GetItemInSlot().Stackable)
                {
                    if (currentItemInSlot.idItem == nextSlot.GetItemInSlot().idItem)
                    {
                        CopyToSlot(nextSlot);
                    }
                }
            }
            nextSlot = null;
        }

        canDrag = false;
        dragIconItem.enabled = false;
    }
    #endregion

    #region Actions

    protected void ChangeToSlot(Slot slot)
    {
        if (slot.UseTypeToRestriction)
        {
            if (slot.restrictionType == currentItemInSlot.itemType)
            {
                RemoveItem(currentItemInSlot);
                slot.ChangeItem(currentItemInSlot);
                currentItemInSlot = null;
            }
        }
        else
        {


            if (slot.restrictionItem())
            {
                ClothingBase clotthing = currentItemInSlot.GetComponent<ClothingBase>();

                if (clotthing.clothingType != CLOTHING_TYPE.BACKPACK)
                {
                    slot.ChangeItem(currentItemInSlot);
                    currentItemInSlot = null;
                }
            }
            else
            {
                RemoveItem(currentItemInSlot);
                slot.ChangeItem(currentItemInSlot);
                currentItemInSlot = null;
            }
        }
    }

    protected void CopyToSlot(Slot slot)
    {
        if (slot != this)
        {
            if (currentItemInSlot.itemType == ITEM_TYPE.CONSUMABLES)
            {
                ConsumableItemBehaviour consumableItemBehaviour = currentItemInSlot.GetComponent<ConsumableItemBehaviour>();

                if (consumableItemBehaviour.typeComsumable == TYPE_CONSUMABLE.DRINK)
                {
                    ConsumableItemBehaviour slotconsumableItemBehaviour = slot.GetItemInSlot().GetComponent<ConsumableItemBehaviour>();

                    consumableItemBehaviour.amount -= slotconsumableItemBehaviour.Replace(consumableItemBehaviour.amount);
                }
            }
            else
            {
                int amountItem = (currentItemInSlot.amountItem + slot.GetItemInSlot().amountItem);
                if (amountItem > 250)
                    return;

                slot.GetItemInSlot().amountItem += currentItemInSlot.amountItem;
                currentItemInSlot = null;
            }
        }
    }

    public void AddItemInSlot(ItemBase item)
    {
        if (currentItemInSlot == null)
        {
            currentItemInSlot = item;
            iconItem.enabled = true;
            amountItem.enabled = true;
            currentSlotIsEmpty = false;

            ItemValues();
            iconItem.sprite = item.iconItem;
        }
    }

    public void ChangeItem(ItemBase item)
    {
        if (currentItemInSlot == null)
        {
            currentItemInSlot = item;
        }

        PutItem(item);
    }

    #endregion

    #region Other

    public void IsStacking(ItemBase item)
    {
        currentItemInSlot.amountItem += item.amountItem;
        ItemValues();
    }

    public virtual bool restrictionItem()
    {
        return false;
    }

    public bool IsEmpty()
    {
        return currentSlotIsEmpty;
    }

    public ItemBase GetItemInSlot()
    {
        return currentItemInSlot;
    }

    public void ResetSlot()
    {
        currentItemInSlot = null;
        amountItem.enabled = false;
        iconItem.enabled = false;
        durabilitySlider.gameObject.SetActive(false);
    }

    #endregion

    #region PutEndRemoveItem

    public virtual void ApplyActionItem(ItemBase item)
    {

    }

    public virtual void RemoveActionItem(ItemBase item)
    {

    }

    #endregion
}