◈ FIGURA
Complete Reference

.minecraft/figura/avatars/
└── MyAvatar/
    ├── avatar.json         ← Required: metadata (can be empty {})
    ├── model.bbmodel       ← Blockbench model file
    ├── skin.png            ← Texture (referenced by model)
    ├── skin_e.png          ← Emissive layer (suffix _e)
    ├── script.lua          ← Main Lua script
    ├── utils.lua           ← Additional scripts (all auto-loaded)
    ├── sounds/
    │   └── blast.ogg       ← Custom sounds (.ogg only)
    └── libs/
        └── math_utils.lua  ← Use require("libs/math_utils")

{
  "name": "My Cool Avatar",
  "description": "A custom Figura avatar",
  "authors": ["YourName"],
  "version": "1.0.0",
  "color": "#5af0c8"
}

-- All scripts run top to bottom when loaded
vanilla_model.ALL:setVisible(false)

-- Use require to share code between files
local utils = require("libs/utils")

-- math.lerp works on vectors too
local v1 = vec(0, 0, 0)
local v2 = vec(1, 2, 3)
local v3 = math.lerp(v1, v2, 0.5)  -- {0.5, 1, 1.5}

-- type() returns Figura type names
print(type(v3))  -- "Vector3"

-- Shorthand syntax
function events.TICK()
    -- runs every game tick
end

-- Register syntax (allows multiple handlers, named removal)
events.TICK:register(function()
    -- also runs every tick
end, "myHandler")

-- Remove by name
events.TICK:remove("myHandler")

-- Clear all handlers from an event
events.TICK:clear()

-- RENDER: smooth rotation following body yaw
function events.RENDER(delta, context)
    local yaw = player:getBodyYaw(delta)
    models.MyModel.Body:setOffsetRot(0, -yaw, 0)
end

-- TICK: run only on host
function events.TICK()
    if not host:isHost() then return end
    -- host-only logic here
end

-- CHAT_SEND_MESSAGE: cancel any message containing "oops"
function events.CHAT_SEND_MESSAGE(msg)
    if msg:find("oops") then return false end
end

-- ON_PLAY_SOUND: mute explosion sounds
function events.ON_PLAY_SOUND(id, pos, vol, pitch, loop)
    if id == "minecraft:entity.generic.explode" then
        return true  -- cancel the sound
    end
end

local part = models.MyModel.Head

-- Position (offset from Blockbench position)
part:setPos(0, 5, 0)        -- move up 5 units
part:getPos()               -- returns Vec3
part:getTruePos()           -- pos + anim pos

-- Rotation (absolute, in degrees)
part:setRot(45, 0, 0)       -- tilt 45° on X
part:setOffsetRot(0, 10, 0) -- relative rot offset

-- Scale (multiplier, 1 = normal)
part:setScale(1.5, 1, 1)    -- 150% width
part:setOffsetScale(2, 2, 2)-- relative scale

-- Pivot (absolute)
part:setPivot(0, 24, 0)
part:setOffsetPivot(0, 4, 0)

-- Visibility
part:setVisible(false)     -- hide (children too)
part:getVisible()          -- true if this and all parents visible

-- Color (RGB 0-1)
part:setColor(1, 0.5, 0)   -- orange tint
part:setPrimaryColor(1, 0, 0)
part:setSecondaryColor(0, 0, 1)

-- Opacity (0-1). Needs TRANSLUCENT render type!
part:setOpacity(0.5)

-- Custom light level (0-15 block light, 0-15 sky light)
part:setLight(15, 15)      -- full bright

-- Overlay (white flash = 0-15, damage red = 0-15)
part:setOverlay(15, 0)    -- white flash

-- Render type
part:setPrimaryRenderType("TRANSLUCENT")
part:setSecondaryRenderType("EYES")

-- UV scrolling (0.0–1.0 normalized)
part:setUV(0.5, 0)          -- scroll half width
part:setUVPixels(8, 0)      -- in pixels

-- Parent type (controls where in skeleton this attaches)
part:setParentType("Head")

-- Texture override
part:setPrimaryTexture("RESOURCE", "minecraft:textures/entity/creeper/creeper.png")
part:setPrimaryTexture("CUSTOM", textures["myTexture"])

-- Add a text label floating above a part
local task = part:newText("myLabel")
task:setText('{"text":"Hello World","color":"gold"}')
task:setPos(0, 12, 0)
task:setScale(0.5, 0.5, 0.5)

-- Add a floating item
local item = part:newItem("myItem")
item:setItem("minecraft:diamond_sword")
item:setDisplayMode("GROUND")

-- Add a floating block
local block = part:newBlock("myBlock")
block:setBlock("minecraft:tnt")
block:setScale(0.5, 0.5, 0.5)

-- Add a sprite (texture quad)
local spr = part:newSprite("mySprite")
spr:setTexture(textures["myTex"], 16, 16)

-- Remove a task
part:removeTask("myLabel")

-- Get world position of a part (use in POST_RENDER)
function events.POST_RENDER()
    local mat = models.MyModel.Hand:partToWorldMatrix()
    local worldPos = mat:apply(vec(0, 0, 0))
    -- worldPos is now the hand's world coordinate
end

-- Hide everything except armor
vanilla_model.ALL:setVisible(false)
vanilla_model.ARMOR:setVisible(true)

-- Read vanilla head rotation (for coping to custom model)
local headRot = vanilla_model.HEAD:getOriginRot()
models.MyModel.Head:setOffsetRot(headRot)

-- Access: animations.modelName.animationName
local walk = animations.MyModel.walk

-- Playback controls
walk:play()
walk:pause()
walk:resume()
walk:stop()
walk:restart()

-- State checks
walk:isPlaying()   -- true/false
walk:isPaused()
walk:isStopped()

-- Time control
walk:setTime(1.5)    -- jump to 1.5 seconds
walk:getTime()
walk:setSpeed(2.0)  -- 2x speed
walk:setWeight(0.5) -- blend weight 0-1

-- Override vanilla transforms
walk:setOverride(true)

-- Loop mode
walk:setLoopMode("LOOP")    -- "ONCE", "LOOP", "HOLD"

-- Blend in/out over N ticks
walk:setBlend(5)

-- Play animation based on player movement
function events.TICK()
    if player:isMoving() then
        animations.MyModel.walk:play()
    else
        animations.MyModel.walk:stop()
    end
end

-- Block queries
local bs = world:getBlockState(vec(0, 64, 0))
print(bs:getId())              -- "minecraft:grass_block"
print(bs:getProperties())     -- {snowy=false, ...}
bs:hasTag("minecraft:logs")   -- tag check
bs:isOpaque()

-- Get area of blocks (max 8x8x8)
local blocks = world:getBlocks(vec(-2,60,-2), vec(2,64,2))

-- Biome
local biome = world:getBiome(player:getPos())
print(biome:getId())           -- "minecraft:plains"
biome:getTemperature()
biome:isHot() biome:isCold()
biome:hasRain() biome:hasSnow()

-- Light
world:getLightLevel(player:getPos())
world:getSkyLightLevel(pos)
world:getBlockLightLevel(pos)
world:isOpenSky(pos)

-- Time & weather
world:getTime()          -- total world time
world:getTimeOfDay()     -- 0-24000
world:getDayTime()       -- 0-24000
world:getDay()
world:getMoonPhase()     -- 0-7
world:getRainGradient(delta)  -- 0-1
world:isThundering()

-- Entities
local players = world:getPlayers()  -- {name=EntityAPI, ...}
local ents = world:getEntities(pos1, pos2)
local ent = world:getEntity("uuid-string")

-- Misc
world:getDimension()   -- "minecraft:overworld"
world:getSpawnPoint()
world:getHeight(x, z) -- highest block at XZ
world:exists()         -- world loaded?

-- Parse new block/item from string
world:newBlock("minecraft:stone[lit=true]")
world:newItem("minecraft:diamond_sword", 1)

-- Toggle rendering features
renderer:setRenderFire(false)       -- hide fire overlay
renderer:setRenderVehicle(false)    -- hide your vehicle
renderer:setRenderCrosshair(false)  -- hide crosshair
renderer:setRenderHud(false)       -- hide vanilla HUD
renderer:setForcePaperdoll(true)   -- always show paperdoll
renderer:setUpsideDown(true)       -- render upside down

-- Shadow
renderer:setShadowRadius(3)   -- 0–12 (default 0.5)

-- Camera position offset
renderer:setCameraPos(0, 0.5, 0)
renderer:setOffsetCameraPivot(0, 1, 0)

-- Camera rotation offset
renderer:setCameraRot(0, 45, 0)     -- absolute
renderer:setOffsetCameraRot(0, 10, 0)-- offset

-- FOV multiplier
renderer:setFov(1.5)   -- 150% FOV (nil = default)

-- Custom outline color (for glowing effect)
renderer:setOutlineColor(1, 0, 0, 1)  -- red glow

-- Custom fire texture
renderer:setPrimaryFireTexture("figura:textures/fire.png")

-- First-person arm visibility
renderer:setRenderLeftArm(true)
renderer:setRenderRightArm(true)

-- Eye offset (affects targeted block/entity)
renderer:setEyeOffset(0, 0.5, 0)

-- Block outline color
renderer:setBlockOutlineColor(0, 1, 1, 0.4)

-- Post effect (Super Secret Settings style)
renderer:setPostEffect("desaturate")

-- Query states
renderer:isFirstPerson()
renderer:isCameraBackwards()

-- Check if running as host
if not host:isHost() then return end

-- Logging
host:writeToLog("debug message")  -- to minecraft log, not chat
host:warnToLog("warning!")

-- Title / subtitle / actionbar
host:setTitle('{"text":"Hello","color":"gold"}')
host:setSubtitle('{"text":"subtitle"}')
host:setActionbar('{"text":"action bar"}')
host:setTitleTimes(10, 40, 10)  -- fade-in, stay, fade-out ticks
host:clearTitle()

