@open-core/framework 1.0.4-beta.1 → 1.0.5-beta.2

package/dist/runtime/client/services/index.d.ts

@@ -0,0 +1,15 @@
+export * from './blip.service';
+export * from './camera';
+export * from './camera-effects.registry';
+export * from './cinematic-builder';
+export * from './cinematic';
+export * from './marker.service';
+export * from './notification.service';
+export * from './ped.service';
+export * from './progress.service';
+export * from './session-bridge.service';
+export * from './spawn.service';
+export * from './streaming.service';
+export * from './textui.service';
+export * from './vehicle.service';
+export * from './vehicle-client.service';

package/dist/runtime/client/services/index.js

@@ -0,0 +1,15 @@
+export * from './blip.service';
+export * from './camera';
+export * from './camera-effects.registry';
+export * from './cinematic-builder';
+export * from './cinematic';
+export * from './marker.service';
+export * from './notification.service';
+export * from './ped.service';
+export * from './progress.service';
+export * from './session-bridge.service';
+export * from './spawn.service';
+export * from './streaming.service';
+export * from './textui.service';
+export * from './vehicle.service';
+export * from './vehicle-client.service';

package/dist/runtime/client/services/marker.service.d.ts

@@ -0,0 +1,43 @@
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { IClientMarkerBridge, type ClientMarkerDefinition } from '../../../adapters/contracts/client/ui/IClientMarkerBridge';
+export interface MarkerOptions {
+    variant?: number;
+    type?: number;
+    size?: Vector3;
+    scale?: Vector3;
+    rotation?: Vector3;
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    bob?: boolean;
+    bobUpAndDown?: boolean;
+    faceCamera?: boolean;
+    rotate?: boolean;
+    drawOnEnts?: boolean;
+    visible?: boolean;
+}
+export interface ManagedMarker {
+    id: string;
+    definition: ClientMarkerDefinition;
+}
+export declare class MarkerService {
+    private readonly markers;
+    private activeMarkers;
+    private idCounter;
+    constructor(markers: IClientMarkerBridge);
+    create(position: Vector3, options?: MarkerOptions): string;
+    remove(id: string): boolean;
+    removeAll(): void;
+    setPosition(id: string, position: Vector3): boolean;
+    setOptions(id: string, options: Partial<MarkerOptions>): boolean;
+    setVisible(id: string, visible: boolean): boolean;
+    get(id: string): ManagedMarker | undefined;
+    getAll(): ManagedMarker[];
+    drawOnce(position: Vector3, options?: MarkerOptions): void;
+    exists(id: string): boolean;
+    private buildDefinition;
+    private normalizeOptions;
+}

package/dist/runtime/client/services/marker.service.js

@@ -0,0 +1,113 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IClientMarkerBridge, } from '../../../adapters/contracts/client/ui/IClientMarkerBridge';
+const DEFAULT_OPTIONS = {
+    variant: 1,
+    type: 1,
+    size: { x: 1.0, y: 1.0, z: 1.0 },
+    scale: { x: 1.0, y: 1.0, z: 1.0 },
+    rotation: { x: 0, y: 0, z: 0 },
+    color: { r: 255, g: 0, b: 0, a: 200 },
+    bob: false,
+    bobUpAndDown: false,
+    faceCamera: false,
+    rotate: false,
+    drawOnEnts: false,
+    visible: true,
+};
+let MarkerService = class MarkerService {
+    markers;
+    activeMarkers = new Map();
+    idCounter = 0;
+    constructor(markers) {
+        this.markers = markers;
+    }
+    create(position, options = {}) {
+        const id = `marker_${++this.idCounter}`;
+        const definition = this.buildDefinition(position, options);
+        this.markers.create(id, definition);
+        this.activeMarkers.set(id, {
+            id,
+            definition,
+        });
+        return id;
+    }
+    remove(id) {
+        const removed = this.markers.remove(id);
+        if (removed)
+            this.activeMarkers.delete(id);
+        return removed;
+    }
+    removeAll() {
+        this.markers.clear();
+        this.activeMarkers.clear();
+    }
+    setPosition(id, position) {
+        const marker = this.activeMarkers.get(id);
+        if (!marker)
+            return false;
+        const updated = this.markers.update(id, { position });
+        if (!updated)
+            return false;
+        marker.definition = { ...marker.definition, position };
+        return updated;
+    }
+    setOptions(id, options) {
+        const marker = this.activeMarkers.get(id);
+        if (!marker)
+            return false;
+        const patch = this.normalizeOptions(options);
+        const updated = this.markers.update(id, patch);
+        if (!updated)
+            return false;
+        marker.definition = { ...marker.definition, ...patch };
+        return updated;
+    }
+    setVisible(id, visible) {
+        return this.setOptions(id, { visible });
+    }
+    get(id) {
+        return this.activeMarkers.get(id);
+    }
+    getAll() {
+        return Array.from(this.activeMarkers.values());
+    }
+    drawOnce(position, options = {}) {
+        this.markers.draw(this.buildDefinition(position, options));
+    }
+    exists(id) {
+        return this.markers.exists(id);
+    }
+    buildDefinition(position, options) {
+        return {
+            position,
+            ...this.normalizeOptions({ ...DEFAULT_OPTIONS, ...options }),
+        };
+    }
+    normalizeOptions(options) {
+        const { type, variant, scale, size, bob, bobUpAndDown, ...rest } = options;
+        return {
+            ...rest,
+            variant: variant ?? type,
+            size: size ?? scale,
+            bob: bob ?? bobUpAndDown,
+        };
+    }
+};
+MarkerService = __decorate([
+    injectable(),
+    __param(0, inject(IClientMarkerBridge)),
+    __metadata("design:paramtypes", [IClientMarkerBridge])
+], MarkerService);
+export { MarkerService };

