@open-core/framework 1.0.2-beta.1 → 1.0.5-beta.1

package/dist/runtime/client/services/cinematic-builder.js

@@ -0,0 +1,467 @@
+function cloneVector3(vector) {
+    return { x: vector.x, y: vector.y, z: vector.z };
+}
+function clonePosition(input) {
+    switch (input.type) {
+        case 'coords':
+            return { type: 'coords', x: input.x, y: input.y, z: input.z };
+        case 'entity':
+            return {
+                type: 'entity',
+                entity: input.entity,
+                offset: input.offset ? cloneVector3(input.offset) : undefined,
+            };
+        case 'entityBone':
+            return {
+                type: 'entityBone',
+                entity: input.entity,
+                bone: input.bone,
+                offset: input.offset ? cloneVector3(input.offset) : undefined,
+            };
+        case 'anchor':
+            return {
+                type: 'anchor',
+                name: input.name,
+                offset: input.offset ? cloneVector3(input.offset) : undefined,
+            };
+        case 'resolver':
+            return {
+                type: 'resolver',
+                resolve: input.resolve,
+            };
+    }
+}
+function cloneNode(input) {
+    return {
+        ...clonePosition(input),
+        rotation: input.rotation ? { ...input.rotation } : undefined,
+        fov: input.fov,
+    };
+}
+function toPosition(input) {
+    if (input instanceof NodeBuilder) {
+        return input.toPosition();
+    }
+    return clonePosition(input);
+}
+function toNode(input) {
+    if (input instanceof NodeBuilder) {
+        return input.build();
+    }
+    return cloneNode(input);
+}
+function toEffect(input) {
+    if (input instanceof EffectBuilder) {
+        return input.build();
+    }
+    return {
+        ...input,
+        params: input.params ? { ...input.params } : undefined,
+    };
+}
+export class EffectBuilder {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    window(fromMs, toMs) {
+        return new EffectBuilder({ ...this.value, fromMs, toMs });
+    }
+    from(fromMs) {
+        return new EffectBuilder({ ...this.value, fromMs });
+    }
+    to(toMs) {
+        return new EffectBuilder({ ...this.value, toMs });
+    }
+    build() {
+        return {
+            ...this.value,
+            params: this.value.params ? { ...this.value.params } : undefined,
+        };
+    }
+}
+export const Fx = {
+    effect(id, params) {
+        return new EffectBuilder({ id, params });
+    },
+    fadeIn(ms = 500) {
+        return new EffectBuilder({ id: 'fadeIn', params: { ms } });
+    },
+    fadeOut(ms = 500) {
+        return new EffectBuilder({ id: 'fadeOut', params: { ms } });
+    },
+    camShake(type = 'HAND_SHAKE', amplitude = 0.35) {
+        return new EffectBuilder({ id: 'camShake', params: { type, amplitude } });
+    },
+    timecycle(name = 'default', strength = 1) {
+        return new EffectBuilder({ id: 'timecycle', params: { name, strength } });
+    },
+    letterbox(top = 0.1, bottom = 0.1, alpha = 230) {
+        return new EffectBuilder({ id: 'letterbox', params: { top, bottom, alpha } });
+    },
+    subtitle(text, durationMs = 1000) {
+        return new EffectBuilder({ id: 'subtitle', params: { text, durationMs } });
+    },
+};
+export class NodeBuilder {
+    value;
+    rotationValue;
+    fovValue;
+    constructor(value) {
+        this.value = value;
+    }
+    offset(x, y, z) {
+        const apply = (source) => {
+            switch (source.type) {
+                case 'coords':
+                    return {
+                        type: 'coords',
+                        x: source.x + x,
+                        y: source.y + y,
+                        z: source.z + z,
+                    };
+                case 'entity':
+                    return {
+                        ...source,
+                        offset: {
+                            x: (source.offset?.x ?? 0) + x,
+                            y: (source.offset?.y ?? 0) + y,
+                            z: (source.offset?.z ?? 0) + z,
+                        },
+                    };
+                case 'entityBone':
+                    return {
+                        ...source,
+                        offset: {
+                            x: (source.offset?.x ?? 0) + x,
+                            y: (source.offset?.y ?? 0) + y,
+                            z: (source.offset?.z ?? 0) + z,
+                        },
+                    };
+                case 'anchor':
+                    return {
+                        ...source,
+                        offset: {
+                            x: (source.offset?.x ?? 0) + x,
+                            y: (source.offset?.y ?? 0) + y,
+                            z: (source.offset?.z ?? 0) + z,
+                        },
+                    };
+                case 'resolver':
+                    return {
+                        type: 'resolver',
+                        resolve: async () => {
+                            const resolved = await source.resolve();
+                            return { x: resolved.x + x, y: resolved.y + y, z: resolved.z + z };
+                        },
+                    };
+            }
+        };
+        const next = new NodeBuilder(apply(this.value));
+        next.rotationValue = this.rotationValue ? { ...this.rotationValue } : undefined;
+        next.fovValue = this.fovValue;
+        return next;
+    }
+    rot(x, y, z) {
+        const next = new NodeBuilder(clonePosition(this.value));
+        next.rotationValue = { x, y, z };
+        next.fovValue = this.fovValue;
+        return next;
+    }
+    fov(value) {
+        const next = new NodeBuilder(clonePosition(this.value));
+        next.rotationValue = this.rotationValue ? { ...this.rotationValue } : undefined;
+        next.fovValue = value;
+        return next;
+    }
+    build() {
+        return {
+            ...clonePosition(this.value),
+            rotation: this.rotationValue ? { ...this.rotationValue } : undefined,
+            fov: this.fovValue,
+        };
+    }
+    toPosition() {
+        return clonePosition(this.value);
+    }
+}
+export const Pos = {
+    coords(x, y, z) {
+        return new NodeBuilder({ type: 'coords', x, y, z });
+    },
+    entity(entity, offset) {
+        return new NodeBuilder({ type: 'entity', entity, offset });
+    },
+    entityBone(entity, bone, offset) {
+        return new NodeBuilder({ type: 'entityBone', entity, bone, offset });
+    },
+    anchor(name, offset) {
+        return new NodeBuilder({ type: 'anchor', name, offset });
+    },
+    resolver(resolve) {
+        return new NodeBuilder({ type: 'resolver', resolve });
+    },
+};
+export class ShotBuilder {
+    id;
+    shot;
+    constructor(id) {
+        this.id = id;
+        this.shot = {
+            id,
+            effects: [],
+        };
+    }
+    duration(durationMs) {
+        this.shot.durationMs = durationMs;
+        return this;
+    }
+    ease(ease) {
+        this.shot.ease = ease;
+        return this;
+    }
+    from(node) {
+        this.shot.from = toNode(node);
+        return this;
+    }
+    to(node) {
+        this.shot.to = toNode(node);
+        return this;
+    }
+    path(...nodes) {
+        this.shot.path = nodes.map(toNode);
+        return this;
+    }
+    lookAt(target, ...targets) {
+        const all = [target, ...targets];
+        if (all.length === 1) {
+            this.shot.lookAt = toPosition(all[0]);
+            return this;
+        }
+        this.shot.lookAt = all.map(toPosition);
+        return this;
+    }
+    effect(effect) {
+        if (!this.shot.effects) {
+            this.shot.effects = [];
+        }
+        this.shot.effects.push(toEffect(effect));
+        return this;
+    }
+    effects(...effects) {
+        for (const effect of effects) {
+            this.effect(effect);
+        }
+        return this;
+    }
+    build(defaults) {
+        const base = this.shot;
+        const resolvedEffects = [...(defaults?.effects?.map(toEffect) ?? []), ...(base.effects ?? [])];
+        const shot = {
+            id: base.id,
+            durationMs: base.durationMs,
+            waitMs: base.waitMs,
+            from: base.from ? cloneNode(base.from) : undefined,
+            to: base.to ? cloneNode(base.to) : undefined,
+            path: base.path ? base.path.map(cloneNode) : undefined,
+            lookAt: Array.isArray(base.lookAt)
+                ? base.lookAt.map((target) => clonePosition(target))
+                : base.lookAt
+                    ? clonePosition(base.lookAt)
+                    : defaults?.lookAt
+                        ? Array.isArray(defaults.lookAt)
+                            ? defaults.lookAt.map((target) => toPosition(target))
+                            : toPosition(defaults.lookAt)
+                        : undefined,
+            ease: base.ease ?? defaults?.ease,
+            effects: resolvedEffects.length > 0 ? resolvedEffects : undefined,
+        };
+        if (typeof defaults?.fov === 'number') {
+            if (shot.from && typeof shot.from.fov !== 'number') {
+                shot.from.fov = defaults.fov;
+            }
+            if (shot.to && typeof shot.to.fov !== 'number') {
+                shot.to.fov = defaults.fov;
+            }
+            if (shot.path) {
+                shot.path = shot.path.map((entry) => ({
+                    ...entry,
+                    fov: typeof entry.fov === 'number' ? entry.fov : defaults.fov,
+                }));
+            }
+        }
+        const defaultRotation = defaults?.rotation;
+        if (defaultRotation) {
+            if (shot.from && !shot.from.rotation) {
+                shot.from.rotation = { ...defaultRotation };
+            }
+            if (shot.to && !shot.to.rotation) {
+                shot.to.rotation = { ...defaultRotation };
+            }
+            if (shot.path) {
+                shot.path = shot.path.map((entry) => ({
+                    ...entry,
+                    rotation: entry.rotation ? { ...entry.rotation } : { ...defaultRotation },
+                }));
+            }
+        }
+        return shot;
+    }
+}
+export class SceneBuilder {
+    definition;
+    defaultsValue = {};
+    startFn;
+    listeners = new Map();
+    constructor(options = {}) {
+        this.definition = {
+            id: options.id,
+            shots: [],
+        };
+        this.startFn = options.start;
+    }
+    id(id) {
+        this.definition.id = id;
+        return this;
+    }
+    flags(flags) {
+        this.definition.skippable = flags.skippable ?? this.definition.skippable;
+        this.definition.freezePlayer = flags.freezePlayer ?? this.definition.freezePlayer;
+        this.definition.invinciblePlayer = flags.invinciblePlayer ?? this.definition.invinciblePlayer;
+        this.definition.hideHud = flags.hideHud ?? this.definition.hideHud;
+        this.definition.hideRadar = flags.hideRadar ?? this.definition.hideRadar;
+        return this;
+    }
+    skippable(value = true) {
+        this.definition.skippable = value;
+        return this;
+    }
+    freezePlayer(value = true) {
+        this.definition.freezePlayer = value;
+        return this;
+    }
+    invinciblePlayer(value = true) {
+        this.definition.invinciblePlayer = value;
+        return this;
+    }
+    hideHud(value = true) {
+        this.definition.hideHud = value;
+        return this;
+    }
+    hideRadar(value = true) {
+        this.definition.hideRadar = value;
+        return this;
+    }
+    defaults(defaults) {
+        this.defaultsValue = {
+            ...this.defaultsValue,
+            ...defaults,
+            rotation: defaults.rotation ?? this.defaultsValue.rotation,
+            lookAt: defaults.lookAt ?? this.defaultsValue.lookAt,
+            effects: defaults.effects ?? this.defaultsValue.effects,
+            fov: defaults.fov ?? this.defaultsValue.fov,
+            ease: defaults.ease ?? this.defaultsValue.ease,
+        };
+        return this;
+    }
+    anchor(name, position) {
+        if (!this.definition.anchors) {
+            this.definition.anchors = {};
+        }
+        this.definition.anchors[name] = cloneVector3(position);
+        return this;
+    }
+    anchors(anchors) {
+        for (const [name, position] of Object.entries(anchors)) {
+            this.anchor(name, position);
+        }
+        return this;
+    }
+    effect(effect) {
+        if (!this.definition.effects) {
+            this.definition.effects = [];
+        }
+        this.definition.effects.push(toEffect(effect));
+        return this;
+    }
+    effects(...effects) {
+        for (const effect of effects) {
+            this.effect(effect);
+        }
+        return this;
+    }
+    preset(id) {
+        if (!this.definition.effectPresets) {
+            this.definition.effectPresets = [];
+        }
+        this.definition.effectPresets.push(id);
+        return this;
+    }
+    presets(...ids) {
+        for (const id of ids) {
+            this.preset(id);
+        }
+        return this;
+    }
+    shot(idOrConfigure, configure) {
+        const id = typeof idOrConfigure === 'string' ? idOrConfigure : undefined;
+        const buildFn = typeof idOrConfigure === 'function' ? idOrConfigure : configure;
+        if (!buildFn) {
+            return this;
+        }
+        const builder = new ShotBuilder(id);
+        const configured = buildFn(builder);
+        const shotBuilder = configured instanceof ShotBuilder ? configured : builder;
+        this.definition.shots.push(shotBuilder.build(this.defaultsValue));
+        return this;
+    }
+    wait(idOrMs, waitMs) {
+        const id = typeof idOrMs === 'string' ? idOrMs : undefined;
+        const duration = typeof idOrMs === 'number' ? idOrMs : (waitMs ?? 0);
+        this.definition.shots.push({ id, waitMs: duration });
+        return this;
+    }
+    on(eventName, handler) {
+        const handlers = this.listeners.get(eventName) ?? new Set();
+        handlers.add(handler);
+        this.listeners.set(eventName, handlers);
+        return this;
+    }
+    build() {
+        return {
+            ...this.definition,
+            anchors: this.definition.anchors
+                ? Object.fromEntries(Object.entries(this.definition.anchors).map(([name, vector]) => [
+                    name,
+                    cloneVector3(vector),
+                ]))
+                : undefined,
+            effects: this.definition.effects?.map((effect) => toEffect(effect)),
+            effectPresets: this.definition.effectPresets ? [...this.definition.effectPresets] : undefined,
+            shots: this.definition.shots.map((shot) => ({
+                ...shot,
+                from: shot.from ? cloneNode(shot.from) : undefined,
+                to: shot.to ? cloneNode(shot.to) : undefined,
+                path: shot.path?.map(cloneNode),
+                lookAt: Array.isArray(shot.lookAt)
+                    ? shot.lookAt.map((target) => clonePosition(target))
+                    : shot.lookAt
+                        ? clonePosition(shot.lookAt)
+                        : undefined,
+                effects: shot.effects?.map((effect) => toEffect(effect)),
+            })),
+        };
+    }
+    start(options = {}) {
+        if (!this.startFn) {
+            throw new Error('SceneBuilder cannot start without a cinematic context. Use cinematic.scene().');
+        }
+        const handle = this.startFn(this, options);
+        for (const [eventName, handlers] of this.listeners.entries()) {
+            for (const handler of handlers) {
+                handle.on(eventName, handler);
+            }
+        }
+        return handle;
+    }
+}