Adición de la gema Metastream Opciones de configuración para el servidor HTTP Exposición de datos a través de Metastream Acceso a los datos a través de la API de HTTP

Gema Metastream

Open 3D Engine (O3DE), el sucesor de Lumberyard, ya está disponible en Developer Preview. Descargar O3DE

o visite elBlog de AWS Game Tech

para obtener más información.

Twitch Metastream es una característica que permite a los emisores personalizar sus transmisiones con superposiciones de estadísticas y eventos de su sesión de juego. Mediante cualquier herramienta de creación web, como Dreamweaver o CoffeeCup, los emisores pueden crear páginas HTML5 personalizadas para controlar la información, los gráficos, el diseño y el funcionamiento de cada superposición única. Metastream permite a los emisores crear experiencias de visualización interactivas más afinadas en cualquiera de sus servicios de streaming favoritos, similar a como lo hacen los emisores de deportes profesionales y de televisión en formato electrónico.

Entre los ejemplos de la información que se muestra en una superposición se incluyen:

Arte de personajes
Puntos fuertes y débiles de los personajes
Clasificaciones de los jugadores
Estadísticas de dos líderes en una partida
Oros obtenidos
Jugadores matados, muertos y necesitados de asistencia
Daños tratados

Los emisores pueden cambiar entre diferentes capas gráficas programadas para eventos del juego. También pueden utilizar el estilo de imagen incrustada para mostrar información complementaria como, por ejemplo, un minimapa y estadísticas del equipo en directo.

Para permitir que los emisores utilicen Twitch Metastream, debe hacer lo siguiente:

Habilite la gema Metastream en su proyecto.
Añada una sola línea de código para cada evento al que desee que accedan los emisores.

nota

Twitch Metastream solo es compatible con Windows.

Adición de la gema Metastream

Habilite la gema Metastream en un proyecto para activar el servidor local HTTP Metastream que se incluye con Lumberyard.

Para habilitar la gema Metastream, consulte Habilitación de gemas.

Opciones de configuración para el servidor HTTP

Después de habilitar Metastream, se incrusta un servidor HTTP en el cliente de juego que actúa como punto de acceso para los datos expuestos. Puede configurar las siguientes opciones para el servidor HTTP.

metastream_enabled

Variable de consola de solo lectura (CVAR) que describe el estado actual del servidor HTTP incrustado. 0 = deshabilitado. 1 = habilitado.

metastream_serverOptions

Establece las opciones para el servidor HTTP incrustado. Las opciones son un conjunto de pares key=value separados por punto y coma.

Si un valor de clave requiere un signo de punto y coma ';' o de igual '=', puede utilizar la macro $semi o $equ.

El servidor HTTP incrustado se basa en CivetWeb. Puede consultar la lista completa de opciones que se pueden configurar en:

https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md

Por motivos de seguridad, se pasan por alto las siguientes opciones de CivetWeb:

enable_directory_listing
cgi_interpreter
run_as_user
put_delete_auth_file

Los archivos que coloque dentro de la raíz del documento serán distribuidos por el servidor HTTP. Consulte Acceso a los datos a través de la API de HTTP.

También puede utilizar los siguientes comandos de la consola:

metastream_start: Inicia el servidor HTTP incrustado.
metastream_stop: Interrumpe el servidor HTTP incrustado.

Exposición de datos a través de Metastream

Metastream expone datos a través de la API de C++.

API de C++

Control del servidor HTTP

La gema Metastream utiliza la siguiente API para iniciar el servidor HTTP:


bool result; // True when the server is successfully started, false when an error occurs.
Metastream::MetastreamRequestBus::BroadcastResult(result,&Metastream::MetastreamRequests::StartHTTPServer);

Si se intenta iniciar el servidor HTTP cuando ya se está ejecutando, ello no produce ningún efecto y la llamada devuelve "true".

La gema Metastream utiliza la siguiente API para detener el servidor HTTP:


Metastream::MetastreamRequestBus::Broadcast(&Metastream::MetastreamRequests::StopHTTPServer);

Si el servidor no se está ejecutando, intentar detener el servidor no produce ningún efecto.

