@nativewrappers/fivem 0.0.1

package/lib/client/weaponComponent/DlcWeaponComponentData.js

@@ -0,0 +1,44 @@
+import { getStringFromUInt8Array, getUInt32FromUint8Array } from '../utils';
+/**
+ * DlcWeaponComponentData
+ *
+ */
+export const DlcWeaponComponentData = new Map();
+/**
+ * Initialize DlcWeaponComponentData, avoid calling expansive native repeatedly
+ *
+ */
+function initializeOnce() {
+    let isInitialized = false;
+    return function () {
+        if (isInitialized || IsDuplicityVersion()) {
+            return;
+        }
+        // magic number based on struct DlcWeaponData
+        const intLength = 4;
+        const strLength = 64;
+        const weaponCount = GetNumDlcWeapons();
+        for (let i = 0; i < weaponCount; i++) {
+            const componentCount = GetNumDlcWeaponComponents(i);
+            for (let j = 0; j < componentCount; j++) {
+                const buffer = new Uint8Array(14 * intLength + 4 * strLength);
+                // https://docs.fivem.net/natives/?_0x6CF598A2957C2BF8
+                Citizen.invokeNative('0x6CF598A2957C2BF8', i, j, buffer, Citizen.returnResultAnyway());
+                // noinspection PointlessArithmeticExpressionJS
+                const dlcWeaponComponentData = {
+                    attachBone: getUInt32FromUint8Array(buffer, 0 * intLength, 1 * intLength),
+                    bActiveByDefault: getUInt32FromUint8Array(buffer, 2 * intLength, 3 * intLength),
+                    unk: getUInt32FromUint8Array(buffer, 4 * intLength, 5 * intLength),
+                    componentHash: getUInt32FromUint8Array(buffer, 6 * intLength, 7 * intLength),
+                    unk2: getUInt32FromUint8Array(buffer, 8 * intLength, 9 * intLength),
+                    componentCost: getUInt32FromUint8Array(buffer, 10 * intLength, 11 * intLength),
+                    name: getStringFromUInt8Array(buffer, 12 * intLength, 12 * intLength + strLength),
+                    desc: getStringFromUInt8Array(buffer, 12 * intLength + strLength, 12 * intLength + 2 * strLength),
+                };
+                DlcWeaponComponentData.set(dlcWeaponComponentData.componentHash, dlcWeaponComponentData);
+            }
+        }
+        isInitialized = true;
+    };
+}
+initializeOnce()();

package/lib/client/weaponComponent/InvalidWeaponComponent.d.ts

@@ -0,0 +1,12 @@
+import { WeaponComponent } from './WeaponComponent';
+import { WeaponComponentHash } from './WeaponComponentHash';
+import { WeaponHash } from '../hashes';
+import { ComponentAttachmentPoint } from './ComponentAttachmentPoint';
+export declare class InvalidWeaponComponent extends WeaponComponent {
+    constructor();
+    get Active(): boolean;
+    set Active(value: boolean);
+    get DisplayName(): string;
+    get LocalizedName(): string;
+    static getAttachmentPoint(hash: WeaponHash, componentHash: WeaponComponentHash): ComponentAttachmentPoint;
+}

package/lib/client/weaponComponent/InvalidWeaponComponent.js

@@ -0,0 +1,28 @@
+import { WeaponComponent } from './WeaponComponent';
+import { WeaponComponentHash } from './WeaponComponentHash';
+import { ComponentAttachmentPoint } from './ComponentAttachmentPoint';
+import { Game } from '../Game';
+export class InvalidWeaponComponent extends WeaponComponent {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        super(null, null, WeaponComponentHash.Invalid);
+    }
+    get Active() {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    set Active(value) { }
+    get DisplayName() {
+        return 'WCT_INVALID';
+    }
+    get LocalizedName() {
+        return Game.getGXTEntry(this.DisplayName);
+    }
+    static getAttachmentPoint(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hash, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    componentHash) {
+        return ComponentAttachmentPoint.Invalid;
+    }
+}

package/lib/client/weaponComponent/WeaponComponent.d.ts

