@nativewrappers/redm-codegen 0.0.2

package/src/namespaces/Scripts.ts

@@ -0,0 +1,816 @@
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import { createFromHandle } from '../types/HandleRegistry';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class Scripts {
+  /**
+   * @returns value
+   */
+  static countPlayerBits(): [number, number] {
+    const result = inv<[number, number]>('0x462C687BEA254BD9', pvi(), rai());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @returns playerBits
+   */
+  static isAnyPlayerBitSet(): [any, number] {
+    const result = inv<[number, number]>('0x179A6F0EE2E79026', pvi());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * goalContext: see <availableContexts> in common/data/stats_and_challenges/goals_*.meta
+   *
+   * @param goalContext 
+   */
+  static activateGoalContext(goalContext: string | number): void {
+    inv<void>('0x7D654266025E921B', _h(goalContext));
+  }
+
+  /**
+   * @param scriptName 
+   * @param stackSize 
+   * @returns
+   */
+  static startNewScript(scriptName: string | null, stackSize: number): number {
+    return inv<number>('0xE81651AD79516E48', scriptName, stackSize, rai());
+  }
+
+  /**
+   * @param awardHash 
+   * @param itemIndex 
+   * @returns rpcGuid; outResultItem
+   */
+  static awardsGetResultItem(awardHash: string | number, itemIndex: number): [any, number, number] {
+    const result = inv<[number, number, number]>('0xAC8FAB22A914AE34', pvi(), _h(awardHash), itemIndex, pvi());
+    return [result[0], result[1], result[2]];
+  }
+
+  /**
+   * Returns true if GtaThread+0x77C is equal to 1. Old name: _BG_EXITED_BECAUSE_BACKGROUND_THREAD_STOPPED
+   *
+   * @returns
+   */
+  static bgIsExitflagSet(): boolean {
+    return inv<boolean>('0x2238EC3EC631AB1F', rai());
+  }
+
+  /**
+   * Starts a new iteration of the current threads.
+   * Call this first, then SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID (0x30B4FA1C82DD4B9F)
+   */
+  static scriptThreadIteratorReset(): void {
+    inv<void>('0x39382EB8DCD8684D');
+  }
+
+  /**
+   * @param threadId 
+   * @returns
+   */
+  static isBackgroundScript(threadId: number): any {
+    return inv<number>('0x20B7F69B40C6B755', threadId);
+  }
+
+  /**
+   * @param dataIndex 
+   * @returns rpcGuid; outLootData
+   */
+  static lootGetLootClaimData(dataIndex: number): [boolean, number, number] {
+    const result = inv<[boolean, number, number]>('0xF1E9045F5AA9E428', pvi(), dataIndex, pvi(), rai());
+    return [!!result[0], result[1], result[2]];
+  }
+
+  /**
+   * @param scriptHash 
+   * @returns
+   */
+  static doesScriptWithNameHashExist(scriptHash: string | number): boolean {
+    return inv<boolean>('0xA34E89749F628284', _h(scriptHash), rai());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param gamemodeName 
+   * @param title 
+   * @param subtitle 
+   */
+  static displayLoadingScreens(p0: string | number, p1: string | number, p2: string | number, gamemodeName: string | null, title: string | null, subtitle: string | null): void {
+    inv<void>('0x1E5B70E53DB661E5', _h(p0), _h(p1), _h(p2), gamemodeName, title, subtitle);
+  }
+
+  /**
+   * @param bitIndex 
+   * @returns value
+   */
+  static clearPlayerBitAtIndex(bitIndex: number): number {
+    const result = inv<number>('0xD426E2E3288469D6', pvi(), bitIndex);
+    return result;
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x6F700A4BF7C3331B(p0: boolean): void {
+    inv<void>('0x6F700A4BF7C3331B', p0);
+  }
+
+  /**
+   * Inserts the given context into the background scripts context map.
+   *
+   * @param contextName 
+   */
+  static bgStartContext(contextName: string | null): void {
+    inv<void>('0x49BA5678BA040CA7', contextName);
+  }
+
+  /**
+   * return : script thread id, 0 if failed
+   * Pass pointer to struct of args in p1, size of struct goes into p2
+   *
+   * @param scriptName 
+   * @param argCount 
+   * @param stackSize 
+   * @returns args
+   */
+  static startNewScriptWithArgs(scriptName: string | null, argCount: number, stackSize: number): [number, number] {
+    const result = inv<[number, number]>('0xB8BA7F44DF1575E1', scriptName, pvi(), argCount, stackSize, rai());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @param threadId 
+   * @returns
+   */
+  static doesThreadExist(threadId: number): any {
+    return inv<number>('0xFF975BC4435A0FA3', threadId);
+  }
+
+  /**
+   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_ERRORS (CEventGroupScriptErrors)
+   *
+   * @param eventGroup 
+   * @returns
+   */
+  static getNumberOfEvents(eventGroup: number): number {
+    return inv<number>('0x5CE8DE5909565748', eventGroup, rai());
+  }
+
+  static shutdownLoadingScreen(): void {
+    inv<void>('0xFC179D7E8886DADF');
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0xE7282390542F570D(p0: any): any {
+    return inv<number>('0xE7282390542F570D', p0);
+  }
+
+  /**
+   * @param scriptIndex 
+   * @param p1 
+   * @returns
+   */
+  static bgGetLaunchParamValue(scriptIndex: number, p1: string | null): number {
+    return inv<number>('0x55C40B7592BAD213', scriptIndex, p1, rai());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0x1BDB5A07307F6929(p0: any, p1: any): void {
+    inv<void>('0x1BDB5A07307F6929', p0, p1);
+  }
+
+  /**
+   * @param index 
+   * @returns
+   */
+  static doesCompressedGlobalBlockBufferExist(index: number): any {
+    return inv<number>('0x66EE5B93C308F734', index);
+  }
+
+  /**
+   * @param index 
+   * @param toggle 
+   */
+  static setGlobalBlockCanBeAccessed(index: number, toggle: boolean): void {
+    inv<void>('0xE66F392BFCE734AF', index, toggle);
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static bgGetScriptIdFromNameHash(p0: string | number): number {
+    return inv<number>('0x829CD22E043A2577', _h(p0), rai());
+  }
+
+  /**
+   * @returns
+   */
+  static getNoLoadingScreen(): boolean {
+    return inv<boolean>('0x323DAF00687E0F28', rai());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @returns
+   */
+  static N_0x0A79C81C418F5D38(p0: any, p1: any): any {
+    return inv<number>('0x0A79C81C418F5D38', p0, p1);
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0xA88E1D7FA1E20080(p0: any): any {
+    return inv<number>('0xA88E1D7FA1E20080', p0);
+  }
+
+  /**
+   * @param params 
+   */
+  static bailWithPassThroughParams(params: string | null): void {
+    inv<void>('0xE98204D3C25AE14C', params);
+  }
+
+  /**
+   * If the function returns 0, the end of the iteration has been reached.
+   *
+   * @returns
+   */
+  static scriptThreadIteratorGetNextThreadId(): number {
+    return inv<number>('0x3CE3FB167E837D7C', rai());
+  }
+
+  /**
+   * @param scriptHash 
+   */
+  static setScriptWithNameHashAsNoLongerNeeded(scriptHash: string | number): void {
+    inv<void>('0x50723A1567C8361E', _h(scriptHash));
+  }
+
+  /**
+   * @param p1 
+   * @returns value
+   */
+  static getBlockOfPlayerBits(p1: number): [number, number] {
+    const result = inv<[number, number]>('0xFA3B530A5CC693D5', pvi(), p1, rai());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * Deletes the given context from the background scripts context map.
+   *
+   * @param contextName 
+   */
+  static bgEndContext(contextName: string | null): void {
+    inv<void>('0x3ABF7BA1C3E2C8CF', contextName);
+  }
+
+  /**
+   * @param scriptHash 
+   * @returns
+   */
+  static hasScriptWithNameHashLoaded(scriptHash: string | number): boolean {
+    return inv<boolean>('0xA5D8E0C2F3C7EEBC', _h(scriptHash), rai());
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x5827BE85A87B073D(p0: any): void {
+    inv<void>('0x5827BE85A87B073D', p0);
+  }
+
+  /**
+   * enum eThreadExitReason
+   * {
+   * THREAD_EXIT_REASON_NONE,
+   * THREAD_EXIT_REASON_BACKGROUND_THREAD_STOPPED,
+   * THREAD_EXIT_REASON_SESSION_MERGE,
+   * THREAD_EXIT_REASON_SCENARIO_OUT_OF_SCOPE,
+   * THREAD_EXIT_REASON_REQUESTED_BY_SCRIPT
+   * };
+   *
+   * @returns
+   */
+  static getThreadExitReason(): number {
+    return inv<number>('0x54AE4FDEEFEAB77E', rai());
+  }
+
+  /**
+   * @param bitIndex 
+   * @returns value
+   */
+  static setPlayerBitAtIndex(bitIndex: number): number {
+    const result = inv<number>('0x31010318BA9897AC', pvi(), bitIndex);
+    return result;
+  }
+
+  /**
+   * @returns value
+   */
+  static clearAllPlayerBits(): number {
+    const result = inv<number>('0xDE544B7EC0C187CC', pvi());
+    return result;
+  }
+
+  /**
+   * @param itemIndex 
+   * @returns rpcGuid; outResultItem
+   */
+  static lootGetResultItem(itemIndex: number): [any, number, number] {
+    const result = inv<[number, number, number]>('0x4293B44A855F82CC', pvi(), itemIndex, pvi());
+    return [result[0], result[1], result[2]];
+  }
+
+  /**
+   * Returns if a script has been loaded into the game. Used to see if a script was loaded after requesting.
+   *
+   * @param scriptName 
+   * @returns
+   */
+  static hasScriptLoaded(scriptName: string | null): boolean {
+    return inv<boolean>('0xE97BD36574F8B0A6', scriptName, rai());
+  }
+
+  /**
+   * @param toggle 
+   */
+  static setNoLoadingScreen(toggle: boolean): void {
+    inv<void>('0x5CB83156AA038F95', toggle);
+  }
+
+  /**
+   * @param scriptIndex 
+   * @param p1 
+   * @returns
+   */
+  static bgDoesLaunchParamExist(scriptIndex: number, p1: string | null): boolean {
+    return inv<boolean>('0x4AE1DFF337A86FDE', scriptIndex, p1, rai());
+  }
+
+  /**
+   * @param threadId 
+   */
+  static requestThreadExit(threadId: number): void {
+    inv<void>('0x7DE4643157AD646C', threadId);
+  }
+
+  /**
+   * Hashed version of BG_END_CONTEXT
+   *
+   * @param contextHash 
+   */
+  static bgEndContextHash(contextHash: string | number): void {
+    inv<void>('0x6D1431744182CDE8', _h(contextHash));
+  }
+
+  /**
+   * @param scriptName 
+   * @returns
+   */
+  static doesScriptExist(scriptName: string | null): boolean {
+    return inv<boolean>('0x552B171E3F69E5AE', scriptName, rai());
+  }
+
+  /**
+   * @returns
+   */
+  static getHashOfThisScriptName(): string | number {
+    return (inv<number>('0xBC2C927F5C264960', rai())) & 0xFFFFFFFF;
+  }
+
+  static bgReloadAllBackgroundScripts(): void {
+    inv<void>('0xBE7D814CFA181B56');
+  }
+
+  /**
+   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_SCRIPT_ERRORS (CEventGroupScriptErrors) Note: eventDataSize is NOT the size in bytes, it is the size determined by the SIZE_OF operator (RAGE Script operator, not C/C++ sizeof). That is, the size in bytes divided by 8 (script variables are always 8-byte aligned!). playerBits (also known as playersToBroadcastTo) is a bitset that indicates which players this event should be sent to. In order to send the event to specific players only, use (1 << playerIndex). Set all bits if it should be broadcast to all players.
+   *
+   * @param eventGroup 
+   * @param eventDataSize 
+   * @param scriptMetadataIndex 
+   * @returns eventData; playerBits
+   */
+  static triggerScriptEvent(eventGroup: number, eventDataSize: number, scriptMetadataIndex: number): [number, number] {
+    const result = inv<[number, number]>('0x5AE99C571D5BBE5D', eventGroup, pvi(), eventDataSize, scriptMetadataIndex, pvi());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * goalContext: see _ACTIVATE_GOAL_CONTEXT
+   *
+   * @param goalContext 
+   * @returns
+   */
+  static isGoalContextActive(goalContext: string | number): any {
+    return inv<number>('0x7409669C5ED50144', _h(goalContext));
+  }
+
+  /**
+   * @param scriptName 
+   */
+  static setScriptAsNoLongerNeeded(scriptName: string | null): void {
+    inv<void>('0x0086D3067E1CFD1C', scriptName);
+  }
+
+  /**
+   * @returns p0; p1; p2
+   */
+  static N_0x64F765D9A1F8F02C(): [number, number, number] {
+    const result = inv<[number, number, number]>('0x64F765D9A1F8F02C', pvi(), pvi(), pvi());
+    return [result[0], result[1], result[2]];
+  }
+
+  /**
+   * @param scriptName 
+   */
+  static requestScript(scriptName: string | null): void {
+    inv<void>('0x46ED607DDD40D7FE', scriptName);
+  }
+
+  /**
+   * @param toggle 
+   */
+  static setAllGlobalBlocksHaveBeenLoaded(toggle: boolean): void {
+    inv<void>('0x11986B05885564D2', toggle);
+  }
+
+  /**
+   * Returns "INVALID_NET_RPC_GUID" if netRpcGuid is invalid.
+   *
+   * @returns netRpcGuid
+   */
+  static netRpcGuidToString(): [string | null, number] {
+    const result = inv<[string, number]>('0xAC9FF854BD4BA9B5', pvi(), ras());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_SCRIPT_ERRORS (CEventGroupScriptErrors) Returns event name hash: https://alloc8or.re/rdr3/doc/enums/eEventType.txt
+   *
+   * @param eventGroup 
+   * @param eventIndex 
+   * @returns
+   */
+  static getEventAtIndex(eventGroup: number, eventIndex: number): string | number {
+    return (inv<number>('0xA85E614430EFF816', eventGroup, eventIndex, rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @param scriptHash 
+   * @param argCount 
+   * @param stackSize 
+   * @returns args
+   */
+  static startNewScriptWithNameHashAndArgs(scriptHash: string | number, argCount: number, stackSize: number): [number, number] {
+    const result = inv<[number, number]>('0xC4BB298BD441BE78', _h(scriptHash), pvi(), argCount, stackSize, rai());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_SCRIPT_ERRORS (CEventGroupScriptErrors)
+   *
+   * @param eventGroup 
+   * @param eventType 
+   * @returns
+   */
+  static getEventExists(eventGroup: number, eventType: string | number): boolean {
+    return inv<boolean>('0xC9F59C0A710ECD34', eventGroup, _h(eventType), rai());
+  }
+
+  /**
+   * @param index 
+   * @returns
+   */
+  static getGlobalBlockCanBeAccessed(index: number): boolean {
+    return inv<boolean>('0x42A7EB5C814C2DE0', index, rai());
+  }
+
+  /**
+   * @returns
+   */
+  static isThreadExitRequested(): any {
+    return inv<number>('0x9E4EF615E307FBBE');
+  }
+
+  static terminateThisThread(): void {
+    inv<void>('0x5E8B6D17FF91CD59');
+  }
+
+  static N_0x76CBCD9EADC00955(): void {
+    inv<void>('0x76CBCD9EADC00955');
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   */
+  static N_0x29FB4CE89472C3CB(p0: any, p1: any, p2: number, p3: number, p4: string | null, p5: string | null, p6: string | null, p7: number): void {
+    inv<void>('0x29FB4CE89472C3CB', p0, p1, f(p2), f(p3), p4, p5, p6, p7);
+  }
+
+  /**
+   * @param threadId 
+   */
+  static terminateThread(threadId: number): void {
+    inv<void>('0x87ED52AE40EA1A52', threadId);
+  }
+
+  /**
+   * @param eventDataSize 
+   * @param scriptMetadataIndex 
+   * @param threadId 
+   * @returns eventData
+   */
+  static triggerScriptEvent2(eventDataSize: number, scriptMetadataIndex: number, threadId: number): number {
+    const result = inv<number>('0x8B61C950A148FFA2', pvi(), eventDataSize, scriptMetadataIndex, threadId);
+    return result;
+  }
+
+  /**
+   * Gets the number of instances of the specified script is currently running. Actually returns numRefs - 1.
+   * if (program)
+   * v3 = rage::scrProgram::GetNumRefs(program) - 1;
+   * return v3; Old name: _GET_NUMBER_OF_REFERENCES_OF_SCRIPT_WITH_NAME_HASH
+   *
+   * @param scriptHash 
+   * @returns
+   */
+  static getNumberOfThreadsRunningTheScriptWithThisHash(scriptHash: string | number): number {
+    return inv<number>('0x8E34C953364A76DD', _h(scriptHash), rai());
+  }
+
+  /**
+   * Waiting for child scripts to terminate / waiting for collapse of child scripts
+   *
+   * @param p0 
+   * @returns
+   */
+  static haveAllChildScriptsTerminated(p0: number): any {
+    return inv<number>('0x380FFA15B72408FB', p0);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   */
+  static N_0xFFDDF802279BE128(p0: any, p1: any, p2: any): void {
+    inv<void>('0xFFDDF802279BE128', p0, p1, p2);
+  }
+
+  /**
+   * @param bitIndex 
+   * @returns value
+   */
+  static isPlayerBitSetAtIndex(bitIndex: number): [boolean, number] {
+    const result = inv<[boolean, number]>('0x72B2E00C9BAC6789', pvi(), bitIndex, rai());
+    return [!!result[0], result[1]];
+  }
+
+  /**
+   * @returns value
+   */
+  static setAllPlayerBits(): number {
+    const result = inv<number>('0x20F4CB76689ACDBC', pvi());
+    return result;
+  }
+
+  /**
+   * Sets bit 0 in GtaThread+0x784
+   */
+  static bgSetExitflagResponse(): void {
+    inv<void>('0x4858148E3B8A75D0');
+  }
+
+  /**
+   * @returns value
+   */
+  static countParticipantBits(): [number, number] {
+    const result = inv<[number, number]>('0x2F050A3FF8738245', pvi(), rai());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * Same as GET_IS_LOADING_SCREEN_ACTIVE
+   *
+   * @returns
+   */
+  static isLoadingScreenVisible(): boolean {
+    return inv<boolean>('0xB54ADBE65D528FCB', rai());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   */
+  static N_0xE4ABE20DCE7C7CFE(p0: any, p1: any, p2: any): void {
+    inv<void>('0xE4ABE20DCE7C7CFE', p0, p1, p2);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @returns value
+   */
+  static setBlockOfPlayerBits(p1: number, p2: number): number {
+    const result = inv<number>('0xC6DFB8C04C86D5A5', pvi(), p1, p2);
+    return result;
+  }
+
+  /**
+   * Hashed version of BG_START_CONTEXT
+   *
+   * @param contextHash 
+   */
+  static bgStartContextHash(contextHash: string | number): void {
+    inv<void>('0x2EB67D564DCC09D5', _h(contextHash));
+  }
+
+  /**
+   * @param threadId 
+   * @returns
+   */
+  static isThreadExitRequestedForThreadWithThisId(threadId: number): any {
+    return inv<number>('0x30BED53646C86D11', threadId);
+  }
+
+  /**
+   * @param index 
+   * @returns
+   */
+  static restoreGlobalBlock(index: number): any {
+    return inv<number>('0xDC3914A99B4A5FDF', index);
+  }
+
+  /**
+   * @param eventGroup 
+   * @param eventIndex 
+   * @param p2 
+   */
+  static setEventFlagForDeletion(eventGroup: number, eventIndex: number, p2: boolean): void {
+    inv<void>('0x4768D5252EAEB76F', eventGroup, eventIndex, p2);
+  }
+
+  /**
+   * @param threadId 
+   * @returns threadExists; hasScriptHandler
+   */
+  static getThreadExistenceDetails(threadId: number): [boolean, boolean] {
+    const result = inv<[number, number]>('0xD92FA81B64920E85', threadId, pvi(), pvi());
+    return [!!result[0], !!result[1]];
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   */
+  static N_0x42A429CDFED6D99D(p0: any, p1: any, p2: any): void {
+    inv<void>('0x42A429CDFED6D99D', p0, p1, p2);
+  }
+
+  /**
+   * @param p0 
+   */
+  static stopDisplayingMpTransitionLoadingScreens(p0: any): void {
+    inv<void>('0x778D4733E0F2F265', p0);
+  }
+
+  /**
+   * @param threadId 
+   * @param ignoreKilledState 
+   * @returns
+   */
+  static isThreadActive(threadId: number, ignoreKilledState: boolean): boolean {
+    return inv<boolean>('0x46E9AE36D8FA6417', threadId, ignoreKilledState, rai());
+  }
+
+  /**
+   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_SCRIPT_ERRORS (CEventGroupScriptErrors) Note: eventDataSize is NOT the size in bytes, it is the size determined by the SIZE_OF operator (RAGE Script operator, not C/C++ sizeof). That is, the size in bytes divided by 8 (script variables are always 8-byte aligned!). https://github.com/femga/rdr3_discoveries/tree/master/AI/EVENTS
+   *
+   * @param eventGroup 
+   * @param eventIndex 
+   * @param eventDataSize 
+   * @returns eventData
+   */
+  static getEventData(eventGroup: number, eventIndex: number, eventDataSize: number): [boolean, number] {
+    const result = inv<[boolean, number]>('0x57EC5FA4D4D6AFCA', eventGroup, eventIndex, pvi(), eventDataSize, rai());
+    return [!!result[0], result[1]];
+  }
+
+  /**
+   * @param awardHash 
+   * @param dataIndex 
+   * @returns rpcGuid; outUnlockData
+   */
+  static awardsGetUnlockClaimData(awardHash: string | number, dataIndex: number): [any, number, number] {
+    const result = inv<[number, number, number]>('0xB9467E41DAB1CF2C', pvi(), _h(awardHash), dataIndex, pvi());
+    return [result[0], result[1], result[2]];
+  }
+
+  /**
+   * @param scriptHash 
+   */
+  static requestScriptWithNameHash(scriptHash: string | number): void {
+    inv<void>('0xF6B9CE3F8D5B9B74', _h(scriptHash));
+  }
+
+  /**
+   * Used in Script Function DISABLE_REGISTERED_WORLD_BRAINS
+   *
+   * @param p0 
+   */
+  static N_0x11B0A0B282FA9B10(p0: boolean): void {
+    inv<void>('0x11B0A0B282FA9B10', p0);
+  }
+
+  /**
+   * @param scriptHash 
+   * @param stackSize 
+   * @returns
+   */
+  static startNewScriptWithNameHash(scriptHash: string | number, stackSize: number): number {
+    return inv<number>('0xEB1C67C3A5333A92', _h(scriptHash), stackSize, rai());
+  }
+
+  /**
+   * @param threadId 
+   * @returns
+   */
+  static getHashOfThread(threadId: number): string | number {
+    return (inv<number>('0x724CB89D35B283D0', threadId, rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @param nameHash 
+   */
+  static requestThreadExitForAllThreadsWithThisName(nameHash: string | number): void {
+    inv<void>('0x7423F7835770F619', _h(nameHash));
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0x1C5EB3C27F7508CB(p0: any, p1: any): void {
+    inv<void>('0x1C5EB3C27F7508CB', p0, p1);
+  }
+
+  /**
+   * goalContext: see _ACTIVATE_GOAL_CONTEXT
+   *
+   * @param goalContext 
+   */
+  static deactivateGoalContext(goalContext: string | number): void {
+    inv<void>('0x50B72A754EE64A71', _h(goalContext));
+  }
+
+  /**
+   * @param bailCode 
+   */
+  static bailToLandingPage(bailCode: number): void {
+    inv<void>('0xBC2C927F5C264243', bailCode);
+  }
+
+  /**
+   * @param index 
+   * @returns
+   */
+  static storeGlobalBlock(index: number): any {
+    return inv<number>('0xB952A3AC41D58F2F', index);
+  }
+
+  static N_0xF9E951A1E5517C06(): void {
+    inv<void>('0xF9E951A1E5517C06');
+  }
+
+  /**
+   * @returns
+   */
+  static getIdOfThisThread(): number {
+    return inv<number>('0x55525C346BEF6960', rai());
+  }
+
+}