@nativewrappers/redm 0.0.44

package/Attribute.d.ts

@@ -0,0 +1,65 @@
+import { eAttributeCore, ePedAttribute, eHudStatusEffect } from "./enums/Attributes";
+import { Ped } from "./entities/Ped";
+export declare class CoreAttribute {
+    private handle;
+    private attribute;
+    constructor(ped: Ped, attribute: eAttributeCore);
+    /**
+     * This doesn't seem to actually do anything
+     * @todo maybe remove unless theres a valid use case
+     * @param amount
+     * @param makeSound
+     */
+    enableOverpower(amount: number, makeSound?: boolean): void;
+    get Overpowered(): boolean;
+    /**
+     * @returns the amount of overpower time left in seconds
+     */
+    get OverpoweredTimeLeft(): number;
+    /**
+     * Returns how full the core is
+     */
+    get CoreValue(): number;
+    set CoreValue(amount: number);
+}
+export declare class PedAttribute {
+    private handle;
+    private attribute;
+    constructor(ped: Ped, attribute: ePedAttribute);
+    /**
+     *
+     * @param amount the amount of points to add to the attribute
+     */
+    addPoints(amount: number): void;
+    /**
+     * Disables the overpower state on this attribute, see {@link enableOverpower} on how to enable
+     */
+    disableOverpower(): void;
+    /**
+     *
+     * @param amount the amount to overpower this attribute by
+     * @param makeSound if activating the overpower should play sound
+     */
+    enableOverpower(amount: number, makeSound?: boolean): void;
+    /**
+     * Gets the amount of attribute points the ped has
+     */
+    get Points(): number;
+    set Points(amount: number);
+    get Rank(): number;
+    set BaseRank(amount: number);
+    get BaseRank(): number;
+    set BonusRank(amount: number);
+    get BonusRank(): number;
+    get MaxRank(): number;
+    get Overpowered(): boolean;
+}
+export declare class Attributes {
+    private pedAttributes;
+    private coreAttributes;
+    constructor(ped: Ped);
+    getCore(attribute: eAttributeCore): CoreAttribute;
+    get(attribute: ePedAttribute): PedAttribute;
+    set CoreIcon(status: eHudStatusEffect);
+    set PeriodicIcon(status: eHudStatusEffect);
+}

package/Attribute.js