@@ -0,0 +1,81 @@
+import { Ped } from '../models';
+import { Weapon } from '../weapon';
+import { WeaponComponentHash } from './WeaponComponentHash';
+import { WeaponHash } from '../hashes';
+import { ComponentAttachmentPoint } from './ComponentAttachmentPoint';
+import { WeaponComponentHudStats } from './WeaponComponentHudStats';
+/**
+ * ped weapon component on weapon
+ *
+ */
+export declare class WeaponComponent {
+    protected readonly owner: Ped;
+    protected readonly weapon: Weapon;
+    protected readonly componentHash: WeaponComponentHash;
+    constructor(owner: Ped, weapon: Weapon, componentHash: WeaponComponentHash);
+    /**
+     * Check WeaponComponent is invalid or not
+     *
+     * @constructor
+     */
+    get IsInvalid(): boolean;
+    /**
+     * get component hash
+     *
+     * @constructor
+     */
+    get ComponentHash(): WeaponComponentHash;
+    /**
+     * check ped has weapon component
+     *
+     * @constructor
+     */
+    get Active(): boolean;
+    /**
+     * give weapon component to ped
+     *
+     * @param value
+     * @constructor
+     */
+    set Active(value: boolean);
+    /**
+     * get component display name / label
+     *
+     * @constructor
+     */
+    get DisplayName(): string;
+    /**
+     * get component localized name
+     *
+     * @constructor
+     */
+    get LocalizedName(): string;
+    /**
+     * get component attachment point
+     *
+     * @constructor
+     */
+    get AttachmentPoint(): ComponentAttachmentPoint;
+    /**
+     * get component hud stats
+     *
+     * @constructor
+     */
+    get HudStats(): WeaponComponentHudStats;
+    /**
+     * get component display name / label by hash
+     *
+     * @param hash
+     * @param componentHash
+     * @constructor
+     */
+    static getComponentDisplayNameFromHash(hash: WeaponHash, componentHash: WeaponComponentHash): string;
+    /**
+     * get component attachment point by WeaponHash and WeaponComponentHash
+     *
+     * @param weaponHash
+     * @param componentHash
+     * @constructor
+     */
+    static getAttachmentPoint(weaponHash: WeaponHash, componentHash: WeaponComponentHash): ComponentAttachmentPoint;
+}

package/lib/client/weaponComponent/WeaponComponent.js

@@ -0,0 +1,119 @@
+import { WeaponComponentHash } from './WeaponComponentHash';
+import { ComponentAttachmentPoint } from './ComponentAttachmentPoint';
+import { Game } from '../Game';
+import { ComponentDisplayNameByHash } from './ComponentDisplayNameByHash';
+import { WeaponComponentHashesByWeaponHash } from './WeaponComponentHashesByWeaponHash';
+import { ComponentAttachmentPointByHash } from './ComponentAttachmentPointByHash';
+import { WeaponComponentHudStats } from './WeaponComponentHudStats';
+/**
+ * ped weapon component on weapon
+ *
+ */
+export class WeaponComponent {
+    constructor(owner, weapon, componentHash) {
+        this.owner = owner;
+        this.weapon = weapon;
+        this.componentHash = componentHash;
+    }
+    /**
+     * Check WeaponComponent is invalid or not
+     *
+     * @constructor
+     */
+    get IsInvalid() {
+        return this.componentHash === WeaponComponentHash.Invalid;
+    }
+    /**
+     * get component hash
+     *
+     * @constructor
+     */
+    get ComponentHash() {
+        return this.componentHash;
+    }
+    /**
+     * check ped has weapon component
+     *
+     * @constructor
+     */
+    get Active() {
+        return HasPedGotWeaponComponent(this.owner.Handle, this.weapon.Hash, this.componentHash);
+    }
+    /**
+     * give weapon component to ped
+     *
+     * @param value
+     * @constructor
+     */
+    set Active(value) {
+        if (value) {
+            GiveWeaponComponentToPed(this.owner.Handle, this.weapon.Hash, this.componentHash);
+        }
+        else {
+            RemoveWeaponComponentFromPed(this.owner.Handle, this.weapon.Hash, this.componentHash);
+        }
+    }
+    /**
+     * get component display name / label
+     *
+     * @constructor
+     */
+    get DisplayName() {
+        return WeaponComponent.getComponentDisplayNameFromHash(this.weapon.Hash, this.componentHash);
+    }
+    /**
+     * get component localized name
+     *
+     * @constructor
+     */
+    get LocalizedName() {
+        return Game.getGXTEntry(this.DisplayName);
+    }
+    /**
+     * get component attachment point
+     *
+     * @constructor
+     */
+    get AttachmentPoint() {
+        return WeaponComponent.getAttachmentPoint(this.weapon.Hash, this.componentHash);
+    }
+    /**
+     * get component hud stats
+     *
+     * @constructor
+     */
+    get HudStats() {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return WeaponComponentHudStats.get(this.componentHash);
+    }
+    /**
+     * get component display name / label by hash
+     *
+     * @param hash
+     * @param componentHash
+     * @constructor
+     */
+    static getComponentDisplayNameFromHash(hash, componentHash) {
+        if (!hash) {
+            return 'WCT_INVALID';
+        }
+        return ComponentDisplayNameByHash.get(componentHash) ?? 'WCT_INVALID';
+    }
+    /**
+     * get component attachment point by WeaponHash and WeaponComponentHash
+     *
+     * @param weaponHash
+     * @param componentHash
+     * @constructor
+     */
+    static getAttachmentPoint(weaponHash, componentHash) {
+        const componentHashes = WeaponComponentHashesByWeaponHash.get(weaponHash);
+        if (!componentHashes) {
+            return ComponentAttachmentPoint.Invalid;
+        }
+        if (componentHashes.every(x => x !== componentHash)) {
+            return ComponentAttachmentPoint.Invalid;
+        }
+        return ComponentAttachmentPointByHash.get(componentHash) ?? ComponentAttachmentPoint.Invalid;
+    }
+}