package/dist/runtime/client/services/notification.service.d.ts

@@ -0,0 +1,25 @@
+import { IClientNotificationBridge, type ClientNotificationDefinition } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+export type NotificationType = 'info' | 'success' | 'warning' | 'error';
+export interface AdvancedNotificationOptions {
+    title: string;
+    subtitle?: string;
+    message: string;
+    flash?: boolean;
+    saveToBrief?: boolean;
+    backgroundColor?: number;
+}
+export declare class NotificationService {
+    private readonly notifications;
+    private readonly platform;
+    constructor(notifications: IClientNotificationBridge, platform: IClientPlatformBridge);
+    show(message: string, blink?: boolean): void;
+    showWithType(message: string, type?: NotificationType): void;
+    showAdvanced(options: AdvancedNotificationOptions): void;
+    showHelp(message: string, duration?: number, beep?: boolean, looped?: boolean): void;
+    clearHelp(): void;
+    showSubtitle(message: string, duration?: number): void;
+    clearSubtitle(): void;
+    showFloatingHelp(message: string): void;
+    showRaw(definition: ClientNotificationDefinition): void;
+}

package/dist/runtime/client/services/notification.service.js

@@ -0,0 +1,70 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IClientNotificationBridge, } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+let NotificationService = class NotificationService {
+    notifications;
+    platform;
+    constructor(notifications, platform) {
+        this.notifications = notifications;
+        this.platform = platform;
+    }
+    show(message, blink = false) {
+        this.notifications.show({ kind: 'feed', message, blink, saveToBrief: true });
+    }
+    showWithType(message, type = 'info') {
+        this.notifications.show({ kind: 'typed', message, type });
+    }
+    showAdvanced(options) {
+        this.notifications.show({
+            kind: 'advanced',
+            title: options.title,
+            subtitle: options.subtitle,
+            message: options.message,
+            flash: options.flash,
+            saveToBrief: options.saveToBrief,
+            backgroundColor: options.backgroundColor,
+        });
+    }
+    showHelp(message, duration = 5000, beep = true, looped = false) {
+        this.notifications.show({ kind: 'help', message, duration, beep, looped });
+    }
+    clearHelp() {
+        this.notifications.clear('help');
+    }
+    showSubtitle(message, duration = 2500) {
+        this.notifications.show({ kind: 'subtitle', message, duration });
+    }
+    clearSubtitle() {
+        this.notifications.clear('subtitle');
+    }
+    showFloatingHelp(message) {
+        this.notifications.show({
+            kind: 'floating',
+            message,
+            worldPosition: this.platform.getEntityCoords(this.platform.getLocalPlayerPed()),
+        });
+    }
+    showRaw(definition) {
+        this.notifications.show(definition);
+    }
+};
+NotificationService = __decorate([
+    injectable(),
+    __param(0, inject(IClientNotificationBridge)),
+    __param(1, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [IClientNotificationBridge,
+        IClientPlatformBridge])
+], NotificationService);
+export { NotificationService };

