Erstellen eines Echtzeit-Skripts

Um Echtzeitserver für Ihr Spiel zu verwenden, müssen Sie ein Skript (in Form von JavaScript Code) bereitstellen, um eine Flotte von Echtzeitservern zu konfigurieren und optional anzupassen. In diesem Thema werden die wichtigsten Schritte beim Erstellen eines Echtzeit-Skripts behandelt. Sobald das Skript fertig ist, laden Sie es in den GameLift Amazon-Service hoch und verwenden Sie es, um eine Flotte zu erstellen (sieheLaden Sie ein Realtime Server-Skript auf Amazon hoch GameLift).

Um ein Skript für die Verwendung mit Echtzeitservern vorzubereiten, fügen Sie Ihrem Echtzeitskript die folgende Funktionalität hinzu.

Den Lebenszyklus der Spielsitzung verwalten (erforderlich)

Ein Realtime-Skript muss mindestens die Init() Funktion enthalten, die den Realtime-Server darauf vorbereitet, eine Spielsitzung zu starten. Es wird auch dringend empfohlen, dass Sie auch eine Möglichkeit zum Beenden von Spielsitzungen bereitstellen, um sicherzustellen, dass weiterhin neue Spielsitzungen auf Ihrer Flotte gestartet werden können.

Wenn die Init() Callback-Funktion aufgerufen wird, wird ein Realtime-Sitzungsobjekt übergeben, das eine Schnittstelle für den Realtime-Server enthält. Weitere Details zu dieser Schnittstelle finden Sie unter Realtime Server-Schnittstelle.

Um eine Spielsitzung ordnungsgemäß zu beenden, muss das Skript auch die Funktion des Realtime-Servers aufrufen. session.processEnding Dies erfordert einen Mechanismus, um zu bestimmen, wann eine Sitzung beendet werden soll. Der Beispielcode des Skripts veranschaulicht einen einfachen Mechanismus, der nach Spielerverbindungen sucht und die Beendigung der Spielsitzung auslöst, wenn für eine bestimmte Zeitspanne keine Spieler mit der Sitzung verbunden waren.

Echtzeitserver mit der grundlegendsten Konfiguration — Initialisierung und Beendigung von Serverprozessen — agieren im Wesentlichen als statuslose Relay-Server. Der Echtzeitserver leitet Nachrichten und Spieldaten zwischen den Spielclients weiter, die mit dem Spiel verbunden sind, ergreift jedoch keine unabhängigen Maßnahmen, um Daten zu verarbeiten oder Logik auszuführen. Sie können optional Spielelogik hinzufügen, die durch Spieleereignisse oder andere Mechanismen ausgelöst wird, wie für Ihr Spiel erforderlich.

Serverseitige Spiellogik hinzufügen (optional)

Sie können Ihrem Echtzeit-Skript optional Spiellogik hinzufügen. Beispielsweise können Sie eine oder alle der folgenden Aktionen durchführen. Der Beispielcode des Skripts dient der Veranschaulichung. Siehe Amazon GameLift Realtime Server-Skriptreferenz.

• Ereignisgesteuerte Logik hinzufügen. Implementierung der Callback-Funktionen zur Reaktion auf Client-Server-Ereignisse. Eine vollständige Liste der Callbacks finden Sie unter Script-Callbacks für Echtzeitserver.

• Auslösen einer Logik durch Senden von Nachrichten an den Server. Erstellen Sie eine Reihe von speziellen Operationscodes für Nachrichten, die von Spiel-Clients an den Server gesendet werden, und fügen Sie Funktionen zur Bearbeitung der Nachrichten hinzu. Verwenden Sie den Callback onMessage und analysieren Sie den Nachrichteninhalt über die gameMessage-Schnittstelle (siehe gameMessage.opcode).

• Aktiviere die Spiellogik, um auf deine anderen AWS Ressourcen zuzugreifen. Details hierzu finden Sie unter Kommunizieren Sie mit anderen AWS Ressourcen aus Ihren Flotten.

• Erlaube der Spiellogik, auf die Flotteninformationen der Instanz zuzugreifen, auf der sie ausgeführt wird. Details hierzu finden Sie unter Flottendaten für eine GameLift Amazon-Instance abrufen.

Beispiel für ein Realtime Server-Skript

Dieses Beispiel veranschaulicht ein grundlegendes Skript, das für die Bereitstellung von Echtzeitservern erforderlich ist, sowie einige benutzerdefinierte Logik. Es enthält die erforderliche Init()-Funktion und verwendet einen Timermechanismus, um die Beendigung der Spielsitzung basierend auf der Zeitspanne ohne Spielerverbindungen auszulösen. Es enthält außerdem einige Hooks für eine benutzerdefinierte Logik, einschließlich einiger Callback-Implementierungen.

// Example Realtime Server Script
'use strict';

// Example override configuration
const configuration = {
    pingIntervalTime: 30000,
    maxPlayers: 32
};

// Timing mechanism used to trigger end of game session. Defines how long, in milliseconds, between each tick in the example tick loop
const tickTime = 1000;

// Defines how to long to wait in Seconds before beginning early termination check in the example tick loop
const minimumElapsedTime = 120;

var session;                        // The Realtime server session object
var logger;                         // Log at appropriate level via .info(), .warn(), .error(), .debug()
var startTime;                      // Records the time the process started
var activePlayers = 0;              // Records the number of connected players
var onProcessStartedCalled = false; // Record if onProcessStarted has been called

