Gibt es ein Unity-Standart für Inventories?

[suckerpunch]

Hallo Liebe Leute,

 

hab mir mal überlegt ein Inventar zu machen, was recht viel einem abnimmt da es mit Event's arbeitet die beim hinzufügen und löschen von Gegenständen gefeuert werden.

 

Ich hab die Klassen komplett ohne vorheriges Recherchieren bezüglich einer direkten Möglichkeit/Klasse von Unity, also nicht böse sein wenn ich das Rad neu erfinde.

 

Beispielhaft sind jetzt als events auf dem Equipment; das ändern des Aussehens des Player-Characters und das Anforderungen von neuen Status Werten vom Server

 

MMOItem -> Ein Item, damit ist nicht GameObject gemeint sondern sozusagen das Datenobjekt was Werte usw beschreibt

 

VisibleObject -> Basisklasse von allen Objekten die man auch eine Visuelle Darstellung haben, Spieler, NPCs, Monster usw.

 

// Copyright (C) Paul Becker, - All Rights Reserved
// Unauthorized copying of this file, via any medium is strictly prohibited
// Proprietary and confidential
// Written by Paul Becker <paul.becker1@gmx.de>, 21:32
#region usings
using System;
using System.Collections.Generic;
using Assets.Helpers;
using Assets.Model.Item;
using UnityEngine;
#endregion
namespace Assets.Model.Player
{
public class Inventory<T, TK>
	where T : MMOItem
	where TK : VisibleObject
{
	private readonly EventDictionary<int, T> _equippedItems = new EventDictionary<int, T>(50);
	private readonly Dictionary<int, T> _inventoryItems = new Dictionary<int, T>(150);
	private readonly TK _owner;
	/// <summary>
	/// Gets the equipped items count.
	/// </summary>
	/// <value>
	/// The equipped items count.
	/// </value>
	public int EquippedItemsCount
	{
		get { return _equippedItems.Count; }
	}

	/// <summary>
	/// Initializes a new instance of the <see cref="Inventory{T, TK}"/> class.
	/// </summary>
	/// <param name="creator">The creator.</param>
	public Inventory(TK creator)
	{
		_equippedItems.OnItemsChangedActions += () => _owner.EvManager.UpdateVisualAppearance(_equippedItems.Values);
		_equippedItems.OnItemsChangedActions += () => _owner.EvManager.RequestNewStatsFromServer();
		this._owner = creator;
	}
	/// <summary>
	/// Registers the on equipement change event.
	/// </summary>
	/// <param name="h">The h.</param>
	public void RegisterOnEquipementChangeEvent(EventDictionary<int, T>.Handler h)
	{
		_equippedItems.OnItemsChangedActions += h;
	}
	/// <summary>
	/// Unregisters the on equipement change event.
	/// </summary>
	/// <param name="h">The h.</param>
	public void UnregisterOnEquipementChangeEvent(EventDictionary<int, T>.Handler h)
	{
		_equippedItems.OnItemsChangedActions -= h;
	}
	/// <summary>
	/// Adds the item to inventory.
	/// </summary>
	/// <param name="uid">The uid.</param>
	/// <param name="amount">The amount.</param>
	/// <param name="item">The item.</param>
	public void AddItemToInventory(int uid, int amount, T item)
	{
		item.Amount = amount;
		_inventoryItems.Add(uid, item);
	}
	/// <summary>
	/// Equips the item.
	/// </summary>
	/// <param name="uid">The uid.</param>
	/// <param name="item">The item.</param>
	public void EquipItem(int uid)
	{
		if (_inventoryItems.ContainsKey(uid))
		{
			_equippedItems.Add(uid, _inventoryItems[uid]);
			_inventoryItems.Remove(uid);
		}
	}

	/// <summary>
	/// Unequips the item.
	/// </summary>
	/// <param name="uid">The uid.</param>
	/// <param name="delete">if set to <c>true</c> [delete].</param>
	public void UnequipItem(int uid, bool delete = false)
	{
		if (!_equippedItems.ContainsKey(uid))
			return;
		if (!delete)
			_inventoryItems.Add(uid, _equippedItems[uid]);
		_equippedItems.Remove(uid);
	}
}
}

 

Dieses Dictionary feuert beim Hinzufügen und Löschen von Values, die ganzen OnItemsChangedActions. Ist auch was feines für Effekte etc.

 