-- Chat
host:sendChatMessage("Hello world!")
host:sendChatCommand("gamemode creative")
host:appendChatHistory("my message")
host:getChatMessage(1)    -- last chat message
host:setChatMessage(1, nil)  -- nil removes it
host:getChatText()          -- text being typed
host:setChatText("draft")
host:isChatOpen()

-- Inventory slots
host:getSlot(0)            -- get first hotbar slot
host:getSlot("armor.head")
host:setSlot(-1, world:newItem("minecraft:stick"))

-- Cursor
host:setUnlockCursor(true)   -- free the cursor
host:isCursorUnlocked()

-- Arm swing
host:swingArm(false)         -- false=main, true=offhand

-- Clipboard
host:getClipboard()
host:setClipboard("text")

-- Screen info
host:getScreen()            -- current screen class name
host:isContainerOpen()
host:getScreenSlot(0)

-- Status effects
local effects = host:getStatusEffects()
-- [{name=..., amplifier=..., duration=..., ambient=..., particles=...}]

-- Screenshot (returns Texture)
local tex = host:screenshot()

-- Player state
host:isJumping()
host:isFlying()
host:getAttackCharge()    -- 0-1
host:getAir()
host:getReachDistance()
host:getPickBlock()       -- targeted block
host:getPickEntity()      -- targeted entity
host:isAvatarUploaded()

-- Camera
host:isFirstPerson()
host:isCameraBackwards()

-- Performance / version
client:getFps()
client:getVersion()           -- "1.21.1"
client:getFiguraVersion()     -- "0.1.5"
client:getClientBrand()      -- "fabric", "forge", etc.
client:getServerBrand()      -- "vanilla", "paper", etc.
client:isSnapshot()

-- Window & GUI
client:getWindowSize()        -- Vec2 in pixels
client:getScaledWindowSize()  -- Vec2 in GUI units
client:getGuiScale()
client:getMousePos()          -- Vec2 pixel coords
client:isWindowFocused()
client:isHudEnabled()
client:isDebugOverlayEnabled() -- F3 screen open
client:isPaused()
client:getFov()

-- Camera
client:getCameraPos()
client:getCameraRot()
client:getCameraDir()
client:getCameraEntity()     -- spectated entity or self
client:getViewer()           -- the local player entity

-- Time
client:getSystemTime()       -- Unix time in milliseconds
client:getDate()             -- {year, month, day, hour, ...}
client:getFrameTime()        -- delta (same as RENDER event)

-- Text measuring
client:getTextWidth("Hello")
client:getTextHeight("Hello")

-- Memory
client:getUsedMemory()
client:getMaxMemory()
client:getJavaVersion()

-- Mod detection
client:isModLoaded("sodium")
client:hasShaderPackMod()
client:hasShaderPack()
client:getShaderPackName()

-- Server info
client:getServerData()   -- {name, ip, motd, ...}
client:getActiveLang()  -- "en_us"

-- HUD overlays
client:getActionbar()
client:getTitle()
client:getSubtitle()
client:getScoreboard()
client:getTabList()

-- Registries & resources
client:getRegistry("block")  -- all block IDs
client:hasResource("minecraft:textures/block/stone.png")
client:getActiveResourcePacks()

-- UUID utils
client:generateUUID()
client:compareVersions("0.1.4", "0.1.5")  -- -1, 0, 1

-- Translation
client:getTranslatedString("item.minecraft.diamond")

-- Play a vanilla sound at a world position
sounds:playSound("minecraft:entity.player.levelup",
    player:getPos(), -- position
    1.0,             -- volume
    1.0              -- pitch
)

-- Play a custom sound from your avatar (.ogg file)
sounds:playSound("sounds/blast", pos, 1, 1)

-- Stop all sounds from your avatar
sounds:stopSound()
sounds:stopSound("minecraft:music.game")  -- specific ID

-- Register a custom sound at runtime from bytes
sounds:newSound("mySound", byteArray)

-- Check if a sound ID is valid
sounds:isPresent("minecraft:block.stone.break")

-- Get all custom sounds registered by this avatar
local customSounds = sounds:getCustomSounds()

-- Spawn a particle
particles:newParticle(
    "minecraft:flame",    -- particle ID
    player:getPos(),      -- world position
    vec(0, 0.1, 0)        -- velocity
)

-- Special dust particle (requires color + size)
particles:newParticle(
    "minecraft:dust 1 0 0 1.5",  -- red dust, size 1.5
    pos
)

-- Remove all particles from this avatar
particles:removeParticles()

-- Check if a particle ID exists
particles:isPresent("minecraft:heart")

-- Spawn hearts in a circle every tick
function events.TICK()
    for i = 0, 7 do
        local angle = i / 8 * math.pi * 2
        local pos = player:getPos() + vec(math.cos(angle), 2, math.sin(angle))
        particles:newParticle("minecraft:heart", pos)
    end
end

-- Create a keybind
local kb = keybinds:newKeybind("Toggle Wings", "key.keyboard.g")

-- Handle press and release
kb:setOnPress(function(modifiers)
    -- modifiers: bitmask (1=shift, 2=ctrl, 4=alt)
    pings.toggleWings(true)
end)

kb:setOnRelease(function()
    pings.toggleWings(false)
end)

-- Check state
kb:isPressed()
kb:getKey()        -- current key string
kb:getKeyName()    -- localized name
kb:isDefault()     -- not remapped by user?
kb:setEnabled(false)   -- disable this keybind
kb:setGui(true)        -- also trigger in GUIs

-- Change the key
kb:setKey("key.keyboard.h")

-- Create a page and set it active
local page = action_wheel:newPage("main")
action_wheel:setPage(page)

-- Add a simple action
local act = page:newAction()
    :title("Fly Mode")
    :item("minecraft:elytra")
    :color(0.4, 0.8, 1)
    :hoverColor(0.7, 1, 1)
    :onLeftClick(function() pings.toggleFly() end)

-- Toggle action (remembers state)
local toggle = page:newAction()
    :title("Wings OFF")
    :toggleTitle("Wings ON")
    :item("minecraft:feather")
    :onToggle(function(state)
        pings.setWings(state)
    end)

-- Scroll action
local scroll = page:newAction()
    :title("Volume")
    :onScroll(function(dir)
        volume = math.clamp(volume + dir * 0.1, 0, 1)
    end)

-- Custom texture on action
act:setTexture(textures["myTex"], 0, 0, 16, 16)

-- Multiple pages
local page2 = action_wheel:newPage("weapons")
action_wheel:setPage(page2)   -- switch to it

-- Check wheel state
action_wheel:isEnabled()      -- wheel open?
action_wheel:getSelected()   -- selected slot index

-- Define ping functions
function pings.setWingState(visible)
    models.MyModel.Wings:setVisible(visible)
end

function pings.playEffect(effectName)
    sounds:playSound("minecraft:entity.player.levelup", player:getPos())
    particles:newParticle("minecraft:totem_of_undying", player:getPos())
end

-- Call from host (e.g., on key press)
function events.TICK()
    if not host:isHost() then return end
    if wingKeybind:isPressed() then
        pings.setWingState(true)
    end
end

-- Three nameplate locations
-- nameplate.ABOVE: above-head nameplate
-- nameplate.CHAT: name in chat
-- nameplate.LIST: name in tab list

-- Customize the above-head nameplate
nameplate.ABOVE:setText('[{"text":"★ ","color":"gold"},{"text":"MyName","color":"white"}]')
nameplate.ABOVE:setPos(0, 0.5, 0)
nameplate.ABOVE:setScale(1.5, 1.5, 1.5)
nameplate.ABOVE:setVisible(true)
nameplate.ABOVE:setBackground(false)  -- hide dark backdrop
nameplate.ABOVE:setShadow(true)

-- Chat nameplate
nameplate.CHAT:setText('[{"text":"☆ "},{"text":"MyName"}]')

-- Dynamic nameplate update every tick
function events.TICK()
    local hp = math.floor(player:getHealth())
    nameplate.ABOVE:setText('{"text":"HP: ' .. hp .. '","color":"red"}')
end

-- Create a new texture (filled with color)
local tex = textures:newTexture("myTex", 64, 64)

-- Pixel manipulation
tex:setPixel(0, 0, vec(1, 0, 0, 1))   -- RGBA 0-1
local col = tex:getPixel(0, 0)

-- Fill rectangle
tex:fill(0, 0, 32, 32, vec(0, 1, 0, 1))  -- green

-- Apply changes to GPU
tex:update()   -- call after pixel edits

-- Copy and retrieve textures
local copy = textures:copy("texCopy", tex)
local found = textures:get("myTex")

-- Grab a vanilla resource texture
local stone = textures:fromVanilla("minecraft:textures/block/stone.png")

-- Read from base64 string
local tex2 = textures:read("decodedTex", base64str)

-- Apply texture to a model part
models.MyModel.Head:setPrimaryTexture("CUSTOM", tex)

-- Animated texture example (in TICK)
local t = 0
function events.TICK()
    t = t + 1
    for x = 0, 15 do
        for y = 0, 15 do
            local v = (math.sin(x * 0.5 + t * 0.1) + 1) / 2
            tex:setPixel(x, y, vec(v, 0.5, 1, 1))
        end
    end
    tex:update()
end

-- Save a value (any Lua primitive or table)
config:save("wingEnabled", true)
config:save("volume", 0.75)
config:save("theme", {r=1, g=0.5, b=0})

-- Load a value (nil if not saved)
local enabled = config:load("wingEnabled")

-- Load all saved values
local all = config:load()

-- Remove a value
config:save("wingEnabled", nil)

-- Change save file name (default = avatar name)
config:setName("myAvatarData")

-- Typical pattern: load on init, save on change
local wingEnabled = config:load("wing") or false

function pings.toggleWing()
    wingEnabled = not wingEnabled
    models.MyModel.Wings:setVisible(wingEnabled)
    if host:isHost() then
        config:save("wing", wingEnabled)
    end
end

-- Raycast a block
local blockState, hitPos, hitSide = raycast:block(
    player:getPos() + vec(0, player:getEyeHeight(), 0),  -- from eye pos
    player:getPos() + player:getLookDir() * 10,           -- to 10 blocks ahead
    "COLLIDER",   -- BlockRaycastType
    "NONE"        -- FluidRaycastType
)
if blockState then
    print(blockState:getId(), hitPos, hitSide)