@@ -0,0 +1,143 @@
+import { _N } from "./utils/Native";
+export class CoreAttribute {
+    handle;
+    attribute;
+    constructor(ped, attribute) {
+        this.handle = ped.Handle;
+        this.attribute = attribute;
+    }
+    /**
+     * This doesn't seem to actually do anything
+     * @todo maybe remove unless theres a valid use case
+     * @param amount
+     * @param makeSound
+     */
+    enableOverpower(amount, makeSound = false) {
+        // EnableAttributeCoreOverpower
+        _N("0x4AF5A4C7B9157D14", this.handle, this.attribute, amount, makeSound);
+    }
+    get Overpowered() {
+        return _N("0x200373A8DF081F22", this.attribute, Citizen.resultAsInteger());
+    }
+    /**
+     * @returns the amount of overpower time left in seconds
+     */
+    get OverpoweredTimeLeft() {
+        // GetAttributeCoreOverpowerSecondsLeft
+        return _N("0xB429F58803D285B1", this.handle, this.attribute, Citizen.resultAsInteger());
+    }
+    /**
+     * Returns how full the core is
+     */
+    get CoreValue() {
+        return GetAttributeCoreValue(this.handle, this.attribute);
+    }
+    set CoreValue(amount) {
+        // SetAttributeCoreValue
+        _N("0xC6258F41D86676E0", this.handle, this.attribute, amount);
+    }
+}
+export class PedAttribute {
+    handle;
+    attribute;
+    constructor(ped, attribute) {
+        this.handle = ped.Handle;
+        this.attribute = attribute;
+    }
+    /**
+     *
+     * @param amount the amount of points to add to the attribute
+     */
+    addPoints(amount) {
+        AddAttributePoints(this.handle, this.attribute, amount);
+    }
+    /**
+     * Disables the overpower state on this attribute, see {@link enableOverpower} on how to enable
+     */
+    disableOverpower() {
+        DisableAttributeOverpower(this.handle, this.attribute);
+    }
+    /**
+     *
+     * @param amount the amount to overpower this attribute by
+     * @param makeSound if activating the overpower should play sound
+     */
+    enableOverpower(amount, makeSound = false) {
+        // EnableAttributeOverpower
+        _N("0xF6A7C08DF2E28B28", this.handle, this.attribute, amount, makeSound);
+    }
+    /**
+     * Gets the amount of attribute points the ped has
+     */
+    get Points() {
+        return GetAttributePoints(this.handle, this.attribute);
+    }
+    set Points(amount) {
+        SetAttributePoints(this.handle, this.attribute, amount);
+    }
+    get Rank() {
+        return GetAttributeRank(this.handle, this.attribute);
+    }
+    set BaseRank(amount) {
+        SetAttributeBaseRank(this.handle, this.attribute, amount);
+    }
+    get BaseRank() {
+        return GetAttributeBaseRank(this.handle, this.attribute);
+    }
+    set BonusRank(amount) {
+        SetAttributeBonusRank(this.handle, this.attribute, amount);
+    }
+    get BonusRank() {
+        return GetAttributeBonusRank(this.handle, this.attribute);
+    }
+    get MaxRank() {
+        // GetMaxAttributeRank
+        return _N("0x704674A0535A471D", this.attribute, Citizen.resultAsInteger());
+    }
+    get Overpowered() {
+        // IsAttributeOverpowered
+        return _N("0x103C2F885ABEB00B", this.attribute, Citizen.resultAsInteger());
+    }
+}
+// There's probably a better way to do this but this will do for now as it reduces repetition
+export class Attributes {
+    pedAttributes = [];
+    coreAttributes = [];
+    constructor(ped) {
+        for (let i = 0; i <= 21; i++) {
+            this.pedAttributes[i] = new PedAttribute(ped, i);
+        }
+        for (let i = 0; i <= 2; i++) {
+            this.coreAttributes[i] = new CoreAttribute(ped, i);
+        }
+    }
+    getCore(attribute) {
+        if (attribute > 2)
+            throw new RangeError("The max enum for CoreAttribute is 2");
+        if (attribute < 0)
+            throw new RangeError("The minimum enum for CoreAttribute is 0");
+        // This should always be valid
+        return this.coreAttributes[attribute];
+    }
+    get(attribute) {
+        if (attribute > 22)
+            throw new RangeError("The max enum for PedAttribute is 22");
+        if (attribute < 0)
+            throw new RangeError("The minimum enum for PedAttribute is 0");
+        return this.pedAttributes[attribute];
+    }
+    set CoreIcon(status) {
+        if (status > 15)
+            throw new RangeError("The max enum for StatusEffect is 15");
+        if (status < 0)
+            throw new RangeError("The minimum enum for StatusEffect is 0");
+        _N("0xA4D3A1C008F250DF", status);
+    }
+    set PeriodicIcon(status) {
+        if (status > 15)
+            throw new RangeError("The max enum for StatusEffect is 15!");
+        if (status < 0)
+            throw new RangeError("The minimum enum for StatusEffect is 0");
+        _N("0xFB6E111908502871", status);
+    }
+}

package/RelationshipGroup.d.ts

@@ -0,0 +1,49 @@
+import { Relationship } from "./enums/Relationship";
+/**
+ * Class to create and manage a relationship group. Useful to manage behavior between Peds.
+ */
+export declare class RelationshipGroup {
+    /**
+     * The hash of the relationship group
+     */
+    private hash;
+    /**
+     * Create a relationship group. Optionally pass a group hash.
+     *
+     * @param name Name of the relationship group.
+     */
+    constructor(name: string);
+    /**
+     * Gets the hash of the relationship group.
+     *
+     * @returns The hash of this object.
+     */
+    get Hash(): number;
+    /**
+     * Get the relationship between two relationship groups.
+     *
+     * @param targetGroup The other relationship group.
+     * @returns The relationship
+     */
+    getRelationshipBetweenGroups(targetGroup: RelationshipGroup): Relationship;
+    /**
+     * Set the relationship group between this relationship group and another one.
+     *
+     * @param targetGroup The other relationship group.
+     * @param relationship The desired relationship.
+     * @param biDirectionally If target group should have same relationship towards this.
+     */
+    setRelationshipBetweenGroups(targetGroup: RelationshipGroup, relationship: Relationship, biDirectionally?: boolean): void;
+    /**
+     * Clear the relationship between this relationship group and another.
+     *
+     * @param targetGroup The other relationship group.
+     * @param relationship The desired relationship to clear.
+     * @param biDirectionally Whether the target group should also clear the relationship.
+     */
+    clearRelationshipBetweenGroups(targetGroup: RelationshipGroup, relationship: Relationship, biDirectionally?: boolean): void;
+    /**
+     * Remove this relationship group from the game. This will not delete this object.
+     */
+    remove(): void;
+}

