Einrichten eines Mehrspielerspiels mit Socket.io

Teil 1: Einführung

Bevorzugte Voraussetzungen

In diesem Tutorial konzentrieren wir uns darauf, wie man einen Server einrichtet und Ihr Spiel damit verbindet, um Multiplayer-Funktionen für Ihr Projekt über Socket.io-Verhaltensweisen zu ermöglichen. Wir werden fortgeschrittene Funktionen und Verhaltensweisen in hyperPad behandeln und es wird dringend empfohlen, zuerst einige andere Tutorials zu überprüfen und ein gutes Gefühl für die Software zu bekommen, bevor Sie fortfahren.

Dieses Tutorial geht davon aus, dass Sie ein gutes Verständnis der Kernfunktionalitäten von hyperPad sowie ein minimales Verständnis schriftlicher Programmierung haben, da wir uns auf Javascript-Skripting zur Erstellung eines Spielservers konzentrieren werden. Außerdem wird in diesem Tutorial ein grundlegendes Verständnis von Netzwerken und den Unterschieden zwischen einem Server und seinen Clients vorausgesetzt.

Das Hauptziel dieses Tutorials ist es, Ihnen beizubringen, was Sie tun müssen, um Multiplayer-Funktionalität in Ihr Spiel hinzuzufügen; nicht das Spiel selbst zu erstellen. Wir werden die Beziehung zwischen Socket.io-Clients und dem Server sowie deren Kommunikation über die Socket.io-Verhaltensweisen untersuchen.

Anforderungen

Um den Server zu erstellen und zu hosten, benötigen Sie einen Computer, der Node.JS (Mac, Windows usw.) ausführen kann. Die Installation von Node.JS und dessen Einrichtung für unseren Zweck wird in diesem Tutorial behandelt. Wenn Sie einen Server in Ihrem Heimnetzwerk hosten, müssen Sie wahrscheinlich die Portweiterleitungseinstellungen Ihres Gateways ändern, wenn Sie eingehende Verbindungen von außerhalb Ihres lokalen Netzwerks wünschen.

Für dieses Tutorial haben wir bereits ein einfaches Demo-Spiel erstellt. Darin gibt es zwei Spieler, die in einem kleinen Labyrinth ein Fangspiel spielen. Wir werden untersuchen, wie die Socket.io-Verhaltensweisen im Beispielprojekt verwendet werden, deshalb wird empfohlen, das Projekt in hyperPad herunterzuladen und zu öffnen.

Das vollständige Beispielprojekt von hyperPad kann hier heruntergeladen werden: Multiplayer tag tutorial.tap

Übersicht

In diesem Tutorial behandeln wir die Grundlagen der Erstellung eines Servers für Ihr Spiel. Der Server wird die meisten Details im Spiel verwalten, wie z. B. Punkte, Spiel-Lobbys usw. Dann werden wir Verhaltensweisen erstellen, die Informationen von unserem Spiel an den Server und umgekehrt senden.

Hier ist der allgemeine Ablauf unseres Spiels:

1. Vom Hauptmenü aus verbinden wir uns mit unserem Server und lassen den Benutzer entscheiden, ob er ein Spiel erstellen oder einem beitreten möchte.

a. Wenn ein Spiel erstellt wird, laden Sie den Warteraum.

b. Wenn einem Spiel beigetreten wird, laden Sie eine Liste verfügbarer Spielräume.

c. Wenn zwei Spieler im Warteraum sind, startet das Spiel.

2. In einem Spiel platziert der Server die Spieler zufällig in einem von vier Bereichen und weist einen von ihnen als "Es" zu.

a. Das Fangen des anderen Spielers wird deren Standorte randomisieren, den "Es"-Status tauschen und einen Punkt für den Spieler hinzufügen, der den anderen gefangen hat.

b. Wenn innerhalb eines bestimmten Zeitraums keine Fänge stattfinden, entfernt der Server 1 Punkt vom Spieler, der derzeit "Es" ist, und tauscht den "Es"-Status, bevor die Spieler erneut zufällig in den Spawn-Zonen platziert werden.

3. Sobald ein Spieler eine bestimmte Anzahl von Punkten erreicht hat, wird ein Overlay angezeigt, das einen Gewinner erklärt. Danach trennen sich die Spieler vom Raum und kehren zum Hauptmenü zurück.

Teil 2: Den Server Einrichten