Exposición de datos

La gema Metastream utiliza una API sencilla para exponer los datos en el juego mediante el sistema EBus. Consulte Acceso a los datos a través de la API de HTTP para ver estos valores. En la actualidad, la API de Metastream admite valores de 64 bits sin firmar, firmados, dobles, Vec3, booleanos y cadenas de UTF8. El sistema EBus exige que estas llamadas vayan por separado. Esta API le permite añadir valores a objetos y/o matrices y la caché. Esto permite disponer de un sistema totalmente flexible para exponer datos a un cliente web.

Adición a la caché

Para añadir un objeto a la caché raíz, utilice la siguiente sintaxis:


void MetastreamRequests::AddStringToCache(const char* table, const char* key, const char* value)
void MetastreamRequests::AddBoolToCache(const char* table, const char* key, bool value)
void MetastreamRequests::AddVec3ToCache(const char* table, const char* key, const Vec3 & value)
void MetastreamRequests::AddDoubleToCache(const char* table, const char* key, double value)
void MetastreamRequests::AddUnsigned64ToCache(const char* table, const char* key, AZ::u64 value)
void MetastreamRequests::AddSigned64ToCache(const char* table, const char* key, AZ::s64 value)
void MetastreamRequests::AddArrayToCache(const char* table, const char* key, const char* arrayName)
void MetastreamRequests::AddObjectToCache(const char* table, const char* key, const char* objectName)

Definiciones de los parámetros que se enumeran:

table: Nombre de la tabla.
key: Nombre de la clave.
value: El valor que se debe añadir. Si el valor existe, se actualiza. Si el tipo de valor es booleano, se representa en el documento JSON como true o false. Los tipos firmado, sin firma y doble se representa como números JSON; las cadenas son UTF8 y se les aplicará escape, si es necesario.
arrayName: El nombre de la matriz que se debe añadir. Si no existe matriz, entonces se añade la matriz vacía. La matriz se elimina después de que se añade a la caché.
objectName: El nombre del objeto que se debe añadir. Si no existe objeto, entonces se añade un objeto NULO. El objeto se elimina después de que se añade a la caché.

Ninguno de los anteriores devuelve ningún valor.

Adición a matriz

Para añadir un objeto a una matriz, utilice la siguiente sintaxis:


void MetastreamRequests::AddStringToArray(const char* table, const char* arrayName, const char* value)
void MetastreamRequests::AddBoolToArray(const char* table, const char* arrayName, bool value)
void MetastreamRequests::AddVec3ToArray(const char* table, const char* arrayName, const Vec3 & value)
void MetastreamRequests::AddDoubleToArray(const char* table, const char* arrayName, double value)
void MetastreamRequests::AddUnsigned64ToArray(const char* table, const char* arrayName, AZ::u64 value)
void MetastreamRequests::AddSigned64ToArray(const char* table, const char* arrayName, AZ::s64 value)
void MetastreamRequests::AddObjectToArray(const char* table, const char* destArrayName, const char* sourceObjectName)

Definiciones de los parámetros que se enumeran:

table: Nombre de la tabla.
arrayName: El nombre de la matriz que se debe añadir. Si no existe matriz, entonces se añade una matriz vacía. La matriz se elimina después de que se añade a la caché.
value: El valor que se debe añadir a la matriz. Si el tipo de valor es booleano, se representa en el documento JSON como true o false. Los tipos firmado, sin firma y doble se representa como números JSON; las cadenas son UTF8 y se les aplicará escape, si es necesario.
arrayName: El nombre de la matriz a la que se debe añadir. Si no existe matriz, se crea una.
destArrayName: El nombre de la matriz de destino a la que se debe añadir. Si no existe matriz, se crea una.
sourceObjectName: El nombre del objeto que se debe añadir a la matriz. Si no existe objeto, entonces se añade un objeto NULO. El objeto se elimina después de que se añade a la caché.

Ninguno de los anteriores devuelve ningún valor.

Adición a objeto

Para añadir un objeto a un objeto, utilice la siguiente sintaxis:


