DriftScript

// The two prefixes, in one file.
//
// `std/math` is the language's own and is pure, so it links in any host. `drift/scene` is this
// engine's, and it carries the effect of reaching a scene. The prefix in the import is what tells
// you which of the two you are looking at.
//
// `Node` is not a language type either. It arrives with the capability, from whatever the host's
// scene is made of, which is why a consumer with no renderer still has a language.

import { clamp } from "std/math"
import { setRotation } from "drift/scene"

data Spin {
    speed: f32 = 45deg
}

fn turn(spin: Spin, node: Node, dt: f32) {
    let step = math.clamp(spin.speed * dt, 0, 90deg)
    scene.setRotation(node, 0, 1, 0, step)
}

// A list, the loops that go with it, and a constant the whole file can name.
//
// `[a, b]`, `xs[i]`, `len`, `push` and `for … in` are language forms rather than a module, which is
// why there is no `std/collections`: a capability's parameter types are names in a data format a
// host writes, and a module function over `List<T>` would need a type variable there.

// A `let` at the top of a file is a constant. Its value is arithmetic over literals and other
// constants; a call is not allowed, because a module is evaluated before its host is bound and
// there would be nothing to call. Another file can import it the way it imports a function.
let CALM = 0.15
// Annotated, because `len` answers a `u32` and there is no implicit widening: a bare `3` here is
// an `f32` and comparing the two is refused by name.
let SAMPLES: u32 = 3

// `continue` skips to the next turn, `break` leaves the loop. There are no labels, so a jump
// always means the loop it is written in.
fn strongestGust(gusts: List<f32>) -> f32 {
    var best: f32 = 0
    for gust in gusts {
        if gust < CALM {
            continue
        }
        if gust > best {
            best = gust
        }
    }
    return best
}

// `push` needs a mutable binding, because growing a list writes to the container.
fn firstFew(gusts: List<f32>) -> List<f32> {
    var picked: List<f32> = []
    for gust in gusts {
        if len(picked) == SAMPLES {
            break
        }
        push(picked, gust)
    }
    return picked
}

// An index past the end throws, for the same reason integer overflow does: there is no value that
// would be right, and returning one would be inventing an answer.
fn opening(gusts: List<f32>) -> f32 {
    if len(gusts) == 0 {
        return 0
    }
    return gusts[0]
}

// A value the page keeps, and a function the page replaces while it keeps it.
//
// `ticks` counts how many times `advance` has run since the page loaded. Edit the body below and
// the count carries on from where it was: the code is replaced, the state it was working on is
// not. That is what hot reload means here, and it is the reason records have no methods.

data Pulse {
    ticks: u32 = 0
    value: f32 = 0
}

fn advance(pulse: mut Pulse, dt: f32) {
    pulse.ticks = pulse.ticks +| 1
    pulse.value = pulse.value + dt
}

// A task is asynchronous behaviour with an owner.
//
// `spawn` starts one inside a `scope`, and leaving the scope cancels whatever has not finished.
// That is the rule that stops detached work outliving the thing that created it, and it is
// structural here rather than something every author has to remember.
//
// `begin` is a task rather than a function, and the compiler insists: a scope opened in a function
// would be left on the same tick it was opened, cancelling everything spawned into it.

data Signal {
    fired: bool = false
    count: u32 = 0
}

task pulse(signal: mut Signal) {
    await fixedTime(250ms)
    signal.count = signal.count +| 1
    signal.fired = true
}

task begin(signal: mut Signal) {
    scope effect {
        spawn pulse(signal)
        await fixedTime(1s)
    }
}

// The same source against two targets.
//
// One provides `drift/animation` and one does not, and the difference is a refusal with the
// module and the target named in it. Nothing about this file changes between the two.
//
// **A script drives a blend tree; it does not build one.** The tree is built where the skeleton
// and the clips already are, and handed to a system through `uses` — so what a script does with
// it is set its parameters and evaluate it. Both kinds of parameter are set the same way: a blend
// weight, and a clock, which is the time a `clip` node was told to read instead of the frame's.

import { blendSet, blendAt, pose } from "drift/animation"