Die Erstellung eines Socket.io-Servers erfordert, dass wir eine Javascript-Anwendung mit der Socket.io-Bibliothek ausführen, die auf Spieler Verbindungen hört. Socket.io ist eine Javascript-Netzwerkbibliothek, die viele der Grundlagen des Aufbaus einer netzwerkbasierten Anwendung für uns vereinfacht. Weitere Details folgen.

Node.JS Herunterladen und Installieren

Um zu beginnen, gehen Sie zu Node.JS und laden Sie es auf den Computer (Mac, Windows usw.) herunter, auf dem Sie den Server hosten möchten. Wenn der Download abgeschlossen ist, führen Sie den Installer aus und folgen Sie dessen Anweisungen. Alle Optionen während der Installation können auf Standardeinstellungen belassen werden. Node.JS ermöglicht es uns, Javascript-Anwendungen eigenständig auszuführen, ohne einen Webbrowser zu benötigen.

Herunterladen und Ausführen des Beispielservers

Laden Sie als nächstes das Multiplayer Server Example dieses Tutorials auf GitHub herunter:

https://github.com/hyperPad/multiplayerServerExample

Klicken Sie auf die Schaltfläche "Clone or download" und wählen Sie "Download ZIP". Dies wird eine Kopie des Codes für das Serverbeispiel herunterladen.

Entpacken Sie die heruntergeladene ZIP-Datei. Im Inneren finden Sie einige kleine Dateien, aber die bemerkenswerteste Datei hier ist die „index.js“-Datei, die den Code für unseren Server enthält. Öffnen Sie als nächstes Ihre Eingabeaufforderung/Terminal im Ordner des Serverbeispiels.

Geben Sie „npm install“ ein und drücken Sie die Eingabetaste, und lassen Sie es laufen. npm ist ein Paketmanager, der die package.json-Datei liest und die notwendigen Pakete für unseren Server herunterlädt. (Inklusive Socket.io!)

Wenn der Befehl abgeschlossen ist, haben wir alles, was wir brauchen, um den Server auszuführen. Geben Sie im Terminal „node .“ ein und der Server wird gestartet.

Das war's! Unser Server hört jetzt an Port 3000 auf eingehende Socket.io-Verbindungen.

„node .“ startet Node.JS im aktuellen Verzeichnis, wo es nach der Verzeichnis-Indexdatei sucht und diese ausführt. Standardmäßig ist dies die „index.js“-Javascript-Datei, in der sich der Großteil des Codes unseres Servers befindet und die in diesem Tutorial analysiert werden wird.

Halten Sie das Terminal offen, da das Schließen auch den Server schließen würde. Sie werden sehen, dass es Nachrichten ausdruckt, wenn Spieler sich verbinden oder trennen und wenn Räume erstellt oder zerstört werden sowie andere Ereignisse.

Hinweis: Um eingehende Verbindungen von außerhalb eines Heimnetzwerks zu ermöglichen, müssen Sie wahrscheinlich Port 3000 an Ihrem Heim-Gateway öffnen. Dieser Vorgang variiert von Netzwerk zu Netzwerk, aber ein Leitfaden kann normalerweise gefunden werden, indem im Internet nach einem Leitfaden zur Portweiterleitung für das Modem/den Router Ihres Hauses gesucht wird. Möglicherweise müssen Sie den Node.JS-Server schließen und neu starten, wenn Sie die Portweiterleitungseinstellungen ändern.

Teil 3: Verbindung zum Server

Sobald Sie die Grundlagen des Servers gestartet haben, können wir uns nun in einem hyperPad-Spiel damit verbinden. Dies sollte so eingerichtet sein, dass es das Erste ist, was in Ihrem Projekt passiert, unabhängig davon, auf welcher Szene Sie sich befinden (da alles mit dem Server kommunizieren muss). Es ist am besten, dieses Verhalten einem Objekt in der Globalen Ebene anzuhängen, damit es auf alle Szenen angewendet wird.

Im Beispielprojekt enthält das Global Layer-Label "Server" das Obige. (Der Download für das Projekt finden Sie in Teil 1 dieses Tutorials im Abschnitt Anforderungen.)

Diese beiden Verhaltensweisen sind alles, was Sie benötigen, um sich mit dem Server zu verbinden. Zuerst ziehen Sie im benutzerdefinierten Tab das Socket.io Client-Verhalten herunter und platzieren es. Hier geben Sie die URL Ihres Servers im URL-Tab in seinem Eigenschaftenfenster ein. Im obigen Bild war die URL unseres Servers "http://192.168.0.191:3000", einschließlich Protokoll und Port. Sie müssen dies ändern, um mit Ihrer Server-URL übereinzustimmen, da es sonst wahrscheinlich nicht funktioniert, wenn Sie das Spiel starten.