package/lib/client/weaponComponent/WeaponComponentCollection.d.ts

@@ -0,0 +1,108 @@
+import { Ped } from '../models';
+import { Weapon } from '../weapon';
+import { WeaponComponentHash } from './WeaponComponentHash';
+import { WeaponComponent } from './WeaponComponent';
+/**
+ * ped weapon components on weapon
+ *
+ */
+export declare class WeaponComponentCollection implements Iterable<WeaponComponent> {
+    private readonly owner;
+    private readonly weapon;
+    private readonly components;
+    private readonly invalidComponent;
+    constructor(owner: Ped, weapon: Weapon);
+    [Symbol.iterator](): Iterator<WeaponComponent>;
+    /**
+     * get component
+     *
+     * @param componentHash
+     */
+    get(componentHash: WeaponComponentHash): WeaponComponent;
+    /**
+     * get current weapon component count
+     *
+     * @constructor
+     */
+    get Count(): number;
+    /**
+     * get clip component
+     *
+     * @param index - index of component
+     */
+    getClipComponent(index: number): WeaponComponent;
+    /**
+     * get clip variation count
+     *
+     * @constructor
+     */
+    get ClipVariationsCount(): number;
+    /**
+     * get scope component
+     *
+     * @param index - index of component
+     */
+    getScopeComponent(index: number): WeaponComponent;
+    /**
+     * get scope variation count
+     *
+     * @constructor
+     */
+    get ScopeVariationsCount(): number;
+    /**
+     * get suppressor component
+     *
+     */
+    getSuppressorComponent(): WeaponComponent;
+    /**
+     * get flash light component
+     *
+     */
+    getFlashLightComponent(): WeaponComponent;
+    /**
+     * get luxury finish component
+     *
+     */
+    getLuxuryFinishComponent(): WeaponComponent;
+    /**
+     * get Mk2 camo component
+     *
+     * @param index - index of component
+     */
+    getMk2CamoComponent(index: number): WeaponComponent;
+    /**
+     * get Mk2 barrel component
+     *
+     * @param index - index of component
+     */
+    getMk2BarrelComponent(index: number): WeaponComponent;
+    /**
+     * Create component object and add to collection
+     *
+     * @param hash
+     * @private
+     */
+    private createAndAddComponent;
+    /**
+     * get all WeaponComponentHash belongs to weapon
+     *
+     * @constructor
+     * @private
+     */
+    private get AllWeaponComponentHashes();
+    /**
+     * get components belongs to attachmentPoints
+     *
+     * @param attachmentPoints
+     * @private
+     */
+    private getComponentHashesByAttachmentPoints;
+    /**
+     * get component by index and attachmentPoints
+     *
+     * @param index - component index
+     * @param attachmentPoints -  attachmentPoints to search
+     * @private
+     */
+    private getAnyComponentByAttachmentPoints;
+}

package/lib/client/weaponComponent/WeaponComponentCollection.js

