Verbessern Sie Ihren Code mit Programmiermustern für Spiele

Wenn Sie Erfahrung mit objektorientierten Programmiersprachen haben, dann haben Sie wahrscheinlich schon von den SOLID-Prinzipien, MVP, Singleton, Factory und Observer Pattern gehört. Unser neues E-Book zeigt Best Practices für die Verwendung dieser Prinzipien und Muster auf, um eine skalierbare Spielcode-Architektur in Ihrem Unity-Projekt zu erstellen.

Für jedes Problem beim Softwaredesign, das Ihnen begegnet, gibt es tausend Entwickler, die es schon einmal erlebt haben. Man kann sie zwar nicht immer direkt um Rat fragen, aber man kann von ihren Entscheidungen durch Entwurfsmuster lernen.

Durch die Implementierung gängiger Entwurfsmuster für die Spieleprogrammierung in Ihrem Unity-Projekt können Sie effizient eine saubere, organisierte und lesbare Codebasis erstellen und pflegen, was wiederum eine solide Grundlage für die Skalierung Ihres Spiels, Entwicklungsteams und Unternehmens schafft.

In unserer Community hören wir oft, dass es einschüchternd sein kann, zu lernen, wie man Entwurfsmuster und Prinzipien wie SOLID und KISS in die tägliche Entwicklung einbezieht. Deshalb ist unser kostenloses E-Book, Verbessern Sie Ihren Code mit Programmiermustern für Spielebekannte Entwurfsmuster erklärt und praktische Beispiele für ihre Verwendung in Ihrem Unity-Projekt gegeben.

Das E-Book wurde von internen und externen Unity-Experten verfasst und ist eine Ressource, die den Werkzeugkasten Ihres Entwicklers erweitern und den Erfolg Ihres Projekts beschleunigen kann. Lesen Sie weiter, um einen Überblick über den Inhalt des Leitfadens zu erhalten.

Entwurfsmuster sind allgemeine Lösungen für häufig auftretende Probleme in der Softwareentwicklung. Dabei handelt es sich nicht um fertige Lösungen, die Sie kopieren und in Ihren Code einfügen können, sondern um zusätzliche Tools, die Ihnen bei richtiger Anwendung bei der Entwicklung größerer, skalierbarer Anwendungen helfen können.

Durch die konsequente Integration von Mustern in Ihr Projekt können Sie die Lesbarkeit des Codes verbessern und Ihre Codebasis sauberer gestalten. Design Patterns reduzieren nicht nur das Refactoring und den Zeitaufwand für das Testen, sie beschleunigen auch die Einführungs- und Entwicklungsprozesse.

Jedes Entwurfsmuster bringt jedoch Kompromisse mit sich, sei es, dass zusätzliche Strukturen gepflegt werden müssen, oder dass zu Beginn mehr Aufwand entsteht. Sie müssen eine Kosten-Nutzen-Analyse durchführen, um festzustellen, ob der Vorteil den Mehraufwand rechtfertigt. Diese Bewertung hängt natürlich von Ihrem Projekt ab.

KISS steht für "keep it simple, stupid". Ziel dieses Grundsatzes ist es, unnötige Komplexität in einem System zu vermeiden, da Einfachheit zu einer höheren Benutzerakzeptanz und Interaktion beiträgt.

Beachten Sie, dass "einfach" nicht gleichbedeutend mit "leicht" ist. Etwas einfach zu machen, bedeutet, es gezielt zu gestalten. Zwar kann man die gleiche Funktionalität auch ohne die Muster erstellen (und oft auch schneller), aber etwas, das schnell und einfach ist, muss nicht zwangsläufig zu etwas Einfachem führen.

Wenn Sie sich nicht sicher sind, ob ein Muster auf Ihr spezielles Problem zutrifft, können Sie damit warten, bis Sie das Gefühl haben, dass es besser passt. Benutzen Sie ein Muster nicht, weil es für Sie neu oder ungewohnt ist. Verwenden Sie es, wenn Sie es brauchen.

In diesem Sinne wurde das E-Book erstellt. Halten Sie den Leitfaden als Inspirationsquelle für neue Wege zur Organisation Ihres Codes bereit - nicht als striktes Regelwerk, das Sie befolgen müssen.

