Share
Ein Spiel besteht normalerweise aus mehreren verschiedenen Entitäten, die miteinander interagieren. Diese Interaktionen sind in der Regel sehr dynamisch und eng mit dem Gameplay verbunden. Dieses Tutorial behandelt das Konzept und die Implementierung eines Nachrichtenwarteschlangensystems, das die Interaktionen von Entitäten vereinheitlichen kann, wodurch Ihr Code bei zunehmender Komplexität verwaltbar und einfach zu warten ist.
Eine Bombe kann mit einer Figur interagieren, indem sie explodiert und Schaden anrichtet, ein Sanitäter-Set kann eine Entität heilen, ein Schlüssel kann eine Tür öffnen und so weiter. Die Interaktionen in einem Spiel sind endlos, aber wie können wir den Code des Spiels überschaubar halten und trotzdem alle diese Interaktionen handhaben? Wie stellen wir sicher, dass sich der Code ändern kann und weiterhin funktioniert, wenn neue und unerwartete Interaktionen auftreten??
Interaktionen in einem Spiel werden in der Regel sehr schnell komplexer.Wenn Interaktionen hinzugefügt werden (insbesondere die unerwarteten), wird Ihr Code immer unübersichtlicher. Bei einer naiven Implementierung werden Sie schnell Fragen stellen wie:
"Dies ist die Entität A, daher sollte ich die Methode aufrufen Beschädigung() darauf richtig? Oder ist es damageByItem ()? Vielleicht das damageByWeapon () Methode ist die richtige? "
Stellen Sie sich dieses Chaos vor, das sich auf alle Ihre Spieleinheiten ausbreitet, weil sie alle auf unterschiedliche Weise miteinander interagieren. Glücklicherweise gibt es eine bessere, einfachere und überschaubarere Art, dies zu tun.
Geben Sie das ein Nachrichtenwarteschlange. Die Grundidee hinter diesem Konzept ist, alle Spielinteraktionen als Kommunikationssystem (das heute noch verwendet wird) zu implementieren: den Nachrichtenaustausch. Menschen haben seit Jahrhunderten über Nachrichten (Briefe) kommuniziert, weil es ein effektives und einfaches System ist.
In unseren Postdiensten kann der Inhalt jeder Nachricht unterschiedlich sein, aber die Art und Weise, wie sie physisch gesendet und empfangen werden, bleibt gleich. Ein Absender legt die Informationen in einen Umschlag und adressiert sie an ein Ziel. Das Ziel kann auf dieselbe Weise antworten (oder nicht), indem es die "Von / Bis" -Felder des Umschlags ändert.
Interaktionen, die über ein Nachrichtenwarteschlangensystem vorgenommen werden.Wenn Sie diese Idee auf Ihr Spiel anwenden, können alle Interaktionen zwischen Entitäten als Nachrichten betrachtet werden. Wenn eine Spieleinheit mit einer anderen Gruppe (oder einer Gruppe von ihnen) interagieren möchte, muss sie lediglich eine Nachricht senden. Das Ziel bearbeitet oder reagiert auf die Nachricht basierend auf ihrem Inhalt und dem Absender.
Bei diesem Ansatz wird die Kommunikation zwischen Spieleinheiten vereinheitlicht. Alle Entitäten können Nachrichten senden und empfangen. Unabhängig von der Komplexität oder Eigenart der Interaktion oder Nachricht ist der Kommunikationskanal immer gleich.
In den nächsten Abschnitten werde ich beschreiben, wie Sie diesen Ansatz der Nachrichtenwarteschlange in Ihrem Spiel implementieren können.
Beginnen wir mit dem Entwurf des Umschlags, dem grundlegendsten Element im Nachrichtenwarteschlangensystem.
Ein Umschlag kann wie in der folgenden Abbildung beschrieben werden:
Struktur einer Nachricht.Die ersten beiden Felder (Absender und Ziel) sind Verweise auf die erstellte Entität bzw. auf die Entität, die diese Nachricht erhalten soll. Mit diesen Feldern können sowohl der Sender als auch der Empfänger feststellen, wohin die Nachricht gesendet wird und woher sie kommt.
Die anderen beiden Felder (Art und Daten) arbeiten Sie zusammen, um sicherzustellen, dass die Nachricht ordnungsgemäß verarbeitet wird. Das Art Feld beschreibt, worum es in dieser Nachricht geht. Zum Beispiel, wenn der Typ ist "Beschädigung", Der Empfänger behandelt diese Nachricht als Befehl, die Gesundheitspunkte zu verringern. wenn der Typ ist "verfolgen", Der Empfänger nimmt es als Anweisung an, etwas zu verfolgen - und so weiter.
Das Daten Feld ist direkt mit dem verbunden Art Feld. Verwenden Sie die vorherigen Beispiele, wenn der Nachrichtentyp ist "Beschädigung", dann ist die Daten Feld enthält eine Zahl sagen, 10-Hier wird beschrieben, wie viel Schaden der Empfänger an seinen Gesundheitspunkten anrichten sollte. Wenn der Nachrichtentyp ist "verfolgen", Daten enthält ein Objekt, das das zu beschreibende Ziel beschreibt.
Das Daten Das Feld kann beliebige Informationen enthalten, was den Umschlag zu einem vielseitigen Kommunikationsmittel macht. In diesem Feld kann alles platziert werden: Ganzzahlen, Floats, Strings und sogar andere Objekte. Die Faustregel besagt, dass der Empfänger wissen muss, was sich im Empfänger befindet Daten Feld basierend auf dem, was in der ist Art Feld.
All diese Theorie kann in eine sehr einfache Klasse namens übersetzt werden Botschaft. Es enthält vier Eigenschaften, eine für jedes Feld:
Message = Funktion (an, aus, Typ, Daten) // Eigenschaften this.to = to; // ein Verweis auf die Entität, die diese Nachricht erhalten soll this.from = from; // ein Verweis auf die Entität, die diese Nachricht gesendet hat this.type = type; // der Typ dieser Nachricht this.data = data; // den Inhalt / die Daten dieser Nachricht;
Als ein Beispiel dafür, wenn eine Entität verwendet wird EIN will ein senden "Beschädigung" Nachricht an die Entität B, es muss lediglich ein Objekt der Klasse instanziieren Botschaft, Legen Sie die Eigenschaft fest zu zu B, Legen Sie die Eigenschaft fest von zu sich selbst (Entität EIN), einstellen Art zu "Beschädigung" und endlich eingestellt Daten zu einer bestimmten Anzahl (10, zum Beispiel):
// Instanziieren Sie die zwei Entitäten var entityA = new Entity (); var entityB = neue Entität (); // Eine Nachricht an entityB erstellen, von entityA, // mit dem Typ "Schaden" und Daten / Wert 10. var msg = new Message (); msg.to = entityB; msg.from = entityA; msg.type = "Schaden"; msg.data = 10; // Sie können die Nachricht auch direkt instanziieren, // indem Sie die benötigten Informationen wie folgt übergeben: var msg = new Message (entityB, entityA, "damage", 10);
Da wir jetzt eine Möglichkeit zum Erstellen von Nachrichten haben, ist es Zeit, über die Klasse nachzudenken, in der sie gespeichert und bereitgestellt werden.
Die Klasse, die für die Speicherung und Zustellung der Nachrichten verantwortlich ist, wird aufgerufen MessageQueue. Es wird als Post-Office funktionieren: Alle Nachrichten werden an diese Klasse weitergeleitet, wodurch sichergestellt wird, dass sie an ihr Ziel gesendet werden.
Vorerst die MessageQueue Klasse wird eine sehr einfache Struktur haben:
/ ** * Diese Klasse ist für das Empfangen von Nachrichten und das * Senden dieser Nachrichten an das Ziel verantwortlich. * / MessageQueue = function () this.messages = []; // Liste der Nachrichten, die versendet werden sollen; // Eine neue Nachricht zur Warteschlange hinzufügen. Die Nachricht muss eine // Instanz der Klasse Message sein. MessageQueue.prototype.add = Funktion (Nachricht) this.messages.push (Nachricht); ;
Die Eigenschaft Mitteilungen ist ein Array. Es werden alle Nachrichten gespeichert, die vom gesendet werden sollen MessageQueue. Die Methode hinzufügen() erhält ein Objekt der Klasse Botschaft als Parameter und fügt dieses Objekt der Liste der Nachrichten hinzu.
Hier ist wie unser vorheriges Beispiel der Entität EIN Messaging-Entität B über Schaden würde funktionieren mit der MessageQueue Klasse:
// Instanziieren Sie die beiden Entitäten und die Nachrichtenwarteschlange var entityA = new Entity (); var entityB = neue Entität (); var messageQueue = new MessageQueue (); // Eine Nachricht an entityB erstellen, von entityA, // mit dem Typ "Schaden" und Daten / Wert 10. var msg = neue Nachricht (entityB, entityA, "damage", 10); // füge die Nachricht der Warteschlange hinzu messageQueue.add (msg);
Wir haben jetzt eine Möglichkeit, Nachrichten in einer Warteschlange zu erstellen und zu speichern. Es ist Zeit, dass sie ihr Ziel erreichen.
Um das zu machen MessageQueue Klasse versenden tatsächlich die geposteten Nachrichten, zuerst müssen wir definieren Wie Entitäten werden Nachrichten bearbeiten und empfangen. Am einfachsten ist es, eine benannte Methode hinzuzufügen onMessage () an jede Entität, die Nachrichten empfangen kann:
/ ** * Diese Klasse beschreibt eine generische Entität. * / Entity = function () // Hier etwas initialisieren, z. Phaser-Sachen; // Diese Methode wird von MessageQueue // aufgerufen, wenn eine Nachricht an diese Entität vorliegt. Entity.prototype.onMessage = Funktion (Nachricht) // Neue Nachricht hier bearbeiten;
Das MessageQueue Klasse wird das aufrufen onMessage () Methode jeder Entität, die eine Nachricht erhalten muss. Der an diese Methode übergebene Parameter ist die Nachricht, die vom Warteschlangensystem geliefert wird (und vom Ziel empfangen wird)..
Das MessageQueue Die Klasse versendet die Nachrichten in der Warteschlange auf einmal Versand() Methode:
/ ** * Diese Klasse ist für das Empfangen von Nachrichten und das * Senden dieser Nachrichten an das Ziel verantwortlich. * / MessageQueue = function () this.messages = []; // Liste der Nachrichten, die versendet werden sollen; MessageQueue.prototype.add = Funktion (Nachricht) this.messages.push (Nachricht); ; // Alle Nachrichten in der Warteschlange an ihr Ziel senden. MessageQueue.prototype.dispatch = function () var i, entity, msg; // Iteave über die Liste der Nachrichten für (i = 0; this.messages.length; i ++) // Die Nachricht der aktuellen Iteration abrufen msg = this.messages [i]; // Ist es gültig? if (msg) // Die Entität abrufen, die diese Nachricht erhalten soll // (die im Feld 'to') entity = msg.to; // Wenn diese Entität vorhanden ist, übermitteln Sie die Nachricht. if (entity) entity.onMessage (msg); // Lösche die Nachricht aus der Warteschlange this.messages.splice (i, 1); ich--; ;
Diese Methode durchläuft alle Nachrichten in der Warteschlange und für jede Nachricht die zu Feld wird verwendet, um eine Referenz zum Empfänger abzurufen. Das onMessage () Dann wird die Methode des Empfängers mit der aktuellen Nachricht als Parameter aufgerufen, und die übermittelte Nachricht wird dann aus der entfernt MessageQueue Liste. Dieser Vorgang wird wiederholt, bis alle Nachrichten versendet wurden.
Es ist Zeit, dass alle Details dieser Implementierung zusammenarbeiten. Verwenden Sie unser Nachrichten-Warteschlangensystem in einer sehr einfachen Demo, die aus wenigen sich bewegenden Entitäten besteht, die miteinander interagieren. Der Einfachheit halber arbeiten wir mit drei Entitäten: Heiler, Läufer und Jäger.
Das Läufer hat eine Gesundheitsleiste und bewegt sich zufällig. Das Heiler wird jeden heilen Läufer das geht in der Nähe vorbei; auf der anderen Seite die Jäger wird in der Nähe Schaden anrichten Läufer. Alle Interaktionen werden über das Nachrichtenwarteschlangensystem abgewickelt.
Beginnen wir mit der Erstellung der PlayState Diese enthält eine Liste von Entitäten (Heiler, Läufer und Jäger) und eine Instanz der MessageQueue Klasse:
var PlayState = function () var-Entitäten; // Liste der Entitäten im Spiel var messageQueue; // die Nachrichtenwarteschlange (Dispatcher) this.create = function () // Die Nachrichtenwarteschlange initialisieren messageQueue = new MessageQueue (); // Eine Gruppe von Entitäten erstellen. Entities = this.game.add.group (); ; this.update = function () // Lasse alle Nachrichten in der Nachrichtenwarteschlange // ihr Ziel erreichen. messageQueue.dispatch (); ; ;
In der Spielschleife, dargestellt durch die aktualisieren() Methode, die Nachrichtenwarteschlange Versand() Die Methode wird aufgerufen, sodass alle Nachrichten am Ende jedes Spielfelds zugestellt werden.
Das Läufer Die Klasse hat folgende Struktur:
/ ** * Diese Klasse beschreibt eine Entität, die nur * umherwandert. * / Runner = function () // Phaser-Zeug hier initialisieren ...; // Wird vom Spiel in jedem Frame aufgerufen. Runner.prototype.update = function () // Hier wird alles bewegt… // Diese Methode wird von der Nachrichtenwarteschlange // aufgerufen, damit der Läufer mit eingehenden Nachrichten umgehen kann. Runner.prototype.onMessage = Funktion (Nachricht) Var. Betrag; // Überprüfen Sie den Nachrichtentyp, damit // Sie entscheiden können, ob diese Nachricht ignoriert werden soll oder nicht. if (message.type == "Schaden") // Die Nachricht handelt von Schaden. // Wir müssen unsere Gesundheitspunkte verringern. Der Betrag // dieser Abnahme wurde vom Absender der Nachricht // im Feld "Daten" angegeben. Betrag = Nachrichtendaten; this.addHealth (-amount); else if (message.type == "heilen") // Die Nachricht handelt von der Heilung. // Wir müssen unsere Gesundheitspunkte erhöhen. Die Anzahl der // Gesundheitspunkte, die erhöht werden sollten, wurde vom Absender der Nachricht // im Feld "Daten" angegeben. Betrag = Nachrichtendaten; this.addHealth (Betrag); else // Hier behandeln wir Nachrichten, die wir nicht verarbeiten können. // Wahrscheinlich einfach ignorieren :);
Der wichtigste Teil ist der onMessage () Diese Methode wird von der Nachrichtenwarteschlange jedes Mal aufgerufen, wenn eine neue Nachricht für diese Instanz vorhanden ist. Wie zuvor erläutert wurde das Feld Art In der Nachricht wird festgelegt, worum es in dieser Kommunikation geht.
Basierend auf dem Nachrichtentyp wird die richtige Aktion ausgeführt: wenn der Nachrichtentyp ist "Beschädigung", Gesundheitspunkte werden verringert; wenn der Nachrichtentyp ist "heilen", Gesundheitspunkte werden erhöht. Die Anzahl der Gesundheitspunkte, um die erhöht oder gesenkt werden soll, wird vom Absender im festgelegt Daten Feld der Nachricht.
In dem PlayState, Wir fügen ein paar Läufer zur Liste der Entitäten hinzu:
var PlayState = function () // (…) this.create = function () // (…) // Hinzufügen von Läufern für (i = 0; i < 4; i++) entities.add(new Runner(this.game, this.game.world.width * Math.random(), this.game.world.height * Math.random())); ; // (… ) ;
Das Ergebnis sind vier Läufer, die sich zufällig bewegen:
Das Jäger Die Klasse hat folgende Struktur:
/ ** * Diese Klasse beschreibt eine Entität, die * nur herumläuft und die vorbeigehenden Läufer verletzt. * / Hunter = Funktion (Spiel, x, y) // Phaser-Zeug hier initialisieren; // Überprüfen Sie, ob die Entität gültig ist, ein Läufer ist und sich innerhalb des Angriffsbereichs befindet. Hunter.prototype.canEntityBeAttacked = function (entity) return entity && entity! = This && (Entity-Instanz von Runner) &&! (Entity-Instanz von Hunter) && entity.position.distance (this.position) <= 150; ; // Invoked by the game during the game loop. Hunter.prototype.update = function() var entities, i, size, entity, msg; // Get a list of entities entities = this.getPlayState().getEntities(); for(i = 0, size = entities.length; i < size; i++) entity = entities.getChildAt(i); // Is this entity a runner and is it close? if(this.canEntityBeAttacked(entity)) // Yeah, so it's time to cause some damage! msg = new Message(entity, this, "damage", 2); // Send the message away! this.getMessageQueue().add(msg); // or just entity.onMessage(msg); if you want to bypass the message queue for some reasong. ; // Get a reference to the game's PlayState Hunter.prototype.getPlayState = function() return this.game.state.states[this.game.state.current]; ; // Get a reference to the game's message queue. Hunter.prototype.getMessageQueue = function() return this.getPlayState().getMessageQueue(); ;
Die Jäger werden sich auch bewegen, aber sie beschädigen alle Läufer, die sich in der Nähe befinden. Dieses Verhalten ist im implementiert aktualisieren() Methode, bei der alle Entitäten des Spiels überprüft und Läufer über Schäden informiert werden.
Die Schadensmeldung wird wie folgt erstellt:
msg = neue Nachricht (Entität, dies "Schaden", 2);
Die Nachricht enthält die Informationen zum Ziel (Entität, in diesem Fall (dh der Entität, die in der aktuellen Iteration analysiert wird), dem Absender (diese, die den Angriff darstellt), die Art der Nachricht ("Beschädigung") und die Höhe des Schadens (2, in diesem Fall dem zugeordnet Daten Feld der Nachricht).
Die Nachricht wird dann über den Befehl an das Ziel gesendet this.getMessageQueue (). add (msg), Dadurch wird die neu erstellte Nachricht der Nachrichtenwarteschlange hinzugefügt.
Zum Schluss fügen wir die Jäger zur Liste der Entitäten in der PlayState:
var PlayState = function () // (…) this.create = function () // (…) // Jäger an Position (20, 30) hinzufügen entity.add (neuer Hunter (this.game, 20, 30) )); ; // (…);
Das Ergebnis sind einige Läufer, die sich bewegen und Nachrichten vom Jäger erhalten, wenn sie sich einander nähern:
Ich habe die fliegenden Umschläge als visuelle Hilfe hinzugefügt, um zu zeigen, was los ist.
Das Heiler Die Klasse hat folgende Struktur:
/ ** * Diese Klasse beschreibt eine Entität, die * jeden Läufer heilen kann, der in der Nähe vorbeigeht. * / Heiler = Funktion (Spiel, x, y) // Initialisierung Phaser-Zeug hier; Healer.prototype.update = function () var-Entitäten, i, Größe, Entität, msg; // Die Liste der Entitäten in den Entitäten des Spiels = this.getPlayState (). GetEntities (); für (i = 0, Größe = Entitäten.Länge; i < size; i++) entity = entities.getChildAt(i); // Is it a valid entity? if(entity) // Check if the entity is within the healing radius if(this.isEntityWithinReach(entity)) // The entity can be healed! // First of all, create a new message regaring the healing msg = new Message(entity, this, "heal", 2); // Send the message away! this.getMessageQueue().add(msg); // or just entity.onMessage(msg); if you want to bypass the message queue for some reasong. ; // Check if the entity is neither a healer nor a hunter and is within the healing radius. Healer.prototype.isEntityWithinReach = function(entity) return !(entity instanceof Healer) && !(entity instanceof Hunter) && entity.position.distance(this.position) <= 200; ; // Get a reference to the game's PlayState Healer.prototype.getPlayState = function() return this.game.state.states[this.game.state.current]; ; // Get a reference to the game's message queue. Healer.prototype.getMessageQueue = function() return this.getPlayState().getMessageQueue(); ;
Der Code und die Struktur sind sehr ähnlich Jäger Klasse, mit Ausnahme einiger Unterschiede. Ähnlich wie die Implementierung des Jägers der Heiler aktualisieren() Die Methode durchläuft die Liste der Entitäten im Spiel und meldet alle Entitäten, die sich innerhalb ihrer Heilreichweite befinden:
msg = neue Nachricht (Entität, dies "heilen", 2);
Die Nachricht hat auch ein Ziel (Entität), ein Absender (diese, (was der Heiler ist, der die Aktion ausführt), ein Nachrichtentyp ("heilen") und die Anzahl der Heilpunkte (2, zugewiesen in der Daten Feld der Nachricht).
Wir fügen das hinzu Heiler zur Liste der Entitäten in der PlayState auf die gleiche Weise wie beim Jäger und das Ergebnis ist eine Szene mit Läufern, einem Jäger und einem Heiler:
Und das ist es! Wir haben drei verschiedene Entitäten, die miteinander interagieren, indem sie Nachrichten austauschen.
Dieses Nachrichten-Warteschlangensystem ist eine vielseitige Methode zum Verwalten von Interaktionen in einem Spiel. Die Interaktionen werden über einen Kommunikationskanal durchgeführt, der einheitlich ist und über eine einzige Schnittstelle verfügt, die einfach zu bedienen und zu implementieren ist.
Wenn Ihr Spiel komplexer wird, sind möglicherweise neue Interaktionen erforderlich. Einige davon sind möglicherweise völlig unerwartet. Daher müssen Sie Ihren Code anpassen, um mit ihnen umzugehen. Wenn Sie ein Nachrichtenwarteschlangensystem verwenden, müssen Sie eine neue Nachricht irgendwo hinzufügen und in einer anderen Nachricht bearbeiten.
Stellen Sie sich zum Beispiel vor, Sie möchten das machen Jäger mit dem interagieren Heiler; Sie müssen nur das machen Jäger Senden Sie beispielsweise eine Nachricht mit der neuen Interaktion, "fliehen"-und sicherstellen, dass die Heiler kann damit umgehen onMessage Methode:
// In der Hunter-Klasse: Hunter.prototype.someMethod = function () // Hole einen Verweis auf einen in der Nähe befindlichen Heiler var healer = this.getNearbyHealer (); // Nachricht zum Fliehen eines Ortes erstellen var place = x: 30, y: 40; var msg = new Message (Entity, this, "fliehen", Ort); // Schicke die Nachricht weg! this.getMessageQueue (). add (msg); ; // In der Healer-Klasse: Healer.prototype.onMessage = function (message) if (message.type == "fliehen") // Lasse die Flucht aus dem Datenfeld in der Nachricht var place = message.data ; // Verwenden Sie die Ortsinformationen fliehen Sie (place.x, place.y); ;
Obwohl das Austauschen von Nachrichten zwischen Entitäten nützlich sein kann, denken Sie möglicherweise darüber nach, warum MessageQueue ist doch nötig. Kannst du nicht einfach den Empfänger anrufen? onMessage () Methode selbst, anstatt sich auf die MessageQueue, wie im Code unten?
Hunter.prototype.someMethod = function () // Hole einen Verweis auf einen in der Nähe befindlichen Heiler var healer = this.getNearbyHealer (); // Nachricht zum Fliehen eines Ortes erstellen var place = x: 30, y: 40; var msg = new Message (Entity, this, "fliehen", Ort); // Die MessageQueue umgehen und // die Nachricht direkt an den Heiler übermitteln. healer.onMessage (msg); ;
Sie könnten ein Nachrichtensystem auf jeden Fall so implementieren, aber die Verwendung eines MessageQueue hat einige Vorteile.
Durch die Zentralisierung der Verteilung von Nachrichten können Sie beispielsweise einige coole Funktionen implementieren, z. B. verzögerte Nachrichten, die Möglichkeit, eine Gruppe von Entitäten zu benachrichtigen, und visuelle Debug-Informationen (z. B. die in diesem Lernprogramm verwendeten fliegenden Umschläge)..
Im Raum ist Platz für Kreativität MessageQueue Klasse, es liegt an Ihnen und den Anforderungen Ihres Spiels.
Durch die Verwaltung von Interaktionen zwischen Spielentitäten mithilfe eines Nachrichtenwarteschlangensystems können Sie Ihren Code für die Zukunft aufgeräumt halten. Neue Interaktionen können einfach und schnell hinzugefügt werden, selbst Ihre komplexesten Ideen, solange sie als Nachrichten verkapselt sind.
Wie in diesem Tutorial beschrieben, können Sie die Verwendung einer zentralen Nachrichtenwarteschlange ignorieren und Nachrichten direkt an die Entitäten senden. Sie können die Kommunikation auch über einen Versand (die MessageQueue Klasse in unserem Fall), um in Zukunft Platz für neue Funktionen zu schaffen, z. B. für verspätete Nachrichten.
Ich hoffe, Sie finden diesen Ansatz hilfreich und fügen ihn Ihrem Gürtel für Spieleentwickler hinzu. Die Methode mag für kleine Projekte wie ein Overkill erscheinen, aber für größere Spiele erspart man sich auf jeden Fall einige Kopfschmerzen.
Accentsconagua