// Copyright (C) Paul Becker, - All Rights Reserved
// Unauthorized copying of this file, via any medium is strictly prohibited
// Proprietary and confidential
// Written by Paul Becker <paul.becker1@gmx.de>, 21:33
#region usings
using System;
using System.Collections.Generic;
using System.Diagnostics;
#endregion
namespace Assets.Helpers
{
public class EventDictionary<TKey, TValue> : Dictionary<TKey, TValue>
{
	public delegate void Handler();
	public event Handler OnItemsChangedActions;
	/// <summary>
	///	 Initialisiert eine neue, leere Instanz der <see cref="T:System.Collections.Generic.Dictionary`2" />-Klasse mit der
	///	 angegebenen Anfangskapazität, wobei der Standardgleichheitsvergleich für den Schlüsseltyp verwendet wird.
	/// </summary>
	/// <param name="capacity">
	///	 Die anfängliche Anzahl von Elementen, die die <see cref="T:System.Collections.Generic.Dictionary`2" /> enthalten
	///	 kann.
	/// </param>
	/// <exception cref="T:System.ArgumentOutOfRangeException">
	///	 <paramref name="capacity" /> ist kleiner als 0 (null).
	/// </exception>
	public EventDictionary(int capacity) : base(capacity)
	{
	}
	/// <summary>
	///	 Initialisiert eine neue, leere Instanz der <see cref="T:System.Collections.Generic.Dictionary`2" />-Klasse mit der
	///	 Standardanfangskapazität, wobei der Standardgleichheitsvergleich für den Schlüsseltyp verwendet wird.
	/// </summary>
	public EventDictionary()
	{
	}
	/// <summary>
	///	 Initialisiert eine neue, leere Instanz der <see cref="T:System.Collections.Generic.Dictionary`2" />-Klasse mit der
	///	 Standardanfangskapazität und dem angegebenen <see cref="T:System.Collections.Generic.IEqualityComparer`1" />.
	/// </summary>
	/// <param name="comparer">
	///	 Die <see cref="T:System.Collections.Generic.IEqualityComparer`1" />-Implementierung, die zum Vergleichen von
	///	 Schlüsseln verwendet werden soll, oder null, wenn der Standard-
	///	 <see cref="T:System.Collections.Generic.EqualityComparer`1" /> für diesen Schlüsseltyp verwendet werden soll.
	/// </param>
	public EventDictionary(IEqualityComparer<TKey> comparer) : base(comparer)
	{
	}
	/// <summary>
	/// Fügt dem Wörterbuch den angegebenen Schlüssel und Wert hinzu.
	/// </summary>
	/// <param name="key">Der Schlüssel des hinzuzufügenden Elements.</param>
	/// <param name="value">Der Wert des zu hinzufügenden Elements. Der Wert kann für Referenztypen null sein.</param>
	public new void Add(TKey key, TValue value)
	{
		base.Add(key, value);
		if (OnItemsChangedActions == null) return;
		OnItemsChangedActions();
	}
	/// <summary>
	/// Entfernt den Wert mit dem angegebenen Schlüssel aus dem
	/// <see cref="T:System.Collections.Generic.Dictionary`2" />.
	/// </summary>
	/// <param name="key">Der Schlüssel des zu entfernenden Elements.</param>
	/// <returns>
	/// true, wenn das Element gefunden und entfernt wurde, andernfalls false.  Diese Methode gibt auch dann false zurück, wenn
	/// <paramref name="key" /> nicht im ursprünglichen
	/// <see cref="T:System.Collections.Generic.Dictionary`2" /> gefunden wurde.
	/// </returns>
	public new bool Remove(TKey key)
	{
		base.Remove(key);
		if (OnItemsChangedActions != null)
			OnItemsChangedActions();
		return !ContainsKey(key);
	}
}
}

 

Nutzung im Player Objekt

Inventory<MMOItem, Player> Inventory = new Inventory<MMOItem, Player>(this);
//Test Action
Inventory.RegisterOnEquipementChangeEvent(() => Debug.Log("Hallo Welt"));

 

 

Eigentliche Frage Mühe umsonst gemacht und es gibt schon was vorgefertigtes was auch ähnliches kann?

 

Also:

• Halten von Dateiobjekten
  
• Registrierung von Events was bei der Änderung der Collection passieren soll
  

[Sascha]

Ich bastel ja ganz gerne mit ScriptableObjects.

Sind schlicht selbst programmierbare Assets, die man in gewohntem Unity Drag&Drop erstellen, bearbeiten und irgendwo rein tun kann.

Hab hier was darüber geschrieben.

 

Ob das jetzt was für euch ist, weiß ich nicht, aber Items zusammen zu klicken gefällt dem Designer idR schon ganz gut