package/RelationshipGroup.js

@@ -0,0 +1,67 @@
+/**
+ * Class to create and manage a relationship group. Useful to manage behavior between Peds.
+ */
+export class RelationshipGroup {
+    /**
+     * The hash of the relationship group
+     */
+    hash;
+    /**
+     * Create a relationship group. Optionally pass a group hash.
+     *
+     * @param name Name of the relationship group.
+     */
+    constructor(name) {
+        const [, groupHash] = AddRelationshipGroup(name);
+        this.hash = groupHash;
+    }
+    /**
+     * Gets the hash of the relationship group.
+     *
+     * @returns The hash of this object.
+     */
+    get Hash() {
+        return this.hash;
+    }
+    /**
+     * Get the relationship between two relationship groups.
+     *
+     * @param targetGroup The other relationship group.
+     * @returns The relationship
+     */
+    getRelationshipBetweenGroups(targetGroup) {
+        return GetRelationshipBetweenGroups(this.Hash, targetGroup.Hash);
+    }
+    /**
+     * Set the relationship group between this relationship group and another one.
+     *
+     * @param targetGroup The other relationship group.
+     * @param relationship The desired relationship.
+     * @param biDirectionally If target group should have same relationship towards this.
+     */
+    setRelationshipBetweenGroups(targetGroup, relationship, biDirectionally = false) {
+        SetRelationshipBetweenGroups(Number(relationship), this.Hash, targetGroup.Hash);
+        if (biDirectionally) {
+            SetRelationshipBetweenGroups(Number(relationship), targetGroup.Hash, this.Hash);
+        }
+    }
+    /**
+     * Clear the relationship between this relationship group and another.
+     *
+     * @param targetGroup The other relationship group.
+     * @param relationship The desired relationship to clear.
+     * @param biDirectionally Whether the target group should also clear the relationship.
+     */
+    clearRelationshipBetweenGroups(targetGroup, relationship, biDirectionally = false) {
+        ClearRelationshipBetweenGroups(Number(relationship), this.Hash, targetGroup.Hash);
+        if (biDirectionally) {
+            ClearRelationshipBetweenGroups(Number(relationship), targetGroup.Hash, this.Hash);
+        }
+    }
+    /**
+     * Remove this relationship group from the game. This will not delete this object.
+     */
+    remove() {
+        RemoveRelationshipGroup(this.Hash);
+    }
+}

package/Volume.d.ts

@@ -0,0 +1,6 @@
+import { Vector3 } from "../common/utils/Vector3";
+export declare class Volume {
+    private handle;
+    constructor(coord: Vector3, rot: Vector3, scale: Vector3, customName?: string);
+    get Handle(): number;
+}

package/Volume.js

@@ -0,0 +1,13 @@
+export class Volume {
+    handle;
+    constructor(coord, rot, scale, customName) {
+        if (customName) {
+            this.handle = CreateVolumeCylinderWithCustomName(coord.x, coord.y, coord.z, rot.x, rot.y, rot.z, scale.x, scale.y, scale.z, customName);
+            return;
+        }
+        this.handle = CreateVolumeCylinder(coord.x, coord.y, coord.z, rot.x, rot.y, rot.z, scale.x, scale.y, scale.z);
+    }
+    get Handle() {
+        return this.handle;
+    }
+}

package/entities/BaseEntity.d.ts

@@ -0,0 +1,7 @@
+export declare class BaseEntity {
+    private handle;
+    constructor(entHandle: number);
+    get Handle(): number;
+    set Health(amount: number);
+    get Health(): number;
+}

package/entities/BaseEntity.js

