Converting Molang Values to Scoreboards via Animation Controllers

In a behaviour pack animation controller, the `on_entry` and `on_exit` arrays accept both slash commands (prefixed with `/`) and raw Molang expressions. New creators often try to combine the two on a single line, writing something like `/scoreboard players set @s health (query.health)`. The command parser does not evaluate Molang; it reads `(query.health)` as a literal string, throws a syntax error because it expects an integer, and fails to run the command.

Going the other way—from a scoreboard into Molang—is only partially supported in modern format versions, and writing from Molang out to a scoreboard has no native syntax at all. Because animation controllers evaluate state transitions using Molang and execute commands when entering those states, the state machine itself has to act as the translator. Instead of creating hundreds of individual states to check if a value equals 1, 2, 3, and so on, you can use binary decomposition inside a single state transition loop.

Every positive integer can be represented as the sum of powers of two (1, 2, 4, 8, 16, 32, 64, 128, etc.). If you copy a Molang query into a temporary Molang variable (`variable.temp_val`), you can test whether that variable is greater than or equal to each power of two, starting from the largest power you expect to handle and working down to 1.

However, you cannot run both `/scoreboard players add` and `variable.temp_val = variable.temp_val - 64;` inside the same `on_entry` array if they depend on each other dynamically, because `on_entry` runs everything unconditionally once the state is entered. Instead, you use a chain of states, or better yet, you compute individual bit flags in Molang variables first and then use a cascade of states—or you use the `animations` array on the entity to run sub-controllers in parallel.

The fastest pure-controller method uses one sub-controller per bit, or a linear chain of states that transitions multiple times if needed. Because a single animation controller only takes one transition per tick, a linear chain of 8 states would take 8 ticks to finish. To make the conversion happen instantly within a single tick, we split each binary bit into its own tiny controller inside the same file, all triggered simultaneously by a master variable.

To convert a value between 0 and 255 in a single tick, we create one preparation controller and eight bit-check controllers inside `BP/animation_controllers/molang_to_score.ac.json`. In the preparation controller, we floor the target Molang query into an integer, store it in `variable.score_input`, and reset the entity's scoreboard objective to 0.

Because Bedrock runs controllers in the order they are listed in the entity's `scripts.animate` array, the preparation controller runs first, followed immediately in the exact same tick by the controllers from `bit_7` (128) down to `bit_0` (1). Each bit controller checks if `variable.score_input` is at least its power of two. If true, it enters its `add` state, adds that power of two to the scoreboard, and subtracts the same amount from `variable.score_input` so the smaller bits only see the remainder.

{
  "format_version": "1.10.0",
  "animation_controllers": {
    "controller.animation.molang_score.prepare": {
      "initial_state": "idle",
      "states": {
        "idle": {
          "transitions": [
            { "convert": "variable.convert_trigger == 1" }
          ]
        },
        "convert": {
          "on_entry": [
            "variable.score_input = math.clamp(math.floor(query.health), 0, 255);",
            "/scoreboard players set @s hp_score 0"
          ],
          "transitions": [
            { "idle": "1.0" }
          ]
        }
      }
    },
    "controller.animation.molang_score.bit_7": {
      "initial_state": "idle",
      "states": {
        "idle": {
          "transitions": [
            { "add": "variable.convert_trigger == 1 && variable.score_input >= 128" }
          ]
        },
        "add": {
          "on_entry": [
            "variable.score_input = variable.score_input - 128;",
            "/scoreboard players add @s hp_score 128"
          ],
          "transitions": [
            { "idle": "1.0" }
          ]
        }
      }
    },
    "controller.animation.molang_score.bit_6": {
      "initial_state": "idle",
      "states": {
        "idle": {
          "transitions": [
            { "add": "variable.convert_trigger == 1 && variable.score_input >= 64" }
          ]
        },
        "add": {
          "on_entry": [
            "variable.score_input = variable.score_input - 64;",
            "/scoreboard players add @s hp_score 64"
          ],
          "transitions": [
            { "idle": "1.0" }
          ]
        }
      }
    },
    "controller.animation.molang_score.bit_0": {
      "initial_state": "idle",
      "states": {
        "idle": {
          "transitions": [
            { "add": "variable.convert_trigger == 1 && variable.score_input >= 1" }
          ]
        },
        "add": {
          "on_entry": [
            "variable.score_input = variable.score_input - 1;",
            "/scoreboard players add @s hp_score 1",
            "variable.convert_trigger = 0;"
          ],
          "transitions": [
            { "idle": "1.0" }
          ]
        }
      }
    }
  }
}