package/dist/runtime/client/services/ped.service.d.ts

@@ -0,0 +1,55 @@
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+export interface PedSpawnOptions {
+    model: string;
+    position: Vector3;
+    heading?: number;
+    networked?: boolean;
+    missionEntity?: boolean;
+    relationshipGroup?: string;
+    blockEvents?: boolean;
+}
+export interface PedAnimationOptions {
+    dict: string;
+    anim: string;
+    blendInSpeed?: number;
+    blendOutSpeed?: number;
+    duration?: number;
+    flags?: number;
+    playbackRate?: number;
+}
+export interface ManagedPed {
+    id: string;
+    handle: number;
+    model: string;
+    position: Vector3;
+}
+export declare class PedService {
+    private readonly platform;
+    private peds;
+    private idCounter;
+    constructor(platform: IClientPlatformBridge);
+    spawn(options: PedSpawnOptions): Promise<{
+        id: string;
+        handle: number;
+    }>;
+    delete(id: string): boolean;
+    deleteByHandle(handle: number): void;
+    deleteAll(): void;
+    playAnimation(handle: number, options: PedAnimationOptions): Promise<void>;
+    stopAnimation(handle: number): void;
+    stopAnimationImmediately(handle: number): void;
+    freeze(handle: number, freeze: boolean): void;
+    setInvincible(handle: number, invincible: boolean): void;
+    giveWeapon(handle: number, weapon: string, ammo?: number, hidden?: boolean, forceInHand?: boolean): void;
+    removeAllWeapons(handle: number): void;
+    getClosest(radius?: number, excludePlayer?: boolean): number | null;
+    getNearby(position: Vector3, radius: number, excludePlayer?: boolean): number[];
+    lookAtEntity(handle: number, entity: number, duration?: number): void;
+    lookAtCoords(handle: number, position: Vector3, duration?: number): void;
+    walkTo(handle: number, position: Vector3, speed?: number): void;
+    setCombatAttributes(handle: number, canFight: boolean, canUseCover?: boolean): void;
+    get(id: string): ManagedPed | undefined;
+    getAll(): ManagedPed[];
+    exists(id: string): boolean;
+}

package/dist/runtime/client/services/ped.service.js