@@ -0,0 +1,15 @@
+export class BaseEntity {
+    handle;
+    constructor(entHandle) {
+        this.handle = entHandle;
+    }
+    get Handle() {
+        return this.handle;
+    }
+    set Health(amount) {
+        SetEntityHealth(this.Handle, amount, 0);
+    }
+    get Health() {
+        return GetEntityHealth(this.Handle);
+    }
+}

package/entities/Entity.d.ts

@@ -0,0 +1,38 @@
+import { BoneIndex, EntityType, ForceType } from "../enums/Entity";
+import { Throwable } from "../types/Throwable";
+import { Vector3 } from "../utils";
+import { BaseEntity } from "./BaseEntity";
+export declare class Entity extends BaseEntity {
+    constructor(handle: number);
+    addTrackingTrails(): void;
+    get EntityType(): EntityType;
+    /**
+     * @param direction - the direction to apply the force towards
+     * @param offset - the offset to apply the force to
+     * @param forceType - the force type to apply
+     * @param boneIndex - the boneIndex to apply the force to, or 0
+     * @param isDirectional - whether the direction is relational?
+     * @param ignoreUpVec - ?
+     * @param isForceRel - whether to multiply the force by the object mass & acceleration
+     */
+    applyForce(direction: Vector3, offset: Vector3, forceType?: ForceType, boneIndex?: BoneIndex, isDirectional?: boolean, ignoreUpVec?: boolean, isForceRel?: boolean): void;
+    /**
+     * @param direction - the direction to apply the force towards
+     * @param forceType - the force type to use
+     * @param isDirectional - whether the direction is local?
+     * @param isForceRel - whether to multiply the force by the object mass & acceleration
+     */
+    applyForceToCenter(direction: Vector3, forceType?: ForceType, isDirectional?: boolean, isForceRel?: boolean): void;
+    /**
+     * @param tgtEntity - the entity to attach to the {@Entity}
+     * @param pos - the position offset
+     * @param rot - the rotation to apply to the entity
+     * @param boneIndex - the bone to attach the entity to, or 0 for the center of the entity
+     * @param enableCollision - whether the entity should have collision enabled
+     * @param useSoftPinning - when false the entity will not detach from the {@Entity}
+     * @param vertexIndex -  ?
+     * @param fixedRot - ?
+     * @throws Error if tgtEntity and {@Entity} are the same entity
+     */
+    attachTo(tgtEntity: Entity, pos: Vector3, rot: Vector3, boneIndex?: BoneIndex, enableCollision?: boolean, useSoftPinning?: boolean, vertexIndex?: number, fixedRot?: boolean): Throwable<void>;
+}

package/entities/Entity.js

@@ -0,0 +1,58 @@
+import { EntityType, ForceType } from "../enums/Entity";
+import { _N } from "../utils";
+import { BaseEntity } from "./BaseEntity";
+export class Entity extends BaseEntity {
+    constructor(handle) {
+        super(handle);
+    }
+    addTrackingTrails() {
+        // _ADD_ENTITY_TRACKING_TRAILS
+        _N("0x1AD922AB5038DEF3", this.Handle);
+    }
+    get EntityType() {
+        return GetEntityType(this.Handle);
+    }
+    /**
+     * @param direction - the direction to apply the force towards
+     * @param offset - the offset to apply the force to
+     * @param forceType - the force type to apply
+     * @param boneIndex - the boneIndex to apply the force to, or 0
+     * @param isDirectional - whether the direction is relational?
+     * @param ignoreUpVec - ?
+     * @param isForceRel - whether to multiply the force by the object mass & acceleration
+     */
+    applyForce(direction, offset, forceType = ForceType.MinForce, boneIndex = 0, isDirectional = false, ignoreUpVec = true, isForceRel = true) {
+        const d = direction;
+        const o = offset;
+        ApplyForceToEntity(this.Handle, forceType, d.x, d.y, d.z, o.x, o.y, o.z, boneIndex, isDirectional, ignoreUpVec, isForceRel, false, true);
+    }
+    /**
+     * @param direction - the direction to apply the force towards
+     * @param forceType - the force type to use
+     * @param isDirectional - whether the direction is local?
+     * @param isForceRel - whether to multiply the force by the object mass & acceleration
+     */
+    applyForceToCenter(direction, forceType = ForceType.MinForce, isDirectional = false, isForceRel = true) {
+        const d = direction;
+        ApplyForceToEntityCenterOfMass(this.Handle, forceType, d.x, d.y, d.z, false, isDirectional, isForceRel, false);
+    }
+    /**
+     * @param tgtEntity - the entity to attach to the {@Entity}
+     * @param pos - the position offset
+     * @param rot - the rotation to apply to the entity
+     * @param boneIndex - the bone to attach the entity to, or 0 for the center of the entity
+     * @param enableCollision - whether the entity should have collision enabled
+     * @param useSoftPinning - when false the entity will not detach from the {@Entity}
+     * @param vertexIndex -  ?
+     * @param fixedRot - ?
+     * @throws Error if tgtEntity and {@Entity} are the same entity
+     */
+    attachTo(tgtEntity, pos, rot, boneIndex = 0, enableCollision = true, useSoftPinning = false, vertexIndex = 0, fixedRot = true) {
+        if (tgtEntity.Handle === this.Handle) {
+            throw new Error("tgtEntity had the same handle as the current entity, attaching an entity to itself will crash");
+        }
+        const p = pos;
+        const r = rot;
+        AttachEntityToEntity(tgtEntity.Handle, this.Handle, boneIndex, p.x, p.y, p.z, r.x, r.y, r.z, false, useSoftPinning, enableCollision, (this.EntityType === EntityType.Ped), vertexIndex, fixedRot, false, false);
+    }
+}

