@nativewrappers/fivem 0.0.31 → 0.0.32

package/client/Raycast.d.ts

@@ -4,7 +4,7 @@ import { Vector3 } from './utils';
 /**
  * Class that represents the result of a raycast.
  */
-export declare class RaycastResult {
+declare abstract class RaycastResult {
     /**
      * Return the entity that was hit.
      */
@@ -33,6 +33,17 @@ export declare class RaycastResult {
      * Raycast result's handle.
      */
     get Result(): number;
+    /**
+     * @returns if the shape test handle was already discarded
+     */
+    get WasDiscarded(): boolean;
+    /**
+     * NOTE: These will not be updated unless polled by `resolve` or the shape
+     * test is synchronous
+     * @returns if the raycast has been marked as ready by the engine
+     */
+    get HasResolved(): boolean;
+    protected applyShapeTestResults(): void;
     private handle;
     private hitPositionArg;
     private hitSomethingArg;
@@ -47,3 +58,14 @@ export declare class RaycastResult {
      */
     constructor(handle: number);
 }
+export declare class SynchronousRaycastResult extends RaycastResult {
+    constructor(handle: number);
+}
+export declare class AsynchronousRaycastResult extends RaycastResult {
+    /**
+     * waits until the shape test handle is valid and then sets the expected
+     * values on the RaycastResult
+     */
+    resolve(timeoutInMs?: number): Promise<void>;
+}
+export {};

package/client/Raycast.js

@@ -1,9 +1,10 @@
+import { ShapeTestStatus } from './enums/RaycastEnums';
 import { Game } from './Game';
-import { Vector3 } from './utils';
+import { Delay, Vector3 } from './utils';
 /**
  * Class that represents the result of a raycast.
  */
-export class RaycastResult {
+class RaycastResult {
     /**
      * Return the entity that was hit.
      */
@@ -46,7 +47,33 @@ export class RaycastResult {
     get Result() {
         return this.result;
     }
-    // FIXME: This only works with StartExpensiveSynchronousShapeTestLosProbe, this should have some getter you have to await afterwards for all of the data
+    /**
+     * @returns if the shape test handle was already discarded
+     */
+    get WasDiscarded() {
+        return this.result === ShapeTestStatus.Discarded;
+    }
+    /**
+     * NOTE: These will not be updated unless polled by `resolve` or the shape
+     * test is synchronous
+     * @returns if the raycast has been marked as ready by the engine
+     */
+    get HasResolved() {
+        return this.result === ShapeTestStatus.Ready;
+    }
+    applyShapeTestResults() {
+        const [result, hit, endCoords, surfaceNormal, materialHash, entityHit] = GetShapeTestResultIncludingMaterial(this.handle);
+        this.result = result;
+        if (!this.HasResolved || this.WasDiscarded)
+            return;
+        this.hitSomethingArg = hit;
+        this.hitPositionArg = Vector3.fromArray(endCoords);
+        this.surfaceNormalArg = Vector3.fromArray(surfaceNormal);
+        this.materialArg = materialHash;
+        if (entityHit !== 0) {
+            this.entityHandleArg = Game.entityFromHandle(entityHit);
+        }
+    }
     /**
      * Create a RaycastResult object that gets the results from a StartShapeTestRay()
      *
@@ -59,12 +86,31 @@ export class RaycastResult {
         this.entityHandleArg = null;
         this.surfaceNormalArg = new Vector3(0, 0, 0);
         this.materialArg = 0;
-        const [result, hit, endCoords, surfaceNormal, materialHash, entityHit] = GetShapeTestResultIncludingMaterial(this.handle);
-        this.hitSomethingArg = hit;
-        this.hitPositionArg = Vector3.fromArray(endCoords);
-        this.surfaceNormalArg = Vector3.fromArray(surfaceNormal);
-        this.materialArg = materialHash;
-        this.entityHandleArg = Game.entityFromHandle(entityHit);
-        this.result = result;
+        this.result = ShapeTestStatus.NotReady;
+    }
+}
+export class SynchronousRaycastResult extends RaycastResult {
+    constructor(handle) {
+        super(handle);
+        // if we're using a synchronous call then we want to instantly update our
+        // data, if its invalid then the caller can deal with it.
+        this.applyShapeTestResults();
+    }
+}
+export class AsynchronousRaycastResult extends RaycastResult {
+    /**
+     * waits until the shape test handle is valid and then sets the expected
+     * values on the RaycastResult
+     */
+    async resolve(timeoutInMs = 1000) {
+        const timeout = GetGameTimer() + timeoutInMs;
+        // this has to be polled every frame or the engien will mark the field shape
+        // test handle as discarded
+        while (!this.HasResolved && !this.WasDiscarded) {
+            this.applyShapeTestResults();
+            if (timeout < GetGameTimer())
+                break;
+            await Delay(0);
+        }
     }
 }

package/client/World.d.ts

@@ -1,11 +1,11 @@
 import { Model, Prop } from './';
 import { Blip } from './Blip';
 import { Camera } from './Camera';
-import { CameraTypes, CloudHat, IntersectOptions, MarkerType, PickupType, RopeType, Weather } from './enums';
+import { CameraTypes, CloudHat, IntersectFlags, MarkerType, PickupType, RopeType, Weather } from './enums';
 import { Ped, Vehicle } from './models';
 import type { BaseEntity } from './models/BaseEntity';
 import { Pickup } from './Pickup';
-import { RaycastResult } from './Raycast';
+import { AsynchronousRaycastResult, SynchronousRaycastResult } from './Raycast';
 import { Rope } from './Rope';
 import { Color, Vector3 } from './utils';
 /**
@@ -340,24 +340,37 @@ export declare abstract class World {
      */
     static drawPoly(vertexA: Vector3, vertexB: Vector3, vertexC: Vector3, color: Color): void;
     /**
-     * Cast ("shoot") a ray in a certain direction to detect entities in the way.
+     * Cast a ray from {@param start} to {@param end}.
      *
-     * @param source Starting position of raycast.
-     * @param direction Direction to cast a ray to.
-     * @param maxDistance Max distance to cast the ray.
+     * @param start Starting position of raycast.
+     * @param end Direction to cast a ray to.
+     * @param losFlags The entity type(s) that the raycast should intersect with
+     * defaults to {@enum IntersectFlags.All}
      * @param options Possible entity types to detect.
      * @param ignoreEntity An entity to ignore (usually player's Ped).
-     * @returns RaycastResult object.
+     * @returns {@see SynchronousRaycastResult} object.
+     */
+    static expensiveRaycast(start: Vector3, end: Vector3, losFlags?: IntersectFlags, shapeTestOptions?: number, ignoreEntity?: BaseEntity): SynchronousRaycastResult;
+    /**
+     * Cast a ray from {@param start} to {@param end} and returns the first hit
+     * entity or coordinate .
+     *
+     * @param start starting position of raycast.
+     * @param end the ending position to raycast to.
+     * @param losFlags The entity type(s) that the raycast should intersect with defaults to {@enum IntersectFlags.All}
+     * @param shapeTestOptions shape test collision modifiers defaults to ignoring glass, see through, and no collided entities
+     * @param ignoreEntity An entity to ignore (usually player's Ped).
+     * @returns {@see AsynchronousRaycastResult} object that must be awaited to get its results.
      */
-    static raycast(source: Vector3, direction: Vector3, maxDistance: number, options: IntersectOptions, ignoreEntity: BaseEntity): RaycastResult;
+    static raycast(start: Vector3, end: Vector3, losFlags?: IntersectFlags, shapeTestOptions?: number, ignoreEntity?: BaseEntity): AsynchronousRaycastResult;
     /**
      * Cast a ray from the local players camera until it hits an entity
      *
      * @param maxDistance Max distance to cast the ray.
-     * @param options Possible entity types to detect.
-     * @returns RaycastResult object.
+     * @param flags Possible entity types to detect.
+     * @returns SynchronousRaycast object.
      */
-    static raycastPlayerCamera(maxDistance: number, options: IntersectOptions): RaycastResult;
+    static raycastPlayerCamera(maxDistance: number, flags: IntersectFlags): SynchronousRaycastResult;
     /**
      * Gets the closest object of this model
      */

package/client/World.js

@@ -1,14 +1,14 @@
 import { Model, Prop } from './';
 import { Blip } from './Blip';
 import { Camera } from './Camera';
-import { CameraTypes, CloudHat, Weather, } from './enums';
+import { CameraTypes, CloudHat, IntersectFlags, SHAPE_TEST_DEFAULT, Weather, } from './enums';
 import { GameplayCamera } from './GameplayCamera';
 import { VehicleHash } from './hashes';
 import { Ped, Vehicle } from './models';
 import { Pickup } from './Pickup';
-import { RaycastResult } from './Raycast';
+import { AsynchronousRaycastResult, SynchronousRaycastResult } from './Raycast';
 import { Rope } from './Rope';
-import { Maths, Vector3, Wait } from './utils';
+import { Maths, Wait } from './utils';
 /**
  * Class with common world manipulations.
  *
@@ -570,32 +570,47 @@ export class World {
     static drawPoly(vertexA, vertexB, vertexC, color) {
         DrawPoly(vertexA.x, vertexA.y, vertexA.z, vertexB.x, vertexB.y, vertexB.z, vertexC.x, vertexC.y, vertexC.z, color.r, color.g, color.b, color.a);
     }
+    // TODO: Add a raycast option for every type.
     /**
-     * Cast ("shoot") a ray in a certain direction to detect entities in the way.
+     * Cast a ray from {@param start} to {@param end}.
      *
-     * @param source Starting position of raycast.
-     * @param direction Direction to cast a ray to.
-     * @param maxDistance Max distance to cast the ray.
+     * @param start Starting position of raycast.
+     * @param end Direction to cast a ray to.
+     * @param losFlags The entity type(s) that the raycast should intersect with
+     * defaults to {@enum IntersectFlags.All}
      * @param options Possible entity types to detect.
      * @param ignoreEntity An entity to ignore (usually player's Ped).
-     * @returns RaycastResult object.
+     * @returns {@see SynchronousRaycastResult} object.
      */
-    static raycast(source, direction, maxDistance, options, ignoreEntity) {
-        const target = Vector3.add(source, Vector3.multiply(direction, maxDistance));
-        return new RaycastResult(StartExpensiveSynchronousShapeTestLosProbe(source.x, source.y, source.z, target.x, target.y, target.z, Number(options), ignoreEntity.Handle, 7));
+    static expensiveRaycast(start, end, losFlags = IntersectFlags.All, shapeTestOptions = SHAPE_TEST_DEFAULT, ignoreEntity) {
+        return new SynchronousRaycastResult(StartExpensiveSynchronousShapeTestLosProbe(start.x, start.y, start.z, end.x, end.y, end.z, losFlags, ignoreEntity?.Handle ?? 0, shapeTestOptions));
+    }
+    /**
+     * Cast a ray from {@param start} to {@param end} and returns the first hit
+     * entity or coordinate .
+     *
+     * @param start starting position of raycast.
+     * @param end the ending position to raycast to.
+     * @param losFlags The entity type(s) that the raycast should intersect with defaults to {@enum IntersectFlags.All}
+     * @param shapeTestOptions shape test collision modifiers defaults to ignoring glass, see through, and no collided entities
+     * @param ignoreEntity An entity to ignore (usually player's Ped).
+     * @returns {@see AsynchronousRaycastResult} object that must be awaited to get its results.
+     */
+    static raycast(start, end, losFlags = IntersectFlags.All, shapeTestOptions = SHAPE_TEST_DEFAULT, ignoreEntity) {
+        return new AsynchronousRaycastResult(StartShapeTestLosProbe(start.x, start.y, start.z, end.x, end.y, end.z, losFlags, ignoreEntity?.Handle ?? 0, shapeTestOptions));
     }
     /**
      * Cast a ray from the local players camera until it hits an entity
      *
      * @param maxDistance Max distance to cast the ray.
-     * @param options Possible entity types to detect.
-     * @returns RaycastResult object.
+     * @param flags Possible entity types to detect.
+     * @returns SynchronousRaycast object.
      */
-    static raycastPlayerCamera(maxDistance, options) {
+    static raycastPlayerCamera(maxDistance, flags) {
         const camera = GameplayCamera.Position;
         const direction = GameplayCamera.ForwardVector;
         const destination = direction.multiply(maxDistance).add(camera);
-        return new RaycastResult(StartExpensiveSynchronousShapeTestLosProbe(camera.x, camera.y, camera.z, destination.x, destination.y, destination.z, Number(options), PlayerPedId(), 7));
+        return new SynchronousRaycastResult(StartExpensiveSynchronousShapeTestLosProbe(camera.x, camera.y, camera.z, destination.x, destination.y, destination.z, flags, PlayerPedId(), 7));
     }
     /**
      * Gets the closest object of this model

package/client/enums/RaycastEnums.d.ts

@@ -0,0 +1,27 @@
+/**
+ * List of possible entity intersections. Used for raycasting.
+ */
+export declare enum IntersectFlags {
+    None = 0,
+    World = 1,
+    Vehicles = 2,
+    Ped = 4,
+    Ragdoll = 8,
+    Object = 16,
+    Pickup = 32,
+    River = 128,
+    Foliage = 256,
+    All = 511
+}
+export declare enum ShapeTestOptions {
+    None = 0,
+    IgnoreGlass = 1,
+    IgnoreSeeThrough = 2,
+    IgnoreNoCollision = 4
+}
+export declare enum ShapeTestStatus {
+    Discarded = 0,
+    NotReady = 1,
+    Ready = 2
+}
+export declare const SHAPE_TEST_DEFAULT: number;

package/client/enums/RaycastEnums.js

@@ -0,0 +1,30 @@
+/**
+ * List of possible entity intersections. Used for raycasting.
+ */
+export var IntersectFlags;
+(function (IntersectFlags) {
+    IntersectFlags[IntersectFlags["None"] = 0] = "None";
+    IntersectFlags[IntersectFlags["World"] = 1] = "World";
+    IntersectFlags[IntersectFlags["Vehicles"] = 2] = "Vehicles";
+    IntersectFlags[IntersectFlags["Ped"] = 4] = "Ped";
+    IntersectFlags[IntersectFlags["Ragdoll"] = 8] = "Ragdoll";
+    IntersectFlags[IntersectFlags["Object"] = 16] = "Object";
+    IntersectFlags[IntersectFlags["Pickup"] = 32] = "Pickup";
+    IntersectFlags[IntersectFlags["River"] = 128] = "River";
+    IntersectFlags[IntersectFlags["Foliage"] = 256] = "Foliage";
+    IntersectFlags[IntersectFlags["All"] = 511] = "All";
+})(IntersectFlags || (IntersectFlags = {}));
+export var ShapeTestOptions;
+(function (ShapeTestOptions) {
+    ShapeTestOptions[ShapeTestOptions["None"] = 0] = "None";
+    ShapeTestOptions[ShapeTestOptions["IgnoreGlass"] = 1] = "IgnoreGlass";
+    ShapeTestOptions[ShapeTestOptions["IgnoreSeeThrough"] = 2] = "IgnoreSeeThrough";
+    ShapeTestOptions[ShapeTestOptions["IgnoreNoCollision"] = 4] = "IgnoreNoCollision";
+})(ShapeTestOptions || (ShapeTestOptions = {}));
+export var ShapeTestStatus;
+(function (ShapeTestStatus) {
+    ShapeTestStatus[ShapeTestStatus["Discarded"] = 0] = "Discarded";
+    ShapeTestStatus[ShapeTestStatus["NotReady"] = 1] = "NotReady";
+    ShapeTestStatus[ShapeTestStatus["Ready"] = 2] = "Ready";
+})(ShapeTestStatus || (ShapeTestStatus = {}));
+export const SHAPE_TEST_DEFAULT = ShapeTestOptions.IgnoreGlass | ShapeTestOptions.IgnoreSeeThrough | ShapeTestOptions.IgnoreNoCollision;

package/client/enums/index.d.ts

@@ -20,7 +20,7 @@ export { HelmetType } from './HelmetType';
 export { HudColor } from './HudColor';
 export { HudComponent } from './HudComponent';
 export { InputMode } from './InputMode';
-export { IntersectOptions } from './IntersectOptions';
+export { IntersectFlags, ShapeTestOptions, SHAPE_TEST_DEFAULT } from './RaycastEnums';
 export { InvertAxis, InvertAxisFlags } from './InvertAxis';
 export { Language } from './Language';
 export { LeaveVehicleFlags } from './LeaveVehicleFlags';

package/client/enums/index.js

@@ -20,7 +20,7 @@ export { HelmetType } from './HelmetType';
 export { HudColor } from './HudColor';
 export { HudComponent } from './HudComponent';
 export { InputMode } from './InputMode';
-export { IntersectOptions } from './IntersectOptions';
+export { IntersectFlags, ShapeTestOptions, SHAPE_TEST_DEFAULT } from './RaycastEnums';
 export { InvertAxisFlags } from './InvertAxis';
 export { Language } from './Language';
 export { LeaveVehicleFlags } from './LeaveVehicleFlags';

package/client/index.d.ts

@@ -10,7 +10,7 @@ export { GameplayCamera } from './GameplayCamera';
 export { ParticleEffect } from './ParticleEffect';
 export { ParticleEffectAsset } from './ParticleEffectAsset';
 export { Pickup } from './Pickup';
-export { RaycastResult } from './Raycast';
+export { AsynchronousRaycastResult, SynchronousRaycastResult } from './Raycast';
 export { RelationshipGroup } from './RelationshipGroup';
 export { Tasks } from './Tasks';
 export { TaskSequence } from './TaskSequence';

package/client/index.js

@@ -10,7 +10,7 @@ export { GameplayCamera } from './GameplayCamera';
 export { ParticleEffect } from './ParticleEffect';
 export { ParticleEffectAsset } from './ParticleEffectAsset';
 export { Pickup } from './Pickup';
-export { RaycastResult } from './Raycast';
+export { AsynchronousRaycastResult, SynchronousRaycastResult } from './Raycast';
 export { RelationshipGroup } from './RelationshipGroup';
 export { Tasks } from './Tasks';
 export { TaskSequence } from './TaskSequence';

package/common/utils/Vector.d.ts

@@ -55,9 +55,6 @@ export declare class Vector {
     y: number;
     z?: number | undefined;
     w?: number | undefined;
-    /**
-     * The type identifier for vectors.
-     */
     type: ClassTypes;
     protected static create(x: number, y?: number): Vector2;
     protected static create(x: number, y?: number, z?: number): Vector3;
@@ -144,6 +141,35 @@ export declare class Vector {
      * @returns A new vector with divided components.
      */
     static divide<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Performs an operation between a vector and either another vector or scalar value converting the vector into absolute values.
+     * @param a - The first vector.
+     * @param b - The second vector or scalar value.
+     * @param operator - The function defining the operation to perform.
+     * @returns A new vector resulting from the operation.
+     */
+    private static operateAbsolute;
+    /**
+     * Subtracts one vector from another or subtracts a scalar value from a vector.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with subtracted components.
+     */
+    static subtractAbsolute<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Multiplies two vectors by their components, or multiplies a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with multiplied components.
+     */
+    static multiplyAbsolute<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Divides two vectors by their components, or divides a vector by a scalar value
+     * @param a - The vector.
+     * @param b - The second vector or scalar vector.
+     * @returns A new vector with divided components.
+     */
+    static divideAbsolute<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
     /**
      * Calculates the dot product of two vectors.
      * @param a - The first vector.
@@ -246,6 +272,18 @@ export declare class Vector {
      * @see Vector.divide
      */
     divide(v: VectorLike | number): this;
+    /**
+     * @see Vector.subtractAbsolute
+     */
+    subtractAbsolute(v: VectorLike): this;
+    /**
+     * @see Vector.multiply
+     */
+    multiplyAbsolute(v: VectorLike | number): this;
+    /**
+     * @see Vector.divide
+     */
+    divideAbsolute(v: VectorLike | number): this;
     /**
      * Converts the vector to an array of its components.
      */
@@ -296,6 +334,10 @@ export declare class Vector3 extends Vector implements Vec3 {
      * @see Vector.crossProduct
      */
     crossProduct(v: Vec3 | Vec4): Vec3 | Vec4;
+    /**
+      * @returns the x and y values as Vec2
+      */
+    toVec2(): Vector2;
 }
 /**
  * Represents a 4-dimensional vector.
@@ -325,5 +367,13 @@ export declare class Vector4 extends Vector {
      * @see Vector.crossProduct
      */
     crossProduct(v: Vec3 | Vec4): Vec3 | Vec4;
+    /**
+      * @returns the x and y values as Vec2
+      */
+    toVec2(): Vector2;
+    /**
+      * @returns the x and y values as Vec3
+      */
+    toVec3(): Vector3;
 }
 export {};

package/common/utils/Vector.js

@@ -145,6 +145,51 @@ export class Vector {
     static divide(a, b) {
         return this.operate(a, b, (x, y) => x / y);
     }
+    /**
+     * Performs an operation between a vector and either another vector or scalar value converting the vector into absolute values.
+     * @param a - The first vector.
+     * @param b - The second vector or scalar value.
+     * @param operator - The function defining the operation to perform.
+     * @returns A new vector resulting from the operation.
+     */
+    static operateAbsolute(a, b, operator) {
+        let { x, y, z, w } = a;
+        const isNumber = typeof b === 'number';
+        x = operator(Math.abs(x), isNumber ? b : Math.abs(b.x ?? 0));
+        y = operator(Math.abs(y), isNumber ? b : Math.abs(b.y ?? 0));
+        if (z)
+            z = operator(Math.abs(z), isNumber ? b : Math.abs(b.z ?? 0));
+        if (w)
+            w = operator(Math.abs(w), isNumber ? b : Math.abs(b.w ?? 0));
+        return this.create(x, y, z, w);
+    }
+    /**
+     * Subtracts one vector from another or subtracts a scalar value from a vector.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with subtracted components.
+     */
+    static subtractAbsolute(a, b) {
+        return this.operateAbsolute(a, b, (x, y) => x - y);
+    }
+    /**
+     * Multiplies two vectors by their components, or multiplies a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with multiplied components.
+     */
+    static multiplyAbsolute(a, b) {
+        return this.operateAbsolute(a, b, (x, y) => x * y);
+    }
+    /**
+     * Divides two vectors by their components, or divides a vector by a scalar value
+     * @param a - The vector.
+     * @param b - The second vector or scalar vector.
+     * @returns A new vector with divided components.
+     */
+    static divideAbsolute(a, b) {
+        return this.operateAbsolute(a, b, (x, y) => x / y);
+    }
     /**
      * Calculates the dot product of two vectors.
      * @param a - The first vector.
@@ -244,9 +289,8 @@ export class Vector {
         this.y = y;
         this.z = z;
         this.w = w;
-        /**
-         * The type identifier for vectors.
-         */
+        // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+        // TO EXIST
         this.type = ClassTypes.Vector2;
     }
     *[Symbol.iterator]() {
@@ -333,6 +377,24 @@ export class Vector {
     divide(v) {
         return Vector.divide(this, v);
     }
+    /**
+     * @see Vector.subtractAbsolute
+     */
+    subtractAbsolute(v) {
+        return Vector.subtractAbsolute(this, v);
+    }
+    /**
+     * @see Vector.multiply
+     */
+    multiplyAbsolute(v) {
+        return Vector.multiplyAbsolute(this, v);
+    }
+    /**
+     * @see Vector.divide
+     */
+    divideAbsolute(v) {
+        return Vector.divideAbsolute(this, v);
+    }
     /**
      * Converts the vector to an array of its components.
      */
@@ -371,6 +433,8 @@ export class Vector2 extends Vector {
      */
     constructor(x, y = x) {
         super(2, x, y);
+        // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+        // TO EXIST, CHANGING IT WILL BREAK STUFF
         this.type = ClassTypes.Vector2;
     }
 }
@@ -387,6 +451,8 @@ export class Vector3 extends Vector {
      */
     constructor(x, y = x, z = y) {
         super(3, x, y, z);
+        // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+        // TO EXIST, CHANGING IT WILL BREAK STUFF
         this.type = ClassTypes.Vector3;
         this.z = z;
     }
@@ -402,6 +468,12 @@ export class Vector3 extends Vector {
     crossProduct(v) {
         return Vector.crossProduct(this, v);
     }
+    /**
+      * @returns the x and y values as Vec2
+      */
+    toVec2() {
+        return new Vector2(this.x, this.y);
+    }
 }
 Vector3.Zero = new Vector3(0, 0, 0);
 /**
@@ -417,6 +489,8 @@ export class Vector4 extends Vector {
      */
     constructor(x, y = x, z = y, w = z) {
         super(4, x, y, z, w);
+        // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+        // TO EXIST, CHANGING IT WILL BREAK STUFF
         this.type = ClassTypes.Vector4;
         this.z = z;
         this.w = w;
@@ -439,5 +513,17 @@ export class Vector4 extends Vector {
     crossProduct(v) {
         return Vector.crossProduct(this, v);
     }
+    /**
+      * @returns the x and y values as Vec2
+      */
+    toVec2() {
+        return new Vector2(this.x, this.y);
+    }
+    /**
+      * @returns the x and y values as Vec3
+      */
+    toVec3() {
+        return new Vector3(this.x, this.y, this.z);
+    }
 }
 Vector4.Zero = new Vector4(0, 0, 0, 0);

package/package.json

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

package/client/enums/IntersectOptions.d.ts

@@ -1,15 +0,0 @@
-/**
- * List of possible entity intersections. Used for raycasting.
- */
-export declare enum IntersectOptions {
-    Everything = -1,
-    None = 0,
-    World = 1,
-    Vehicles = 2,
-    PedsSimpleCollision = 4,
-    Peds = 8,
-    Objects = 16,
-    Water = 32,
-    Unk3 = 128,
-    Foliage = 256
-}

package/client/enums/IntersectOptions.js

@@ -1,16 +0,0 @@
-/**
- * List of possible entity intersections. Used for raycasting.
- */
-export var IntersectOptions;
-(function (IntersectOptions) {
-    IntersectOptions[IntersectOptions["Everything"] = -1] = "Everything";
-    IntersectOptions[IntersectOptions["None"] = 0] = "None";
-    IntersectOptions[IntersectOptions["World"] = 1] = "World";
-    IntersectOptions[IntersectOptions["Vehicles"] = 2] = "Vehicles";
-    IntersectOptions[IntersectOptions["PedsSimpleCollision"] = 4] = "PedsSimpleCollision";
-    IntersectOptions[IntersectOptions["Peds"] = 8] = "Peds";
-    IntersectOptions[IntersectOptions["Objects"] = 16] = "Objects";
-    IntersectOptions[IntersectOptions["Water"] = 32] = "Water";
-    IntersectOptions[IntersectOptions["Unk3"] = 128] = "Unk3";
-    IntersectOptions[IntersectOptions["Foliage"] = 256] = "Foliage";
-})(IntersectOptions || (IntersectOptions = {}));