@@ -0,0 +1,172 @@
+import { WeaponComponent } from './WeaponComponent';
+import { InvalidWeaponComponent } from './InvalidWeaponComponent';
+import { WeaponComponentHashesByWeaponHash } from './WeaponComponentHashesByWeaponHash';
+import { ComponentAttachmentPoint } from './ComponentAttachmentPoint';
+import { ComponentAttachmentPointByHash } from './ComponentAttachmentPointByHash';
+/**
+ * ped weapon components on weapon
+ *
+ */
+export class WeaponComponentCollection {
+    constructor(owner, weapon) {
+        this.components = new Map();
+        this.invalidComponent = new InvalidWeaponComponent();
+        this.owner = owner;
+        this.weapon = weapon;
+    }
+    [Symbol.iterator]() {
+        let pointer = 0;
+        const components = Array.from(this.components.values());
+        return {
+            next() {
+                if (pointer < components.length) {
+                    return { done: false, value: components[pointer++] };
+                }
+                else {
+                    return { done: true, value: null };
+                }
+            },
+        };
+    }
+    /**
+     * get component
+     *
+     * @param componentHash
+     */
+    get(componentHash) {
+        if (this.AllWeaponComponentHashes.some(x => x === componentHash)) {
+            let component = this.components.get(componentHash);
+            if (!component) {
+                component = this.createAndAddComponent(componentHash);
+            }
+            return component;
+        }
+        return this.invalidComponent;
+    }
+    /**
+     * get current weapon component count
+     *
+     * @constructor
+     */
+    get Count() {
+        return this.components.size;
+    }
+    /**
+     * get clip component
+     *
+     * @param index - index of component
+     */
+    getClipComponent(index) {
+        return this.getAnyComponentByAttachmentPoints(index, ComponentAttachmentPoint.Clip, ComponentAttachmentPoint.Clip2);
+    }
+    /**
+     * get clip variation count
+     *
+     * @constructor
+     */
+    get ClipVariationsCount() {
+        return this.getComponentHashesByAttachmentPoints(ComponentAttachmentPoint.Clip, ComponentAttachmentPoint.Clip2).length;
+    }
+    /**
+     * get scope component
+     *
+     * @param index - index of component
+     */
+    getScopeComponent(index) {
+        return this.getAnyComponentByAttachmentPoints(index, ComponentAttachmentPoint.Scope, ComponentAttachmentPoint.Scope2);
+    }
+    /**
+     * get scope variation count
+     *
+     * @constructor
+     */
+    get ScopeVariationsCount() {
+        return this.getComponentHashesByAttachmentPoints(ComponentAttachmentPoint.Scope, ComponentAttachmentPoint.Scope2).length;
+    }
+    /**
+     * get suppressor component
+     *
+     */
+    getSuppressorComponent() {
+        return this.getAnyComponentByAttachmentPoints(undefined, ComponentAttachmentPoint.Supp, ComponentAttachmentPoint.Supp2);
+    }
+    /**
+     * get flash light component
+     *
+     */
+    getFlashLightComponent() {
+        return this.getAnyComponentByAttachmentPoints(undefined, ComponentAttachmentPoint.FlashLaser, ComponentAttachmentPoint.FlashLaser2);
+    }
+    /**
+     * get luxury finish component
+     *
+     */
+    getLuxuryFinishComponent() {
+        return this.getAnyComponentByAttachmentPoints(undefined, ComponentAttachmentPoint.GunRoot);
+    }
+    /**
+     * get Mk2 camo component
+     *
+     * @param index - index of component
+     */
+    getMk2CamoComponent(index) {
+        return this.getAnyComponentByAttachmentPoints(index, ComponentAttachmentPoint.GunRoot);
+    }
+    /**
+     * get Mk2 barrel component
+     *
+     * @param index - index of component
+     */
+    getMk2BarrelComponent(index) {
+        return this.getAnyComponentByAttachmentPoints(index, ComponentAttachmentPoint.Barrel);
+    }
+    /**
+     * Create component object and add to collection
+     *
+     * @param hash
+     * @private
+     */
+    createAndAddComponent(hash) {
+        const uintHash = hash >>> 0;
+        console.log('createAndAdd', hash, uintHash);
+        console.log('about to create', this.owner, this.weapon, uintHash);
+        const component = new WeaponComponent(this.owner, this.weapon, uintHash);
+        this.components.set(uintHash, component);
+        return component;
+    }
+    /**
+     * get all WeaponComponentHash belongs to weapon
+     *
+     * @constructor
+     * @private
+     */
+    get AllWeaponComponentHashes() {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return WeaponComponentHashesByWeaponHash.get(this.weapon.Hash);
+    }
+    /**
+     * get components belongs to attachmentPoints
+     *
+     * @param attachmentPoints
+     * @private
+     */
+    getComponentHashesByAttachmentPoints(...attachmentPoints) {
+        return this.AllWeaponComponentHashes.filter(hash => attachmentPoints.some(attachmentPoint => ComponentAttachmentPointByHash.get(hash) === attachmentPoint));
+    }
+    /**
+     * get component by index and attachmentPoints
+     *
+     * @param index - component index
+     * @param attachmentPoints -  attachmentPoints to search
+     * @private
+     */
+    getAnyComponentByAttachmentPoints(index, ...attachmentPoints) {
+        const hashes = this.getComponentHashesByAttachmentPoints(...attachmentPoints);
+        if (index === undefined) {
+            return this.get(hashes[0]) ?? this.invalidComponent;
+        }
+        return 0 <= index && index <= hashes.length - 1
+            ? this.get(hashes[index])
+            : this.invalidComponent;
+    }
+}