// Example custom op codes for user-defined messages
// Any positive op code number can be defined here. These should match your client code.
const OP_CODE_CUSTOM_OP1 = 111;
const OP_CODE_CUSTOM_OP1_REPLY = 112;
const OP_CODE_PLAYER_ACCEPTED = 113;
const OP_CODE_DISCONNECT_NOTIFICATION = 114;

// Example groups for user-defined groups
// Any positive group number can be defined here. These should match your client code.
// When referring to user-defined groups, "-1" represents all groups, "0" is reserved.
const RED_TEAM_GROUP = 1;
const BLUE_TEAM_GROUP = 2;

// Called when game server is initialized, passed server's object of current session
function init(rtSession) {
    session = rtSession;
    logger = session.getLogger();
}

// On Process Started is called when the process has begun and we need to perform any
// bootstrapping.  This is where the developer should insert any code to prepare
// the process to be able to host a game session, for example load some settings or set state
//
// Return true if the process has been appropriately prepared and it is okay to invoke the
// GameLift ProcessReady() call.
function onProcessStarted(args) {
    onProcessStartedCalled = true;
    logger.info("Starting process with args: " + args);
    logger.info("Ready to host games...");

    return true;
}

// Called when a new game session is started on the process
function onStartGameSession(gameSession) {
    // Complete any game session set-up

    // Set up an example tick loop to perform server initiated actions
    startTime = getTimeInS();
    tickLoop();
}

// Handle process termination if the process is being terminated by GameLift
// You do not need to call ProcessEnding here
function onProcessTerminate() {
    // Perform any clean up
}

// Return true if the process is healthy
function onHealthCheck() {
    return true;
}

// On Player Connect is called when a player has passed initial validation
// Return true if player should connect, false to reject
function onPlayerConnect(connectMsg) {
    // Perform any validation needed for connectMsg.payload, connectMsg.peerId
    return true;
}

// Called when a Player is accepted into the game
function onPlayerAccepted(player) {
    // This player was accepted -- let's send them a message
    const msg = session.newTextGameMessage(OP_CODE_PLAYER_ACCEPTED, player.peerId,
                                             "Peer " + player.peerId + " accepted");
    session.sendReliableMessage(msg, player.peerId);
    activePlayers++;
}

// On Player Disconnect is called when a player has left or been forcibly terminated
// Is only called for players that actually connected to the server and not those rejected by validation
// This is called before the player is removed from the player list
function onPlayerDisconnect(peerId) {
    // send a message to each remaining player letting them know about the disconnect
    const outMessage = session.newTextGameMessage(OP_CODE_DISCONNECT_NOTIFICATION,
                                                session.getServerId(),
                                                "Peer " + peerId + " disconnected");
    session.getPlayers().forEach((player, playerId) => {
        if (playerId != peerId) {
            session.sendReliableMessage(outMessage, playerId);
        }
    });
    activePlayers--;
}

// Handle a message to the server
function onMessage(gameMessage) {
    switch (gameMessage.opCode) {
      case OP_CODE_CUSTOM_OP1: {
        // do operation 1 with gameMessage.payload for example sendToGroup
        const outMessage = session.newTextGameMessage(OP_CODE_CUSTOM_OP1_REPLY, session.getServerId(), gameMessage.payload);
        session.sendGroupMessage(outMessage, RED_TEAM_GROUP);
        break;
      }
    }
}

// Return true if the send should be allowed
function onSendToPlayer(gameMessage) {
    // This example rejects any payloads containing "Reject"
    return (!gameMessage.getPayloadAsText().includes("Reject"));
}

// Return true if the send to group should be allowed
// Use gameMessage.getPayloadAsText() to get the message contents
function onSendToGroup(gameMessage) {
    return true;
}

// Return true if the player is allowed to join the group
function onPlayerJoinGroup(groupId, peerId) {
    return true;
}

// Return true if the player is allowed to leave the group
function onPlayerLeaveGroup(groupId, peerId) {
    return true;
}

// A simple tick loop example
// Checks to see if a minimum amount of time has passed before seeing if the game has ended
async function tickLoop() {
    const elapsedTime = getTimeInS() - startTime;
    logger.info("Tick... " + elapsedTime + " activePlayers: " + activePlayers);

    // In Tick loop - see if all players have left early after a minimum period of time has passed
    // Call processEnding() to terminate the process and quit
    if ( (activePlayers == 0) && (elapsedTime > minimumElapsedTime)) {
        logger.info("All players disconnected. Ending game");
        const outcome = await session.processEnding();
        logger.info("Completed process ending with: " + outcome);
        process.exit(0);
    }
    else {
        setTimeout(tickLoop, tickTime);
    }
}

// Calculates the current time in seconds
function getTimeInS() {
    return Math.round(new Date().getTime()/1000);
}

exports.ssExports = {
    configuration: configuration,
    init: init,
    onProcessStarted: onProcessStarted,
    onMessage: onMessage,
    onPlayerConnect: onPlayerConnect,
    onPlayerAccepted: onPlayerAccepted,
    onPlayerDisconnect: onPlayerDisconnect,
    onSendToPlayer: onSendToPlayer,
    onSendToGroup: onSendToGroup,
    onPlayerJoinGroup: onPlayerJoinGroup,
    onPlayerLeaveGroup: onPlayerLeaveGroup,
    onStartGameSession: onStartGameSession,
    onProcessTerminate: onProcessTerminate,
    onHealthCheck: onHealthCheck
};