Creazione di uno script in tempo reale

Per utilizzare Realtime Servers per il tuo gioco, devi fornire uno script (sotto forma di JavaScript codice) per configurare e, facoltativamente, personalizzare una flotta di server in tempo reale. Questo argomento descrive i passaggi chiave per la creazione di uno script in tempo reale. Una volta che lo script è pronto, caricalo sul GameLift servizio Amazon e usalo per creare una flotta (vediCarica uno script Realtime Servers su Amazon GameLift).

Per preparare uno script da utilizzare con Realtime Servers, aggiungi la seguente funzionalità al tuo script Realtime.

Gestisci il ciclo di vita delle sessioni di gioco (obbligatorio)

Come minimo, uno script in tempo reale deve includere la Init() funzione, che prepara il server Realtime ad avviare una sessione di gioco. Inoltre, è consigliabile fornire un modo per terminare le sessioni di gioco, così da assicurare che le nuove sessioni di gioco possano continuare a essere avviate sul parco istanze.

Alla funzione di Init() callback, quando viene chiamata, viene passato un oggetto di sessione in tempo reale, che contiene un'interfaccia per il server Realtime. Per ulteriori informazioni su questa interfaccia, consulta Interfaccia Realtime Server.

Per terminare correttamente una sessione di gioco, lo script deve anche richiamare la funzione del server Realtime. session.processEnding Ciò richiede alcuni meccanismi per determinare quando terminare una sessione. Il codice script di esempio illustra un semplice meccanismo che controlla le connessioni dei giocatori e attiva la terminazione della sessione di gioco quando nessun giocatore è connesso alla sessione per un determinato intervallo di tempo.

I server in tempo reale con la configurazione più semplice (inizializzazione e terminazione dei processi del server) agiscono essenzialmente come server di inoltro senza stato. Il server in tempo reale trasmette messaggi e dati di gioco tra i client di gioco connessi al gioco, ma non intraprende alcuna azione indipendente per elaborare i dati o eseguire la logica. È anche possibile aggiungere una logica di gioco, attivata da eventi di gioco o da altri meccanismi, in base alle esigenze del gioco medesimo.

Aggiungi la logica di gioco lato server (opzionale)

Facoltativamente, puoi aggiungere la logica di gioco al tuo script in tempo reale. Ad esempio, è possibile eseguire una o tutte le seguenti operazioni. Il codice di esempio di script fornisce illustrazione. Consultare Riferimento allo script Amazon GameLift Realtime Servers.

• Aggiunta di logica basata sugli eventi. Implementa le funzioni di chiamata per rispondere a eventi client-server. Per un elenco completo di chiamate, consulta Richiamate di script per server in tempo reale.

• Attivazione della logica mediante l'invio di messaggi al server. Crea un set di codici di operazione speciali per i messaggi inviati dai client di gioco al server e aggiunge funzioni per gestire la ricezione Utilizza la chiamata onMessage e analizza il contenuto del messaggio tramite l'interfaccia gameMessage (consulta gameMessage.opcode).

• Abilita la logica di gioco per accedere alle tue altre AWS risorse. Per informazioni dettagliate, consultare Comunica con altre AWS risorse delle tue flotte.

• Consenti alla logica di gioco di accedere alle informazioni sulla flotta dell'istanza su cui è in esecuzione. Per informazioni dettagliate, consultare Ottieni dati sulla flotta per un'GameLiftistanza Amazon.

Esempio di script Realtime Servers

Questo esempio illustra uno script di base necessario per implementare Realtime Server più una logica personalizzata. Contiene la funzione Init() richiesta e utilizza un meccanismo timer per attivare la terminazione delle sessioni di gioco in base all'intervallo di tempo in cui nessun giocatore si è connesso. Include anche alcuni hook per logica personalizzata, tra cui alcune implementazioni di chiamate.

// 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
};