Funciones sociales

All Out ofrece chat de texto y chat de voz opcional para que los uses en tus juegos

Lectura del chat

Usa core_globals.server_on_chat_message_received cuando el código del juego necesita reaccionar a mensajes normales de chat en el servidor:

ao_before_scene_load :: proc() {
    core_globals.server_on_chat_message_received = on_chat_message;
}

on_chat_message :: proc(player: Player, message: string) {
    log_info("% dijo %", {player.get_username(), message});
}

Referencia de la API de chat

Chat :: struct {
    Mode :: enum {
        DEFAULT;
        BUBBLE_ONLY;
    }

    set_mode :: proc(mode: Mode);
    server_send_message :: proc(message: string, player: Player = null);
    is_open :: proc() -> bool;
}

Chat.server_send_message es para código del lado del servidor, como controladores de comandos de chat. Pasa jugador para dirigirlo a un jugador, o déjalo null para enviarlo ampliamente. Usa Chat.set_mode(.BUBBLE_ONLY) en el cliente local para juegos que quieran chat en burbujas sin el panel de chat estándar.

Comandos de chat

Los comandos de chat son principalmente una herramienta de desarrollador/admin para pruebas y operaciones en vivo:

• Iniciar rondas antes / omitir oleadas

• Otorgar conjuntos de objetos de prueba o moneda

• Activar eventos del juego para depuración

Para crear un comando, escribe una proc y анota la función con @chat_command.

El nombre del procedimiento es el nombre del comando: start_round se invoca como /start_round. La invocación ignora los espacios en blanco alrededor y prefiere un nombre con el mismo uso de mayúsculas y minúsculas exacto; luego recurre a una coincidencia sin distinguir mayúsculas y minúsculas.

Los jugadores pueden escribir comandos en el chat con una /:

• /start_round

• /grant_test_loadout

• /trigger_event meteor_shower

Los comandos de chat se ejecutan en el servidor. Usa Notifier.notify(player, "...") para enviar una respuesta a un solo jugador.

No todos los jugadores tendrán el chat de texto habilitado (los controles parentales y los silencios de moderación pueden desactivar el cuadro de texto), así que no deberías depender de los comandos de chat para sistemas críticos de juego.

Comandos comunes de desarrollo/admin

// Iniciar una ronda antes de tiempo (solo admin)
start_round :: proc(player: Player) {
    g_round_manager.start_round();
    Notifier.notify(player, "Ronda iniciada.");
} @chat_command

// Otorgarte un conjunto de prueba (solo admin)
grant_test_loadout :: proc(player: Player) {
    // Ejemplo: usa aquí tu propia lógica para otorgar objetos
    // item := Items.create_item_instance(sword_defn);
    // Items.move_item_to_inventory(item, player.default_inventory);
    Notifier.notify(player, "Conjunto de prueba otorgado.");
} @chat_command

// Activar un evento por nombre (solo admin, con un argumento opcional)
trigger_event :: proc(player: Player, event_name: string = "meteor_shower") {
    g_event_system.trigger(event_name);
    Notifier.notify(player, "Evento activado: %", {event_name});
} @chat_command

Permisos

Usa anotaciones de permisos para controlar quién puede ejecutar un comando:

Anotación	Quién puede usarlo
@any	Todos los jugadores
@vip	Jugadores VIP y administradores
@youtuber	Jugadores y administradores youtubers
@owner	Propietario del juego y administradores
@owner_or_editor	Propietario del juego, editores y administradores
(ninguno)	Solo administradores

// Los VIP y administradores pueden usar esto
skip_wave :: proc(player: Player) {
    g_wave_manager.skip_to_next_wave();
    Notifier.notify(player, "Oleada omitida.");
} @chat_command @vip

Al iniciar desde el editor, los comandos de chat están permitidos para una iteración/pruebas más rápidas.

Argumentos y parámetros opcionales

El primer parámetro siempre debe ser Player. Después de eso puedes agregar argumentos (y darles valores predeterminados para hacerlos opcionales).

De forma predeterminada, los comandos son solo administradores.

Los tipos de argumento admitidos son string, tipos enteros, tipos de coma flotante, booly Player.

Un Player el argumento usa el token completo delimitado por espacios o entre comillas y coincide exactamente con el nombre visible del jugador. Los nombres que contienen dígitos o guiones bajos funcionan directamente; pon entre comillas los nombres que contienen espacios.

// Solo administradores (predeterminado)
give_currency :: proc(player: Player, amount: s64 = 100) {
    if amount < 0 {
        Notifier.notify(player, "La cantidad debe ser cero o mayor.");
        return;
    }

    Economy.deposit_currency(player, "Coins", amount);
    Notifier.notify(player, "Te di % monedas.", {amount});
} @chat_command

Los administradores pueden usar:

• /give_currency → otorga 100 monedas

• /give_currency 500 → otorga 500 monedas

Cadenas con espacios

Pon las cadenas entre comillas si contienen espacios:

say :: proc(player: Player, message: string) {
    // Tu propia función de difusión/mensaje del juego aquí
    log_info("% dice: %", {player.get_username(), message});
} @chat_command @any

Ejemplo:

/say "¡Hola a todos!"

Obtener el uso de un comando

Los jugadores pueden añadir ? a un comando para ver la información de los parámetros:

/spawn_enemy?

Activación del chat de voz

Los jugadores controlan el chat de voz a través de la configuración de su cuenta y dispositivo. Los juegos no pueden forzarlo ni eludir los permisos del micrófono, los controles parentales o las restricciones de moderación.

La voz es posicional. El alcance audible predeterminado es de 10 unidades del mundo:

Voice :: struct {
    set_range :: proc(range: float);
    get_range :: proc() -> float;
}

Establece un alcance positivo durante el inicio de la escena:

ao_start :: proc() {
    Voice.set_range(14);
}

Voice.set_range cambia el alcance de toda la escena. Los valores no positivos se ignoran.

Canales de comunicación

Cada jugador tiene máscaras de habla y escucha que se aplican tanto al chat de voz como al de texto. Dos jugadores pueden comunicarse cuando la máscara de habla del emisor se superpone con la máscara de escucha del receptor.

TEAM_RED  :: 1.(u64) << 0;
TEAM_BLUE :: 1.(u64) << 1;

put_on_red_team :: proc(player: Player) {
    player.comms_channel_speak_mask = TEAM_RED;
    player.comms_channel_listen_mask = TEAM_RED;
}

Los jugadores escuchan y hablan en todos los canales por defecto.

Moderación

All Out supervisa automáticamente el chat de texto y de voz para detectar comportamientos que infrinjan nuestras normas de la comunidad y desactivará las funciones sociales en las primeras infracciones o aplicará suspensiones a los infractores reincidentes.

Si ves comportamiento malo repetido o comportamiento que haya eludido nuestra detección automática, por favor repórtalo usando el sistema de denuncias del juego o desde su perfil.

Si un jugador ha sido suspendido por accidente, por favor indícale que se ponga en contacto con nosotros para revertir la acción.