@nativewrappers/fivem 0.0.22 → 0.0.25

package/client/Game.d.ts

@@ -9,6 +9,10 @@ export declare abstract class Game {
      * @param input The input string to calculate the hash
      */
     static generateHash(input: string): number;
+    static setLocalPlayerGhosted(isGhosted: boolean, inverseGhost: boolean): void;
+    static setGhostAlpha(alpha: number): void;
+    static resetGhostAlpha(): void;
+    static setGhostingInverted(isInverted: boolean): void;
     /**
      * Gets the game language
      */

package/client/Game.js

@@ -19,6 +19,20 @@ export class Game {
         this.hashCache.set(input, hash);
         return hash;
     }
+    static setLocalPlayerGhosted(isGhosted, inverseGhost) {
+        // @ts-ignore
+        SetLocalPlayerAsGhost(isGhosted, inverseGhost);
+    }
+    static setGhostAlpha(alpha) {
+        SetGhostedEntityAlpha(alpha);
+    }
+    static resetGhostAlpha() {
+        ResetGhostedEntityAlpha();
+    }
+    static setGhostingInverted(isInverted) {
+        // actual name is SET_INVERT_GHOSTING
+        N_0xd7b6c73cad419bcf(isInverted);
+    }
     /**
      * Gets the game language
      */

package/client/models/Player.d.ts

@@ -37,6 +37,8 @@ export declare class Player {
     get PvPEnabled(): boolean;
     set PvPEnabled(value: boolean);
     get IsDead(): boolean;
+    set DisableFiring(value: boolean);
+    set Ghosted(isGhosted: boolean);
     get EntityPlayerIsAimingAt(): BaseEntity | null;
     get StealthNoise(): number;
     get FakeWantedLevel(): number;

package/client/models/Player.js

@@ -90,10 +90,19 @@ export class Player {
     get IsDead() {
         return IsPlayerDead(this.handle);
     }
-    // Should this even be here?
-    // public set DisableFiring(value: boolean) {
-    //   DisablePlayerFiring(this.handle, value);
-    // }
+    set DisableFiring(value) {
+        DisablePlayerFiring(this.handle, value);
+    }
+    set Ghosted(isGhosted) {
+        // if we're the local player then use the local version of the native
+        if (this.Handle === 128) {
+            SetLocalPlayerAsGhost(isGhosted);
+        }
+        else {
+            // actual name is SET_REMOTE_PLAYER_AS_GHOST
+            SetRelationshipToPlayer(this.handle, isGhosted);
+        }
+    }
     get EntityPlayerIsAimingAt() {
         const [entityHit, entity] = GetEntityPlayerIsFreeAimingAt(this.handle);
         if (entityHit) {

package/client/models/Vehicle.d.ts

@@ -124,6 +124,12 @@ export declare class Vehicle extends BaseEntity {
     set IsBurnoutForced(value: boolean);
     get IsInBurnout(): boolean;
     get Driver(): Ped;
+    get Ghosted(): boolean;
+    set GhostedForGhostPlayers(isGhostedForGhostPlayers: boolean);
+    set Ghosted(isGhosted: boolean);
+    static set GhostAlpha(alpha: number);
+    get IsInGhostCollision(): boolean;
+    static resetGhostAlpha(): void;
     get Occupants(): Ped[];
     get Passengers(): Ped[];
     get Doors(): VehicleDoorCollection;

package/client/models/Vehicle.js

@@ -382,6 +382,29 @@ export class Vehicle extends BaseEntity {
     get Driver() {
         return this.getPedOnSeat(VehicleSeat.Driver);
     }
+    // while ghosted use entity index, it doesn't look like you can ghost
+    // anything but players and vehicles
+    get Ghosted() {
+        // actual name is IS_ENTITY_A_GHOST
+        return IsEntityGhostedToLocalPlayer(this.handle);
+    }
+    set GhostedForGhostPlayers(isGhostedForGhostPlayers) {
+        // actual name is SET_ENTITY_GHOSTED_FOR_GHOST_PLAYERS
+        NetworkSetEntityGhostedWithOwner(this.handle, isGhostedForGhostPlayers);
+    }
+    set Ghosted(isGhosted) {
+        SetNetworkVehicleAsGhost(this.Handle, isGhosted);
+    }
+    static set GhostAlpha(alpha) {
+        SetGhostedEntityAlpha(alpha);
+    }
+    get IsInGhostCollision() {
+        // actual name is IS_ENTITY_IN_GHOST_COLLISION
+        return N_0x7ef7649b64d7ff10(this.handle);
+    }
+    static resetGhostAlpha() {
+        ResetGhostedEntityAlpha();
+    }
     get Occupants() {
         const driver = this.Driver;
         if (!Ped.exists(driver)) {

package/common/utils/Vector.d.ts

@@ -9,26 +9,19 @@ export interface Vec2 {
 /**
  * Represents a 3-dimensional vector.
  */
-export interface Vec3 {
-    x: number;
-    y: number;
+export interface Vec3 extends Vec2 {
     z: number;
 }
 /**
  * Represents a 4-dimensional vector.
  */
-export interface Vec4 {
-    x: number;
-    y: number;
-    z: number;
+export interface Vec4 extends Vec3 {
     w: number;
 }
 /**
  * An object with vector components.
  */
-interface VectorObject {
-    x: number;
-    y: number;
+export interface Vec extends Vec2 {
     z?: number;
     w?: number;
 }
@@ -47,7 +40,7 @@ type VectorType = typeof Vector;
 /**
  * Represents an object or class that can be treated as a vector.
  */
-type VectorLike = VectorObject | Vector;
+type VectorLike = Vec | Vector;
 /**
  * Utility type to get the vector type of an object based on its component.
  */
@@ -121,14 +114,14 @@ export declare class Vector {
      * @param z - The value to add to the z-component.
      * @returns A new vector with the z-component incremented.
      */
-    static addZ<T extends VectorType, U extends VectorLike>(this: T, obj: U, z: number): InferVector<U>;
+    static addZ<T extends VectorType, U extends Vec3 | Vec4>(this: T, obj: U, z: number): InferVector<U>;
     /**
      * Adds a scalar value to the w-component of a vector.
      * @param obj - The vector.
      * @param w - The value to add to the w-component.
      * @returns A new vector with the w-component incremented.
      */
-    static addW<T extends VectorType, U extends VectorLike>(this: T, obj: U, w: number): InferVector<U>;
+    static addW<T extends VectorType, U extends Vec4>(this: T, obj: U, w: number): InferVector<U>;
     /**
      * Subtracts one vector from another or subtracts a scalar value from a vector.
      * @param a - The vector.
@@ -163,7 +156,7 @@ export declare class Vector {
      * @param b - The second vector.
      * @returns A new vector perpendicular to both input vectors.
      */
-    static crossProduct<T extends VectorType, U extends VectorObject>(this: T, a: U, b: U): U;
+    static crossProduct<T extends VectorType, U extends Vec3 | Vec4>(this: T, a: U, b: U): U;
     /**
      * Normalizes a vector, producing a new vector with the same direction but with a magnitude of 1.
      * @param vector - The vector to be normalized.
@@ -256,7 +249,7 @@ export declare class Vector {
     /**
      * Converts the vector to an array of its components.
      */
-    toArray(): number[];
+    toArray<T extends this>(): VectorArray<T>;
     /**
      * Replaces the components of the vector with the components of another vector object.
      * @param v - The object whose components will replace the current vector's components.
@@ -302,7 +295,7 @@ export declare class Vector3 extends Vector implements Vec3 {
     /**
      * @see Vector.crossProduct
      */
-    crossProduct(v: VectorLike): VectorLike;
+    crossProduct(v: Vec3 | Vec4): Vec3 | Vec4;
 }
 /**
  * Represents a 4-dimensional vector.
@@ -331,6 +324,6 @@ export declare class Vector4 extends Vector {
     /**
      * @see Vector.crossProduct
      */
-    crossProduct(v: VectorLike): VectorLike;
+    crossProduct(v: Vec3 | Vec4): Vec3 | Vec4;
 }
 export {};

package/common/utils/Vector.js

@@ -155,11 +155,9 @@ export class Vector {
     static dotProduct(a, b) {
         let result = 0;
         for (const key of ['x', 'y', 'z', 'w']) {
-            const v1 = a[key];
-            const v2 = b[key];
-            if (v1 && v2)
-                result += v1 * v2;
-            else if (v1 || v2) {
+            if (key in a && key in b)
+                result += a[key] * b[key];
+            else {
                 throw new Error('Vectors must have the same dimensions');
             }
         }

package/package.json

@@ -4,7 +4,7 @@
   "author": "Remco Troost <d0p3t>",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.22",
+  "version": "0.0.25",
   "publishConfig": {
     "directory": "lib"
   },