Jetzt haben wir die Serverinformationen, die wir möchten, aber wir müssen uns immer noch damit verbinden. Alles, was wir jetzt tun müssen, ist das "Connect to Socket"-Verhalten. Ziehen Sie eines herunter, öffnen Sie seine Eigenschaften und wählen Sie den Client in dem leeren Feld aus und setzen Sie die Funktionseigenschaft auf "Connect".

Jetzt werden wir, wenn unser Projekt geladen wird, automatisch eine Verbindung zu unserem Server herstellen.

Teil 4: Räume Erstellen und Betreten

Der nächste Schritt besteht darin, unsere Spiel-Lobbys zu erstellen, in denen Spieler beitreten und zusammen spielen können.

Hier ist unser einfacher Hauptmenü-Bildschirm. Alles, was man tun muss, ist auf einen der Buttons zu tippen, um entweder einen Raum zu starten oder nach verfügbaren Räumen zu suchen.

Räume Erstellen

Schauen wir uns an, wie wir mit dem Server kommunizieren, um unseren Raum zu erstellen.

Es ist ziemlich einfach, oder? Um das schnell zu wiederholen: Sobald wir unseren Button berühren, werden wir aufgefordert, einen Raumnamen einzugeben. Wenn das erledigt ist, wird dieser Name an den Server gesendet, wo der Raum erstellt wird und wir die Warteraum-Szene laden.

Von hier an werden wir häufig das Emit to Socket verwenden. Das liegt daran, dass es unsere Hauptmethode ist, um Daten zum Server zu senden. Denken Sie daran, es einfach als die "Online-Version" von Broadcast Message und Receive Message (Emit to Socket führt beide Aktionen gleichzeitig aus).

Jetzt müssen wir einige Informationen zu unserem Server hinzufügen, damit er den Raum erstellt, sobald die Nachricht von unserem Emit-Verhalten empfangen wird.

socket.on('createRoom', (roomName, callback) => {

Diese Zeile erstellt ein Socket-Event (als Lambda-Ausdruck) auf dem Server, das auf Emits mit dem Ereignis 'createRoom' hört.

Der erste Parameter ist der Wert, den wir über das Emit to Socket-Verhalten übergeben, in diesem Fall den Raumnamen, den der Benutzer eingegeben hat. Hier haben wir diesen Parameter 'roomName' genannt.

Der zweite Parameter ist eine Funktion, die wir später im Socket-Event aufrufen, um den Client zu signalisieren. Das Emit to Socket-Verhalten wird nur dann mit der Ausführung fortfahren, wenn die Callback-Funktion auf dem Server aufgerufen wird. Hier haben wir diesen Parameter 'callback' genannt.

const room = {
id: uuid(),
name: roomName,
sockets: []
};

Dies erstellt eine Instanz einer Struktur, die wesentliche Informationen über einen Raum enthält.

'id' wird ein eindeutiger Bezeichner sein, der von der Dienstprogrammfunktion 'uuid()' generiert wird. Dies wird uns helfen, diesen Raum spezifisch gegenüber einer Liste von vielen anderen erstellten Räumen zu identifizieren.

'name' wird auf den Namen gesetzt, den der Benutzer zuvor eingegeben hat.

'sockets' wird als leeres Array initialisiert. Später wird dieses Array die Spieler-Sockets verfolgen, die mit diesem Raum verbunden sind.

rooms[room.id] = room;

'rooms' ist eine globale Liste von aktuell aktiven Räumen. Da wir einen neuen Raum erstellen, werden wir ihn in der Liste anhand seiner ID speichern.

joinRoom(socket, room);

Dies ruft die globale Funktion 'joinRoom' (Zeile 29) auf, die das Spieler-Socket zum 'sockets'-Array des Raumes hinzufügt. Da der Spieler den Raum erstellt hat, wird auch er ihm beitreten.

callback();
});

Zuletzt rufen wir die Callback-Funktion auf, um den Client zu benachrichtigen, dass der Raum erstellt wurde. Dies ermöglicht es dem Emit to Socket, mit der Ausführung fortzufahren, was den Ladebildschirm für den Warteraum als nächstes lädt. Damit endet das 'createRoom'-Socket-Event.

Räume Beitreten