package/entities/Ped.d.ts

@@ -0,0 +1,167 @@
+import { Attributes } from "../Attribute";
+import { eDamageCleanliness, KnockOffVehicle, TamingState } from "../enums/Ped";
+import { VehicleSeat } from "../enums/VehicleSeat";
+import { Vector3 } from "../utils";
+import { BaseEntity } from "./BaseEntity";
+import { Vehicle } from "./Vehicle";
+import { Player } from "./Player";
+export type OptionalPed = Ped | null;
+export declare class Ped extends BaseEntity {
+    private attributes;
+    constructor(handle: number);
+    /**
+     * Blocks scenarios inbetween the specified vectors
+     * @todo Move to Game
+     * @param vec1
+     * @param vec2
+     * @param blockingFlags you can find blocking flags [here](https://github.com/Halen84/RDR3-Native-Flags-And-Enums/blob/main/ADD_SCENARIO_BLOCKING_AREA/README.md)
+     * @returns the scenarioId that can be used in {@link removeScenarioBlock} to unblock
+     */
+    static blockScenariosInArea(vec1: Vector3, vec2: Vector3, blockingFlags: number): number;
+    /**
+     * Removes the blocking of scenarios in the specified area
+     * @param scenarioId the number returned from {@link blockScenariosInArea}
+     */
+    static removeScenarioBlock(scenarioId: number): void;
+    /**
+     * While this increases the peds max health, if used on a player it wont increase the max core value on the hud
+     */
+    set MaxHealth(amount: number);
+    /**
+     * @returns the maximum health of the ped
+     */
+    get MaxHealth(): number;
+    /**
+     * @returns the {@link Attributes} for the current ped
+     */
+    get Attributes(): Attributes;
+    get InVehicle(): boolean;
+    get IsInjured(): boolean;
+    get IsFatallyInjured(): boolean;
+    get IsPlayer(): boolean;
+    get Heading(): number;
+    set Heading(heading: number);
+    get IsShooting(): boolean;
+    get Accuracy(): number;
+    set Accuracy(accuracy: number);
+    get CanBeKnockedOffVehicle(): boolean;
+    get IsMale(): boolean;
+    get IsHuman(): boolean;
+    get IsOnTopOfVehicle(): boolean;
+    get Vehicle(): Vehicle;
+    /**
+     * @returns the last mount that this ped was on, or null if it doesn't exist
+     */
+    get Mount(): OptionalPed;
+    /**
+     * returns the horse that this ped is leading
+     */
+    get LeadingHorse(): OptionalPed;
+    /**
+     * returns the owner of the current animal
+     */
+    get Owner(): OptionalPed;
+    get TamingState(): TamingState;
+    get IsInteractingWithAnimal(): boolean;
+    get IsSittingInAnyVehicle(): boolean;
+    get IsPlantingBomb(): boolean;
+    get IsInAnyBoat(): boolean;
+    get IsInAnyHeli(): boolean;
+    get IsInAnyPlane(): boolean;
+    get IsInFlyingVehicle(): boolean;
+    get IsFalling(): boolean;
+    get IsSliding(): boolean;
+    get IsJumping(): boolean;
+    get IsClimbing(): boolean;
+    get IsClimbingLadder(): boolean;
+    get IsVaulting(): boolean;
+    get IsDiving(): boolean;
+    get IsOpeningADoor(): boolean;
+    set SeeingRange(value: number);
+    set HearingRange(value: number);
+    get IsStealthed(): boolean;
+    get IsJacking(): boolean;
+    get IsStunned(): boolean;
+    get IsBeingJacked(): boolean;
+    get IsInCombatRoll(): boolean;
+    get CrouchMovement(): boolean;
+    /**
+     * returns true if {@link DamageCleanliness} was ever lower than {@link eDamageCleanliness.Good}
+     */
+    get IsDamaged(): boolean;
+    set IsDamaged(damaged: boolean);
+    get DamageCleanliness(): eDamageCleanliness;
+    set DamageCleanliness(cleanliness: eDamageCleanliness);
+    set DefenseModifier(amount: number);
+    set CanBeTargeted(toggle: boolean);
+    /**
+     * returns the ped who jacked this ped
+     */
+    getJacker(): Ped;
+    setCrouchMovement(state: boolean, immediately?: boolean): void;
+    canBeTargetedByPlayer(player: Player, toggle: boolean): void;
+    clearLastBoneDamage(): void;
+    set OwnsAnimal(animal: Ped);
+    isInteractionPossible(animal: Ped): boolean;
+    isOnVehicle(vehicle: Vehicle): boolean;
+    isSittingInVehicle(vehicle: Vehicle): boolean;
+    warpOutOfVehicle(): void;
+    /**
+     * puts the ped onto the specified mount
+     * @param targetPed the horse to put the ped on
+     * @param seatIndex the seat index to put the ped on
+     */
+    setOntoMount(targetPed: Ped, seatIndex: VehicleSeat): void;
+    removeFromMount(): void;
+    /**
+     *
+     * @param seatIndex the seat index to check
+     * @returns true of the specified seat is free on the mount
+     */
+    isSeatFree(seatIndex: VehicleSeat): boolean;
+    /**
+     * Sets the ped into the specified vehicle
+     * @param vehicle the vehicle to put the ped into
+     * @param seatIndex the seat index to put the ped into
+     */
+    setIntoVehicle(vehicle: Vehicle, seatIndex: VehicleSeat): void;
+    /**
+     * kills the ped and optionally sets the killer
+     * @param killer the entity that killed the ped
+     */
+    killPed(killer?: BaseEntity): void;
+    damage(amount: number, boneId?: number, killer?: Ped): void;
+    /**
+     * this returns a different type then the getter so we can't use set, maybe ts will fix soon (tm)
+     * @param state how hard it will be to knock a ped off their vehicle
+     */
+    setCanBeKnockedOffVehicle(state: KnockOffVehicle): void;
+    /**
+     * Removes the specified ped if its not a player entity
+     */
+    delete(): void;
+    /**
+     * creates a clone of the ped
+     * @param network if the ped should be a networked entity
+     * @param bScriptHostPed whether to register the ped as pinned to the script host in the R* network model.
+     * @param copyHeadBlend whether to copy the peds head blend
+     * @returns the cloned ped
+     */
+    clone(network: boolean, bScriptHostPed: boolean, copyHeadBlend: boolean): Ped;
+    /**
+     * clones the ped onto the target ped
+     * @param targetPed the ped to clone onto
+     */
+    cloneTo(targetPed: Ped): void;
+    /**
+     * @param amount - the amount of armour to add to the ped
+     */
+    addArmour(amount: number): void;
+    applyDamage(damageAmount: number, boneId?: number, pedKiller?: OptionalPed): void;
+    /**
+     * @param damagePack - the damage decal to apply see [here](https://github.com/femga/rdr3_discoveries/blob/master/peds_customization/ped_decals.lua) for more documentation
+     * @param damage - the damage to apply
+     * @param mult - the multiplier?
+     */
+    applyDamagePack(damagePack: string, damage: number, mult: number): void;
+}