Jump to content
Unity Insider Forum

suckerpunch

Members
  • Gesamte Inhalte

    107
  • Benutzer seit

  • Letzter Besuch

  • Tagessiege

    1

Alle erstellten Inhalte von suckerpunch

    1. AgentCodeMonk

      AgentCodeMonk

      ...völlig überbewertet ...und auch gleichzeitig unterbewertet... wer kauft sich sowas und nutzt es wirklich? ...solange die hürden dermaßen groß sind -> brille aufsetzen... handschuhe tragen... das ganze kabelgedöns... ist ein cooles spielzeug für entwickler, aber für den "normalen" menschen?!

  1. Auch wenn ich das wie ne alte Platte leier: AWESOME
  2. Das Projekt bestand daraus den Input for oben unten rauszunehmen, well done! Hä? Ne mal ernsthaft das war mir jetzt nen bissl zu simpel, Erklärung bitte
  3. Sollte eher 35k/Jahr und Pro Person sein. Je nachdem welche Region in DE ist selbst das sehr dürftig für den Aufwand
  4. Wenn dann Abtretung der Rechte bei vollständiger Bezahlung (also im Erfolgsfall), außerdem zwischen wem wird der Vertrag geschlossen, zwischen 2 Privatpersonen oder zwischen den Arbeitnehmer und den Arbeitgeber in Form einer Firma.
  5. Hab wirklich Verständnis aber Vertrag ohne Bezahlung, oder ist die eventuelle Bezahlung auch im Vertrag geregelt ?
  6. Stellt euch mal vor aus wem besteht das Team, Erfahrungen, alte Projekte usw.
  7. suckerpunch

    Gong App

    Beste Seite die ich jemals gesehen habe. Ernst gemeint. Wo kann man den Webdesigner anheuern ?
  8. Das Spiel sieht echt gut aus, Co-Op ftw
  9. suckerpunch

    #3 Tabl - The Riddler?

    Ist halt hier ein Forum und du hast 0 Beiträge. Bring doch dein Wissen im Forum ein.
  10. Er ist immerhin 15 und hat eine eigene Firme, und sein Hobby ist Leute beleidigen. Da haste keine Zeit sich mit was selber zu beschäftigen!
  11. Erschöpfung sollte doch aber abnehmen nach einer Weile, also wenn Balken voll ist sollte er nach 5 Sekunden oder so sich anfangen wieder langsam zu leeren. Jedenfalls sterb ich nicht vom Sprinten im Realen Leben, bin erschöpft mach kurz Pause und dann geht weiter.
  12. Hallo schönes Spiel aber ist das so gedacht das man nach längeren Sprinten (?!) stirbt.
  13. Gibts schon Updates ? PS: Seite geht nicht
  14. 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
  15. suckerpunch

    ZBRUSH Kopf....

    Für mich als Programmierer der seine Kreativität nur in Codezeilen ausdrücken kann immer wieder beeindruckend was die klassisch künstlerische Garde so alles zaubern kann.
  16. Man muss Singleton's natürlich auch dort anwenden wo sie Sinn machen wenn hinter der Klasse eine Vererbungsstruktur steht dann sollte man eh meistens die Finger davon lassen weil das zu ganz anderen Problemen führt. Das was du ansprichst Zentrale Klasse die Instanzen verwaltet und erzeugt ist doch eher das Factory-Pattern. Würde mich bei Singleton's wirklich auf Engines, Loaders, DAOs beschränken
  17. Da sollte aber den Geschw.-Gewinn wieder zu nichte machen.
  18. Gut jetzt einfach mal die unbereinigte (Standard Using's) Klasse kopiert
  19. Ist ja nur die Klasse ohne Namespace und Using Angaben, das ergänzt die IDE ja bereitwillig : )
  20. Ist aber auch genau der Grund wieso man selten UDP im Spielbereich sieht, man weiß halt nie ob es angekommen ist.
  21. Hallo Liebe Forengemeinde, die Fortgeschrittenen unter uns kennen sicherlich das Singleton-Pattern, dies muss oft händisch für jede Klasse neu implementiert werden, was es gerade Anfängern schwer macht es immer umzusetzen. Ich mach es kurz, diese Klasse soll es jeden erleichtern das Pattern umsetzen und allein durch das erweitern dieser Klasse ein Singleton zu haben using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Util { /// <summary> /// Lazy-loading singleton /// </summary> /// <typeparam name="T">The type to have the singleton instance of</typeparam> [serializable] public abstract class Singleton<T> where T : new() { /// <summary> /// Private constructor to avoid external instantiation. /// </summary> /// <remarks> /// This is present to keep the compiler from providing a default public constructor /// </remarks> protected Singleton() { } /// <summary> /// Return an instance of /// </summary> public static T Instance { get { return SingletonHolder.instance; } set { SingletonHolder.instance = value; } } /// <summary> /// Sealed class to avoid any heritage from this helper class /// </summary> private sealed class SingletonHolder { internal static T instance = new T(); /// <summary> /// Explicit static constructor to tell C# compiler not to mark type as beforefieldinit /// </summary> static SingletonHolder() { } } } } Es ist Hauptsächlich für die typischen Klassen gedacht die nur einmal vorkommen sollen, NetworkService, DataLoader, verschiedene Engines Benutzung wäre dann einfach public class MySQL : Singleton<MySQL> { } Und schon wäre die Klasse MySQL ein Singleton und kann nur einmal erzeugt werden. Mit freundlichen Grüßen suckerpunch PS: Die Klasse stammt aus einem sehr sehr großen Projekt und ist eigentlich hinreichend erprobt.
  22. Über das Netzwerk würde ich das serialisieren von Objekten eh die Finger lassen, jedenfalls wenn es um den typischen Client Server Infoaustausch geht, ich komme aus der Emulator Szene (Aion/WoW/Blade & Soul), von daher kann ich sagen das sich die letzten 7 Jahre wo ich dabei bin bei unterschiedlichen Spielen doch immer der gleiche Netzwerkmechanismus durchgesetzt hat. Für C# wäre der ungefähr so public abstract class BnsPacket : MemoryStream { public NetConnection Connection; public bool Crypted = true; public int Opcode; public PacketType Type; protected BnsPacket(PacketType direction) { Type = direction; } } Man nutzt einen Memorystream, die ersten 4 Bytes sind der Opcode (dieser wird auf der Gegenseite zur Identifizierung genutzt), danach schreibt man seine Infos rein (da gibts freilich eine Helperklasse für) diese Infos werden nur über primitive Datentypen abgebildet und sehr sehr selten Strings. So werden die Packete sehr klein in Gegensatz zu einer ganzen Klasse und man spart sich in der Masse enorm Rechenzeit. Wie an den Spielen zu sehen beziehe ich mich hier auf MMORPG's, wo ein einzelner Client in kurzer Zeit Tausende Packete versendet und empfängt. PS: Versendet wird das einfach über eine asynchrone TcpConnection. PPS: Vielleicht besteht zu solchen Serverthemen auch mal Tutorial/Snippet Bedarf
  23. 176 Kb ob das den Braten Fett macht
×
×
  • Neu erstellen...