Creación de un script de Realtime

Para utilizar Amazon GameLift Servers En tiempo real para tu juego, necesitas proporcionar un script (en forma de JavaScript código) para configurar y, opcionalmente, personalizar una flota de Amazon GameLift Servers En tiempo real. En este tema se explican los pasos principales para crear un script de Realtime. Una vez que el guion esté listo, cárguelo en el Amazon GameLift Servers realice el mantenimiento y utilícelo para crear una flota (consulteImplementar un script para Amazon GameLift Servers Realtime).

Para preparar un guion para su uso con Amazon GameLift Servers En tiempo real, añada la siguiente funcionalidad a su script en tiempo real.

Administración del ciclo de vida de la sesión de juego (obligatorio)

Como mínimo, un script de Realtime debe incluir la función Init(), que prepara el servidor de Realtime para iniciar una sesión de juego. También es muy recomendable que proporcione además una forma de terminar las sesiones de juego, para garantizar que las nuevas sesiones de juego se puedan seguir iniciando en la flota.

La función de devolución de llamada Init(), cuando se llama, se transfiere un objeto de sesión de Realtime, que contiene una interfaz para el servidor de Realtime. Consulte Amazon GameLift Servers Interfaz en tiempo real para obtener más detalles sobre esta interfaz.

Para finalizar una sesión de juego con fluidez, el script también debe llamar a la función session.processEnding del servidor de Realtime. Esto requiere algún mecanismo para determinar cuándo finalizar una sesión. El código de ejemplo de script ilustra un mecanismo sencillo que comprueba las conexiones de jugadores y desencadena la finalización de la sesión de juego cuando no se ha conectado ningún jugador a la sesión durante un período de tiempo especificado.

Amazon GameLift Servers Realtime, con la configuración más básica (inicialización y finalización de los procesos del servidor), actúa esencialmente como servidores de retransmisión sin estado. El servidor de Realtime transmite los mensajes y datos del juego entre los clientes que se conectan al juego, pero no realiza ninguna acción independiente para procesar los datos o ejecutar la lógica. Si lo desea, puede añadir lógica del juego que se desencadene a partir de eventos del juego u otros mecanismos, según sea necesario para el juego.

Adición de lógica de juego del servidor (opcional)

Si lo desea, puede añadir la lógica del juego a su script de Realtime. Por ejemplo, es posible que realice alguna de las siguientes acciones. El código de ejemplo de script proporciona una ilustración. Consulte Referencia de guion para Amazon GameLift Servers Realtime.

• Añadir lógica basada en eventos. Implemente las funciones de devolución de llamada para responder a eventos de cliente-servidor. Consulte Script callbacks para Amazon GameLift Servers Realtime para obtener una lista completa de devoluciones de llamada.

• Desencadenar la lógica enviando mensajes al servidor. Cree un conjunto de códigos de operación especiales para los mensajes enviados desde clientes de juego al servidor y añada funciones para gestionar la recepción. Utilice la devolución de llamada onMessage y analice el contenido de los mensajes mediante la interfaz gameMessage (consulte gameMessage.opcode).

• Activa la lógica del juego para acceder a tus otros recursos. AWS Para obtener más información, consulte Comuníquese con otros AWS recursos de sus flotas.

• Permite que la lógica del juego acceda a la información de la flota para la instancia en la que se esté ejecutando. Para obtener más información, consulte Obtenga datos de flota para un Amazon GameLift Servers instancia.

Amazon GameLift Servers Ejemplo de script en tiempo real

Este ejemplo ilustra un script básico necesario para la implementación Amazon GameLift Servers Tiempo real y un poco de lógica personalizada. Contiene la función Init() requerida y utiliza un mecanismo de temporizador para desencadenar la finalización de sesiones de juego basada en la duración de tiempo sin conexiones de jugadores. También incluye algunos enlaces para lógica personalizada, incluidas algunas implementaciones de devolución de llamada.

// 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 Amazon GameLift Servers
// 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
};