@nativewrappers/fivem 0.0.65 → 0.0.73

package/Camera.js

@@ -1,162 +0,0 @@
-import { PedBone } from "./models";
-import { BaseEntity } from "./models/BaseEntity";
-import { Vector3 } from "./utils";
-import { LoadAnimDict } from "./utils/Animations";
-export class Camera {
-    static shakeNames = [
-        "HAND_SHAKE",
-        "SMALL_EXPLOSION_SHAKE",
-        "MEDIUM_EXPLOSION_SHAKE",
-        "LARGE_EXPLOSION_SHAKE",
-        "JOLT_SHAKE",
-        "VIBRATE_SHAKE",
-        "ROAD_VIBRATION_SHAKE",
-        "DRUNK_SHAKE",
-        "SKY_DIVING_SHAKE",
-        "FAMILY5_DRUG_TRIP_SHAKE",
-        "DEATH_FAIL_IN_EFFECT_SHAKE",
-    ];
-    handle;
-    constructor(handle) {
-        this.handle = handle;
-    }
-    get Handle() {
-        return this.handle;
-    }
-    get IsActive() {
-        return IsCamActive(this.handle);
-    }
-    set IsActive(active) {
-        SetCamActive(this.handle, active);
-    }
-    get Position() {
-        return Vector3.fromArray(GetCamCoord(this.handle));
-    }
-    set Position(position) {
-        SetCamCoord(this.handle, position.x, position.y, position.z);
-    }
-    get Rotation() {
-        return Vector3.fromArray(GetCamRot(this.handle, 2));
-    }
-    set Rotation(rotation) {
-        SetCamRot(this.handle, rotation.x, rotation.y, rotation.z, 2);
-    }
-    // public get Matrix() : Matrix {}
-    /**
-     * Gets the direction the camera is facing. Same as ForwardVector
-     */
-    get Direction() {
-        return this.ForwardVector;
-    }
-    set Direction(direction) {
-        const dir = direction.normalize();
-        const vec1 = new Vector3(dir.x, dir.y, 0);
-        const vec2 = new Vector3(dir.z, vec1.distanceSquared(vec1), 0);
-        const vec3 = vec2.normalize();
-        this.Rotation = new Vector3(Math.atan2(vec3.x, vec3.y) * 57.295779513082323, this.Rotation.y, Math.atan2(dir.x, dir.y) * -57.295779513082323);
-    }
-    //   public get UpVector() : Vector3 {
-    //       return Matrix.Up;
-    //   }
-    get ForwardVector() {
-        const rotation = Vector3.multiply(this.Rotation, Math.PI / 180);
-        const normalized = Vector3.normalize(new Vector3(-Math.sin(rotation.z) * Math.abs(Math.cos(rotation.x)), Math.cos(rotation.z) * Math.abs(Math.cos(rotation.x)), Math.sin(rotation.x)));
-        return new Vector3(normalized.x, normalized.y, normalized.z);
-    }
-    //   public get RightVector() : Vector3 {
-    //       return Matrix.Right;
-    //   }
-    // public Vector3 GetOffsetPosition(Vector3 offset) {
-    //     return Vector3.TransformCoordinate(offset, Matrix);
-    // }
-    // public Vector3 GetPositionOffset(Vector3 worldCoords) {
-    //     return Vector3.TransformCoordinate(worldCoords, Matrix.Invert(Matrix));
-    // }
-    get FieldOfView() {
-        return GetCamFov(this.handle);
-    }
-    set FieldOfView(fieldOfView) {
-        SetCamFov(this.handle, fieldOfView);
-    }
-    get NearClip() {
-        return GetCamNearClip(this.handle);
-    }
-    set NearClip(nearClip) {
-        SetCamNearClip(this.handle, nearClip);
-    }
-    get FarClip() {
-        return GetCamFarClip(this.handle);
-    }
-    set FarClip(farClip) {
-        SetCamFarClip(this.handle, farClip);
-    }
-    set NearDepthOfField(nearDepthOfField) {
-        SetCamNearDof(this.handle, nearDepthOfField);
-    }
-    get FarDepthOfField() {
-        return GetCamFarDof(this.handle);
-    }
-    set FarDepthOfField(farDepthOfField) {
-        SetCamFarDof(this.handle, farDepthOfField);
-    }
-    set DepthOfFieldStrength(strength) {
-        SetCamDofStrength(this.handle, strength);
-    }
-    set MotionBlurStrength(strength) {
-        SetCamMotionBlurStrength(this.handle, strength);
-    }
-    shake(shakeType, amplitude) {
-        ShakeCam(this.handle, Camera.shakeNames[Number(shakeType)], amplitude);
-    }
-    stopShaking() {
-        StopCamShaking(this.handle, true);
-    }
-    get IsShaking() {
-        return IsCamShaking(this.handle);
-    }
-    set ShakeAmplitude(amplitude) {
-        SetCamShakeAmplitude(this.handle, amplitude);
-    }
-    async playAnim(animName, animDict, position, rotation) {
-        await LoadAnimDict(animDict);
-        PlayCamAnim(this.handle, animName, animDict, position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, false, 2);
-        RemoveAnimDict(animDict);
-    }
-    pointAt(target, offset = new Vector3(0, 0, 0)) {
-        if (target instanceof BaseEntity) {
-            PointCamAtEntity(this.handle, target.Handle, offset.x, offset.y, offset.z, true);
-        }
-        else if (target instanceof PedBone) {
-            PointCamAtPedBone(this.handle, target.Owner.Handle, target.Index, offset.x, offset.y, offset.z, true);
-        }
-        else {
-            PointCamAtCoord(this.handle, target.x, target.y, target.z);
-        }
-    }
-    stopPointing() {
-        StopCamPointing(this.handle);
-    }
-    interpTo(to, duration, easePosition, easeRotation) {
-        SetCamActiveWithInterp(to.handle, this.handle, duration, Number(easePosition), Number(easeRotation));
-    }
-    get IsInterpolating() {
-        return IsCamInterpolating(this.handle);
-    }
-    attachTo(object, offset) {
-        if (object instanceof BaseEntity) {
-            AttachCamToEntity(this.handle, object.Handle, offset.x, offset.y, offset.z, true);
-        }
-        else if (object instanceof PedBone) {
-            AttachCamToPedBone(this.handle, object.Owner.Handle, object.Index, offset.x, offset.y, offset.z, true);
-        }
-    }
-    detach() {
-        DetachCam(this.handle);
-    }
-    delete() {
-        DestroyCam(this.handle, false);
-    }
-    exists() {
-        return DoesCamExist(this.handle);
-    }
-}