Wenden wir uns nun einigen der wichtigsten Software-Design-Prinzipien zu.

SOLID ist ein mnemonisches Akronym für fünf Kerngrundlagen des Softwaredesigns. Man kann sie sich als fünf Grundregeln vorstellen, die man beim Programmieren beachten sollte, um sicherzustellen, dass objektorientierte Designs flexibel und wartbar bleiben.

Die SOLID-Prinzipien wurden erstmals von Robert C. Martin in dem Papier Design Principles and Design Patterns vorgestellt. Erstmals im Jahr 2000 veröffentlicht, sind die beschriebenen Prinzipien auch heute noch gültig, auch für C#-Scripting in Unity:

• Die Einzelverantwortung besagt, dass jedes Modul, jede Klasse oder Funktion für eine Sache verantwortlich ist und nur diesen Teil der Logik kapselt.
• Open-closed besagt, dass Klassen offen für Erweiterungen, aber geschlossen für Änderungen sein müssen; das bedeutet, dass Sie Ihre Klassen so strukturieren müssen, dass sie neues Verhalten erzeugen können, ohne den ursprünglichen Code zu verändern.
• Die Liskov-Substitution besagt, dass abgeleitete Klassen bei der Vererbung durch ihre Basisklasse ersetzbar sein müssen.
• Die Schnittstellentrennung besagt, dass kein Client gezwungen werden sollte, von Methoden abzuhängen, die er nicht verwendet. Die Kunden sollten nur das umsetzen, was sie brauchen.
• Die Inversion von Abhängigkeiten besagt, dass High-Level-Module nichts direkt von Low-Level-Modulen importieren sollten. Beide sollten von Abstraktionen abhängen.

Im E-Book finden Sie illustrierte Beispiele für jedes Prinzip mit klaren Erklärungen für die Verwendung in Unity. In einigen Fällen kann die Einhaltung von SOLID zu einem zusätzlichen Arbeitsaufwand führen. Möglicherweise müssen Sie einige Ihrer Funktionen in Abstraktionen oder Schnittstellen umwandeln, aber das zahlt sich oft durch langfristige Einsparungen aus.

Diese Prinzipien dominieren seit fast zwei Jahrzehnten das Softwaredesign auf Unternehmensebene, weil sie sich so gut für große, skalierbare Anwendungen eignen. Wenn Sie sich nicht sicher sind, wie Sie sie verwenden sollen, können Sie sich auf das KISS-Prinzip berufen. Halten Sie es einfach und versuchen Sie nicht, die Prinzipien in Ihre Skripte zu zwingen, nur um der Sache willen. Lassen Sie sie sich organisch und aus der Notwendigkeit heraus entwickeln.

Wenn Sie mehr erfahren möchten, sehen Sie sich die SOLID-Präsentation von Dan Sagmiller von Productive Edge auf der Unite Austin 2017 an.

Was ist der Unterschied zwischen einem Entwurfsprinzip und einem Entwurfsmuster? Eine Möglichkeit, diese Frage zu beantworten, besteht darin, SOLID als ein Rahmenwerk für das Schreiben von objektorientiertem Code oder als einen grundlegenden Ansatz dafür zu betrachten. Design Patterns sind zwar Lösungen oder Werkzeuge, die Sie implementieren können, um alltägliche Software-Probleme zu vermeiden, aber denken Sie daran, dass es sich dabei nicht um Rezepte von der Stange handelt - oder gar um Algorithmen mit bestimmten Schritten, um bestimmte Ergebnisse zu erzielen.

Ein Entwurfsmuster kann man sich wie eine Blaupause vorstellen. Es handelt sich um einen allgemeinen Plan, der die eigentliche Konstruktion Ihnen überlässt. So können beispielsweise zwei Programme demselben Muster folgen, aber sehr unterschiedlichen Code enthalten.

Wenn Entwickler in der freien Wildbahn auf das gleiche Problem stoßen, werden viele von ihnen zwangsläufig ähnliche Lösungen finden. Wenn sich eine Lösung oft genug wiederholt, kann es sein, dass jemand ein Muster "entdeckt" und ihm offiziell einen Namen gibt.

