RedM animations: dictionaries, scenarios and emotes, from one clip to a scripted scene

RedM animations are what make a character look alive: a sheriff checking a pocket watch, a cook turning meat over a fire, a player raising their hands at gunpoint. Every one of them is a clip from the game's own files, played by a script. This guide covers how they work, how to play one from Lua, how to find the names, how to hold a prop, how to build a multi-step scene, and how to turn it into an emote players can use. The native calls in the examples are copied from scripts we ship.

How RedM animations work

Dictionaries and clips

Animations live in dictionaries, and each dictionary holds one or more clips. You always need both names. mech_busted@arrest holds four clips, one of them hands_up_loop. Names read like a path split by @, so amb_camp@world_player_fire_cook_knife@male_a@wip_base is a camp, cooking with a knife, one variation, the base loop.

Scenarios

A scenario is a packaged behaviour, such as WORLD_HUMAN_CLEAN_TABLE. The game plays its own enter, loop and exit, and often brings its own props. Less control, much less code.

Props on bones

A knife, a cup or a badge is a separate object, attached to a named bone on the ped with an offset and a rotation. The animation moves the bone and the prop follows.

How to play a RedM animation from a script

Four steps, every time: request the dictionary, wait until it has loaded, play the clip, and clean up when you are done. This is the loader from the scene runtime in Poggy AnimTool ($24.99), with a hands-up command around it:

local function loadDict(dict, timeout)
    if HasAnimDictLoaded(dict) then return true end
    RequestAnimDict(dict)
    local t = timeout or 5000
    while not HasAnimDictLoaded(dict) and t > 0 do
        Wait(50); t = t - 50
    end
    return HasAnimDictLoaded(dict)
end

local DICT, CLIP = 'mech_busted@arrest', 'hands_up_loop'

RegisterCommand('handsup', function()
    if not DoesAnimDictExist(DICT) or not loadDict(DICT) then return end
    -- flag 1 loops; 0 plays once
    TaskPlayAnim(PlayerPedId(), DICT, CLIP, 8.0, -8.0, -1, 1, 0, false, false, false, "", false)
end)

RegisterCommand('handsdown', function()
    StopAnimTask(PlayerPedId(), DICT, CLIP, 1.0)
    RemoveAnimDict(DICT)
end)

The timeout matters. A loop that waits forever on a misspelt dictionary is a thread that never ends. The two numbers after the clip name are the blend in and blend out speeds; lower values fade more slowly.

Flags

The flag after the duration controls how the clip plays. Two values are safe to rely on: 1 loops the clip until you stop it, and 0 plays it once. Other bits restrict the clip to the upper body or let the player keep walking. Published flag lists do not all agree on which bit does what, so test a value in game before you build on it.

Scenarios

local ped = PlayerPedId()
ClearPedTasks(ped)
TaskStartScenarioInPlace(ped, joaat("WORLD_HUMAN_CLEAN_TABLE"), -1)
-- later
ClearPedTasks(ped)

A duration of -1 runs until something clears it. Use a scenario when the game already has the behaviour you want, and an animation when you need exact timing or your own prop.

Finding animation names

The game ships tens of thousands of dictionaries, and nobody remembers them. The community keeps lists of dictionary and clip names dumped from the game files, and there are free viewer resources that play a clip on your character in game. Search the Cfx.re forum and GitHub for a RedM animation list; pick one that shows clip names as well as dictionaries.

Two tips. Dictionaries starting amb_ hold ambient behaviours, which is where many good roleplay idles are. And always preview a clip on a ped before writing code around it: many clips are one half of a pair, made for a second character or a prop you do not have.

Props and bones

To put something in a character's hand, load the model, create the object, and attach it to a bone with AttachEntityToEntity. Common bones are PH_R_Hand and PH_L_Hand, the hand prop points; Poggy Crafting (Free) holds its knife on SKEL_R_Finger13. The hard part is the offset and rotation: six numbers found by trial and error, usually by editing and restarting again and again. Two traps:

• Networked or local. An object created with the networked argument of CreateObject set to false exists only for the player who made it. Others see the animation, but an empty hand.
• Clean up. Delete the prop when the animation stops, and on onResourceStop, so a restart does not leave one behind.

How to set up crafting shows hand props in use on crafting animations.

Building a multi-step scene

A scene is several clips in a row, with props appearing and moving along the way: pick up the cup, drink, set it down. By hand that means timing each clip with GetAnimDuration, starting the next when one ends, and moving the prop on cue. Some dictionaries return 0 for their length, which breaks the timing.

This is the job Poggy AnimTool ($24.99) was built for. It is an in-game timeline editor, opened with /animtool by staff with the command.animtool ACE:

The runtime is readable, not escrowed, so you ship it inside your own resource, loaded first:

-- fxmanifest.lua
client_scripts { 'scene_player.lua', 'my_script.lua' }

-- my_script.lua
local scene = { ... }   -- pasted from AnimTool

ScenePlayer.playOnce(PlayerPedId(), scene)   -- props are removed when it ends

local player = ScenePlayer.new(PlayerPedId())
player:load(scene)
player:play()            -- :pause()  :seek(t)  :stop()  :setSpeed(s)  :setLoop(b)
player.onFinish = function() player:destroy() end

Players never need AnimTool; they only run what you export. It calls no framework functions, and like every Poggy script it runs on VORP Core, RSG Core and QBCore RedM through the free Poggy Core (Free), which also keeps it updated.

Syncing for other players

An animation on your own ped is normally seen by nearby players, because the game syncs a player's tasks. Props are the part that goes missing: they must be networked objects, or every nearby client must attach its own copy. ScenePlayer creates its props as local objects and drives the clip from a clock on the player's own client, so it is built for what that player sees. If others must see a scene exactly, test it with a second player before you rely on it, and spawn networked props yourself where you need them.

Performance and cleanup

• Time out every wait. A dictionary or model that never loads should end the attempt, not hang it.
• Release what you load. RemoveAnimDict when the clip is done, and SetModelAsNoLongerNeeded once the prop exists.
• End your threads. A scene that ticks every frame costs a little while it runs; call destroy() when it finishes, or use playOnce, which does it for you.
• Stop gently. StopAnimTask blends out one clip; ClearPedTasks wipes everything the ped is doing, including another script's work.

RedM server performance covers finding the scripts that cost the most.

Turning animations into emotes

An emote is an animation bound to a command. Keep the list in config, not code, so staff can add one without a developer. Poggy Transform ($9.99) does exactly this for its wolves and dogs: each emote is a command, a label, a loop setting and a dictionary and clip, played with /ae howl and stopped with /ae stop. Give every looping emote a way out, a stop command or a key, because a player stuck in a loop files a ticket.

Emotes work best with words. Poggy Scenes ($9.99) adds overhead /me and /do and a box that collects nearby /me lines, so "/me checks his watch" and the animation arrive together. RedM roleplay commands covers /me and /do in depth. For a job-locked example, Poggy Badges ($20) plays a pocket-watch style animation with the badge in hand when a player with a listed job shows it.

Free emote menus exist on the Cfx.re forum and GitHub, and for a list of stock emotes they are enough. Reach for an editor when you want your own scenes with props, and when you are tired of restarting a resource to move a cup two centimetres.