void MetastreamRequests::AddArrayToObject(const char* table, const char* destObjectName, const char* key, const char* srcArrayName)
void MetastreamRequests::AddObjectToObject(const char* table, const char* destObjectName, const char* key, const char* sourceObjectName)
void MetastreamRequests::AddStringToObject(const char* table, const char* objectName, const char* key, const char* value)
void MetastreamRequests::AddBoolToObject(const char* table, const char* objectName, const char* key, bool value)
void MetastreamRequests::AddVec3ToObject(const char* table, const char* objectName, const char* key, const Vec3 & value)
void MetastreamRequests::AddDoubleToObject(const char* table, const char* objectName, const char* key, double value)
void MetastreamRequests::AddUnsigned64ToObject(const char* table, const char* objectName, const char* key, AZ::u64 value)
void MetastreamRequests::AddSigned64ToObject(const char* table, const char* objectName, const char* key, AZ::s64 value)

Definiciones de los parámetros que se enumeran:

table: Nombre de la tabla.
key: Nombre de la clave.
objectName: El nombre del objeto que se debe añadir. Si no existe un objeto, se crea uno.
value: El valor que se debe añadir. Si el valor existe, se actualiza. Si el tipo de valor es booleano, se representa en el documento JSON como true o false. Los tipos firmado, sin firma y doble se representa como números JSON; las cadenas son UTF8 y se les aplicará escape, si es necesario.
srcArrayName: El nombre de la matriz a la que se debe añadir. Si no existe matriz, se crea una. La matriz se elimina después de que se añade al objeto.
sourceObjectName: El nombre del objeto que se debe añadir. Si no existe objeto, entonces se añade un objeto NULO. El objeto se elimina después de que se añade a la caché.

Ninguno de los anteriores devuelve ningún valor.

Examples

El siguiente ejemplo muestra cómo utilizar la API C++ de Metastream en un proyecto:


Metastream::MetastreamRequestBus::Broadcast(&Metastream::MetastreamRequestBus::Events::AddToCache, table, key, value);

nota

Cualquier valor que se añada a la caché debe ser compatible con JSON. Para obtener más información, consulte el documento JSON RFC.

El siguiente ejemplo muestra cómo reflejar la información del sistema. Básicamente, toda la información se añade a un nombre de objeto, sysInfo, y este objeto se añade a la caché como systeminfo.

Objeto compuesto:


Metastream::MetastreamRequestBus::Broadcast(
    &Metastream::MetastreamRequestBus::Events::AddUnsigned64ToObject,
    kDataBaseName.c_str(), "sysInfo",  "drivespace", GetFreeDriveSpace());
    
Metastream::MetastreamRequestBus::Broadcast(
    &Metastream::MetastreamRequestBus::Events::AddUnsigned64ToObject,
    kDataBaseName.c_str(),  "sysInfo",  "memoryload", GetMemoryLoad());
    
Metastream::MetastreamRequestBus::Broadcast(
    &Metastream::MetastreamRequestBus::Events::AddDoubleToObject,
    kDataBaseName.c_str(),  "sysInfo",  "cpuloadsystem", GetCPULoadSystem());
    
Metastream::MetastreamRequestBus::Broadcast(
    &Metastream::MetastreamRequestBus::Events::AddDoubleToObject,
    kDataBaseName.c_str(),  "sysInfo",  "cpuloadprocess", GetCPULoadProcess());
    
Metastream::MetastreamRequestBus::Broadcast(
    &Metastream::MetastreamRequestBus::Events::AddUnsigned64ToObject,
    kDataBaseName.c_str(),  "sysInfo",  "tickcount", GetTickCount64());
    
Metastream::MetastreamRequestBus::Broadcast(
    &Metastream::MetastreamRequestBus::Events::AddObjectToCache,
    kDataBaseName.c_str(),  "systeminfo",  "sysInfo");

Enlaces Lua de Metastream

A partir de Lumberyard 1.10, Twitch Metastream se refleja mediante el contexto de comportamiento, que le permite utilizar Metastream a través de Script Canvas y Lua.

Los siguientes métodos se pueden invocar desde Lua:


-- Controlling the HTTP server:
MetastreamRequestBus.Broadcast.StartHTTPServer();
MetastreamRequestBus.Broadcast.StopHTTPServer();

