> For the complete documentation index, see [llms.txt](https://docs.cuxial.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.cuxial.com/scripts/es/interfaz/cuxial-emotes/developers.md).

# Exports y eventos

Exports, eventos y estados del jugador públicos de Cuxial Emotes para usar desde otros recursos.

Otros recursos pueden reproducir y cancelar emotes, bloquear al jugador, cambiar el estilo de caminar y consultar qué está haciendo. Lo que no aparece en esta página es interno.

Todos los exports de cliente actúan sobre el jugador local, salvo que se indique lo contrario.

## Exports de cliente

### Reproducir y cancelar

| Export                | Parámetros                            | Devuelve  | Qué hace                                                                                                                                                                                           |
| --------------------- | ------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `PlayEmoteByCommand`  | `command: string`, `variant?: number` | `boolean` | Reproduce un emote, escenario, estilo de caminar o expresión por su comando. Devuelve `false` si el comando no existe, el jugador está bloqueado o el cooldown sigue activo.                       |
| `StartAnimationPlay`  | `command: string`, `variant?: number` | —         | Igual que el anterior, sin valor de retorno.                                                                                                                                                       |
| `PlayEmote`           | `data: table`, `variation?: number`   | `boolean` | Reproduce un emote a partir de su tabla de datos, tal como la devuelve `findEmoteByCommand`.                                                                                                       |
| `playScenario`        | `name: string`                        | —         | Inicia un escenario de GTA en el sitio. No hace nada dentro de un vehículo ni con el jugador bloqueado.                                                                                            |
| `CancelEmote`         | `skipReset?: boolean`                 | —         | Cancela el emote actual. Si hay un emote de torso superpuesto, solo cancela ese. Con `true` lo corta todo al momento, se salta la animación de salida y funciona aunque el jugador esté bloqueado. |
| `StopAnimation`       | `skipReset?: boolean`                 | —         | Alias de `CancelEmote`.                                                                                                                                                                            |
| `CancelUpperLayer`    | —                                     | —         | Cancela solo la animación de torso superpuesta a otro emote.                                                                                                                                       |
| `CancelAllAnimations` | —                                     | —         | Limpia los emotes y los estados de movimiento (manos arriba, brazos cruzados, señalar, tumbado). No hace nada con el jugador bloqueado.                                                            |
| `PlayAnimOnNPC`       | `command: string`, `ped: number`      | —         | Reproduce un emote o un escenario del catálogo en otro ped.                                                                                                                                        |

```lua
local played = exports.cuxial_emotes:PlayEmoteByCommand('adjust')
if not played then
    print('No se pudo reproducir el emote')
end

-- más tarde
exports.cuxial_emotes:CancelEmote()
```

### Bloqueo y estado

| Export                  | Parámetros        | Devuelve       | Qué hace                                                                                   |
| ----------------------- | ----------------- | -------------- | ------------------------------------------------------------------------------------------ |
| `SetEmoteLock`          | `locked: boolean` | —              | Mientras está bloqueado, el jugador no puede iniciar ni cancelar emotes, ni abrir el menú. |
| `IsEmoteLocked`         | —                 | `boolean`      | Si el bloqueo está activo.                                                                 |
| `SetCanPlayAnimation`   | `value: boolean`  | —              | Permite o impide iniciar emotes.                                                           |
| `CanPlayAnimation`      | —                 | `boolean`      | Si se pueden iniciar emotes.                                                               |
| `SetCanCancelAnimation` | `value: boolean`  | —              | Permite o impide cancelar el emote actual.                                                 |
| `SetAnimationPlaying`   | `value: boolean`  | —              | Fuerza el indicador de «hay un emote en curso».                                            |
| `IsPlayingAnimation`    | —                 | `boolean`      | Si hay un emote en curso.                                                                  |
| `isPlayerDead`          | —                 | `boolean`      | Si el script considera muerto al jugador, según `deadCheck`.                               |
| `GetBaseLayer`          | —                 | `table \| nil` | Emote actual: `{ data, variation, dict, anim }`.                                           |
| `GetUpperLayer`         | —                 | `table \| nil` | Emote de torso actual, con la misma forma.                                                 |
| `HasUpperLayer`         | —                 | `boolean`      | Si hay un emote de torso superpuesto.                                                      |

```lua
-- Mantener al jugador en una animación de tu script
exports.cuxial_emotes:SetEmoteLock(true)
-- ... tu escena ...
exports.cuxial_emotes:SetEmoteLock(false)
```

{% hint style="warning" %}
Libera siempre el bloqueo que pongas. Un jugador bloqueado no puede usar ningún emote hasta que se llame a `SetEmoteLock(false)`. El bloqueo también se libera cuando se detiene el recurso que lo puso.
{% endhint %}

### Catálogo

| Export                | Parámetros                              | Devuelve                        | Qué hace                                                                                                                                                              |
| --------------------- | --------------------------------------- | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `findEmoteByCommand`  | `command: string`                       | `table \| nil`, `string \| nil` | Datos del emote y su tipo: `'emote'`, `'scenario'`, `'walk'` o `'expression'`.                                                                                        |
| `buildAnimationsList` | —                                       | `table[]`                       | La lista que muestra el menú. Cada entrada tiene `name`, `title`, `description`, `category` y `liked`. Los emotes llevan además `isSynced`, `icon`, `tags` y `added`. |
| `GetAnimationFromSet` | `setIndex: number`, `animIndex: number` | `string \| nil`                 | Comando guardado en un hueco de un set rápido.                                                                                                                        |
| `buildPropsFromData`  | `props: table`, `variation?: number`    | `table[]`                       | Convierte los `Options.Props` de un emote en entradas `{ hash, bone, placement, variant }`.                                                                           |
| `CleanAllPedProps`    | —                                       | —                               | Quita los props de emote que lleva el jugador.                                                                                                                        |

```lua
local emote, kind = exports.cuxial_emotes:findEmoteByCommand('atm')
if emote then
    print(emote.Label, kind)
end
```

### Estilo de caminar, expresión y apuntado

| Export                 | Parámetros                              | Devuelve                         | Qué hace                                                                                                                                          |
| ---------------------- | --------------------------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `SetWalk`              | `clipset: string`, `skipSave?: boolean` | —                                | Aplica un clipset de movimiento, como `'move_m@brave'`, y lo pone en el estado `walkstyle`. Con `skipSave` no se guarda para la siguiente sesión. |
| `ResetWalk`            | —                                       | —                                | Vuelve a la forma de caminar por defecto y limpia el estado `walkstyle`.                                                                          |
| `RestoreLastWalkStyle` | —                                       | —                                | Vuelve a aplicar el clipset del estado `walkstyle`, o la forma de caminar por defecto si no hay ninguno.                                          |
| `SetExpression`        | `name: string`, `skipSave?: boolean`    | —                                | Aplica una expresión facial, como `'mood_angry_1'`. Con `skipSave` no se guarda para la siguiente sesión.                                         |
| `ResetExpression`      | —                                       | —                                | Vuelve a la expresión por defecto.                                                                                                                |
| `SetWeaponAnimation`   | `dict?: string`, `name?: string`        | —                                | Establece la animación que se reproduce al apuntar con un arma de `data/weapons.lua`. Llámalo sin argumentos para quitarla.                       |
| `GetWeaponAnimation`   | —                                       | `string \| nil`, `string \| nil` | Diccionario y clip de apuntado actuales.                                                                                                          |

```lua
-- Tu script ha cambiado el clipset de movimiento con natives para un efecto.
-- Al terminar, devuelve al jugador su estilo de caminar.
exports.cuxial_emotes:RestoreLastWalkStyle()
```

### Movimiento

| Export             | Parámetros       | Devuelve         | Qué hace                            |
| ------------------ | ---------------- | ---------------- | ----------------------------------- |
| `IsPlayerCrouched` | —                | `boolean \| nil` | Agachado.                           |
| `IsPlayerProne`    | —                | `boolean`        | Tumbado.                            |
| `IsPlayerCrawling` | —                | `boolean`        | Arrastrándose.                      |
| `IsHandUp`         | —                | `boolean`        | Manos arriba.                       |
| `IsPointing`       | —                | `boolean`        | Señalando.                          |
| `IsCrossArms`      | —                | `boolean`        | Brazos cruzados.                    |
| `IsInRagdoll`      | —                | `boolean`        | En ragdoll provocado por el script. |
| `SetPlayerCrouch`  | `value: boolean` | —                | Fuerza agacharse o levantarse.      |
| `SetHandsUp`       | `value: boolean` | —                | Fuerza subir o bajar las manos.     |

```lua
if exports.cuxial_emotes:IsHandUp() then
    -- el jugador se está rindiendo
end
```

### Editor de posición, modo foto y zonas

| Export                    | Parámetros         | Devuelve       | Qué hace                                                                                             |
| ------------------------- | ------------------ | -------------- | ---------------------------------------------------------------------------------------------------- |
| `GetLockedEditPosition`   | —                  | `table \| nil` | Posición fijada con el editor de posición: `{ x, y, z, heading }`.                                   |
| `UnlockEditedPosition`    | —                  | —              | Libera esa posición.                                                                                 |
| `IsPhotoModeActive`       | —                  | `boolean`      | Si el modo foto está abierto.                                                                        |
| `IsCameraActive`          | —                  | `boolean`      | Si la cámara libre está en uso.                                                                      |
| `GetActiveZones`          | —                  | `string[]`     | Nombres internos de las zonas de emotes en las que está el jugador, con la forma `cuxial_zone_<id>`. |
| `IsInZone`                | `zoneName: string` | `boolean`      | Si el jugador está dentro de la zona con ese nombre interno.                                         |
| `GetActiveZoneCategories` | —                  | `string[]`     | Nombres de las categorías de zona disponibles en el menú en este momento.                            |

```lua
if exports.cuxial_emotes:IsPhotoModeActive() then return end
```

## Exports de servidor

### ForcePlaySyncedEmote

Inicia un emote en pareja entre dos jugadores sin pedir confirmación.

```lua
exports.cuxial_emotes:ForcePlaySyncedEmote(requesterId, responderId, senderCommand)
```

| Parámetro       | Tipo   | Descripción                                          |
| --------------- | ------ | ---------------------------------------------------- |
| `requesterId`   | number | Id de servidor del jugador que hace `senderCommand`. |
| `responderId`   | number | Id de servidor del otro jugador.                     |
| `senderCommand` | string | Comando de un emote sincronizado.                    |

Devuelve `boolean`: `true` si el emote ha empezado. Falla si alguno de los dos no está conectado, si los dos ids son el mismo, si el comando no es un emote sincronizado con un `OtherEmote` válido o si los jugadores están más lejos que `sync.distance`.

```lua
local started = exports.cuxial_emotes:ForcePlaySyncedEmote(source, targetId, 'rasurar')
```

### Exports de ítems

`condom_closed`, `condom_open`, `pregnancy_test` y `hiv_test` son enganches de ítem para `ox_inventory`. Están pensados para referenciarse desde la definición del ítem, no para llamarlos a mano. Mira [Instalación](/scripts/es/interfaz/cuxial-emotes/installation.md).

## Eventos

### cuxial\_emotes:OpenMenu

Cliente, local. Abre el menú de emotes. Útil desde un menú radial.

```lua
TriggerEvent('cuxial_emotes:OpenMenu')
```

### cuxial\_emotes:PlayQuickAnim

Cliente, evento de red. Reproduce un hueco del set rápido activo. El hueco va en el segundo argumento, con la forma que usan los menús radiales.

```lua
TriggerEvent('cuxial_emotes:PlayQuickAnim', nil, { id = 1 })
```

### cuxial\_emotes:ChangeSet

Cliente, evento de red. Cambia el set rápido activo.

```lua
TriggerEvent('cuxial_emotes:ChangeSet', nil, { id = 2 })
```

Los dos eventos de sets rápidos solo existen cuando `emotes.quickAnims` es `true`.

### cuxial\_emotes:server:syncedEmoteStarted

Servidor, local. Se dispara cada vez que empieza un emote en pareja.

```lua
AddEventHandler('cuxial_emotes:server:syncedEmoteStarted', function(requesterId, responderId, command)
    print(('%s y %s empezaron %s'):format(requesterId, responderId, command))
end)
```

## Estados del jugador

El script escribe estos state bags en el jugador. Se pueden leer desde cualquier recurso.

| Clave                           | Replicado      | Valor                                                   |
| ------------------------------- | -------------- | ------------------------------------------------------- |
| `isInEmote`                     | Sí             | `true` mientras hay un emote en curso.                  |
| `inSynchronizedEmote`           | Sí             | Id de servidor de la pareja durante un emote en pareja. |
| `walkstyle`                     | Sí             | Clipset de movimiento actual.                           |
| `expression`                    | Sí             | Expresión facial actual.                                |
| `handsUp`                       | Sí             | `true` con las manos arriba.                            |
| `emoteProps`, `emotePropsUpper` | Sí             | Props del emote actual.                                 |
| `crouch`                        | No, solo local | `true` mientras está agachado.                          |

```lua
-- lado servidor
if Player(source).state.handsUp then
    -- permitir el cacheo
end
```

El script también lee dos estados que ponen otros recursos:

| Clave       | Efecto                                                                  |
| ----------- | ----------------------------------------------------------------------- |
| `dead`      | El jugador cuenta como muerto cuando `deadCheck.useStateBag` es `true`. |
| `isLimited` | Mientras está puesto, el jugador no puede iniciar emotes.               |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.cuxial.com/scripts/es/interfaz/cuxial-emotes/developers.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
