xray16 1.0.5 → 1.0.8

package/types/xr_ai/xr_memory.d.ts

@@ -0,0 +1,148 @@
+declare module "xray16" {
+  /**
+   * @source C++ class memory_object
+   * @customConstructor memory_object
+   * @group xr_memory
+   */
+  export class memory_object extends EngineBinding {
+    public readonly last_level_time: u32;
+    public readonly level_time: u32;
+
+    protected constructor();
+  }
+
+  /**
+   * @source C++ class entity_memory_object : memory_object
+   * @customConstructor entity_memory_object
+   * @group xr_memory
+   */
+  export class entity_memory_object extends memory_object {
+    public readonly object_info: object;
+    public readonly self_info: object;
+
+    protected constructor();
+
+    public object(): game_object;
+  }
+
+  /**
+   * @source C++ class object_params
+   * @customConstructor object_params
+   * @group xr_memory
+   */
+  export class object_params {
+    public level_vertex: u32;
+    public position: vector;
+
+    private constructor();
+  }
+
+  /**
+   * @source C++ class hit_memory_object : entity_memory_object
+   * @customConstructor hit_memory_object
+   * @group xr_memory
+   */
+  export class hit_memory_object extends entity_memory_object {
+    public readonly amount: f32;
+    public readonly bone_index: u16;
+    public readonly direction: vector;
+
+    protected constructor();
+  }
+
+  /**
+   * @source C++ class game_memory_object : memory_object
+   * @customConstructor game_memory_object
+   * @group xr_memory
+   */
+  export class game_memory_object extends memory_object {
+    public object_info: unknown; /* MemorySpace::CObjectParams<class CGameObject>& */
+    public self_info: unknown; /* MemorySpace::CObjectParams<class CGameObject>& */
+    public object(): game_object;
+
+    protected constructor();
+  }
+
+  /**
+   * @source C++ class not_yet_visible_object
+   * @customConstructor not_yet_visible_object
+   * @group xr_memory
+   */
+  export class not_yet_visible_object extends EngineBinding {
+    protected constructor();
+
+    public value: f32;
+    public object(): game_object;
+  }
+
+  /**
+   * @source C++ class visible_memory_object
+   * @customConstructor visible_memory_object
+   * @group xr_memory
+   */
+  export class visible_memory_object extends game_memory_object {
+    protected constructor();
+  }
+
+  /**
+   * @source C++ class memory_info : visible_memory_object
+   * @customConstructor visible_memory_object
+   * @group xr_memory
+   */
+  export class memory_info extends visible_memory_object {
+    public readonly hit_info: boolean;
+    public readonly sound_info: boolean;
+    public readonly visual_info: boolean;
+
+    protected constructor();
+  }
+
+  /**
+   * @source C++ class sound_memory_object : game_memory_object
+   * @customConstructor sound_memory_object
+   * @group xr_memory
+   */
+  export class sound_memory_object extends game_memory_object {
+    public readonly power: f32;
+
+    protected constructor();
+
+    public type(): i32;
+  }
+
+  /**
+   * @source C++ class danger_object
+   * @customConstructor danger_object
+   * @group xr_memory
+   */
+  export class danger_object {
+    public static attack_sound: 1;
+    public static attacked: 5;
+    public static bullet_ricochet: 0;
+    public static enemy_sound: 7;
+    public static entity_attacked: 2;
+    public static entity_corpse: 4;
+    public static entity_death: 3;
+    public static grenade: 6;
+    public static hit: 2;
+    public static sound: 1;
+    public static visual: 0;
+
+    public type(): TXR_danger_object;
+    public time(): u32;
+    public position(): vector;
+    public object(): game_object;
+    public perceive_type(): number; /* CDangerObject::EDangerPerceiveType */
+    public dependent_object(): game_object;
+  }
+
+  /**
+   * @group xr_memory
+   */
+  export type TXR_danger_objects = typeof danger_object;
+
+  /**
+   * @group xr_memory
+   */
+  export type TXR_danger_object = EnumeratedStaticsValues<TXR_danger_objects>;
+}

package/types/xr_lib/xr_animation.d.ts