data GaitState {
    // Seconds, for anything that carries on while the character stands still.
    phase: f32 = 0
    // The distance the character has covered, on the gait clips' own axis.
    stride: f32 = 0
}

fn step(state: mut GaitState, dt: f32, speed: f32) {
    state.phase += dt
    state.stride += dt * speed
}

fn drive(tree: Blend, state: GaitState, joints: u32) -> Pose {
    let out = animation.pose(joints)
    animation.blendSet(tree, "speed", 1.0)
    animation.blendSet(tree, "gait", state.stride)
    animation.blendAt(tree, state.phase, out)
    return out
}

// `@deterministic` is a claim the compiler checks, not a note to the reader.
//
// A simulation is given its delta as a parameter rather than reaching out for one. That is what
// makes it a function of its inputs, which is the property a replay depends on.

@deterministic
fn step(position: f32, velocity: f32, dt: f32) -> f32 {
    return position + velocity * dt
}

@pure
fn squared(x: f32) -> f32 {
    return x * x
}

// A script driving real geometry.
//
// It reaches the engine through `drift/scene`, and it knows nothing about a canvas, a mesh or a
// renderer. The scene beside it does not animate: everything moving on screen is moving because
// this function ran.
//
// **Edit `advance`** — multiply the step, swap the axis — and the cube responds on the next frame
// while `turned` keeps counting. The state survives; the code does not have to.
//
// **Editing `speed`'s default does not move the running cube**, and that is the same rule rather
// than an exception to it. A default is what a *fresh* instance starts with; a live one keeps every
// value it already has. If a reload reapplied defaults, `turned` would snap back to 0 on every
// keystroke — which is exactly the thing this box exists to show it does not do. Add a field and it
// arrives at its default; change an existing one and the running state is untouched.

import { setRotation } from "drift/scene"

data Spin {
    speed: f32 = 45deg
    turned: f32 = 0
    tilt: f32 = 0
}

fn advance(spin: mut Spin, node: Node, dt: f32) {
    spin.turned = spin.turned + spin.speed * dt
    scene.setRotation(node, 0, 1, 0, spin.turned)
}

// A record, a mutation, and the two things the compiler will not let you skip.
//
// `door` is `mut`, so its fields may be written. `by` is not, so it may only be read. A record
// literal gives every field a value: there is no partial construction.

import { clamp } from "std/math"

data Door {
    open: bool = false
    angle: f32 = 0
}

fn swing(door: mut Door, by: f32) {
    door.angle = math.clamp(door.angle + by, 0, 180deg)
    if door.angle > 45deg {
        door.open = true
    }
}

fn closed() -> Door {
    return Door { open: false, angle: 0 }
}

// Written before this host provided the capability. It links now, and not a character of it moved.
//
// This is the property the whole language is arranged around, and this file is the receipt. It was
// written when `drift/ai` had no provider here: it parsed, it type-checked, and only linking
// declined it, naming the module and the target and whether the capability existed at all, which is
// a different answer from "no". Then the engine bound the module, and the file linked that day,
// unedited.
//
// So press compile and watch it link. The point is not that it works; it is that nothing about the
// file had to change for it to start working.
//
// What the script does and does not do is worth reading twice. It tells an agent that something
// happened and asks what the agent is doing. It does not receive a plan, and it never runs one:
// a model's output is not an execution path, and a tool resolves by id to something registered
// long before the model was asked.

import { agent, wake, degraded, intentId } from "drift/ai"

data Sentry {
    alarmed: bool = false
    lastIntent: String = ""
}

fn alarm(sentry: mut Sentry, id: String, priority: i32) {
    if let found = ai.agent(id) {
        ai.wake(found, "heard something", priority)
        sentry.alarmed = true
    }
}

// `degraded` is how a script asks whether the agent is over budget and running on its policy floor
// alone. A floor is deterministic and synchronous, so an agent with no provider still behaves, and
// the answer here is a quality signal rather than a failure.
fn observe(sentry: mut Sentry, id: String) -> bool {
    if let found = ai.agent(id) {
        sentry.lastIntent = ai.intentId(found)
        return ai.degraded(found)
    } else {
        return true
    }
}