end

-- Raycast an entity
local entity, hitPos = raycast:entity(
    player:getPos() + vec(0, player:getEyeHeight(), 0),
    player:getPos() + player:getLookDir() * 15
)
if entity then
    print("Hit: ", entity:getName())
end

-- AABB raycast (custom bounding boxes)
local hit = raycast:aabb(
    startPos, endPos,
    {{-0.5, 0, -0.5, 0.5, 2, 0.5}}  -- {minX,minY,minZ,maxX,maxY,maxZ}
)

-- Check if networking is allowed
if not net:isNetworkingAllowed() then return end

-- GET request
local future = net.http:request("https://api.example.com/data")
    :method("GET")
    :send()

-- POST with body and headers
local future2 = net.http:request("https://api.example.com/submit")
    :method("POST")
    :header("Content-Type", "application/json")
    :body('{"key":"value"}')
    :send()

-- Handle the future result in TICK
function events.TICK()
    if future and future:isDone() then
        if future:hasError() then
            print("Error!")
        else
            local resp = future:getValue()
            print(resp:getResponseCode())
            -- resp:getData() returns an InputStream
        end
        future = nil
    end
end

skin.png       ← base texture
skin_e.png     ← emissive layer (suffix _e before .png)

-- Set parent type via Lua
models.MyModel.WingL:setParentType("LeftElytra")
models.MyModel.HUDElement:setParentType("Camera")

-- Or name the Blockbench group starting with the parent type:
-- Group named "Head" → auto-attaches to the head bone

-- ─────────────────────────────────────────────
--  SETUP — runs once when avatar loads
-- ─────────────────────────────────────────────
vanilla_model.ALL:setVisible(false)  -- hide entire vanilla player
vanilla_model.ARMOR:setVisible(true)  -- but keep armor visible

-- ─────────────────────────────────────────────
--  STATE
-- ─────────────────────────────────────────────
local wingsOpen = false

-- ─────────────────────────────────────────────
--  PINGS — synced to all viewers
-- ─────────────────────────────────────────────
function pings.setWings(state)
    wingsOpen = state
    models.MyModel.Wings:setVisible(state)
    if state then
        animations.MyModel.wings_open:play()
    else
        animations.MyModel.wings_close:play()
    end
end

-- ─────────────────────────────────────────────
--  KEYBIND (host only)
-- ─────────────────────────────────────────────
if host:isHost() then
    local wingKey = keybinds:newKeybind("Toggle Wings", "key.keyboard.g")
    wingKey:setOnPress(function()
        pings.setWings(not wingsOpen)
    end)
end

-- ─────────────────────────────────────────────
--  TICK — game logic every 1/20 second
-- ─────────────────────────────────────────────
function events.TICK()
    -- Drive walk/idle animation from player movement
    if player:isMoving(true) then
        animations.MyModel.walk:play()
        animations.MyModel.idle:stop()
    else
        animations.MyModel.idle:play()
        animations.MyModel.walk:stop()
    end
end

-- ─────────────────────────────────────────────
--  RENDER — every rendered frame (use delta!)
-- ─────────────────────────────────────────────
function events.RENDER(delta)
    -- Copy vanilla head rotation to custom head
    local rot = player:getRot(delta)
    models.MyModel.Head:setOffsetRot(rot.x, 0, 0)

    -- Smooth body yaw
    local yaw = player:getBodyYaw(delta)
    models.MyModel.Body:setOffsetRot(0, -yaw, 0)
end

local A = animations.MyModel  -- shorthand

function events.TICK()
    local onGround  = player:isOnGround()
    local moving    = player:isMoving(true)
    local sprinting  = player:isSprinting()
    local falling   = player:isFalling()
    local gliding   = player:isGliding()
    local crouching = player:isCrouching()

    -- Stop all before starting the right one
    A.idle:stop() A.walk:stop() A.run:stop()
    A.fall:stop() A.glide:stop() A.crouch:stop()

    if gliding then
        A.glide:play()
    elseif not onGround and falling then
        A.fall:play()
    elseif crouching then
        A.crouch:play()
    elseif sprinting then
        A.run:play()
    elseif moving then
        A.walk:play()
    else
        A.idle:play()
    end
end

function events.TICK()
    local vel = player:getVelocity()
    local speed = math.sqrt(vel.x^2 + vel.z^2)  -- horizontal speed
    animations.MyModel.walk:setSpeed(speed * 10)  -- scale anim speed
    if speed > 0.01 then
        animations.MyModel.walk:play()
    else
        animations.MyModel.walk:stop()
    end
end

function events.TICK()
    local hp = player:getHealth()
    local maxHp = player:getMaxHealth()
    local t = hp / maxHp  -- 0 = dead, 1 = full

    animations.MyModel.healthy:setWeight(t)
    animations.MyModel.hurt:setWeight(1 - t)
    animations.MyModel.healthy:play()
    animations.MyModel.hurt:play()
end

local attackAnim = animations.MyModel.attack
attackAnim:setLoopMode("ONCE")

if host:isHost() then
    local atkKey = keybinds:newKeybind("Attack", "key.keyboard.f")
    atkKey:setOnPress(function()
        pings.playAttack()
    end)
end

function pings.playAttack()
    attackAnim:restart()  -- restart each time
end

local t = 0
function events.RENDER(delta)
    t = t + delta * 0.1
    local bob = math.sin(t) * 2  -- ±2 units vertical
    models.MyModel:setPos(0, bob, 0)
end

local t = 0
function events.RENDER(delta)
    t = t + delta * 0.15
    local wag = math.sin(t) * 25  -- ±25 degrees
    models.MyModel.Tail:setOffsetRot(0, wag, 0)
end

local t = 0
function events.RENDER(delta)
    t = t + delta * 0.08
    local s = 1 + math.sin(t) * 0.05  -- ±5% scale
    models.MyModel:setScale(s, s, s)
end

function events.RENDER(delta)
    local rot = player:getRot(delta)
    -- Clamp pitch so eyes don't over-rotate
    local pitch = math.clamp(rot.x, -30, 30)
    local yaw   = math.clamp(rot.y, -45, 45)  -- relative to body
    models.MyModel.EyeL:setOffsetRot(pitch, yaw, 0)
    models.MyModel.EyeR:setOffsetRot(pitch, yaw, 0)
end

function events.TICK()
    local item = player:getHeldItem(false)  -- main hand
    local id = item:getId()

    -- Show sword model only when holding a sword
    local holdingSword = id:find("sword") ~= nil
    models.MyModel.SwordProp:setVisible(holdingSword)

    -- Show magic staff when holding a stick
    models.MyModel.Staff:setVisible(id == "minecraft:stick")
end

function events.TICK()
    local helmet = player:getItem(5)  -- slot 5 = helmet
    if helmet:getId() == "minecraft:netherite_helmet" then
        models.MyModel.Hat:setPrimaryTexture("CUSTOM", textures["hat_nether"])
    else
        models.MyModel.Hat:setPrimaryTexture("PRIMARY")  -- restore default
    end
end

local scroll = 0
function events.RENDER(delta)
    scroll = (scroll + delta * 0.01) % 1
    models.MyModel.Portal:setUV(scroll, 0)
end

-- Set up once on load
local task = models.MyModel.Head:newItem("crownItem")
task:setItem("minecraft:golden_helmet")
task:setDisplayMode("GUI")
task:setPos(0, 12, 0)
task:setScale(0.6, 0.6, 0.6)

-- Slowly spin it
local t = 0
function events.RENDER(delta)
    t = t + delta * 3
    task:setRot(0, t, 0)
end

-- A part anchored to world position (e.g. orbiting rune)
models.MyModel.Rune:setParentType("World")

local t = 0
function events.RENDER(delta)
    t = t + delta * 0.05
    local r = 1.5
    local pos = player:getPos(delta)
    models.MyModel.Rune:setPos(
        pos.x + math.cos(t) * r,
        pos.y + 1,
        pos.z + math.sin(t) * r
    )
    models.MyModel.Rune:setRot(0, -math.deg(t), 0)
end

function events.TICK()
    local t = player:getHealth() / player:getMaxHealth()
    -- t=1: green. t=0.5: yellow. t=0: red
    local r = math.clamp(2 - t * 2, 0, 1)
    local g = math.clamp(t * 2, 0, 1)
    models.MyModel:setColor(r, g, 0)
end

function events.TICK()
    local pos = player:getPos()
    local light = world:getLightLevel(pos)  -- 0-15
    -- In dark (light=0) → full bright; in light (light=15) → dim glow
    local glow = math.map(light, 0, 15, 15, 0)
    models.MyModel.GlowPart:setLight(math.floor(glow), 15)
end

local currentScale = 1
function events.RENDER(delta)
    local sat = math.clamp(player:getSaturation() / 20, 0, 1)
    local targetScale = math.lerp(0.9, 1.1, sat)
    currentScale = math.lerp(currentScale, targetScale, 0.05)  -- smooth
    models.MyModel:setScale(currentScale, currentScale, currentScale)
end

function events.TICK()
    if not host:isHost() then return end
    local effects = host:getStatusEffects()
    local hasSpeed = false
    local hasInvis = false

    for _, e in pairs(effects) do
        if e.name == "minecraft:speed"  then hasSpeed = true end
        if e.name == "minecraft:invisibility" then hasInvis = true end
    end

    models.MyModel:setOpacity(hasInvis and 0.3 or 1.0)
    animations.MyModel.speedLines:setVisible(hasSpeed)
end

function events.TICK()
    local gm = player:getGamemode()
    -- Show creative "aura" in creative mode
    models.MyModel.CreativeAura:setVisible(gm == "CREATIVE")
end

function events.TICK()
    local biome = world:getBiome(player:getPos())
    local id = biome:getId()

    -- Underwater helmet
    models.MyModel.Helm:setVisible(player:isUnderwater())

    -- Snow effect in cold biomes
    models.MyModel.SnowLayer:setVisible(biome:hasSnow())

    -- Desert glow in hot biomes
    models.MyModel.SunGlow:setVisible(biome:isHot())