@@ -0,0 +1,81 @@
+declare module "xray16" {
+  /**
+   * @source C++ class duality
+   * @customConstructor duality
+   * @group xr_animation
+   */
+  export class duality {
+    public v: f32;
+    public h: f32;
+
+    public constructor();
+    public constructor(v: f32, h: f32);
+
+    public set(v: f32, h: f32): duality;
+  }
+
+  /**
+   * @source C++ class noise
+   * @customConstructor noise
+   * @group xr_animation
+   */
+  export class noise {
+    public fps: f32;
+    public grain: f32;
+    public intensity: f32;
+
+    public constructor();
+    public constructor(fps: f32, grain: f32, intensity: f32);
+
+    public set(fps: f32, grain: f32, intensity: f32): noise;
+  }
+
+  /**
+   * @source C++ class effector
+   * @customConstructor effector
+   * @group xr_animation
+   */
+  export class effector extends EngineBinding {
+    public constructor(int: i32, float: f32);
+
+    public start(): void;
+
+    public process(effector_params: effector_params): boolean;
+
+    public finish(): void;
+  }
+
+  /**
+   * @source C++ class effector_params
+   * @customConstructor effector_params
+   * @group xr_animation
+   */
+  export class effector_params extends EngineBinding {
+    public color_add: color;
+    public color_base: color;
+    public color_gray: color;
+    public dual: duality;
+    public blur: f32;
+    public gray: f32;
+    public noise: noise;
+
+    public constructor();
+
+    public assign(effector_params: effector_params): void;
+  }
+
+  /**
+   * @source C++ class color_animator
+   * @customConstructor color_animator
+   * @group xr_animation
+   */
+  export class color_animator extends EngineBinding {
+    public constructor(value: string);
+
+    public length(): u32;
+
+    public load(value: string): void;
+
+    public calculate(value: f32): fcolor;
+  }
+}

package/types/xr_lib/xr_bitwise.d.ts

@@ -0,0 +1,21 @@
+declare module "xray16" {
+  /**
+   * @group xr_bitwise
+   */
+  export function bit_and(this: void, left: i32, right: i32): i32;
+
+  /**
+   * @group xr_bitwise
+   */
+  export function bit_or(this: void, first: i32, second: i32): i32;
+
+  /**
+   * @group xr_bitwise
+   */
+  export function bit_not(this: void, value: i32): i32;
+
+  /**
+   * @group xr_bitwise
+   */
+  export function bit_xor(this: void, left: i32, right: i32): i32;
+}

package/types/xr_lib/xr_color.d.ts

@@ -0,0 +1,40 @@
+declare module "xray16" {
+  /**
+   * @source C++ class fcolor
+   * @customConstructor fcolor
+   * @group xr_color
+   */
+  export class fcolor extends EngineBinding {
+    public a: f32;
+    public b: f32;
+    public g: f32;
+    public r: f32;
+
+    public set(a: f32, b: f32, c: f32, d: f32): fcolor;
+
+    public set(it: fcolor): fcolor;
+
+    public set(value: u32): fcolor;
+  }
+
+  /**
+   * @source C++ class color
+   * @customConstructor color
+   * @group xr_color
+   */
+  export class color {
+    public b: f32;
+    public g: f32;
+    public r: f32;
+
+    public constructor();
+    public constructor(r: f32, g: f32, b: f32);
+
+    public set(r: f32, g: f32, b: f32): void;
+  }
+
+  /**
+   * @group xr_color
+   */
+  export function GetARGB(this: void, a: u16, r: u16, g: u16, b: u16): i32;
+}

package/types/xr_lib/xr_debug.d.ts

@@ -0,0 +1,100 @@
+declare module "xray16" {
+  /**
+   * @source C++ class profile_timer
+   * @customConstructor profile_timer
+   * @group xr_debug
+   */
+  export class profile_timer extends EngineBinding {
+    public constructor();
+    public constructor(timer: profile_timer);
+
+    public stop(): void;
+
+    public start(): void;
+
+    public time(): f32;
+
+    /**
+     * Overridden string cast is implemented for profiling timer.
+     *
+     * @returns serialized profile time.
+     */
+    public toString(): string;
+  }
+
+  /**
+   * @source C++ class CConsole
+   * @customConstructor CConsole
+   * @group xr_debug
+   */
+  export class CConsole extends EngineBinding {
+    private constructor();
+
+    public execute(command: string): void;
+
+    public execute_deferred(command: string): void;
+
+    public execute_script(script: string): void;
+
+    public show(): void;
+
+    public hide(): void;
+
+    public get_bool(key: string): boolean;
+
+    public get_float(key: string): f32;
+
+    public get_integer(key: string): i32;
+
+    public get_string(key: string): string;
+
+    public get_token(key: string): string;
+  }
+
+  /**
+   * Log formatted message in game console and log file.
+   * Resulting message looks like "[LUA]  %s", where message is provided text parameter.
+   *
+   * Note: text length is limited and supplying too long value will crash the game. todo: check exact limit.
+   *
+   * @group xr_debug
+   * @param text - string to print
+   */
+  export function log(this: void, text: string): void;
+
+  /**
+   * @group xr_debug
+   */
+  export function error_log(this: void, text: string): void;
+
+  /**
+   * @group xr_debug
+   */
+  export function print_stack(this: void): void;
+
+  /**
+   * @group xr_debug
+   */
+  export function flush(this: void): void;
+
+  /**
+   * Get console object reference.
+   * Allows flushing logs / executing commands / getting global engine variables.
+   *
+   * @group xr_debug
+   * @returns console object reference
+   */
+  export function get_console(this: void): CConsole;
+
+  /**
+   * @group xr_debug
+   */
+  export function command_line(this: void): string;
+
+  /**
+   * Prefetch provided script before executing next lines.
+   *
+   * @group xr_global_declaration
+   */
+  export function prefetch(this: void, path: string): void;
+}

