What the camera sees

/// An arrow at the edge of the screen that points at the beacon while the
/// beacon is out of sight. Once all of the beacon is in view there is nothing
/// to point at, and the arrow hides. It reads the camera the game is seen
/// through, whichever that is.
component Arrow {
    /// The node the arrow points at: the beacon on its pillar.
    #[node_path]
    beacon: i32 = 0,
    /// How big the beacon's picture is: the box that has to be in view.
    size: Vec2 = vec2(32.0, 64.0),
    /// How far in from the edge of the view the arrow sits.
    #[suffix("u")]
    margin: f32 = 12.0,

    fn loop() {
        // The beacon's picture stands on its node, so its middle is half its
        // height above the node.
        let middle = position_of(node(beacon)) - vec2(0.0, size.y * 0.5);
        if camera_fit(middle, size) == .Whole {
            // All of it is on screen.
            hide();
        } else {
            show();
            // The arrow goes where the beacon is, held inside the view's edges
            // by the margin: at the edge nearest the beacon.
            let view = camera_view();
            let spot = vec2(
                clamp(middle.x, view.x + margin, view.z - margin),
                clamp(middle.y, view.y + margin, view.w - margin),
            );
            move_to(spot);
            // And it turns to face the beacon from there.
            anneal_rotation(angle_of(middle - spot), 0.1, .OutQuad);
        }
    }
}

/// The camera that looks at the castle gate. It is in the group `gate`, so the
/// lever's `open` reaches it as it reaches the bars. It is off until then.
/// When the gate is told to open, the game is seen through it for three
/// seconds, and then the town's camera, which is in the group `watch`, is told
/// to take the game back.
component GateCamera {
    fn on_signal() {
        // The lever said `open`: this camera becomes the one the game is seen
        // through, and every other camera in the scene goes off, in the same
        // step.
        if heard("open") {
            make_current();
            // Three seconds of the bars rising and the gate standing open.
            await wait(3.0);
            // Then the town's camera is told to take the game back.
            emit_to("watch", "back");
        }
    }
}

/// The camera's shots. The camera is in the group `watch`, so the vista spot
/// and the gate camera can speak to it; this script is what it does when it
/// hears. The two shots are framings of the Camera Rig on this node, switched
/// by name.
component Shots {
    fn on_signal() {
        // The spot said `vista`, as the watchman walked into it: the vista
        // framing is switched on. It outranks `follow`, so the camera blends
        // to it over the vista's own Duration.
        if heard("vista") {
            set_flag("CameraRigComponent", "framings.vista.active", true);
        }
        // The spot said `follow`, as he walked out of it: the vista is
        // switched off, and the camera cuts to him instead of gliding there.
        if heard("follow") {
            set_flag("CameraRigComponent", "framings.vista.active", false);
            cut();
        }
        // The gate camera said `back`, three seconds after the lever: the game
        // is seen through this camera again. Its rig was on him the whole
        // time, so the game comes back to him at once.
        if heard("back") {
            make_current();
        }
    }
}