end

function events.TICK()
    local pos = player:getPos()
    -- Block directly below the player
    local below = world:getBlockState(vec(
        math.floor(pos.x), math.floor(pos.y - 0.1), math.floor(pos.z)
    ))

    -- Different footstep particles per surface
    if player:isMoving(true) and player:isOnGround() then
        local id = below:getId()
        if id == "minecraft:grass_block" then
            particles:newParticle("minecraft:happy_villager", pos)
        elseif id == "minecraft:sand" then
            particles:newParticle("minecraft:cloud", pos)
        end
    end
end

function events.TICK()
    local tod = world:getDayTime()  -- 0-24000
    local isNight = tod > 13000 and tod < 23000
    local rain = world:getRainGradient(1) > 0.5

    models.MyModel.NightForm:setVisible(isNight)
    models.MyModel.DayForm:setVisible(not isNight)
    models.MyModel.Umbrella:setVisible(rain)

    -- Moon phase ear shape
    local moonPhase = world:getMoonPhase()  -- 0-7
    models.MyModel.Ears:setScale(1 + moonPhase * 0.05, 1, 1)
end

local nearLava = false
function events.TICK()
    local pos = player:getPos()
    nearLava = false
    -- Scan 3x3x3 area around player
    local blocks = world:getBlocks(pos - vec(2,2,2), pos + vec(2,2,2))
    for _, b in ipairs(blocks) do
        if b:getId():find("lava") then
            nearLava = true
            break
        end
    end
    models.MyModel.FireAura:setVisible(nearLava)
end

-- Attach a health bar text above head
local hpTask = models.MyModel.Head:newText("hpBar")
hpTask:setPos(0, 15, 0)
hpTask:setScale(0.4, 0.4, 0.4)
hpTask:setBackground(false)
hpTask:setShadow(true)

function events.TICK()
    local hp = player:getHealth()
    local max = player:getMaxHealth()
    local bars = math.floor(hp / max * 10)
    local bar = string.rep("█", bars) .. string.rep("░", 10 - bars)
    local col = hp > max * 0.5 and "green" or (hp > max * 0.25 and "yellow" or "red")
    hpTask:setText('{"text":"'..bar..'","color":"'..col..'"}')
end

-- Part with parent type Camera always faces viewer
models.MyModel.HUD:setParentType("Camera")
models.MyModel.HUD:setPos(0, 0, -1)  -- 1 unit in front of camera
models.MyModel.HUD:setScale(0.1, 0.1, 0.1)

local lastLevel = -1
function events.TICK()
    if not host:isHost() then return end
    local lvl = player:getExperienceLevel()
    if lastLevel >= 0 and lvl > lastLevel then
        host:setTitle('{"text":"Level Up! ★","color":"gold","bold":true}')
        host:setSubtitle('{"text":"Level ' .. lvl .. '","color":"yellow"}')
        host:setTitleTimes(5, 50, 10)
    end
    lastLevel = lvl
end

local stepTimer = 0
function events.TICK()
    stepTimer = stepTimer - 1
    if player:isMoving(true) and player:isOnGround() and stepTimer <= 0 then
        local spd = player:isSprinting() and 6 or 10  -- faster steps when sprinting
        stepTimer = spd
        sounds:playSound(
            "minecraft:entity.player.swim",
            player:getPos(),
            0.4,  -- volume
            math.random() * 0.4 + 0.8  -- random pitch
        )
    end
end

function events.TICK()
    if not player:isMoving() then return end
    local pos = player:getPos() + vec(0, 0.5, 0)
    -- Spread particles slightly
    for i = 1, 3 do
        local spread = vec(
            (math.random() - 0.5) * 0.3,
            math.random() * 0.2,
            (math.random() - 0.5) * 0.3
        )
        particles:newParticle("minecraft:end_rod", pos + spread)
    end
end

local wasFalling = false
function events.TICK()
    local falling = player:isFalling()
    local onGround = player:isOnGround()

    if wasFalling and onGround then
        -- Just landed!
        local pos = player:getPos()
        for i = 1, 20 do
            local angle = i / 20 * math.pi * 2
            local vel = vec(math.cos(angle) * 0.3, 0.3, math.sin(angle) * 0.3)
            particles:newParticle("minecraft:cloud", pos, vel)
        end
        sounds:playSound("minecraft:block.stone.hit", pos, 0.8, 0.8)
    end
    wasFalling = falling and not onGround
end

function events.ON_PLAY_SOUND(id, pos, vol, pitch, loop, category)
    -- Cancel all explosion sounds
    if id:find("explode") or id:find("explosion") then
        return true  -- returning true cancels the sound
    end
    -- Replace creeper hiss with a meow
    if id == "minecraft:entity.creeper.primed" then
        sounds:playSound("minecraft:entity.cat.ambient", pos, vol, pitch)
        return true  -- cancel original
    end
end

local powerActive = false
local powerLerp = 0

function pings.setPower(active)
    powerActive = active
end

if host:isHost() then
    local key = keybinds:newKeybind("Power Mode", "key.keyboard.v")
    key:setOnPress(function()   pings.setPower(true)  end)
    key:setOnRelease(function() pings.setPower(false) end)
end

function events.RENDER(delta)
    local target = powerActive and 1 or 0
    powerLerp = math.lerp(powerLerp, target, 0.1)
    -- Scale and color modulated by power level
    local s = 1 + powerLerp * 0.3
    models.MyModel:setScale(s, s, s)
    models.MyModel:setColor(1, 1 - powerLerp * 0.5, 1 - powerLerp)
end

local modes = {"normal", "stealth", "power"}
local modeIdx = 1

function pings.setMode(idx)
    modeIdx = idx
    local m = modes[idx]
    models.MyModel.NormalForm:setVisible(m == "normal")
    models.MyModel.StealthForm:setVisible(m == "stealth")
    models.MyModel.PowerForm:setVisible(m == "power")
end