package/Checkpoint.js

@@ -1,43 +0,0 @@
-import { CheckpointIcon } from "./enums";
-import { Vector3 } from "./utils";
-export class Checkpoint {
-    handle;
-    position = new Vector3(0, 0, 0);
-    targetPosition = new Vector3(0, 0, 0);
-    icon = CheckpointIcon.Empty;
-    radius = 0;
-    constructor(handle) {
-        this.handle = handle;
-    }
-    get Position() {
-        return this.position;
-    }
-    set Position(position) {
-        this.position = position;
-    }
-    get TargetPosition() {
-        return this.targetPosition;
-    }
-    set TargetPosition(targetPosition) {
-        this.targetPosition = targetPosition;
-    }
-    get Icon() {
-        return this.icon;
-    }
-    set Icon(icon) {
-        this.icon = icon;
-    }
-    // TODO
-    //   public get CustomIcon(): CheckpointIcon {
-    //     return this.icon;
-    //   }
-    //     public set CustomIcon(icon: CheckpointIcon) {
-    //     this.icon = icon;
-    //   }
-    get Radius() {
-        return this.radius;
-    }
-    set Radius(radius) {
-        this.radius = radius;
-    }
-}

package/Events.js

@@ -1,74 +0,0 @@
-import { ClassTypes } from "../common/utils/ClassTypes";
-import { Ped } from "./models/Ped";
-import { Vector2, Vector3, Vector4 } from "./utils";
-import { Player } from "./models/Player";
-import { Prop } from "./models/Prop";
-import { Vehicle } from "./models/Vehicle";
-import { BaseEntity } from "./models";
-const getClassFromArguments = (...args) => {
-    const newArgs = [];
-    for (const arg of args) {
-        if (!arg.type) {
-            newArgs.push(arg);
-            continue;
-        }
-        switch (arg.type) {
-            case ClassTypes.Vector2: {
-                newArgs.push(Vector2.fromObject(arg));
-                continue;
-            }
-            case ClassTypes.Vector3: {
-                newArgs.push(Vector3.fromObject(arg));
-                continue;
-            }
-            case ClassTypes.Vector4: {
-                newArgs.push(Vector4.fromObject(arg));
-                continue;
-            }
-            case ClassTypes.Ped: {
-                newArgs.push(Ped.fromNetworkId(arg.handle));
-                continue;
-            }
-            case ClassTypes.Player: {
-                newArgs.push(Player.fromServerId(arg.source));
-                continue;
-            }
-            case ClassTypes.Prop: {
-                newArgs.push(Prop.fromNetworkId(arg.handle));
-                continue;
-            }
-            case ClassTypes.Vehicle: {
-                newArgs.push(Vehicle.fromNetworkId(arg.netId));
-                continue;
-            }
-            case ClassTypes.Entity: {
-                newArgs.push(BaseEntity.fromNetworkId(arg.netId));
-                continue;
-            }
-            default: {
-                newArgs.push(arg);
-            }
-        }
-    }
-    return newArgs;
-};
-// TODO: Add a third argument to enable recursive decent and change any
-// object/array to its proper type
-export class Events {
-    /**
-     * An onNet wrapper that properly converts the type into the correct type
-     */
-    static onNet = (eventName, event) => {
-        onNet(eventName, (...args) => {
-            event(...getClassFromArguments(...args));
-        });
-    };
-    /**
-     * An on wrapper that properly converts the classes
-     */
-    static on = (eventName, event) => {
-        on(eventName, (...args) => {
-            event(...getClassFromArguments(...args));
-        });
-    };
-}