In the code above, `bit_5` through `bit_1` (for values 32, 16, 8, 4, and 2) follow the exact same pattern as `bit_6`. Note that resetting `variable.convert_trigger = 0;` if placed inside `bit_0` would only run when the number is odd. To ensure the trigger resets cleanly whether `bit_0` fires or not, you should either leave `variable.convert_trigger` driven by a continuous condition (such as `query.is_alive`) or add one final cleanup controller at the end of the chain that sets `variable.convert_trigger = 0;` unconditionally.

Inside your entity's behaviour file (for example, `BP/entities/player.json`), you register the controllers in `description.animations` and list them in strict descending order inside `description.scripts.animate`. If you list `bit_0` before `bit_7`, `bit_0` will see that a health of 20 is `>= 1`, subtract 1, and leave 19, ruining the binary math for the rest of the chain.

{
  "format_version": "1.16.0",
  "minecraft:entity": {
    "description": {
      "identifier": "minecraft:player",
      "is_spawnable": false,
      "is_summonable": false,
      "animations": {
        "score_prep": "controller.animation.molang_score.prepare",
        "score_b7": "controller.animation.molang_score.bit_7",
        "score_b6": "controller.animation.molang_score.bit_6",
        "score_b5": "controller.animation.molang_score.bit_5",
        "score_b4": "controller.animation.molang_score.bit_4",
        "score_b3": "controller.animation.molang_score.bit_3",
        "score_b2": "controller.animation.molang_score.bit_2",
        "score_b1": "controller.animation.molang_score.bit_1",
        "score_b0": "controller.animation.molang_score.bit_0"
      },
      "scripts": {
        "initialize": [
          "variable.convert_trigger = 0;",
          "variable.score_input = 0;"
        ],
        "animate": [
          "score_prep",
          "score_b7",
          "score_b6",
          "score_b5",
          "score_b4",
          "score_b3",
          "score_b2",
          "score_b1",
          "score_b0"
        ]
      }
    },
    "components": {}
  }
}

Scoreboards in Minecraft Bedrock only store 32-bit signed integers; they cannot hold floating-point decimals. When converting a decimal query like `query.head_x_rotation` or `query.modified_move_speed`, multiply the value by 10 or 100 before calling `math.floor()` in the preparation step. For example, `math.floor(query.modified_move_speed * 100)` turns `0.75` into `75`, preserving two decimal places of precision inside your integer scoreboard.

If the Molang query can return negative numbers (such as pitch rotation or relative coordinates), you have two options. The simplest is adding a constant offset before decomposing—for example, adding 180 to a rotation query that ranges from -180 to 180 so the input is always between 0 and 360, then subtracting 180 from the scoreboard at the very end using `/scoreboard players remove @s rot_score 180`. Alternatively, you can add a sign-check controller before the bit controllers that tests if the value is `< 0`, multiplies `variable.score_input` by `-1`, and sets a flag so you know the resulting score is negative.

Every time a bit controller enters its `add` state, it transitions back to `idle` on the following tick. That means a continuous conversion can only run once every two ticks (10 times per second) because the state machine has to spend one tick in `add` and one tick returning to `idle` before it can fire `on_entry` again. If you truly need 20-ticks-per-second updates, you must replaces the `idle` state with two alternating active states (`add_a` and `add_b`) that bounce back and forth every tick while the condition holds.

Executing up to nine `/scoreboard` commands per entity every couple of ticks carries noticeable overhead if applied to dozens of mobs at once. Limit this technique to players, boss entities, or on-demand triggers (such as converting the score only when an entity takes damage or interacts). If your add-on already uses a `manifest.json` with a `@minecraft/server` script module, reading an entity property or rotation in JavaScript and calling `ScoreboardObjective.setScore()` is much cleaner and avoids command execution overhead altogether.

Applies to all modern Bedrock versions supporting behaviour pack animation controllers (format_version 1.10.0 for animation controllers and 1.16.0+ for entity scripts.animate). No experimental toggles are required.

Read out of the game itself, so the ids match the version you are building for.