if host:isHost() then
    keybinds:newKeybind("Cycle Mode", "key.keyboard.m")
        :setOnPress(function()
            local next = (modeIdx % #modes) + 1
            pings.setMode(next)
            host:setActionbar('{"text":"Mode: '..modes[next]..'","color":"aqua"}')
        end)
end

-- Initialize default
pings.setMode(1)

-- ── PAGE 1: Avatar Controls ──────────────────
local page1 = action_wheel:newPage("controls")
action_wheel:setPage(page1)

-- Toggle action (remembers state, shows different title)
local wingToggle = page1:newAction()
    :title("Wings: OFF")
    :toggleTitle("Wings: ON")
    :item("minecraft:feather")
    :color(0.8, 0.8, 0.8)
    :toggleColor(0.5, 0.9, 1.0)
    :onToggle(function(state)
        pings.setWings(state)
    end)

-- Scroll wheel for glow color
local glowColors = {
    vec(1,0,0), vec(0,1,0), vec(0,0,1),
    vec(1,1,0), vec(1,0,1), vec(0,1,1)
}
local colorIdx = 1

page1:newAction()
    :title("Glow Color")
    :item("minecraft:glowstone_dust")
    :onScroll(function(dir)
        colorIdx = ((colorIdx - 1 + math.floor(dir)) % #glowColors) + 1
        pings.setGlowColor(colorIdx)
    end)
    :onLeftClick(function()
        colorIdx = (colorIdx % #glowColors) + 1
        pings.setGlowColor(colorIdx)
    end)

-- Switch to page 2
page1:newAction()
    :title("→ Emotes")
    :item("minecraft:map")
    :onLeftClick(function()
        action_wheel:setPage("emotes")
    end)

-- ── PAGE 2: Emotes ───────────────────────────
local page2 = action_wheel:newPage("emotes")

local emoteList = {
    {"Wave",   "minecraft:hand",   "wave"},
    {"Dance",  "minecraft:music_disc_cat", "dance"},
    {"Sit",    "minecraft:oak_stairs", "sit"},
}
for _, e in ipairs(emoteList) do
    local name, item, anim = e[1], e[2], e[3]
    page2:newAction()
        :title(name)
        :item(item)
        :onLeftClick(function()
            pings.playEmote(anim)
        end)
end

page2:newAction()
    :title("← Back")
    :item("minecraft:arrow")
    :onLeftClick(function()
        action_wheel:setPage("controls")
    end)

-- Ping handlers
function pings.playEmote(name)
    animations.MyModel[name]:restart()
end
function pings.setGlowColor(idx)
    colorIdx = idx
    local c = glowColors[idx]
    models.MyModel.Glow:setColor(c.x, c.y, c.z)
end

-- Rich formatted name with health indicator
local updateTimer = 0
function events.TICK()
    updateTimer = updateTimer - 1
    if updateTimer > 0 then return end
    updateTimer = 5  -- update every 5 ticks

    local hp = math.floor(player:getHealth())
    local maxHp = math.floor(player:getMaxHealth())
    local heartColor = hp > maxHp * 0.5 and "red" or "dark_red"
    local name = player:getName()

    nameplate.ABOVE:setText(toJson({
        {text="❤ ", color=heartColor},
        {text=hp.."/"..maxHp.." ", color="white"},
        {text=name, color="aqua", bold=true}
    }))
end

-- Show a colored prefix in chat messages
nameplate.CHAT:setText(toJson({
    {text="[★] ", color="gold", bold=true},
    {text=player:getName(), color="white"}
}))

-- Tab list prefix
nameplate.LIST:setText(toJson({
    {text="◈ ", color="aqua"},
    {text=player:getName(), color="white"}
}))

-- Create a small texture and assign to a model part
local tex = textures:newTexture("healthTex", 16, 4)
models.MyModel.HealthBar:setPrimaryTexture("CUSTOM", tex)

local lastHp = -1
function events.TICK()
    local hp = player:getHealth()
    if hp == lastHp then return end  -- only update when changed
    lastHp = hp

    local filled = math.floor((hp / player:getMaxHealth()) * 16)
    for x = 0, 15 do
        local color = x < filled
            and vec(0.9, 0.1, 0.1, 1)   -- filled: red
            or  vec(0.2, 0.2, 0.2, 1)   -- empty: dark gray
        for y = 0, 3 do
            tex:setPixel(x, y, color)
        end
    end
    tex:update()
end

local ptex = textures:newTexture("plasma", 32, 32)
models.MyModel.GlowPart:setPrimaryTexture("CUSTOM", ptex)
models.MyModel.GlowPart:setPrimaryRenderType("EYES")

local t = 0
function events.TICK()
    t = t + 0.05
    for x = 0, 31 do
        for y = 0, 31 do
            local v = math.sin(x * 0.4 + t) + math.sin(y * 0.4 + t * 1.3)
            v = (v + 2) / 4  -- normalize to 0-1
            ptex:setPixel(x, y, vec(v, 0.3, 1 - v, 1))
        end
    end
    ptex:update()
end

local shakeTime = 0
local shakeIntensity = 0

function events.DAMAGE(type, source, attacker, amount)
    shakeTime = 10
    shakeIntensity = math.clamp(amount * 0.5, 1, 5)
end

function events.RENDER(delta)
    if shakeTime > 0 then
        shakeTime = shakeTime - delta
        local i = shakeIntensity * (shakeTime / 10)
        renderer:setOffsetCameraRot(
            (math.random() - 0.5) * i,
            (math.random() - 0.5) * i,
            0
        )
    else
        renderer:setOffsetCameraRot(0, 0, 0)
    end
end

local zoomed = false
local fovLerp = 1

function pings.setZoom(z)
    zoomed = z
end

if host:isHost() then
    local zoomKey = keybinds:newKeybind("Zoom", "key.mouse.right")
    zoomKey:setOnPress(function()   pings.setZoom(true)  end)
    zoomKey:setOnRelease(function() pings.setZoom(false) end)
end

function events.RENDER(delta)
    local target = zoomed and 0.2 or 1.0  -- 0.2 = 20% FOV (strong zoom)
    fovLerp = math.lerp(fovLerp, target, 0.15)
    renderer:setFov(fovLerp)
end

function events.TICK()
    local team = player:getTeamInfo()
    if team then
        -- Use the team color for glow outline
        local c = team.color  -- returns a color string like "red"
        renderer:setOutlineColor(
            c == "red"  and 1 or 0,
            c == "green" and 1 or 0,
            c == "blue"  and 1 or 0,
            1
        )
    end
end

local swayX, swayY = 0, 0
local lastRot = vec(0, 0)

function events.RENDER(delta)
    local rot = player:getRot(delta)
    local dX = rot.x - lastRot.x
    local dY = rot.y - lastRot.y
    lastRot = rot

    -- Smooth sway
    swayX = math.lerp(swayX, -dX * 0.3, 0.1)
    swayY = math.lerp(swayY, -dY * 0.3, 0.1)

    if renderer:isFirstPerson() then
        models.MyModel.ArmR:setOffsetPos(swayY, swayX, 0)
    end
end

-- Default settings
local settings = {
    wingEnabled = false,
    glowColor   = 1,
    volume      = 1.0,
    mode        = "normal",
}

-- Load saved settings on startup (host only)
if host:isHost() then
    local saved = config:load()  -- returns all saved keys
    if saved then
        for k, v in pairs(saved) do
            if settings[k] ~= nil then
                settings[k] = v
            end
        end
    end
end

-- Helper: save all and apply via ping
local function applyAndSave()
    pings.applySettings(settings.wingEnabled, settings.glowColor, settings.mode)
    if host:isHost() then
        for k, v in pairs(settings) do
            config:save(k, v)
        end
    end
end

function pings.applySettings(wings, color, mode)
    settings.wingEnabled = wings
    settings.glowColor   = color
    settings.mode        = mode
    models.MyModel.Wings:setVisible(wings)
    -- etc.
end

-- Apply saved settings once loaded
applyAndSave()

-- Beam that extends from hand to the first block/entity hit
local laser = models.MyModel.Hand:newSprite("laser")
laser:setTexture(textures["laser"], 1, 16)

function events.TICK()
    local eyePos = player:getPos() + vec(0, player:getEyeHeight(), 0)
    local dir    = player:getLookDir()

    local hit, hitPos = raycast:block(eyePos, eyePos + dir * 20)
    if not hit then
        local ent, entPos = raycast:entity(eyePos, eyePos + dir * 20)
        hitPos = entPos or (eyePos + dir * 20)
    end

    local dist = (hitPos - eyePos):length()
    laser:setScale(0.1, dist * 16, 0.1)  -- stretch to hit point
end

function events.TICK()
    local pos = player:getPos()
    -- Cast straight down to find ground
    local hit, groundPos = raycast:block(pos, pos - vec(0, 20, 0))
    if hit then
        local dist = pos.y - groundPos.y
        -- Scale shadow by distance (fades when high)
        local alpha = math.clamp(1 - dist / 20, 0, 1)
        models.MyModel.GroundShadow:setOpacity(alpha)
        models.MyModel.GroundShadow:setPos(
            pos.x - groundPos.x,
            groundPos.y + 0.05,
            pos.z - groundPos.z
        )
    end
end

local remoteFuture = nil

function events.ENTITY_INIT()
    if not net:isNetworkingAllowed() then
        print("Networking not allowed by viewer")
        return
    end
    if not net:isLinkAllowed("https://raw.githubusercontent.com/...") then
        return
    end
    remoteFuture = net.http:request("https://raw.githubusercontent.com/your/repo/main/config.json"):send()
end

function events.TICK()
    if not remoteFuture then return end
    if not remoteFuture:isDone() then return end

    if remoteFuture:hasError() then
        print("Fetch failed!")
        remoteFuture = nil
        return
    end

    local resp = remoteFuture:getValue()
    if resp:getResponseCode() == 200 then
        -- Read all bytes from stream and parse as JSON
        local stream = resp:getData()
        local dataFuture = stream:readAsync(99999)
        -- Handle dataFuture in next tick cycle...
    end
    remoteFuture = nil
end

-- Store data others can read
avatar:store("team", "blue")
avatar:store("level", 42)
avatar:store("form", "dragon")

-- Read another player's stored data
function events.TICK()
    local players = world:getPlayers()
    for name, ply in pairs(players) do
        if ply:hasAvatar() then
            local theirTeam = ply:getVariable("team")
            if theirTeam == "blue" then
                print(name .. " is on the blue team!")
            end
        end
    end
end

-- main.lua — entry point
local anim   = require("modules/animations")
local fx     = require("modules/effects")
local ui     = require("modules/ui")

-- Setup
vanilla_model.ALL:setVisible(false)
anim.init()
ui.init()

function events.TICK()
    anim.tick()
    fx.tick()
end

function events.RENDER(delta)
    anim.render(delta)
end

-- Return a module table
local M = {}
local A = animations.MyModel

function M.init()
    A.idle:setLoopMode("LOOP")
    A.walk:setLoopMode("LOOP")
end

function M.tick()
    if player:isMoving(true) then
        A.walk:play() A.idle:stop()
    else
        A.idle:play() A.walk:stop()
    end
end

function M.render(delta)
    local rot = player:getRot(delta)
    models.MyModel.Head:setOffsetRot(rot.x, 0, 0)
end

return M

local wasInWater = false
function events.TICK()
    local inWater = player:isInWater()
    if inWater and not wasInWater then
        -- Just entered water
        pings.splash()
    elseif not inWater and wasInWater then
        -- Just exited water
        pings.drip()
    end
    wasInWater = inWater
    -- Swap model for underwater form
    models.MyModel.LandForm:setVisible(not inWater)
    models.MyModel.WaterForm:setVisible(inWater)
end

-- Get avatar info
print("Avatar size: " .. avatar:getSize() .. " bytes")
print("Complexity: " .. avatar:getComplexity())
print("Instructions used: " .. avatar:getCurrentInstructions())
print("Owner UUID: " .. avatar:getUUID())
print("Can edit nameplate: " .. tostring(avatar:canEditVanillaModel()))

-- Share with others via store()
avatar:store("complexity", avatar:getComplexity())

avatar/
  script.lua          -- script principal
  EZAnims.lua
  GSAnimBlend.lua
  model.bbmodel       -- animações: idle, walk, sprint, jump...

-- 1. GSAnimBlend SEMPRE primeiro
local GSBlend = require("GSAnimBlend")
local anims   = require("EZAnims")

-- 2. Registrar o modelo
local m = anims:addBBModel(animations.model)

-- 3. Global blend for all EZAnims animations
m:setBlendTimes(6, 3)   -- exclusivas=6t, inclusivas=3t

-- 4. Animações específicas com parâmetros individuais
animations.model.death:setBlendTime(20):setBlendCurve("easeInQuad")
animations.model.hurt:setBlendTime(2, 4)
animations.model.idle:setBlendCurve("easeInOutCubic")
animations.model.sprint:setBlendCurve("easeOutBack")

local GSBlend = require("GSAnimBlend")
local anims   = require("EZAnims")
local m = anims:addBBModel(animations.model)
m:setBlendTimes(6)

local modeSword = false

-- Ping to sync with other players
function pings.setSword(b)
    modeSword = b
    m:setState(b and "sword" or nil)
end

-- Action Wheel
local page = action_wheel:newPage()
action_wheel:setPage(page)

page:newAction()
    :title("Espada")
    :item("minecraft:iron_sword")
    :toggleItem("minecraft:diamond_sword")
    :onToggle(function(b)
        pings.setSword(b)
    end)

local GSBlend = require("GSAnimBlend")
local anims   = require("EZAnims")
local m = anims:addBBModel(animations.model)
m:setBlendTimes(8)

-- Model parts with vanilla-based animation
local bodyParts = {
    models.model.Head,
    models.model.Body,
    models.model.LeftArm,
    models.model.RightArm,
    models.model.LeftLeg,
    models.model.RightLeg,
}

-- Aplicar genBlendVanilla nas animations de movimento
local vanillaCallback = GSBlend.callback.genBlendVanilla(bodyParts)
animations.model.idle:setOnBlend(vanillaCallback)
animations.model.walk:setOnBlend(vanillaCallback)
animations.model.sprint:setOnBlend(vanillaCallback)
animations.model.crouch:setOnBlend(vanillaCallback)

-- Custom Bezier curve for idle (smooth with slight overshoot)
animations.model.idle:setBlendCurve(
    GSBlend.callback.genBezier(0.34, 1.56, 0.64, 1)
)

local GSBlend = require("GSAnimBlend")
local anims   = require("EZAnims")
local m = anims:addBBModel(animations.model)
m:setBlendTimes(6)

-- When cutscene_start plays, ALL EZAnims animations stop
m:addAllOverrider(animations.model.cutscene_inicio)

local emCutscene = false

function pings.startCutscene()
    emCutscene = true
    animations.model.cutscene_inicio:play()
end

function pings.endCutscene()
    emCutscene = false
    animations.model.cutscene_inicio:stop()
end

local squapi = require("SquAPI")

─── Ears ────────────────────────────────────────────
squapi.ear:new(
    models.model.Head.LeftEar,
    models.model.Head.RightEar,
    1,      -- rangeMultiplier
    false,  -- horizontalEars
    2,      -- bendStrength
    true,   -- doEarFlick
    350,    -- earFlickChance
    0.1,    -- stiffness
    0.8     -- bounce
)

─── Tail (4 segments) ────────────────────────────────
squapi.tail:new({
    models.model.Body.Tail,
    models.model.Body.Tail.TailSeg1,
    models.model.Body.Tail.TailSeg1.TailSeg2,
    models.model.Body.Tail.TailSeg1.TailSeg2.TailTip,
}, 18, 6, 1.2, 2, 2.5, 0, 0, 1, 0.005, 0.9, 90, -80, 40)

─── Smooth Head ───────────────────────────────────────
squapi.smoothHead:new(
    {models.model.Head},
    1,     -- strength
    0.08, -- tilt sutil
    1,     -- speed
    true, -- keepOriginalHeadPos
    true  -- fixPortrait
)

local squapi = require("SquAPI")

─── Eyes following gaze ─────────────────────────────
squapi.eye:new(models.model.Head.EyeLeft,  0.3, 1.2, 0.5, 0.6)
squapi.eye:new(models.model.Head.EyeRight, 0.3, 1.2, 0.5, 0.6)

─── Automatic random blink ───────────────────────────
-- A animação "blink" deve ser Play Once e ter a animação de piscar
squapi.randimation:new(
    animations.model.blink,
    80,    -- intervalo mínimo (ticks)
    300,   -- intervalo máximo
    true   -- does not blink while sleeping
)

─── Idle micro-movement (subtle head shake) ──────────
squapi.randimation:new(animations.model.headTwitch, 200, 600)

local squapi = require("SquAPI")

─── Squash & Stretch no pulo/pouso ─────────────────────
squapi.squishy:new(
    models.model,          -- raiz do modelo
    0.35,                  -- springStrength
    0.25,                  -- dampening
    -0.6,                  -- crouchBounce (achata ao agachar)
    vec(0.65, 0.55, 0.65), -- lowerLimit
    vec(1.2, 1.45, 1.2)   -- upperLimit
)

─── Bounce while walking ────────────────────────────
squapi.bounceWalk:new(models.model, 1.2)  -- 1.2x more pronounced

-- ────────────────────────────────────────────────────────
-- Furry Avatar: SquAPI + EZAnims + GSAnimBlend
-- ────────────────────────────────────────────────────────

-- Ordem de require importa!
local GSBlend = require("GSAnimBlend")
local anims   = require("EZAnims")
local squapi  = require("SquAPI")

── EZAnims ──────────────────────────────────────────
local m = anims:addBBModel(animations.model)
m:setBlendTimes(7, 3)
animations.model.death:setBlendTime(18):setBlendCurve("easeInCubic")
animations.model.hurt:setBlendTime(2, 5)

── SquAPI: Ears ─────────────────────────────────────
squapi.ear:new(
    models.model.Head.LeftEar, models.model.Head.RightEar,
    1, false, 2, true, 300, 0.1, 0.82
)

── SquAPI: Tail ─────────────────────────────────────
squapi.tail:new({
    models.model.Body.Tail,
    models.model.Body.Tail.Seg1,
    models.model.Body.Tail.Seg1.Seg2,
    models.model.Body.Tail.Seg1.Seg2.Tip,
}, 16, 5, 1.2, 2, 2.5)

── SquAPI: Smooth Head ──────────────────────────────
squapi.smoothHead:new(
    {models.model.Head}, 1, 0.08, 1, true, true,
    {animations.model.attack},  -- endireita ao atacar
    0.6, 0.4
)

── SquAPI: Eyes + Blink ─────────────────────────────
squapi.eye:new(models.model.Head.EyeL, 0.3, 1.2, 0.5, 0.6)
squapi.eye:new(models.model.Head.EyeR, 0.3, 1.2, 0.5, 0.6)
squapi.randimation:new(animations.model.blink, 80, 280, true)

── SquAPI: Squash & Bounce ──────────────────────────────
squapi.squishy:new(models.model, 0.3, 0.25, -0.5)
squapi.bounceWalk:new(models.model, 1)

local physBone = require("physBoneAPI")

-- Preset for default hair
physBone:setPreset("cabelo",
    1,    22,   -- mass, length
    0.75, 0.18, -- gravity, airResistance
    1,    nil,  -- simSpeed, equilibrium
    0,    nil,  -- springForce, force
    nil,  vec(0.5, 1, 1),  -- rotMod, vecMod
    nil,  -- rollMod
    0, 18, 0, 0.5, 0.15  -- nodeStart, nodeEnd, density=0 (sem debug), radius, bounce
)

function events.ENTITY_INIT()
    -- Aplicar em múltiplos grupos de cabelo com o mesmo preset
    models.model.Head.HairLeft:newPhysBone("physBone"):updateWithPreset("cabelo")
    models.model.Head.HairRight:newPhysBone("physBone"):updateWithPreset("cabelo")
    models.model.Head.HairBack:newPhysBone("physBone"):updateWithPreset("cabelo")

    -- Franja com menos movimento lateral (vecMod.x menor)
    local franja = models.model.Head.Franja:newPhysBone("physBone")
    franja:updateWithPreset("cabelo")
          :setVecMod(0.2, 1, 0.8)  -- barely sways sideways
          :setGravity(0.4)          -- lighter
end

local SP = require("swinging_physics")

-- Corrente de 4 elos pendurada na orelha esquerda
local e1 = SP.swingOnHead(models.model.Head.ChainL.Elo1, 90, {-60,60,-45,45,-30,30})
local e2 = SP.swingOnHead(models.model.Head.ChainL.Elo1.Elo2, 90, nil, models.model.Head.ChainL.Elo1, 1)
local e3 = SP.swingOnHead(models.model.Head.ChainL.Elo1.Elo2.Elo3, 90, nil, models.model.Head.ChainL.Elo1, 2)
local gem = SP.swingOnHead(models.model.Head.ChainL.Elo1.Elo2.Elo3.Gema, 90, nil, models.model.Head.ChainL.Elo1, 3)

-- Brinco simples na orelha direita com limites globais
local brincoD = SP.swingOnHead(
    models.model.Head.BrincoR, 270,
    {-40, 40, -30, 30, -20, 20},
    nil, 0, true  -- globalLimits: does not clip into head when looking up
)

local physBone = require("physBoneAPI")
local SP       = require("swinging_physics")

── PhysBone: Cape on back ───────────────────────────
physBone:setPreset("capa",
    1, 32, 0.5, 0.1, 1, nil, 0, nil, nil,
    vec(1, 1, 0.25),  -- vecMod: barely sways forward
    nil, 0, 28, 0, 0.5, 0
)

function events.ENTITY_INIT()
    models.model.Body.Cape:newPhysBone("physBone"):updateWithPreset("capa")
end

── SwingingPhysics: Pendant on neck ─────────────────
SP.swingOnBody(
    models.model.Body.Pendant, 0,
    {-30, 30, -25, 25, -20, 20}
)

local SP = require("swinging_physics")

local brinco  = SP.swingOnHead(models.model.Head.Earring, 90)
local pingente = SP.swingOnBody(models.model.Body.Pendant, 0)

local physicsOn = true

function pings.togglePhysics(b)
    physicsOn = b
    brinco:setEnabled(b)
    pingente:setEnabled(b)
end

-- Action Wheel toggle
local page = action_wheel:newPage()
action_wheel:setPage(page)
page:newAction()
    :title("Physics")
    :item("minecraft:diamond")
    :onToggle(function(b) pings.togglePhysics(b) end)

local confetti = require("confetti")

-- Registrar: mesh do Blockbench chamado "StarParticle"
confetti.registerMesh("star", models.model.StarParticle, 35)

local trilhaAtiva = false

function pings.setTrilha(b) trilhaAtiva = b end

function events.TICK()
    if not trilhaAtiva then return end

    -- Spawns 2 particles per tick while moving
    local vel = player:getVelocity()
    if vel:length() > 0.05 then
        for _ = 1, 2 do
            confetti.newParticle(
                "star",
                player:getPos() + vec(
                    (math.random() - 0.5) * 0.4,
                    math.random() * 0.8,
                    (math.random() - 0.5) * 0.4
                ),
                vec(
                    (math.random() - 0.5) * 0.08,
                    0.05 + math.random() * 0.1,
                    (math.random() - 0.5) * 0.08
                ),
                {
                    emissive = true,
                    rotationOverTime = math.random() * 20 - 10,
                    scaleOverTime = -0.035,
                    scale = 1,
                    acceleration = vec(0, -0.003, 0),
                }
            )
        end
    end
end

local confetti = require("confetti")
confetti.registerMesh("spark", models.model.SparkParticle, 60)

local estavaMorto = false

function events.TICK()
    local morto = player:isDead()

    if morto and not estavaMorto then
        -- Explode 40 faíscas no momento da morte
        for _ = 1, 40 do
            local angle = math.random() * math.pi * 2
            local speed = 0.15 + math.random() * 0.35
            confetti.newParticle(
                "spark",
                player:getPos() + vec(0, 1, 0),
                vec(
                    math.cos(angle) * speed,
                    0.1 + math.random() * 0.4,
                    math.sin(angle) * speed
                ),
                {
                    emissive = true,
                    acceleration = vec(0, -0.02, 0),
                    friction = 0.92,
                    rotationOverTime = math.random() * 30 - 15,
                    ticker = function(p)
                        confetti.defaultTicker(p)
                        -- Encolhe no fim da vida
                        p.scale = math.clamp(p.lifetime / 20, 0, 1)
                    end
                }
            )
        end
    end

    estavaMorto = morto
end

local confetti = require("confetti")

-- Sprite de fogo: 3 frames de 4x5px a partir do UV (0,10)
confetti.registerSprite("fire", textures["model.fx"], vec(0,10,4,5))

function events.TICK()
    -- Fogo ao redor dos pés
    confetti.newParticle(
        "fire",
        player:getPos() + vec(
            math.random() * 1.2 - 0.6, 0.05,
            math.random() * 1.2 - 0.6
        ),
        vec(0, 0.04, 0),
        {
            billboard = true,
            scale = 0.5 + math.random() * 0.4,
            frame = 0,  -- variável customizada para frame atual
            ticker = function(p)
                -- Não precisa de defaultTicker: não quer movimento físico
                p.lifetime = p.lifetime - 1
                -- Avança o frame a cada 2 ticks
                if world:getTime() % 2 == 0 then
                    p.options.frame = (p.options.frame + 1) % 3
                end
                p.task:setUVPixels(p.bounds.x + p.options.frame * 4, p.bounds.y)
            end
        }
    )
end

local confetti = require("confetti")
confetti.registerMesh("confete", models.model.Confete, 80)

function pings.dispararConfetti()
    -- 60 pedaços de confete em arco
    for _ = 1, 60 do
        confetti.newParticle(
            "confete",
            player:getPos() + vec(0, 1.5, 0),
            vec(
                (math.random() - 0.5) * 0.5,
                0.3 + math.random() * 0.5,
                (math.random() - 0.5) * 0.5
            ),
            {
                acceleration = vec(0, -0.025, 0),
                friction = 0.97,
                rotation = vec(math.random()*360, math.random()*360, 0),
                rotationOverTime = vec(math.random()*20-10, math.random()*20-10, 0),
            }
        )
    end
end

local page = action_wheel:newPage()
action_wheel:setPage(page)
page:newAction()
    :title("Confetti!")
    :item("minecraft:firework_rocket")
    :onLeftClick(function() pings.dispararConfetti() end)

local animText = require("animatedText")

-- Criar nameplate acima da cabeça
animText.new(
    "nameplate",
    models.model.Head,
    vec(0, 22, 0),
    vec(0.45, 0.45, 1),
    "BILLBOARD"
)

-- Atualiza o texto ao HP mudar
local lastHp = -1
function events.TICK()
    local hp = math.floor(player:getHealth())
    if hp ~= lastHp then
        lastHp = hp
        local cor = hp > 10 and "green" or hp > 5 and "yellow" or "red"
        animText.setText("nameplate", {
            {text = "◈ ",             color = "aqua"},
            {text = player:getName(), color = "white", bold = true},
            {text = "  ❤",            color = cor},
            {text = tostring(hp),      color = cor, bold = true},
        })
    end
end

-- Onda senoidal em cada caractere
local t = 0
function events.TICK() t = t + 1 end

function events.RENDER(delta, ctx)
    if ctx ~= "FIRST_PERSON" and ctx ~= "RENDER" then return end

    local tasks = animText.getTask("nameplate").textTasks
    for i, char in pairs(tasks) do
        local wave = math.sin((t + delta) / 8 + i * 0.55) * 0.4
        animText.transform("nameplate", vec(0, wave, 0), nil, nil, char)
    end
end

local animText = require("animatedText")

-- Criar o texto
animText.new("rainbow", models.model.Head, vec(0,24,0), vec(0.5,0.5,1), "BILLBOARD",
    {text = "✦ FIGURA ✦"}
)

-- Reconstruir o texto com cores por caractere (rainbow)
local rainbow = {"red", "gold", "yellow", "green", "aqua", "blue", "light_purple"}
local chars   = {"✦"," ","F","I","G","U","R","A"," ","✦"}
local jsonArr = {}
for i, c in ipairs(chars) do
    jsonArr[i] = {text = c, color = rainbow[(i-1)%#rainbow+1], bold = true}
end
animText.setText("rainbow", jsonArr)

-- Outline em todos os chars
for _, v in pairs(animText.getTask("rainbow").textTasks) do
    v.task:outline(true):outlineColor(vec(0,0,0))
end

local chat_bubble = require("modules/chat_bubble/chat_bubble")

-- Configurações personalizadas
chat_bubble.bubbleLifetime  = 160   -- 8s no total
chat_bubble.fadeTime        = 40    -- 2s de fade
chat_bubble.maxMessageLength = 72   -- até 72 caracteres
chat_bubble.localIndicator  = "."   -- mensagem começando com "." não vai ao chat

-- Nameplate animada
local animText   = require("animatedText")
-- Chat Bubble (texto ao enviar mensagem)
local chatBubble = require("modules/chat_bubble/chat_bubble")
-- Speech Bubble (ícone ao digitar) — não precisa de require, auto-init

── Nameplate ────────────────────────────────────────
animText.new("name", models.model.Head, vec(0,22,0), vec(0.4,0.4,1), "BILLBOARD", {
    {text = "♦ ", color = "gold"},
    {text = player:getName(), color = "white", bold = true},
    {text = " ♦", color = "gold"},
})

── Chat Bubble ──────────────────────────────────────
chatBubble.bubbleLifetime = 140
chatBubble.fadeTime = 30
chatBubble.localIndicator = "."

── Nameplate wave effect (render) ───────────────────
local t = 0
function events.TICK() t = t + 1 end
function events.RENDER(delta, ctx)
    if ctx ~= "RENDER" then return end
    for i, c in pairs(animText.getTask("name").textTasks) do
        animText.transform("name", vec(0, math.sin((t+delta)/8+i*0.6)*0.35, 0), nil, nil, c)
    end
end

-- ═══════════════════════════════════════════════════════
--  REQUIRES — ordem importa: GSAnimBlend primeiro
-- ═══════════════════════════════════════════════════════
local GSBlend   = require("GSAnimBlend")
local anims     = require("EZAnims")
local squapi    = require("SquAPI")
local physBone  = require("physBoneAPI")
local SP        = require("swinging_physics")
local confetti  = require("confetti")
local animText  = require("animatedText")
local chatBubble = require("modules/chat_bubble/chat_bubble")

vanilla_model.ALL:setVisible(false)

-- ═══════════════════════════════════════════════════════
--  EZANIMS + GSANIMBLEND
-- ═══════════════════════════════════════════════════════
local m = anims:addBBModel(animations.model)
m:setBlendTimes(7, 3)
animations.model.death:setBlendTime(18):setBlendCurve("easeInCubic")
animations.model.hurt:setBlendTime(2, 5)

-- genBlendVanilla nas animations de movimento
local bodyParts = {
    models.model.Head, models.model.Body,
    models.model.LeftArm, models.model.RightArm,
    models.model.LeftLeg, models.model.RightLeg,
}
local vanillaBlend = GSBlend.callback.genBlendVanilla(bodyParts)
animations.model.idle:setOnBlend(vanillaBlend)
animations.model.walk:setOnBlend(vanillaBlend)

-- ═══════════════════════════════════════════════════════
--  SQUAPI
-- ═══════════════════════════════════════════════════════
squapi.ear:new(models.model.Head.LeftEar, models.model.Head.RightEar,
    1, false, 2, true, 300, 0.1, 0.82)

squapi.tail:new({
    models.model.Body.Tail,       models.model.Body.Tail.Seg1,
    models.model.Body.Tail.Seg1.Seg2,
    models.model.Body.Tail.Seg1.Seg2.Tip,
}, 16, 5, 1.2, 2, 2.5)

squapi.smoothHead:new({models.model.Head}, 1, 0.08, 1, true, true,
    {animations.model.attack}, 0.6, 0.4)

squapi.eye:new(models.model.Head.EyeL, 0.3, 1.2, 0.5, 0.6)
squapi.eye:new(models.model.Head.EyeR, 0.3, 1.2, 0.5, 0.6)
squapi.randimation:new(animations.model.blink, 80, 280, true)
squapi.squishy:new(models.model, 0.3, 0.25, -0.5)
squapi.bounceWalk:new(models.model, 1)

-- ═══════════════════════════════════════════════════════
--  PHYSBONE + SWINGING
-- ═══════════════════════════════════════════════════════
physBone:setPreset("cabelo", 1,22,0.75,0.18,1,nil,0,nil,nil,vec(0.5,1,1),nil,0,18,0,0.5,0.15)

function events.ENTITY_INIT()
    models.model.Head.HairL:newPhysBone("physBone"):updateWithPreset("cabelo")
    models.model.Head.HairR:newPhysBone("physBone"):updateWithPreset("cabelo")
end

local brinco = SP.swingOnHead(models.model.Head.Earring, 90,
    {-50,50,-40,40,-25,25}, nil, 0, true)

-- ═══════════════════════════════════════════════════════
--  CONFETTI
-- ═══════════════════════════════════════════════════════
confetti.registerMesh("spark", models.model.SparkFX, 50)
local trilha = false

function events.TICK()
    if trilha and player:getVelocity():length() > 0.05 then
        confetti.newParticle("spark", player:getPos()+vec(0,0.5,0),
            vec((math.random()-0.5)*0.1, 0.08+math.random()*0.08, (math.random()-0.5)*0.1),
            {emissive=true, scaleOverTime=-0.03, acceleration=vec(0,-0.005,0)})
    end
end

-- ═══════════════════════════════════════════════════════
--  ANIMATED TEXT + CHAT BUBBLES
-- ═══════════════════════════════════════════════════════
animText.new("np", models.model.Head, vec(0,22,0), vec(0.42,0.42,1), "BILLBOARD", {
    {text = "◈ ", color = "aqua"},
    {text = player:getName(), color = "white", bold = true},
})
chatBubble.bubbleLifetime = 140
chatBubble.localIndicator = "."

-- Onda na nameplate
local tick = 0
events.TICK:register(function() tick = tick + 1 end)
events.RENDER:register(function(d, ctx)
    if ctx ~= "RENDER" then return end
    for i, c in pairs(animText.getTask("np").textTasks) do
        animText.transform("np", vec(0, math.sin((tick+d)/8+i*0.6)*0.35, 0), nil, nil, c)
    end
end)

-- ═══════════════════════════════════════════════════════
--  ACTION WHEEL
-- ═══════════════════════════════════════════════════════
local page = action_wheel:newPage()
action_wheel:setPage(page)

-- Toggle estado "sword"
page:newAction():title("Espada"):item("minecraft:iron_sword")
    :onToggle(function(b)
        pings.setSword(b)
    end)

-- Toggle trilha de partículas
page:newAction():title("Trilha"):item("minecraft:blaze_powder")
    :onToggle(function(b)
        pings.setTrilha(b)
    end)

-- Toggle física dos acessórios
page:newAction():title("Physics"):item("minecraft:diamond"):toggled(true)
    :onToggle(function(b)
        pings.setFisica(b)
    end)

-- ── PINGS ──────────────────────────────────────────────
function pings.setSword(b)
    m:setState(b and "sword" or nil)
end

function pings.setTrilha(b)
    trilha = b
end

function pings.setFisica(b)
    brinco:setEnabled(b)
end

-- Simple use: just to get access to :setBlendTime()
require("GSAnimBlend")

-- Uso avançado: guardar referência para acessar curvas, callbacks, oldF
local GSBlend = require("GSAnimBlend")

require("GSAnimBlend")

-- Blend in and out with the same duration (in ticks — 20 ticks = 1 second)
animations.MeuModelo.Idle:setBlendTime(5)       -- 0.25s
animations.MeuModelo.Idle:setBlendTime(10)      -- 0.5s

-- Blend in e out com tempos diferentes
animations.MeuModelo.Ataque:setBlendTime(3, 8)  -- 3 ticks in, 8 ticks out

-- Mudar a curva de easing do blend
animations.MeuModelo.Idle:setBlendCurve("linear")
animations.MeuModelo.Walk:setBlendCurve("easeInOutCubic")
animations.MeuModelo.Ataque:setBlendCurve("easeOutBack")

-- Também aceita alias no estilo método encadeado
animations.MeuModelo.Idle
    :blendTime(5)
    :blendCurve("smoothstep")

-- Curva de onda: blend in, out, e de volta — efeito de pulsar
local function wave(x)
  return (math.cos(x * math.pi * 3) - 1) / -2
end

animations.MeuModelo.Idle:setBlendCurve(wave)

-- Curva que fica em 0 e vai para 1 de repente na metade
local function step(x)
  return x >= 0.5 and 1 or 0
end

-- Usando GSBlend.curve para referenciar curvas prontas
local GSBlend = require("GSAnimBlend")
local minhaCurva = GSBlend.curve.easeOutBack
animations.MeuModelo.Idle:setBlendCurve(minhaCurva)

local GSBlend = require("GSAnimBlend")
local animBlend = GSBlend.oldF.blend  -- função nativa de blend do Figura

-- Callback recebe (state, data) — veja os tipos abaixo
local function meuCallback(state, data)
  -- Aplica o peso de blend normalmente
  animBlend(state.anim, math.lerp(state.from, state.to, state.progress))

  -- Código extra: partículas de fogo quando blend > 50%
  if state.rawProgress > 0.5 then
    particles:newParticle(
      "flame",
      player:getPos():add(math.random() * 2 - 1, 1, math.random() * 2 - 1)
    )
  end

  -- Limpeza quando o blend terminar
  if state.done then
    -- Faça cleanup aqui — este é o último frame do callback
  end
end

-- Prioridade 0 = substitui o callback padrão
animations.MeuModelo.Idle:setOnBlend(meuCallback, 0)

-- Prioridade 1 = roda DEPOIS do padrão (não substitui)
animations.MeuModelo.Idle:setOnBlend(meuCallback, 1)

local GSBlend = require("GSAnimBlend")

── genBlendVanilla: smooth transition from vanilla pose → animated ──
animations.MeuModelo.Walk:setOnBlend(
  GSBlend.callback.genBlendVanilla({
    models.MeuModelo.Head,
    models.MeuModelo.Body,
    models.MeuModelo.LeftArm,
    models.MeuModelo.RightArm,
    models.MeuModelo.LeftLeg,
    models.MeuModelo.RightLeg,
  })
)

── genBezier: custom cubic-bezier curve (like CSS) ──
local minhaCurva = GSBlend.callback.genBezier(0.68, -0.55, 0.27, 1.55)
animations.MeuModelo.Idle:setBlendCurve(minhaCurva)

── genDualBlend: different callback for in and out ──
animations.MeuModelo.Ataque:setOnBlend(
  GSBlend.callback.genDualBlend(
    GSBlend.callback.base,          -- callback ao iniciar
    GSBlend.callback.genBlendVanilla({ models.MeuModelo.RightArm }) -- callback ao parar
  )
)

local GSBlend = require("GSAnimBlend")

-- Apply blend directly via Figura (bypassing the lib layer)
GSBlend.oldF.blend(animations.MyModel.Idle, 0.5)

-- Ver o que está disponível em oldF
-- /figura run GSBlend = require("GSAnimBlend")
-- /figura run printTable(GSBlend.oldF)

require("GSAnimBlend")                 -- must be required BEFORE EZAnims
local anims = require("EZAnims")

local myModel = anims:addBBModel(animations.model)

-- Define blend para todos as animations gerenciadas pelo EZAnims de uma vez
myModel:setBlendTimes(6)       -- 6 ticks para exclusivas e inclusivas
myModel:setBlendTimes(6, 3)    -- 6 exclusivas, 3 inclusivas
myModel:setBlendTimes()        -- zera os blend times

-- Você ainda pode configurar animations individuais manualmente
animations.model.death:setBlendTime(15):setBlendCurve("easeInQuad")

-- This alone is sufficient for basic use
require("EZAnims")

-- To use advanced functions, store the reference:
local anims = require("EZAnims")
local myModel = anims:addBBModel(animations.nomeDoSeuModelo)

── Multiple animations of the same type ───────────────
-- The number goes right after the base name
-- idle, idle2, idle3 → as três serão selecionadas aleatoriamente ao ficar parado

── Intro (animation that loops in) ─────────────────
-- Use uma única animação com instruction keyframe no fim para definir o loop:
-- (no final da timeline, adicione keyframe de instrução com o código abaixo)
-- this:setTime(loopStart)  -- onde loopStart é o tempo em segundos do loop

── Outro (plays when the state ENDS) ─────────────────
-- Nome: statename_outro  Ex: idle_outro, walk_outro
-- Se usar com setState(): idle_sword_outro (outro vai por último)

── Custom state (setState) ───────────────────────────
-- Nome: statename_sufixo  Ex: idle_sword, walk_sword, sprint_sword
-- Ao chamar setState("sword"), as versões _sword tocam no lugar das normais
-- Animações sem versão _sword continuam usando a versão padrão

── Multiple + State + Outro ──────────────────────────
-- idle2_sword_outro → 2ª animação de idle, com estado "sword", é outro

local anims = require("EZAnims")

-- Two models on the same instance (synchronized)
local myModel = anims:addBBModel(animations.corpo, animations.acessorios)

-- Estado com espada: idle_sword, walk_sword etc. tocam no lugar dos normais
local comEspada = false

function pings.toggleEspada()
  comEspada = not comEspada
  myModel:setState(comEspada and "sword" or nil)
end

-- Overrider: durante uma cutscene, para tudo
myModel:addAllOverrider(animations.corpo.cutscene_inicio)

-- Detectar estado de voo para usar na Action Wheel
function events.TICK()
  if anims:isFlying() then
    -- fazer algo quando estiver voando
  end
end

local anims = require("EZAnims")

-- 1. Desativar busca automática ANTES de addBBModel
anims:disableAutoSearch()
local m = anims:addBBModel(animations.model)

-- 2. Registrar apenas as animations que você tem
-- (Remova ou deixe nil as que não existem — economiza instruções)
m:setAnims({
  idle    = { animations.model.idle, animations.model.idle2 },
  walk    = { animations.model.walk },
  sprint  = { animations.model.sprint },
  crouch  = { animations.model.crouch },
  jumpup  = { animations.model.jump },
  jumpdown= { animations.model.jump },
  hurt    = { animations.model.hurt },
  death   = { animations.model.death },
  attackR = { animations.model.attack },
  holdR   = { animations.model.hold },
  fly     = { animations.model.fly },
}, true)  -- true = tem animations de voo criativo

-- IMPORTANTE: GSAnimBlend SEMPRE primeiro
local GSBlend = require("GSAnimBlend")
local anims   = require("EZAnims")

local m = anims:addBBModel(animations.model)

-- Blend para TODAS as animations gerenciadas pelo EZAnims
m:setBlendTimes(6)         -- 6 ticks (0.3s) para exclusivas e inclusivas
m:setBlendTimes(8, 4)     -- 8 exclusivas, 4 inclusivas

-- Blend personalizado para animations específicas (opcional)
animations.model.death:setBlendTime(20):setBlendCurve("easeInQuad")
animations.model.hurt:setBlendTime(2)

-- genBlendVanilla em animations de movimento para transição suave
local bodyParts = {
  models.model.Head, models.model.Body,
  models.model.LeftArm, models.model.RightArm,
  models.model.LeftLeg, models.model.RightLeg,
}
animations.model.idle:setOnBlend(GSBlend.callback.genBlendVanilla(bodyParts))
animations.model.walk:setOnBlend(GSBlend.callback.genBlendVanilla(bodyParts))