@@ -0,0 +1,166 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+let PedService = class PedService {
+    platform;
+    peds = new Map();
+    idCounter = 0;
+    constructor(platform) {
+        this.platform = platform;
+    }
+    async spawn(options) {
+        const { model, position, heading = 0, networked = false, missionEntity = true, blockEvents = true, } = options;
+        const modelHash = this.platform.getHashKey(model);
+        if (!this.platform.isModelInCdimage(modelHash) || !this.platform.isModelValid(modelHash)) {
+            throw new Error(`Invalid ped model: ${model}`);
+        }
+        this.platform.requestModel(modelHash);
+        while (!this.platform.hasModelLoaded(modelHash)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        const ped = this.platform.createPed(4, modelHash, position, heading, networked, true);
+        this.platform.setModelAsNoLongerNeeded(modelHash);
+        if (!ped || ped === 0)
+            throw new Error('Failed to create ped');
+        if (missionEntity)
+            this.platform.setEntityAsMissionEntity(ped, true, true);
+        if (blockEvents)
+            this.platform.setBlockingOfNonTemporaryEvents(ped, true);
+        this.platform.setPedRelationshipGroupHash(ped, this.platform.getHashKey('CIVMALE'));
+        const id = `ped_${++this.idCounter}`;
+        this.peds.set(id, { id, handle: ped, model, position });
+        return { id, handle: ped };
+    }
+    delete(id) {
+        const ped = this.peds.get(id);
+        if (!ped)
+            return false;
+        if (this.platform.doesEntityExist(ped.handle)) {
+            this.platform.setEntityAsMissionEntity(ped.handle, true, true);
+            this.platform.deletePed(ped.handle);
+        }
+        this.peds.delete(id);
+        return true;
+    }
+    deleteByHandle(handle) {
+        if (this.platform.doesEntityExist(handle)) {
+            this.platform.setEntityAsMissionEntity(handle, true, true);
+            this.platform.deletePed(handle);
+        }
+        for (const [id, ped] of this.peds) {
+            if (ped.handle === handle) {
+                this.peds.delete(id);
+                break;
+            }
+        }
+    }
+    deleteAll() {
+        for (const ped of this.peds.values()) {
+            if (this.platform.doesEntityExist(ped.handle)) {
+                this.platform.setEntityAsMissionEntity(ped.handle, true, true);
+                this.platform.deletePed(ped.handle);
+            }
+        }
+        this.peds.clear();
+    }
+    async playAnimation(handle, options) {
+        const { dict, anim, blendInSpeed = 8.0, blendOutSpeed = -8.0, duration = -1, flags = 1, playbackRate = 0.0, } = options;
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.requestAnimDict(dict);
+        while (!this.platform.hasAnimDictLoaded(dict)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        this.platform.taskPlayAnim(handle, dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate);
+    }
+    stopAnimation(handle) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.clearPedTasks(handle);
+    }
+    stopAnimationImmediately(handle) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.clearPedTasksImmediately(handle);
+    }
+    freeze(handle, freeze) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.freezeEntityPosition(handle, freeze);
+    }
+    setInvincible(handle, invincible) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.setEntityInvincible(handle, invincible);
+    }
+    giveWeapon(handle, weapon, ammo = 100, hidden = false, forceInHand = true) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.giveWeaponToPed(handle, this.platform.getHashKey(weapon), ammo, hidden, forceInHand);
+    }
+    removeAllWeapons(handle) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.removeAllPedWeapons(handle, true);
+    }
+    getClosest(radius = 10.0, excludePlayer = true) {
+        const playerPed = this.platform.getLocalPlayerPed();
+        const handle = this.platform.getClosestPed(this.platform.getEntityCoords(playerPed), radius);
+        if (!handle)
+            return null;
+        if (excludePlayer && handle === playerPed)
+            return null;
+        return handle;
+    }
+    getNearby(position, radius, excludePlayer = true) {
+        return this.platform.getNearbyPeds(position, radius, excludePlayer ? this.platform.getLocalPlayerPed() : undefined);
+    }
+    lookAtEntity(handle, entity, duration = -1) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.taskLookAtEntity(handle, entity, duration);
+    }
+    lookAtCoords(handle, position, duration = -1) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.taskLookAtCoord(handle, position, duration);
+    }
+    walkTo(handle, position, speed = 1.0) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.taskGoStraightToCoord(handle, position, speed);
+    }
+    setCombatAttributes(handle, canFight, canUseCover = true) {
+        if (!this.platform.doesEntityExist(handle))
+            return;
+        this.platform.setPedCombatAttributes(handle, 46, canFight);
+        this.platform.setPedCombatAttributes(handle, 0, canUseCover);
+    }
+    get(id) {
+        return this.peds.get(id);
+    }
+    getAll() {
+        return Array.from(this.peds.values());
+    }
+    exists(id) {
+        const ped = this.peds.get(id);
+        return ped ? this.platform.doesEntityExist(ped.handle) : false;
+    }
+};
+PedService = __decorate([
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge])
+], PedService);
+export { PedService };

package/dist/runtime/client/services/progress.service.d.ts

@@ -0,0 +1,57 @@
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+export interface ProgressOptions {
+    label: string;
+    duration: number;
+    useCircular?: boolean;
+    canCancel?: boolean;
+    disableControls?: boolean;
+    disableMovement?: boolean;
+    disableCombat?: boolean;
+    animation?: {
+        dict: string;
+        anim: string;
+        flags?: number;
+    };
+    prop?: {
+        model: string;
+        bone: number;
+        offset: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+export interface ProgressState {
+    active: boolean;
+    progress: number;
+    label: string;
+    startTime: number;
+    duration: number;
+    options: ProgressOptions;
+}
+export declare class ProgressService {
+    private readonly platform;
+    private readonly runtime;
+    private state;
+    private tickHandle;
+    private callback;
+    private propHandle;
+    constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
+    start(options: ProgressOptions): Promise<boolean>;
+    cancel(): void;
+    isActive(): boolean;
+    getProgress(): number;
+    getState(): ProgressState | null;
+    private startProgress;
+    private drawProgressBar;
+    private cleanup;
+    private loadAnimDict;
+    private loadModel;
+}