Räume zu betreten ist etwas anders, da wir die Informationen aus einer anderen Szene über den Button erreichen müssen.

Für den Beitritt zu Räumen haben wir den Anfang unserer Verhaltensweisen auf unserer globalen Ebene platziert, zusammen mit der Verbindung zu dem Server. Auf diese Weise können wir auf die Informationen aus einer beliebigen unserer Szenen zugreifen, in diesem Fall unserer Raumliste. Für den Button wird das Tippen einfach den Spieler in die Raumlisten-Szene laden.

Hier haben wir unser zweites Verhalten zur Kommunikation mit dem Server. Das Socket-Event kann als Receive Message betrachtet werden, da es nur aktiviert wird, wenn die festgelegte Nachricht vom Server übertragen wurde.

Die beste Art zu denken, wenn man Socket Event und Emit to Socket verwendet, ist, dass Socket Event nur auf Informationen reagiert, die vom Server kommen, während Emit to Socket als Reaktion auf lokal durchgeführte Aktionen aufgerufen wird.

Was unsere Logik betrifft, so werden wir, sobald wir mit dem Server verbunden sind, die 'getRoomNames'-Anforderung an ihn senden, um alle verfügbaren Raumnamen zu erhalten.

Dann würden wir ein Label setzen, auf das der Spieler tippen kann, um einzutreten.

Dies ist unsere Raumlisten-Szene. Hier werden alle verfügbaren Spielräume geladen und angezeigt. Indem man einfach den Raumnamen antippt, wird der Spieler hinein geladen. Dank unserer vorherigen Verhaltensweisen wird die Liste automatisch alle offenen Räume laden und die Raumnamen-Labels auf dem Bildschirm darstellen. Sollte nichts angezeigt werden, haben wir unseren-refresh List Button, der einfach die Verhaltensweisen wiederholt, um sie erneut zu laden.

Hier haben wir die Logik zur Einrichtung der Liste. Wir werden nicht zu sehr ins Detail gehen, da wir nur wissen wollen, wie dies mit unserem Server verbunden ist.

Zu Beginn haben wir unser Emit to Socket-Verhalten. Dies fordert den Server auf, Informationen über verfügbare Räume zu senden. Danach haben wir ein Get Array Value-Verhalten. Alle Daten, die vom Server kommen, werden als Array gesendet und die benötigten Informationen befinden sich an den ersten Werten. Daher setzen wir unser Get Array Value auf den Wert an Index 0. Von dort aus werden unsere Verhaltensweisen diese Daten extrahieren und eine Beschriftung für jeden Raum erstellen, die auf unserem Bildschirm erscheint.

Als nächstes werden wir das Objekt überprüfen, auf das wir tippen müssen; in unserer Szene ist es das Label namens Raumnamen.

Dieser Text agiert bei seiner Erzeugung als unser Button, aber wir müssen immer noch die Raum-ID, mit der wir uns verbinden möchten, anhängen. Dazu müssen wir zuerst die Raum-ID erfassen, und das tun wir mit dem Get Attribute-Verhalten und setzen es dynamisch. Dann, emitieren wir an den Server, dass wir diesem Raum beitreten und in den Warteraum laden möchten.

socket.on('joinRoom', (roomId, callback) => {

Das ist der Einstiegspunkt für das Socket-Ereignis 'joinRoom'. Der Wert des ersten Parameters ist die Raum-ID, die wir betreten möchten, die an den Server gesendet wurde. Hier haben wir den Parameter 'roomId' genannt.

const room = rooms[roomId];
joinRoom(socket, room);

Mit der vom Client gegebenen roomId können wir die richtige Rauminstanz auf dem Server finden. Damit rufen wir die globale Funktion 'joinRoom' (Zeile 29) mit dem Socket des Spielers auf, der sich verbinden möchte, sowie der Rauminstanz selbst. Schauen wir uns die Funktion 'joinRoom' gleich genauer an.

callback();
});

Zuletzt rufen wir die Callback-Funktion auf, um den Client zu benachrichtigen, dass er mit dem Laden der Warteraum-Szene fortfahren kann, was das Ende des 'joinRoom'-Socket-Events markiert.

Was genau passiert also in der 'joinRoom'-Funktion? Schauen wir uns das an.

room.socket.push(socket);

Wie bereits erwähnt, verfolgt das Mitgliedsarray 'room.socket' die in einem Raum verbundenen Sockets. Diese Zeile tut genau dies, indem sie den Socket in das Array einfügt.