Viele der heutigen Software-Entwurfsmuster stammen aus dem bahnbrechenden Werk Design Patterns: Elements of Reusable Object-Oriented Software von Erich Gamma, Richard Helm, Ralph Johnson und John Vlissides. In diesem Buch werden 23 solcher Muster vorgestellt, die in einer Vielzahl von alltäglichen Anwendungen identifiziert wurden.

Die Originalautoren werden oft als "Gang of Four" (GoF) bezeichnet, und Sie werden die Originalmuster auch als GoF-Muster hören. Obwohl die zitierten Beispiele meist in C++ (und Smalltalk) zu finden sind, können Sie ihre Ideen auf jede objektorientierte Sprache, wie z. B. C#, anwenden.

Seit der ursprünglichen Veröffentlichung von Design Patterns durch die Gang of Four im Jahr 1994 haben Entwickler Dutzende weiterer objektorientierter Muster in einer Vielzahl von Bereichen eingeführt, darunter auch in der Spieleentwicklung.

Sie können zwar als Spieleprogrammierer arbeiten, ohne sich mit Entwurfsmustern zu beschäftigen, aber das Erlernen dieser Muster wird Ihnen helfen, ein besserer Entwickler zu werden. Schließlich werden Entwurfsmuster als solche bezeichnet, weil sie allgemeine Lösungen für bekannte Probleme darstellen.

Software-Ingenieure entdecken sie im Laufe der Entwicklung immer wieder neu. Vielleicht haben Sie einige dieser Muster bereits unbewusst umgesetzt.

Trainieren Sie, nach ihnen zu suchen. Diese Vorgehensweise kann Ihnen helfen:

• Lernen Sie objektorientiertes Programmieren: Entwurfsmuster sind keine Geheimnisse, die in einem esoterischen StackOverflow-Beitrag vergraben sind. Sie sind gängige Methoden zur Überwindung alltäglicher Hürden in der Entwicklung. Sie können Sie darüber informieren, wie viele andere Entwickler das gleiche Problem angegangen sind - denken Sie daran, selbst wenn Sie keine Muster verwenden, tut es jemand anderes.
• Sprechen Sie mit anderen Entwicklern: Muster können als Kurzschrift dienen, wenn man versucht, im Team zu kommunizieren. Erwähnen Sie das "Befehlsmuster" oder den "Objektpool" und erfahrene Unity-Entwickler werden wissen, was Sie zu implementieren versuchen.
• Entdecken Sie neue Frameworks: Wenn Sie ein integriertes Paket oder etwas aus dem Asset Store importieren, stoßen Sie unweigerlich auf eines oder mehrere der hier beschriebenen Muster. Das Erkennen von Entwurfsmustern hilft Ihnen zu verstehen, wie ein neues Framework funktioniert und welche Überlegungen bei seiner Erstellung angestellt wurden.

Wie bereits erwähnt, sind nicht alle Entwurfsmuster auf jede Spielanwendung anwendbar. Suchen Sie nicht mit dem Maslowschen Hammer, sonst finden Sie vielleicht nur Nägel.

Wie bei jedem anderen Werkzeug auch, hängt die Nützlichkeit eines Entwurfsmusters vom Kontext ab. Jede von ihnen bietet in bestimmten Situationen einen Vorteil, hat aber auch ihre Nachteile. Jede Entscheidung in der Softwareentwicklung ist mit Kompromissen verbunden.

Erzeugen Sie viele GameObjects im laufenden Betrieb? Wirkt sich das auf Ihre Leistung aus? Kann eine Umstrukturierung Ihres Codes das Problem lösen? Seien Sie sich dieser Entwurfsmuster bewusst, und wenn die Zeit reif ist, ziehen Sie sie aus Ihrer Gamedev-Trickkiste, um das anstehende Problem zu lösen.

Neben den Design Patterns der Gang of Four ist Game Programming Patterns von Robert Nystrom eine weitere hervorragende Ressource, die derzeit kostenlos als webbasierte Ausgabe erhältlich ist. Der Autor beschreibt eine Vielzahl von Software-Patterns in einer nüchternen Art und Weise.

