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

package/dist/client/player/player.js

@@ -1,480 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientPlayer = void 0;
-/**
- * Client-side player representation with convenient accessors and methods.
- */
-class Player {
-    constructor() {
-        this.meta = {};
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Core Getters
-    // ─────────────────────────────────────────────────────────────────────────────
-    /** Get the player's ped handle */
-    get ped() {
-        return PlayerPedId();
-    }
-    /** Get the player ID */
-    get id() {
-        return PlayerId();
-    }
-    /** Get the server ID (source) */
-    get serverId() {
-        return GetPlayerServerId(this.id);
-    }
-    /** Get the player's current coordinates */
-    get coords() {
-        const [x, y, z] = GetEntityCoords(this.ped, false);
-        return { x, y, z };
-    }
-    /** Get the player's current heading (rotation) */
-    get heading() {
-        return GetEntityHeading(this.ped);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Health & Status
-    // ─────────────────────────────────────────────────────────────────────────────
-    /** Get current health (0-200, 100 = dead) */
-    get health() {
-        return GetEntityHealth(this.ped);
-    }
-    /** Get max health */
-    get maxHealth() {
-        return GetEntityMaxHealth(this.ped);
-    }
-    /** Get current armor (0-100) */
-    get armor() {
-        return GetPedArmour(this.ped);
-    }
-    /** Check if the player is dead */
-    get isDead() {
-        return IsEntityDead(this.ped);
-    }
-    /** Check if player is in water */
-    get isInWater() {
-        return IsEntityInWater(this.ped);
-    }
-    /** Check if player is swimming */
-    get isSwimming() {
-        return IsPedSwimming(this.ped);
-    }
-    /** Check if player is falling */
-    get isFalling() {
-        return IsPedFalling(this.ped);
-    }
-    /** Check if player is climbing */
-    get isClimbing() {
-        return IsPedClimbing(this.ped);
-    }
-    /** Check if player is ragdolling */
-    get isRagdoll() {
-        return IsPedRagdoll(this.ped);
-    }
-    /** Check if player is parachuting */
-    get isParachuting() {
-        return IsPedInParachuteFreeFall(this.ped);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Vehicle State
-    // ─────────────────────────────────────────────────────────────────────────────
-    /** Check if player is in any vehicle */
-    get isInVehicle() {
-        return IsPedInAnyVehicle(this.ped, false);
-    }
-    /** Get current vehicle handle (or null if not in vehicle) */
-    get currentVehicle() {
-        if (!this.isInVehicle)
-            return null;
-        return GetVehiclePedIsIn(this.ped, false);
-    }
-    /** Get last vehicle the player was in */
-    get lastVehicle() {
-        const vehicle = GetVehiclePedIsIn(this.ped, true);
-        return vehicle !== 0 ? vehicle : null;
-    }
-    /** Check if player is the driver of current vehicle */
-    get isDriver() {
-        const vehicle = this.currentVehicle;
-        if (!vehicle)
-            return false;
-        return GetPedInVehicleSeat(vehicle, -1) === this.ped;
-    }
-    /** Get current vehicle seat index (-1 = driver, 0+ = passengers) */
-    get vehicleSeat() {
-        const vehicle = this.currentVehicle;
-        if (!vehicle)
-            return null;
-        for (let seat = -1; seat < GetVehicleMaxNumberOfPassengers(vehicle); seat++) {
-            if (GetPedInVehicleSeat(vehicle, seat) === this.ped) {
-                return seat;
-            }
-        }
-        return null;
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Combat State
-    // ─────────────────────────────────────────────────────────────────────────────
-    /** Check if player is shooting */
-    get isShooting() {
-        return IsPedShooting(this.ped);
-    }
-    /** Check if player is aiming */
-    get isAiming() {
-        return IsPlayerFreeAiming(this.id);
-    }
-    /** Check if player is reloading */
-    get isReloading() {
-        return IsPedReloading(this.ped);
-    }
-    /** Check if player is in cover */
-    get isInCover() {
-        return IsPedInCover(this.ped, false);
-    }
-    /** Check if player is in melee combat */
-    get isInMeleeCombat() {
-        return IsPedInMeleeCombat(this.ped);
-    }
-    /** Get currently equipped weapon hash */
-    get currentWeapon() {
-        const [_, weaponHash] = GetCurrentPedWeapon(this.ped, true);
-        return weaponHash;
-    }
-    /** Get ammo count for current weapon */
-    get currentWeaponAmmo() {
-        return GetAmmoInPedWeapon(this.ped, this.currentWeapon);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Movement State
-    // ─────────────────────────────────────────────────────────────────────────────
-    /** Check if player is walking */
-    get isWalking() {
-        return IsPedWalking(this.ped);
-    }
-    /** Check if player is running */
-    get isRunning() {
-        return IsPedRunning(this.ped);
-    }
-    /** Check if player is sprinting */
-    get isSprinting() {
-        return IsPedSprinting(this.ped);
-    }
-    /** Check if player is on foot */
-    get isOnFoot() {
-        return IsPedOnFoot(this.ped);
-    }
-    /** Check if player is stationary */
-    get isStill() {
-        return IsPedStill(this.ped);
-    }
-    /** Get movement speed in m/s */
-    get speed() {
-        return GetEntitySpeed(this.ped);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Health & Armor Setters
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Set player health.
-     * @param value - Health value (100 = dead, 200 = full)
-     */
-    setHealth(value) {
-        SetEntityHealth(this.ped, value);
-    }
-    /**
-     * Set player armor.
-     * @param value - Armor value (0-100)
-     */
-    setArmor(value) {
-        SetPedArmour(this.ped, Math.max(0, Math.min(100, value)));
-    }
-    /**
-     * Heal the player to full health and armor.
-     */
-    heal() {
-        this.setHealth(this.maxHealth);
-        this.setArmor(100);
-    }
-    /**
-     * Revive the player at current position.
-     */
-    revive() {
-        const coords = this.coords;
-        NetworkResurrectLocalPlayer(coords.x, coords.y, coords.z, this.heading, 1, false);
-        this.heal();
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Position & Movement
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Set player coordinates.
-     * @param vector3 - Target position
-     * @param heading - Optional heading
-     */
-    setCoords(vector3, heading) {
-        SetEntityCoordsNoOffset(this.ped, vector3.x, vector3.y, vector3.z, false, false, false);
-        if (heading !== undefined) {
-            SetEntityHeading(this.ped, heading);
-        }
-    }
-    /**
-     * Set player heading/rotation.
-     * @param heading - Heading in degrees
-     */
-    setHeading(heading) {
-        SetEntityHeading(this.ped, heading);
-    }
-    /**
-     * Freeze/unfreeze the player in place.
-     * @param freeze - Whether to freeze
-     */
-    freeze(freeze) {
-        FreezeEntityPosition(this.ped, freeze);
-    }
-    /**
-     * Set player invincibility.
-     * @param invincible - Whether invincible
-     */
-    setInvincible(invincible) {
-        SetEntityInvincible(this.ped, invincible);
-    }
-    /**
-     * Set player visibility.
-     * @param visible - Whether visible
-     */
-    setVisible(visible) {
-        SetEntityVisible(this.ped, visible, false);
-    }
-    /**
-     * Set player alpha/transparency.
-     * @param alpha - Alpha value (0-255)
-     */
-    setAlpha(alpha) {
-        SetEntityAlpha(this.ped, alpha, false);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Weapons
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Give a weapon to the player.
-     * @param weapon - Weapon name (e.g., 'WEAPON_PISTOL')
-     * @param ammo - Ammo count
-     * @param equipNow - Whether to equip immediately
-     */
-    giveWeapon(weapon, ammo = 100, equipNow = true) {
-        const weaponHash = GetHashKey(weapon);
-        GiveWeaponToPed(this.ped, weaponHash, ammo, false, equipNow);
-    }
-    /**
-     * Remove a weapon from the player.
-     * @param weapon - Weapon name
-     */
-    removeWeapon(weapon) {
-        const weaponHash = GetHashKey(weapon);
-        RemoveWeaponFromPed(this.ped, weaponHash);
-    }
-    /**
-     * Remove all weapons from the player.
-     */
-    removeAllWeapons() {
-        RemoveAllPedWeapons(this.ped, true);
-    }
-    /**
-     * Set current weapon ammo.
-     * @param weapon - Weapon name
-     * @param ammo - Ammo count
-     */
-    setWeaponAmmo(weapon, ammo) {
-        const weaponHash = GetHashKey(weapon);
-        SetPedAmmo(this.ped, weaponHash, ammo);
-    }
-    /**
-     * Check if player has a specific weapon.
-     * @param weapon - Weapon name
-     */
-    hasWeapon(weapon) {
-        const weaponHash = GetHashKey(weapon);
-        return HasPedGotWeapon(this.ped, weaponHash, false);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Animations & Tasks
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Play an animation on the player.
-     * @param dict - Animation dictionary
-     * @param name - Animation name
-     * @param duration - Duration (-1 for looped)
-     * @param flags - Animation flags
-     */
-    async playAnimation(dict, name, duration = -1, flags = 1) {
-        RequestAnimDict(dict);
-        while (!HasAnimDictLoaded(dict)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-        TaskPlayAnim(this.ped, dict, name, 8.0, -8.0, duration, flags, 0.0, false, false, false);
-    }
-    /**
-     * Stop current animation.
-     */
-    stopAnimation() {
-        ClearPedTasks(this.ped);
-    }
-    /**
-     * Stop animation immediately.
-     */
-    stopAnimationImmediately() {
-        ClearPedTasksImmediately(this.ped);
-    }
-    /**
-     * Check if player is playing a specific animation.
-     * @param dict - Animation dictionary
-     * @param name - Animation name
-     */
-    isPlayingAnimation(dict, name) {
-        return IsEntityPlayingAnim(this.ped, dict, name, 3);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Vehicle Interaction
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Warp player into a vehicle.
-     * @param vehicle - Vehicle handle
-     * @param seat - Seat index (-1 = driver)
-     */
-    warpIntoVehicle(vehicle, seat = -1) {
-        TaskWarpPedIntoVehicle(this.ped, vehicle, seat);
-    }
-    /**
-     * Task player to exit current vehicle.
-     * @param flags - Exit flags (0 = normal, 16 = immediately)
-     */
-    exitVehicle(flags = 0) {
-        const vehicle = this.currentVehicle;
-        if (vehicle) {
-            TaskLeaveVehicle(this.ped, vehicle, flags);
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Ped Flags & Properties
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Set can ragdoll.
-     * @param canRagdoll - Whether player can ragdoll
-     */
-    setCanRagdoll(canRagdoll) {
-        SetPedCanRagdoll(this.ped, canRagdoll);
-    }
-    /**
-     * Set ped config flag.
-     * @param flag - Flag ID
-     * @param value - Flag value
-     */
-    setConfigFlag(flag, value) {
-        SetPedConfigFlag(this.ped, flag, value);
-    }
-    /**
-     * Get ped config flag.
-     * @param flag - Flag ID
-     */
-    getConfigFlag(flag) {
-        return GetPedConfigFlag(this.ped, flag, true);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Meta Storage
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Set a metadata value.
-     * @param key - Meta key
-     * @param value - Meta value
-     */
-    setMeta(key, value) {
-        this.meta[key] = value;
-    }
-    /**
-     * Get a metadata value.
-     * @param key - Meta key
-     */
-    getMeta(key) {
-        return this.meta[key];
-    }
-    /**
-     * Delete a metadata value.
-     * @param key - Meta key
-     */
-    deleteMeta(key) {
-        delete this.meta[key];
-    }
-    /**
-     * Get all metadata.
-     */
-    getAllMeta() {
-        return Object.assign({}, this.meta);
-    }
-    /**
-     * Clear all metadata.
-     */
-    clearMeta() {
-        this.meta = {};
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Utility Methods
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Get distance to a position.
-     * @param position - Target position
-     */
-    distanceTo(position) {
-        const coords = this.coords;
-        return Math.sqrt(Math.pow(coords.x - position.x, 2) +
-            Math.pow(coords.y - position.y, 2) +
-            Math.pow(coords.z - position.z, 2));
-    }
-    /**
-     * Check if player is within range of a position.
-     * @param position - Target position
-     * @param range - Maximum range
-     */
-    isNearPosition(position, range) {
-        return this.distanceTo(position) <= range;
-    }
-    /**
-     * Get the entity the player is looking at.
-     * @param maxDistance - Maximum detection distance
-     */
-    getEntityLookingAt(maxDistance = 10.0) {
-        const [hit, entity] = GetEntityPlayerIsFreeAimingAt(this.id);
-        if (!hit || !entity || entity === 0)
-            return null;
-        const coords = this.coords;
-        const entityCoords = GetEntityCoords(entity, true);
-        const distance = Math.sqrt(Math.pow(coords.x - entityCoords[0], 2) +
-            Math.pow(coords.y - entityCoords[1], 2) +
-            Math.pow(coords.z - entityCoords[2], 2));
-        return distance <= maxDistance ? entity : null;
-    }
-    /**
-     * Disable a control action.
-     * @param control - Control ID
-     * @param padIndex - Pad index (usually 0)
-     */
-    disableControl(control, padIndex = 0) {
-        DisableControlAction(padIndex, control, true);
-    }
-    /**
-     * Check if a control is pressed.
-     * @param control - Control ID
-     * @param padIndex - Pad index (usually 0)
-     */
-    isControlPressed(control, padIndex = 0) {
-        return IsControlPressed(padIndex, control);
-    }
-    /**
-     * Check if a control was just pressed.
-     * @param control - Control ID
-     * @param padIndex - Pad index (usually 0)
-     */
-    isControlJustPressed(control, padIndex = 0) {
-        return IsControlJustPressed(padIndex, control);
-    }
-}
-exports.ClientPlayer = new Player();

package/dist/client/player/player.loader.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.playerClientLoader = void 0;
-const utils_1 = require("../../utils");
-const player_1 = require("./player");
-const logger_1 = require("../../shared/logger");
-const clientSession = logger_1.coreLogger.child('Session', logger_1.LogDomain.CLIENT);
-const playerClientLoader = () => {
-    on('onClientResourceStart', (resourceName) => {
-        if (resourceName !== GetCurrentResourceName())
-            return;
-        clientSession.debug('Client player loader initialized');
-    });
-    onNet('core:playerSessionInit', (data) => {
-        player_1.ClientPlayer.setMeta('playerId', data.playerId);
-        clientSession.info('Player session initialized', { playerId: data.playerId });
-    });
-    onNet('core:teleportTo', (x, y, z, heading) => {
-        player_1.ClientPlayer.setCoords(utils_1.Vec3.create(x, y, z), heading);
-    });
-};
-exports.playerClientLoader = playerClientLoader;

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

@@ -1 +0,0 @@
-export * from './spawn.service';

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

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./spawn.service"), exports);

package/dist/client/services/core/spawn.service.d.ts

@@ -1,20 +0,0 @@
-import { Vector3 } from '../../../utils';
-export declare class Spawner {
-    private spawned;
-    init(): Promise<void>;
-    handleSpawn(data: {
-        position: Vector3;
-        model: string;
-    }): Promise<void>;
-    handleRespawn(position: Vector3, heading?: number): Promise<void>;
-    handleTeleport(position: Vector3, heading?: number): Promise<void>;
-    spawn(position: Vector3, model: string, heading?: number): Promise<void>;
-    teleportTo(position: Vector3, heading?: number): Promise<void>;
-    respawn(position: Vector3, heading?: number): Promise<void>;
-    isSpawned(): boolean;
-    private ensureNetworkReady;
-    private closeLoadingScreens;
-    private setPlayerModel;
-    private ensurePed;
-    private placePed;
-}

package/dist/client/services/core/spawn.service.js

@@ -1,143 +0,0 @@
-"use strict";
-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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Spawner = void 0;
-const tsyringe_1 = require("tsyringe");
-const onNet_1 = require("../../decorators/onNet");
-const logger_1 = require("../../../shared/logger");
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-let Spawner = class Spawner {
-    constructor() {
-        this.spawned = false;
-    }
-    async init() {
-        logger_1.loggers.spawn.debug('SpawnService initialized');
-    }
-    async handleSpawn(data) {
-        await this.spawn(data.position, data.model);
-    }
-    async handleRespawn(position, heading = 0.0) {
-        await this.respawn(position, heading);
-    }
-    async handleTeleport(position, heading) {
-        await this.teleportTo(position, heading);
-    }
-    async spawn(position, model, heading = 0.0) {
-        logger_1.loggers.spawn.info('First spawn requested', {
-            position: { x: position.x, y: position.y, z: position.z },
-            model,
-        });
-        await this.ensureNetworkReady();
-        this.closeLoadingScreens();
-        await this.setPlayerModel(model);
-        const ped = await this.ensurePed();
-        await this.placePed(ped, position, heading);
-        this.spawned = true;
-        logger_1.loggers.spawn.info('Player spawned successfully (first spawn)');
-    }
-    async teleportTo(position, heading) {
-        const ped = await this.ensurePed();
-        FreezeEntityPosition(ped, true);
-        SetEntityCoordsNoOffset(ped, position.x, position.y, position.z, false, false, false);
-        if (heading !== undefined) {
-            SetEntityHeading(ped, heading);
-        }
-        FreezeEntityPosition(ped, false);
-        logger_1.loggers.spawn.debug('Teleported', {
-            position: { x: position.x, y: position.y, z: position.z },
-        });
-    }
-    async respawn(position, heading = 0.0) {
-        const ped = await this.ensurePed();
-        ClearPedTasksImmediately(ped);
-        SetEntityHealth(ped, GetEntityMaxHealth(ped));
-        await this.teleportTo(position, heading);
-        logger_1.loggers.spawn.info('Player respawned', {
-            position: { x: position.x, y: position.y, z: position.z },
-        });
-    }
-    isSpawned() {
-        return this.spawned;
-    }
-    async ensureNetworkReady() {
-        while (!NetworkIsSessionStarted()) {
-            await delay(0);
-        }
-    }
-    closeLoadingScreens() {
-        try {
-            ShutdownLoadingScreen();
-        }
-        catch (_a) { }
-        try {
-            ShutdownLoadingScreenNui();
-        }
-        catch (_b) { }
-    }
-    async setPlayerModel(model) {
-        const modelHash = GetHashKey(model);
-        if (!IsModelInCdimage(modelHash) || !IsModelValid(modelHash)) {
-            logger_1.loggers.spawn.error(`Invalid model requested`, { model });
-            throw new Error('MODEL_INVALID');
-        }
-        RequestModel(modelHash);
-        while (!HasModelLoaded(modelHash)) {
-            await delay(0);
-        }
-        SetPlayerModel(PlayerId(), modelHash);
-        SetModelAsNoLongerNeeded(modelHash);
-    }
-    async ensurePed() {
-        let ped = PlayerPedId();
-        while (ped === 0) {
-            await delay(0);
-            ped = PlayerPedId();
-        }
-        return ped;
-    }
-    async placePed(ped, position, heading) {
-        FreezeEntityPosition(ped, true);
-        SetEntityCoordsNoOffset(ped, position.x, position.y, position.z, false, false, false);
-        SetEntityHeading(ped, heading);
-        ResetEntityAlpha(ped);
-        SetEntityVisible(ped, true, false);
-        SetEntityCollision(ped, true, true);
-        SetEntityInvincible(ped, false);
-        ClearPedTasksImmediately(ped);
-        RemoveAllPedWeapons(ped, true);
-        FreezeEntityPosition(ped, false);
-        if (!IsScreenFadedIn() && !IsScreenFadingIn()) {
-            DoScreenFadeIn(500);
-        }
-    }
-};
-exports.Spawner = Spawner;
-__decorate([
-    (0, onNet_1.OnNet)('core:spawner:spawn'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Spawner.prototype, "handleSpawn", null);
-__decorate([
-    (0, onNet_1.OnNet)('core:spawner:respawn'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], Spawner.prototype, "handleRespawn", null);
-__decorate([
-    (0, onNet_1.OnNet)('core:spawner:teleport'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Number]),
-    __metadata("design:returntype", Promise)
-], Spawner.prototype, "handleTeleport", null);
-exports.Spawner = Spawner = __decorate([
-    (0, tsyringe_1.injectable)()
-], Spawner);

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

@@ -1,4 +0,0 @@
-export * from './core';
-export * from './ui';
-export * from './world';
-export * from './streaming';