socket.join(room.id, () => {
socket.roomId = room.id;
console.log(socket.id, "Beigetreten", room.id);
});

Dies ist der offizielle Aufruf, um den Client mit einem Raum zu verbinden. Zuerst sagen wir dem Socket, dass er einem Raum nach seiner ID beitreten soll. Wenn das abgeschlossen ist, wird der folgende Callback aufgerufen, wobei wir die Raum-ID an den Socket anhängen. Zuletzt protokollieren wir in der Konsole, dass ein Spieler einem Raum beigetreten ist!

Der Warteraum

Der Warteraum ist einfach eine Szene, in die wir die Spieler laden, während sie auf andere Spieler warten, die beitreten oder auf einen Spielstart warten.

Beim Betreten des Raumes geben wir eine 'ready'-Nachricht an den Server aus. Sobald der Server zwei davon erhalten hat, sendet er eine Nachricht, dass das Spiel gestartet wird ('initGame'). Wir nehmen diese Nachricht mit unserem Socket Event entgegen, wodurch wir unsere Spielebene laden. Was unsere Verhaltensweisen betrifft, ist das alles. Sie können einen Button hinzufügen, der Sie vom Raum trennt und zurück zum Hauptmenü bringt, wenn Sie möchten.

Auf der Serverseite lassen Sie uns den Code analysieren, um zu sehen, was dort vor sich geht.

Dies ist das 'ready'-Ereignis, das aufgerufen wird, wenn ein Client einem Raum beigetreten ist und bereit ist, sich zu verbinden.

const room = rooms[socket.roomId];

Da wir die Raum-ID an den Socket angehängt haben, können wir das Zimmer überprüfen, um zu sehen, ob das Spiel gestartet werden kann.