-- Adding to the root cache directly:
MetastreamRequestBus.Broadcast.AddStringToCache(table, key, value);      -- where value is a string
MetastreamRequestBus.Broadcast.AddBoolToCache(table, key, value);        -- where value is a bool
MetastreamRequestBus.Broadcast.AddDoubleToCache(table, key, value);      -- where value is a double
MetastreamRequestBus.Broadcast.AddUnsigned64ToCache(table, key, value);  -- where value is an unsigned 64-bit number
MetastreamRequestBus.Broadcast.AddSigned64ToCache(table, key, value);    -- where value is a signed 64-bit number
  
MetastreamRequestBus.Broadcast.AddArrayToCache(table, key, arrayName);   -- where arrayName is the name of a temporary array (see below)
MetastreamRequestBus.Broadcast.AddObjectToCache(table, key, objectName); -- where objectName is the name of a temporary object (see below)
  
-- Adding to a temporary Array:
MetastreamRequestBus.Broadcast.AddStringToArray(table, arrayName, value);
MetastreamRequestBus.Broadcast.AddBoolToArray(table, arrayName, value);
MetastreamRequestBus.Broadcast.AddDoubleToArray(table, arrayName, value);
MetastreamRequestBus.Broadcast.AddUnsigned64ToArray(table, arrayName, value);
MetastreamRequestBus.Broadcast.AddSigned64ToArray(table, arrayName, value);
MetastreamRequestBus.Broadcast.AddObjectToArray(table, arrayName, objectName);
  
-- Adding to a temporary Object:
MetastreamRequestBus.Broadcast.AddStringToObject(table, objectName, key, value);
MetastreamRequestBus.Broadcast.AddBoolToObject(table, objectName, key, value);
MetastreamRequestBus.Broadcast.AddDoubleToObject(table, objectName, key, value);
MetastreamRequestBus.Broadcast.AddUnsigned64ToObject(table, objectName, key, value);
MetastreamRequestBus.Broadcast.AddSigned64ToObject(table, objectName, key, value);
MetastreamRequestBus.Broadcast.AddArrayToObject(table, objectName, key, arrayName);
MetastreamRequestBus.Broadcast.AddObjectToObject(table, objectName, key, objectName);

Acceso a los datos a través de la API de HTTP

Puede acceder a datos del juego expuestos a través de Metastream mediante solicitudes Get de la API HTTP. A continuación, puede utilizar JavaScript para trabajar con los datos.

http://localhost:port/pathToFile: Transmite un archivo de la raíz de documentos. Los tipos de archivos incluyen HTML, CSS, JS, imágenes, sonidos, recursos o activos.

nota
La ruta de datos se reserva para datos de Metastream. No será posible obtener acceso a los archivos que se guardan en el directorio document_root/data/.
http://localhost:port/data: Devuelve una lista con las tablas de Metastream disponibles que contienen pares key=value.
http://localhost:port/data?table=table_name: Devuelve una lista con todas las claves de Metastream en la tabla especificada.

nota
Puede recuperar varios pares clave-valor en una sola solicitud enumerando las claves en una lista separada por comas. Por ejemplo, http://localhost:8082/data?table=sample&key=key1,key2,key3
http://localhost:port/data?table=table_name&key=key_name: Devuelve el valor de la clave especificada en la tabla especificada.

nota
Es posible recuperar varios pares key=value en una sola solicitud enumerando las claves deseadas separadas por comas. Por ejemplo, http://localhost:8082/data?table=sample&key=key1,key2,key3.
Para enumerar todas las claves y sus valores para una tabla: http://localhost:8082/data?table=sample&key=*

Las solicitudes de datos se devuelven en el siguiente formato:

Solicitud	Return
`/data`	`{ "tables": [ "table1", "table2", ... ] }`
`/data?table=table_name`	`{ "keys": [ "key1", "key2", ... ] }`
`/data?table=table_name&key=key_name`	`{ "key_name": value }`
`/data?table=table_name&key=keys_list`	`{ "key1": value1, "key2": value2, ... }`

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Gema Maestro

Gema Microphone