package/types/{xr_object → xr_lib}/xr_dialog.d.ts

@@ -6,11 +6,17 @@ declare module "xray16" {
    */
   export class CPhraseScript {
     public AddAction(value: string): void;
+
     public AddDisableInfo(value: string): void;
+
     public AddDontHasInfo(value: string): void;
+
     public AddGiveInfo(value: string): void;
+
     public AddHasInfo(value: string): void;
+
     public AddPrecondition(value: string): void;
+
     public SetScriptText(value: string): void;
   }
 
@@ -29,6 +35,6 @@ declare module "xray16" {
    * @group xr_dialog
    */
   export class CPhraseDialog {
-    public AddPhrase(text: string, phrase_id: string, prev_phrase_id: string, goodwill_level: number): CPhrase;
+    public AddPhrase(text: string, phrase_id: string, prev_phrase_id: string, goodwill_level: i32): CPhrase;
   }
 }

package/types/xr_lib/xr_flags.d.ts

@@ -0,0 +1,148 @@
+declare module "xray16" {
+  /**
+   * @source C++ class flags8
+   * @customConstructor flags8
+   * @group xr_flags
+   */
+  export class flags8 {
+    public constructor();
+
+    public and(value1: flags8, value2: u8): flags8;
+
+    public and(value: u8): flags8;
+
+    public assign(value: flags8): flags8;
+
+    public assign(value: u8): flags8;
+
+    public equal(value2: Readonly<flags8>): boolean;
+
+    public equal(value2: Readonly<flags8>, value3: u8): boolean;
+
+    public get(): u8;
+
+    public invert(): flags8;
+
+    public invert(value: flags8): flags8;
+
+    public invert(value: u8): flags8;
+
+    public is(value: flags8, value2: u8): boolean;
+
+    public is(value: u8): boolean;
+
+    public is_any(value1: flags8, value2: u8): boolean;
+
+    public is_any(value: u8): boolean;
+
+    public one(): flags8;
+
+    public or(value: flags8, value2: u8): flags8;
+
+    public or(value: u8): flags8;
+
+    public set(value: u8, value2: boolean): flags8;
+
+    public test(value: u8): boolean;
+
+    public zero(): flags8;
+  }
+
+  /**
+   * @source C++ class flags16
+   * @customConstructor flags16
+   * @group xr_flags
+   */
+  export class flags16 {
+    public constructor();
+
+    public and(value1: flags16, value2: u16): flags16;
+
+    public and(value: u16): flags16;
+
+    public assign(value: flags16): flags16;
+
+    public assign(value: u16): flags16;
+
+    public equal(value2: Readonly<flags16>): boolean;
+
+    public equal(value2: Readonly<flags16>, value3: u16): boolean;
+
+    public get(): u16;
+
+    public invert(): flags16;
+
+    public invert(value: flags16): flags16;
+
+    public invert(value: u16): flags16;
+
+    public is(value: flags16, value2: u16): boolean;
+
+    public is(value: u16): boolean;
+
+    public is_any(value1: flags16, value2: u16): boolean;
+
+    public is_any(value: u16): boolean;
+
+    public one(): flags16;
+
+    public or(value: flags16, value2: u16): flags16;
+
+    public or(value: u16): flags16;
+
+    public set(value: u16, value2: boolean): flags16;
+
+    public test(value: u16): boolean;
+
+    public zero(): flags16;
+  }
+
+  /**
+   * @source C++ class flags32
+   * @customConstructor flags32
+   * @group xr_flags
+   */
+  export class flags32 {
+    public constructor();
+
+    public and(value1: flags32, value2: u32): flags32;
+
+    public and(value: u32): flags32;
+
+    public assign(value: flags32): flags32;
+
+    public assign(value: u32): flags32;
+
+    public equal(value2: Readonly<flags32>): boolean;
+
+    public equal(value2: Readonly<flags32>, value3: u32): boolean;
+
+    public get(): u32;
+
+    public invert(): flags32;
+
+    public invert(value: flags32): flags32;
+
+    public invert(value: u32): flags32;
+
+    public is(value: flags32, value2: u32): boolean;
+
+    public is(value: u32): boolean;
+
+    public is_any(value1: flags32, value2: u32): boolean;
+
+    public is_any(value: u32): boolean;
+
+    public one(): flags32;
+
+    public or(value: flags32, value2: u32): flags32;
+
+    public or(value: u32): flags32;
+
+    public set(value: u32, value2: boolean): flags32;
+
+    public test(value: u32): boolean;
+
+    public zero(): flags32;
+  }
+}