In unserem neuen E-Book können Sie in die Abschnitte eintauchen, in denen gängige Entwurfsmuster wie Factory-, Object Pool-, Singleton-, Command-, State- und Observer-Muster sowie der Model View Presenter (MVP) erklärt werden. Jeder Abschnitt erklärt das Muster mit seinen Vor- und Nachteilen und bietet ein Beispiel für die Implementierung in Unity, damit Sie es in Ihrem Projekt optimal einsetzen können.

Unity implementiert bereits mehrere etablierte Gamedev-Muster, so dass Sie sich die Mühe sparen können, diese selbst zu schreiben. Dazu gehören:

• Spielschleife: Das Herzstück aller Spiele ist eine Endlosschleife, die unabhängig von der Taktfrequenz funktionieren muss, da die Hardware, mit der eine Spielanwendung betrieben wird, sehr unterschiedlich sein kann. Um Computer mit unterschiedlichen Geschwindigkeiten zu berücksichtigen, müssen Spieleentwickler oft einen festen Zeitschritt (mit einer bestimmten Anzahl von Bildern pro Sekunde) und einen variablen Zeitschritt verwenden, bei dem die Engine misst, wie viel Zeit seit dem letzten Bild vergangen ist.
  
  Unity kümmert sich darum, so dass Sie es nicht selbst implementieren müssen. Sie müssen nur den Spielverlauf mit MonoBehaviour-Methoden wie Update, LateUpdate und FixedUpdate verwalten.
  
• Aktualisierung: In Ihrer Spielanwendung werden Sie das Verhalten jedes Objekts oft Frame für Frame aktualisieren. Während Sie dies in Unity manuell nachbilden können, erledigt die Klasse MonoBehaviour dies automatisch. Verwenden Sie die entsprechenden Update-, LateUpdate- oder FixedUpdate-Methoden, um Ihre GameObjects und Komponenten an einen Tick der Spieluhr anzupassen.

• Prototyp: Oft müssen Sie Objekte kopieren, ohne das Original zu verändern. Dieses Schöpfungsmuster löst das Problem des Duplizierens und Klonens eines Objekts, um andere Objekte zu schaffen, die ihm ähnlich sind. Auf diese Weise vermeiden Sie die Definition einer separaten Klasse, um jede Art von Objekt in Ihrem Spiel zu erzeugen.
  
  Das Prefab-System von Unity implementiert eine Form des Prototyping für GameObjects. Auf diese Weise können Sie ein Vorlagenobjekt komplett mit seinen Komponenten duplizieren. Setzen Sie bestimmte Eigenschaften außer Kraft, um Voreinstellungsvarianten zu erstellen, oder verschachteln Sie Voreinstellungen innerhalb anderer Voreinstellungen, um Hierarchien zu erstellen. Verwenden Sie einen speziellen Prefab-Bearbeitungsmodus, um Prefabs isoliert oder im Kontext zu bearbeiten.
  
• Komponente:Die meisten Leute, die mit Unity arbeiten, kennen dieses Muster. Anstatt große Klassen mit mehreren Zuständigkeiten zu erstellen, bauen Sie kleinere Komponenten, die jeweils eine Aufgabe erfüllen.
  
  Wenn Sie die Komposition verwenden, um Komponenten auszuwählen, können Sie diese für ein komplexes Verhalten kombinieren. Fügen Sie Rigidbody- und Collider-Komponenten für die Physik oder einen MeshFilter und MeshRenderer für die 3D-Geometrie hinzu. Jedes GameObjects ist nur so reichhaltig und einzigartig wie seine Sammlung von Komponenten.

Sowohl das E-Book als auch ein Beispielprojekt zur Verwendung von Entwurfsmustern stehen jetzt zum kostenlosen Download bereit. Sehen Sie sich die Beispiele an und entscheiden Sie, welches Entwurfsmuster am besten zu Ihrem Projekt passt. Mit zunehmender Erfahrung werden Sie erkennen, wie und wann sie Ihren Entwicklungsprozess verbessern können. Wie immer ermutigen wir Sie, den Forumsthread zu besuchen und uns mitzuteilen, was Sie von dem E-Book und der Leseprobe halten.