if (room.sockets.length == 2) {

Hier überprüfen wir, ob jetzt zwei Spieler im Raum warten. Angenommen, das ist jetzt wahr, und wir fahren fort, um das Spiel zu starten.

for (const client of room.sockets) {
client.emit('initGame');
}

Jetzt, da es zwei Spieler gibt, durchlaufen wir jedes Socket und senden das 'initGame'-Ereignis, damit jeder Client die Level-Szene lädt, wie zuvor gezeigt.

Teil 5: Gameplay

Jetzt kommen wir zum Kern der Sache. Hier ist das Spielevel, das wir für dieses Tutorial entworfen haben.

Bevor wir jedoch damit beginnen, haben wir ein Label mit dem Titel "Game Logic", schauen wir uns das mal an.

Wow, das sind viele Verhaltensweisen! Keine Sorge, das ist nur, wie wir unsere Spieler im Spiel erzeugen. Lassen Sie uns einen genaueren Blick darauf werfen;

Wir beginnen mit einem Emit to Socket-Verhalten, das dem Server sagt, dass unser Spiel gestartet ist, mit dem Ereignis 'startGame'. Wir holen dann das Array, das der Server zurückgibt, nehmen den ersten Wert und mit dem Get Dictionary Value holen wir die verschiedenen Attribute, die unser Objekt benötigt. Ein separater Baum macht dasselbe, jedoch für den Gegner-Spieler. Schließlich senden wir die Nachricht 'init' an unser Spielerobjekt, um die Dinge zu starten.

Sehen wir uns an, was auf der Serverseite passiert, wenn wir das 'startGame'-Ereignis auslösen.

Die erste Hälfte dieses Socket-Events, die Sie hier sehen, setzt einige Anfangswerte für jeden Client fest und fügt dann jeden Client, der nicht der sendende Client ist, zum lokalen 'others'-Array hinzu.

In der zweiten Hälfte wird eine lokale Dictionaries-Liste mit dem Namen 'ack' erstellt. Darin haben wir Informationen über uns selbst und den/die anderen Client(s). Wir senden dann diese Informationen zurück an den Client, indem wir unser Wörterbuch 'ack' an die Callback-Funktion übergeben, die zum Ergebniswert des aufrufenden Emit to Socket-Verhaltens wird.

Danach erfolgt ein Timeout-Call von 5 Sekunden, bevor die Runde beginnt, nun da jeder alle Informationen hat, die er benötigt, um das Spiel zu spielen. Die 'beginRound'-Funktion (Zeile 99) steuert einige spielespezifische Logiken für dieses Projekt. Wir werden nicht zu sehr ins Detail gehen, aber im Grunde befasst sie sich damit, wo die Spieler erscheinen, Punkte zu überprüfen und den Clients zu sagen, wer „Es“ ist.

Wie bereits erwähnt, wird die 'init'-Nachricht am "Game Logic"-Label ausgelöst, wenn alles einsatzbereit ist. An dem Spielerobjekt werden wir nun die Verhaltensweisen betrachten, wo es die 'init'-Nachricht empfängt.

Hier sehen Sie, dass wir mehrere Verhaltensbäume an unserem Spieler haben. Zuerst beginnen wir mit dem oberen linken Baum.

Dies ist das Verhalten, das praktisch alles andere in unserem Spiel startet.

Zuerst empfangen wir die 'init'-Nachricht, die vom "Game Logic"-Label gesendet wurde. Von dort holen wir die Server-ID unseres Objekts und aktivieren ein Socket Event sowie die Einrichtung des Spielbildschirms, damit wir unserem Charakter genau folgen können.

Bewegungssynchronisierung

Hier ist eines unserer wichtigsten Verhaltensweisen. Dieser kleine Baum ist dafür ausgelegt, die Position unseres Spielers auf dem Server jedes Mal zu aktualisieren, wenn wir den Joystick bewegen. Sie haben wahrscheinlich bemerkt, dass er auch einige Dictionary-Werte verwendet. Wir erhalten diese Werte von einem eigenständigen Dictionary-Verhalten, das die X- und Y-Positionen unseres Spielers enthält.

Schauen wir uns das 'moved'-Ereignis auf dem Server an.

data = JSON.parse(data);

Dictionaries, die von einem Client an einen Server gesendet werden, müssen geparst werden, um die Daten leicht lesen zu können. Dies liegt daran, dass Dictionaries in hyperPad in eine JSON-Struktur kodiert werden, wenn sie an einen Server gesendet werden. Diese Zeile parst die JSON-Zeichenfolgenstruktur und speichert die Dictionary-Liste wieder in derselben lokalen 'data'-Variablen.

socket.x = data.x;
socket.y = data.y;

Hier aktualisieren wir die X- und Y-Positionen, die auf dem Socket gespeichert sind, mit den neuen Werten, die vom Client gegeben werden.

for (const client of room.sockets) {
if (client == socket) {
continue;
}
client.emit(socket.id, {
x: socket.x,
y: socket.y,
score: socket.score,
isIt: socket.isIt
});
}

N als nächstes durchlaufen wir alle Clients, um sie über unsere neue Position und andere Details zu informieren, und schließen uns selbst aus (d.h. Der sendende Client muss seine eigene Position nicht wissen).

Dieser Baum steuert den Großteil unseres Spiels. Wir verwenden ein Socket Event, wenn der Server überprüft, welcher Spieler als "Es" markiert ist, und dies wird durch "beginRound" (Zeile 99) auf dem Server gesendet.

Dann greifen wir auf die Server-ID unseres Objekts aus dem Array zu und verwenden den Dictionary-Wert, um es in die verschiedenen Datenstücke aufzuschlüsseln, die es enthält. Von dort holen wir unser Punktestand, ob wir "Es" sind, sowie die x- und y-Positionen unseres Objekts und wenden sie auf die Attribute unseres Objekts an. Die restlichen Verhaltensweisen sind zur Einrichtung und Steuerung der Benutzeroberfläche in unserem Spiel.

Fazit

Es gab viel zu verarbeiten, aber hoffentlich haben Sie, wenn Sie bis zu diesem Punkt gekommen sind, ein Verständnis dafür, wie man die Socket.io-Verhaltensweisen nutzt, um Multiplayer-Erlebnisse für Ihre Spieler zu schaffen.

Versuchen Sie es selbst! Nehmen Sie ein bestehendes Spiel, das Sie erstellt haben, und versuchen Sie, ihm einige Online-Funktionen hinzuzufügen, wie z. B. eine Highscore-Leiterbalken-Szene, die sich mit einem Server verbindet und eine Liste der zehn besten Punkte mit Spielernamen anfordert, die angezeigt werden sollen.

Es ist schwierig, eine Skriptsprache wie Javascript in einem einzigen Artikel zu lehren. Glücklicherweise gibt es, wenn Sie Probleme haben, viele andere Ressourcen, die Ihnen beim Schreiben von Javascript-Anwendungen für Node.JS und Socket.io helfen;

Lernen Sie Javascript - https://developer.mozilla.org/bm/docs/Web/JavaScript

Lernen Sie Socket.io - https://socket.io/docs/

Lernen Sie Node.JS - https://nodejs.org/en/docs/