@nativewrappers/redm-codegen 0.0.2

package/dist/namespaces/Map.js

@@ -0,0 +1,641 @@
+import { Vector3 } from '../types/Vector3';
+import { inv, rai, rav, pvi, pvf, pvv, _h, f } from '../types/NativeAliases';
+export class Map {
+    /**
+     * Doesn't actually return anything.
+     *
+     * @returns
+     */
+    static forceSonarBlipsThisFrame() {
+        return inv('0xEE1C7BA69BB74B08');
+    }
+    /**
+     * @param scale
+     * @param p1
+     */
+    static setMinimapFowOverrideRevealScale(scale, p1) {
+        inv('0xE5A7F70B7C0F3271', f(scale), _h(p1));
+    }
+    /**
+     * @param regionHash
+     */
+    static disableRegionBlip(regionHash) {
+        inv('0x6786D7AFAC3162B3', _h(regionHash));
+    }
+    /**
+     * in the decompiles this doesnt seem to ever be executed the param needed needs to be above 0 but its always passed as 0
+     * removes the icon from lockon prompt
+     *
+     * @param entity
+     * @param p1
+     */
+    static removeBlipIconFromEntityLockonPrompt(entity, p1) {
+        inv('0xBB68D4D3CA3DE402', entity.handle, p1);
+    }
+    /**
+     * @param hash
+     */
+    static revealMinimapFow(hash) {
+        inv('0xF8096DF9B87246E3', _h(hash));
+    }
+    /**
+     * @param blip
+     * @returns
+     */
+    static getBlipCoords(blip) {
+        return Vector3.fromArray(inv('0x201C319797BDA603', blip, rav()));
+    }
+    /**
+     * https://github.com/femga/rdr3_discoveries/blob/master/graphics/minimap/radar/radar_configs.lua
+     * configHash: -1943724816, 347777538, -117986897, -789269373, -547506804, -1986542417, 2080113112
+     * p1: usually 898171178 or 0 in R* scripts (doesn't seems to have any effect)
+     *
+     * @param configHash
+     * @param p1
+     */
+    static setRadarConfigType(configHash, p1) {
+        inv('0x9C113883487FD53C', _h(configHash), _h(p1));
+    }
+    /**
+     * It's unclear what exactly this does, but I assume it marks the blip as "no longer needed"
+     *
+     * @param blip
+     */
+    static abandonBlip(blip) {
+        inv('0xDEEDE7C41742E011', blip);
+    }
+    /**
+     * @param blip
+     * @param styleHash
+     * @returns
+     */
+    static blipAddStyle(blip, styleHash) {
+        return inv('0xBD62D98799A3DAF0', blip, _h(styleHash));
+    }
+    /**
+     * @param blipHash
+     * @param volume
+     * @returns
+     */
+    static blipAddForVolume(blipHash, volume) {
+        return inv('0xA6EF0C54A3443E70', _h(blipHash), volume.handle, rai());
+    }
+    /**
+     * If modifierHash is 0, ALL modifiers will be removed.
+     *
+     * @param blip
+     * @param modifierHash
+     * @returns
+     */
+    static blipRemoveModifier(blip, modifierHash) {
+        return inv('0xB059D7BD3D78C16F', blip, _h(modifierHash));
+    }
+    static unlockMinimapAngle() {
+        inv('0x5373DE8E179BC2A0');
+    }
+    /**
+     * @param blipHash
+     * @param entity
+     * @returns
+     */
+    static blipAddForEntity(blipHash, entity) {
+        return inv('0x23F74C2FDA6E7C61', _h(blipHash), entity.handle, rai());
+    }
+    /**
+     * @param typeHash
+     * @param entity
+     */
+    static triggerSonarBlipOnEntity(typeHash, entity) {
+        inv('0x0C7A2289A5C4D7C9', _h(typeHash), entity.handle);
+    }
+    /**
+     * Not official native name
+     * Removes the blip from an entity and makes it static on the map, try it on GetMainPlayerBlipId() for a demonstration
+     *
+     * @param blip
+     */
+    static blipDetachFromEntity(blip) {
+        inv('0x250C75EB1728CC0D', blip);
+    }
+    /**
+     * Locks the minimap to the specified angle in integer degrees. angle: The angle in whole degrees. If less than 0 or greater than 360, unlocks the angle.
+     *
+     * @param angle
+     */
+    static lockMinimapAngle(angle) {
+        inv('0x0BFD145EF819FB3A', angle);
+    }
+    /**
+     * adds the entity blip icon to the entity lockon prompt if wrong param will remove the icon if had any
+     *
+     * @param entity
+     * @param blipId
+     */
+    static setEntityBlipIconToLockonEntityPrompt(entity, blipId) {
+        inv('0x97F6F158CC5B5CA2', entity.handle, blipId);
+    }
+    /**
+     * @returns blip
+     */
+    static removeBlip() {
+        const result = inv('0xF2C3C9DA47AAA54A', pvi());
+        return result;
+    }
+    static clearGpsPlayerWaypoint() {
+        inv('0x08FDC6F796E350D1');
+    }
+    /**
+     * @param blip
+     * @param hash
+     * @param p2
+     */
+    static setBlipSprite(blip, hash, p2) {
+        inv('0x74F74D3207ED525C', blip, _h(hash), p2);
+    }
+    /**
+     * checks if the entity lockon prompt contains an icon
+     *
+     * @param entity
+     * @param blipId
+     * @returns
+     */
+    static isBlipIconOnLockonEntityPrompt(entity, blipId) {
+        return inv('0x3CB8859F04763C78', entity.handle, blipId);
+    }
+    /**
+     * @param toggle
+     */
+    static allowSonarBlips(toggle) {
+        inv('0x6E6E64788C07D2E0', toggle);
+    }
+    static showActivePointsOfInterest() {
+        inv('0x3FBB838AEA30C1D8');
+    }
+    /**
+     * @returns
+     */
+    static isWaypointActive() {
+        return inv('0x202B1BBFC6AB5EE4', rai());
+    }
+    /**
+     * @param blip
+     * @returns p1; p2
+     */
+    static setBlipFlashes(blip) {
+        const result = inv('0x0DF2B55F717DDB10', blip, pvi(), pvi());
+        return [result[0], result[1], result[2]];
+    }
+    /**
+     * @param blipHash
+     * @param pickup
+     * @returns
+     */
+    static blipAddForPickupPlacement(blipHash, pickup) {
+        return inv('0xA486008892065FB9', _h(blipHash), pickup.handle, rai());
+    }
+    static hideActivePointsOfInterest() {
+        inv('0xA1B4052C2A3DCC1E');
+    }
+    /**
+     * @param volume
+     * @param p1
+     */
+    static setMinimapFowRevealVolume(volume, p1) {
+        inv('0x63CBBD6CA6F321F9', volume.handle, _h(p1));
+    }
+    /**
+     * https://github.com/femga/rdr3_discoveries/tree/master/useful_info_from_rpfs/blip_styles
+     * Removes any existing modifiers and sets the style.
+     *
+     * @param blip
+     * @param styleHash
+     * @returns
+     */
+    static blipSetStyle(blip, styleHash) {
+        return inv('0xEDD964B7984AC291', blip, _h(styleHash));
+    }
+    /**
+     * @param zoomLevel
+     */
+    static setRadarZoom(zoomLevel) {
+        inv('0xCAF6489DA2C8DD9E', zoomLevel);
+    }
+    /**
+     * @param regionHash
+     * @param styleHash
+     * @returns
+     */
+    static isRegionHighlightedWithStyle(regionHash, styleHash) {
+        return inv('0xE38450DBCBC70E3D', _h(regionHash), _h(styleHash));
+    }
+    /**
+     * Unlike `GET_WAYPOINT_COORDS - 0x29B30D07C3F7873B`, which returns a single value, this native returns the x and y coordinates of the waypoint separately as floats from pointer. To retrieve each coordinate, `Citizen.PointerValueFloat()` must be used with this function.
+     *
+     * @returns x; y
+     */
+    static getWaypointPosition() {
+        const result = inv('0xF08E42BFA46BDFF8', pvf(), pvf());
+        return [result[0], result[1], result[2]];
+    }
+    /**
+     * Clear blip data. It must be used before RemoveBlip I'm pretty sure that blips are handled internally with databinding. This function should then allow you to clear blip container and therefore free up memory?.
+     *
+     * @param blipid
+     * @returns
+     */
+    static clearBlip(blipid) {
+        return inv('0x01B928CA2E198B01', blipid);
+    }
+    /**
+     * hash can be the hash of "guarma" or "world".
+     *
+     * @param zone
+     */
+    static setMinimapZone(zone) {
+        inv('0xA657EC9DBC6CC900', _h(zone));
+    }
+    /**
+     * @param blipHash
+     * @param pos
+     * @param radius
+     * @returns
+     */
+    static blipAddForRadius(blipHash, pos, radius) {
+        return inv('0x45F13B7E0A15C880', _h(blipHash), f(pos.x), f(pos.y), f(pos.z), f(radius), rai());
+    }
+    /**
+     * @param waypointRecording
+     * @param point
+     * @param numPoints
+     * @param colorNameHash
+     * @param p4
+     * @param p5
+     */
+    static startGpsCustomRouteFromWaypointRecordingRoute(waypointRecording, point, numPoints, colorNameHash, p4, p5) {
+        inv('0x6B44F13D888F770D', waypointRecording, point, numPoints, _h(colorNameHash), p4, p5);
+    }
+    /**
+     * @param pos
+     * @returns outPosition
+     */
+    static findClosestGpsPosition(pos) {
+        const result = inv('0x3FDA2B79AEEE351C', f(pos.x), f(pos.y), f(pos.z), pvv());
+        return [result[0], Vector3.fromArray(result[1])];
+    }
+    /**
+     * @returns
+     */
+    static getMainPlayerBlipId() {
+        return inv('0x5CD2889B2B381D45', rai());
+    }
+    /**
+     * @param blipHash
+     * @param pos
+     * @param scale
+     * @param p7
+     * @returns
+     */
+    static blipAddForArea(blipHash, pos, scale, p7) {
+        return inv('0xEC174ADBCB611ECC', _h(blipHash), f(pos.x), f(pos.y), f(pos.z), f(scale.x), f(scale.y), f(scale.z), p7, rai());
+    }
+    /**
+     * @param blip
+     * @param scale
+     */
+    static setBlipScale(blip, scale) {
+        inv('0xD38744167B2FA257', blip, f(scale));
+    }
+    /**
+     * Checks if the GPS route to the waypoint is navigable along a road. If a route exists but there is no valid road path, this function returns false.
+     *
+     * @returns
+     */
+    static isGpsRouteOnRoad() {
+        return inv('0xF47A1EB2A538A3A3');
+    }
+    /**
+     * list of minimap props: https://github.com/femga/rdr3_discoveries/tree/master/graphics/minimap/minimapObjects
+     * variations parameter are the interior locations you see on the map like these bellow
+     * variation 0 https://i.imgur.com/jkLhn3Z.png
+     * variation 2 https://i.imgur.com/eKV0Tcm.png
+     * variation 4 https://i.imgur.com/rjwOgEH.png
+     * there are more and you can find them in the decompiles
+     *
+     * @param minimapProp
+     * @param pos
+     * @param rotation
+     * @param variation
+     */
+    static addPropToMinimap(minimapProp, pos, rotation, variation) {
+        inv('0x1392105DA88BBFFB', _h(minimapProp), f(pos.x), f(pos.y), f(rotation), variation);
+    }
+    /**
+     * @param minimapProp
+     */
+    static removePropFromMinimap(minimapProp) {
+        inv('0xE057FEA9A22EB3EE', _h(minimapProp));
+    }
+    /**
+     * will remove the blip icon from the entity lockon prompt, use 0 for p1
+     *
+     * @param entity
+     * @param p1
+     */
+    static clearBlipIconFromLockonEntityPrompt(entity, p1) {
+        inv('0x44813684F72B563C', entity.handle, p1);
+    }
+    /**
+     * https://alloc8or.re/rdr3/doc/enums/rage__eGpsFlags.txt
+     *
+     * @param p0
+     * @param p1
+     */
+    static setGpsFlags(p0, p1) {
+        inv('0x5DE61C90DDECFA2D', p0, f(p1));
+    }
+    /**
+     * @param blip
+     * @param player
+     */
+    static setBlipNameToPlayerName(blip, player) {
+        inv('0x093DD5A31BC2B459', blip, player.handle);
+    }
+    /**
+     * @param blip
+     * @param blipType
+     * @param blipHash
+     */
+    static setBlipFlashTimer(blip, blipType, blipHash) {
+        inv('0x02FF4CF43B7209D1', blip, blipType, _h(blipHash));
+    }
+    /**
+     * @param hash
+     */
+    static resetMinimapFow(hash) {
+        inv('0xEB3CB3386C775D72', _h(hash));
+    }
+    /**
+     * @param colorNameHash
+     * @param onFoot
+     * @param inVehicle
+     */
+    static startGpsMultiRoute(colorNameHash, onFoot, inVehicle) {
+        inv('0x3D3D15AF7BCAAF83', _h(colorNameHash), onFoot, inVehicle);
+    }
+    /**
+     * will add a blip icon to the entity lockon prompt that you specify
+     *
+     * @param entity
+     * @param blipIcon
+     */
+    static setBlipIconToLockonEntityPrompt(entity, blipIcon) {
+        inv('0x7563CBCA99253D1A', entity.handle, _h(blipIcon));
+    }
+    /**
+     * Returns the Blip handle of given Entity.
+     *
+     * @param entity
+     * @returns
+     */
+    static getBlipFromEntity(entity) {
+        return inv('0x6D2C41A8BD6D6FD0', entity.handle, rai());
+    }
+    /**
+     * Clears the previously set coordinates for the pause map view, removing any specified focal point and radius that were set using `SetPausemapCoordsWithRadius - 0xE0884C184728C75B`
+     */
+    static clearPausemapCoords() {
+        inv('0x7C9F4CDF402CA82A');
+    }
+    /**
+     * Used for GUARMA MODE; Enabled: toggle = false, 0; Disabled: toggle = true, 0
+     * Hash p1 seems to be unused, always 0
+     *
+     * @param toggle
+     * @param p1
+     */
+    static setFowUpdatePlayerOverride(toggle, p1) {
+        inv('0x63E7279D04160477', toggle, _h(p1));
+    }
+    /**
+     * @param blip
+     * @returns
+     */
+    static isBlipOnMinimap(blip) {
+        return inv('0x46534526B9CD2D17', blip, rai());
+    }
+    /**
+     * https://alloc8or.re/rdr3/doc/enums/eBlipModifier.txt
+     * https://github.com/femga/rdr3_discoveries/tree/master/useful_info_from_rpfs/blip_modifiers Old name: _BLIP_SET_MODIFIER
+     *
+     * @param blip
+     * @param modifierHash
+     * @returns
+     */
+    static blipAddModifier(blip, modifierHash) {
+        return inv('0x662D364ABF16DE2F', blip, _h(modifierHash));
+    }
+    /**
+     * Does the same as SET_GPS_MULTI_ROUTE_RENDER(false);
+     */
+    static clearGpsMultiRoute() {
+        inv('0x9E0AB9AAEE87CE28');
+    }
+    /**
+     * @param blip
+     * @returns
+     */
+    static doesBlipExist(blip) {
+        return inv('0xCD82FA174080B3B1', blip, rai());
+    }
+    /**
+     * @param discoveryHash
+     */
+    static discoverySetEnabled(discoveryHash) {
+        inv('0xDA98246C7A3C2189', _h(discoveryHash));
+    }
+    /**
+     * @param styleHash
+     * @returns
+     */
+    static blipAddForStyle(styleHash) {
+        return inv('0x3E593DF9C2962EC6', _h(styleHash), rai());
+    }
+    /**
+     * https://github.com/femga/rdr3_discoveries/tree/master/useful_info_from_rpfs/textures/blips
+     * https://github.com/femga/rdr3_discoveries/tree/master/useful_info_from_rpfs/textures/blips_mp
+     *
+     * @param blipHash
+     * @param pos
+     * @returns
+     */
+    static blipAddForCoords(blipHash, pos) {
+        return inv('0x554D9D53F696D002', _h(blipHash), f(pos.x), f(pos.y), f(pos.z), rai());
+    }
+    /**
+     * @param pos
+     * @param p3
+     */
+    static addPointToGpsMultiRoute(pos, p3) {
+        inv('0x64C59DD6834FA942', f(pos.x), f(pos.y), f(pos.z), p3);
+    }
+    static setRadarAsExteriorThisFrame() {
+        inv('0xA8EBBAE986FB5457');
+    }
+    /**
+     * @param pos
+     * @param radius
+     */
+    static setPausemapCoordsWithRadius(pos, radius) {
+        inv('0xE0884C184728C75B', f(pos.x), f(pos.y), f(pos.z), f(radius));
+    }
+    /**
+     * If Minimap / Radar should be displayed.
+     *
+     * @param toggle
+     */
+    static displayRadar(toggle) {
+        inv('0x1B3DA717B9AFF828', toggle);
+    }
+    /**
+     * @param blip
+     * @param pos
+     */
+    static setBlipCoords(blip, pos) {
+        inv('0x4FF674F5E23D49CE', blip, f(pos.x), f(pos.y), f(pos.z));
+    }
+    /**
+     * @param discoveryHash
+     */
+    static discoverRegion(discoveryHash) {
+        inv('0xD8C7162AB2E2AF45', _h(discoveryHash));
+    }
+    /**
+     * Up to eight coordinates may be revealed per frame
+     *
+     * @param pos
+     * @param p3
+     */
+    static setMinimapFowRevealCoordinate(pos, p3) {
+        inv('0x73348402566ECB6E', f(pos.x), f(pos.y), f(pos.z), _h(p3));
+    }
+    static setWaypointOff() {
+        inv('0xFA8C41E8020D3439');
+    }
+    /**
+     * @returns
+     */
+    static getWaypointCoords() {
+        return Vector3.fromArray(inv('0x29B30D07C3F7873B', rav()));
+    }
+    /**
+     * @param blip
+     * @param name
+     */
+    static setBlipName(blip, name) {
+        inv('0x9CB1A1623062F402', blip, name);
+    }
+    /**
+     * @param p0
+     */
+    static N_0xD3F58E9316B7FC2A(p0) {
+        inv('0xD3F58E9316B7FC2A', p0);
+    }
+    /**
+     * @param blip
+     * @returns
+     */
+    static isBlipAttachedToAnyEntity(blip) {
+        return inv('0xE9F676788F8D5E1E', blip);
+    }
+    /**
+     * @param blip
+     * @param rotation
+     */
+    static setBlipRotation(blip, rotation) {
+        inv('0x6049966A94FBE706', blip, rotation);
+    }
+    /**
+     * @param blip
+     * @param textLabel
+     */
+    static setBlipNameFromTextFile(blip, textLabel) {
+        inv('0x0A062D6D7C0B2C2C', blip, textLabel);
+    }
+    /**
+     * @param toggle
+     * @param p1
+     */
+    static setMinimapFowShouldUpdate(toggle, p1) {
+        inv('0x632AA10BF7EA53D3', toggle, _h(p1));
+    }
+    /**
+     * regionHash: https://github.com/femga/rdr3_discoveries/tree/master/graphics/minimap/wanted_regions
+     *
+     * @param regionHash
+     * @param styleHash
+     */
+    static enableRegionBlip(regionHash, styleHash) {
+        inv('0x563FCB6620523917', _h(regionHash), _h(styleHash));
+    }
+    /**
+     * @param entity
+     * @returns
+     */
+    static doesEntityHaveBlip(entity) {
+        return inv('0x9FA00E2FC134A9D0', entity.handle);
+    }
+    /**
+     * @param toggle
+     */
+    static setGpsMultiRouteRender(toggle) {
+        inv('0x4426D65E029A4DC0', toggle);
+    }
+    /**
+     * Clears the GPS flags.
+     */
+    static clearGpsFlags() {
+        inv('0x4D3771237C79FF41');
+    }
+    /**
+     * It adds blip a icon to active prompts like from scenarios or pickups without the need to use lockon
+     *
+     * @param entity
+     * @param blipIcon
+     */
+    static setBlipIconOnEntityActivePrompt(entity, blipIcon) {
+        inv('0x1726963E6049DB53', entity.handle, _h(blipIcon));
+    }
+    static clearGpsCustomRoute() {
+        inv('0x1EAA5674B4D181C5');
+    }
+    /**
+     * @param p0
+     * @param p1
+     * @param p2
+     */
+    static setGpsCustomRouteRender(p0, p1, p2) {
+        inv('0xF6CEF599FC470B33', p0, p1, p2);
+    }
+    /**
+     * @param discoveryHash
+     * @returns
+     */
+    static isDiscoveryActive(discoveryHash) {
+        return inv('0x3F81EA4275D39D6F', _h(discoveryHash));
+    }
+    /**
+     * @param typeHash
+     * @param pos
+     */
+    static triggerSonarBlip(typeHash, pos) {
+        inv('0x72DD432F3CDFC0EE', _h(typeHash), f(pos.x), f(pos.y), f(pos.z));
+    }
+    /**
+     * Reveals the entire minimap (FOW = Fog of War)
+     *
+     * @param toggle
+     */
+    static setMinimapHideFow(toggle) {
+        inv('0x4B8F743A4A6D2FF8', toggle);
+    }
+}