bc-stubs 96.0.0

package/bc/Screens/MiniGame/KinkyDungeon/KinkyDungeonEnemyEventList.d.ts

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {entity} enemy
+ * @param {any} AIData
+ */
+declare function KDResetIntent(enemy: entity, AIData: any): void;
+/**
+ * Helper function called to leash player to the nearest furniture
+ * @param {entity} enemy
+ * @param {any} AIData
+ * @returns {boolean}
+ */
+declare function KDSettlePlayerInFurniture(enemy: entity, AIData: any, tags: any, guardDelay?: number): boolean;
+/**
+ * Play is actions enemies do when they are NEUTRAL
+ * @type {Record<string, EnemyEvent>}
+ */
+declare let KDIntentEvents: Record<string, EnemyEvent>;

package/bc/Screens/MiniGame/KinkyDungeon/KinkyDungeonErrors.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Sets up the KD crash handler
+ */
+declare function KinkyDungeonSetupCrashHandler(): void;
+/**
+ * Tears down the KD crash handler
+ */
+declare function KinkyDungeonTeardownCrashHandler(): void;
+/**
+ * Error event handler for uncaught errors
+ * @param {ErrorEvent} event - The error event
+ */
+declare function KinkyDungeonOnUncaughtError(event: ErrorEvent): void;
+/**
+ * Generates an error report string containing crash debug data
+ * @param {ErrorEvent} event - The error event
+ * @returns {string} - The report
+ */
+declare function KinkyDungeonGenerateErrorReport(event: ErrorEvent): string;
+/**
+ * Generates a report string containing debug data about the current state of the game
+ * @returns {string} - The report
+ */
+declare function KinkyDungeonCrashReportStateData(): string;
+/**
+ * Generates an error report string containing debug data about the thrown error
+ * @param {ErrorEvent} event - The error event
+ * @returns {string} - The report
+ */
+declare function KinkyDungeonCrashReportErrorDetails(event: ErrorEvent): string;
+/**
+ * Generates a report string containing the current save state of the game
+ * @returns {string} - The report
+ */
+declare function KinkyDungeonCrashReportSaveData(): string;
+/**
+ * Generates a report string containing debug data with general diagnostics information
+ * @returns {string} - The report
+ */
+declare function KinkyDungeonCrashReportDiagnostics(): string;
+/**
+ * Generates a report string containing debug data with device detection information
+ * @returns {string} - The report
+ */
+declare function KinkyDungeonCrashReportDeviceDetails(): string;
+/**
+ * Sanitizes a string to remove beta codes from it
+ * @returns {string} - The sanitized string
+ */
+declare function KinkyDungeonStackSanitize(stack: any): string;
+/**
+ * Opens the KD crash report modal, displaying the provided report
+ * @param {string} report - The report to display
+ */
+declare function KinkyDungeonShowCrashReportModal(report: string): void;
+declare function KinkyDungeonErrorImage(src: any): HTMLImageElement;
+declare function KinkyDungeonErrorPreamble(content: any): HTMLParagraphElement;
+declare function KinkyDungeonErrorModalButton(text: any): HTMLButtonElement;
+declare function KinkyDungeonErrorCopy(report: any, reportElement: any): Promise<boolean>;

package/bc/Screens/MiniGame/KinkyDungeon/KinkyDungeonEvents.d.ts

@@ -0,0 +1,151 @@
+declare function KDMapHasEvent(map: any, event: any): boolean;
+declare function KinkyDungeonSendEvent(Event: any, data: any, forceSpell: any): void;
+/** Called during initialization */
+declare function KinkyDungeonResetEventVariables(): void;
+/** Called every tick */
+declare function KinkyDungeonResetEventVariablesTick(delta: any): void;
+/**
+ *
+ * @param {string} Event
+ * @param {KinkyDungeonEvent} kinkyDungeonEvent
+ * @param {item} item
+ * @param {*} data
+ */
+declare function KinkyDungeonHandleInventoryEvent(Event: string, kinkyDungeonEvent: KinkyDungeonEvent, item: item, data: any): void;
+/**
+ *
+ * @param {string} Event
+ * @param {any} buff
+ * @param {any} entity
+ * @param {*} data
+ */
+declare function KinkyDungeonHandleBuffEvent(Event: string, e: any, buff: any, entity: any, data: any): void;
+/**
+ *
+ * @param {string} Event
+ * @param {any} outfit
+ * @param {*} data
+ */
+declare function KinkyDungeonHandleOutfitEvent(Event: string, e: any, outfit: any, data: any): void;
+/**
+ *
+ * @param {string} Event
+ * @param {KinkyDungeonEvent} e
+ * @param {any} spell
+ * @param {*} data
+ */
+declare function KinkyDungeonHandleMagicEvent(Event: string, e: KinkyDungeonEvent, spell: any, data: any): void;
+/**
+ *
+ * @param {string} Event
+ * @param {KinkyDungeonEvent} e
+ * @param {weapon} weapon
+ * @param {*} data
+ */
+declare function KinkyDungeonHandleWeaponEvent(Event: string, e: KinkyDungeonEvent, weapon: weapon, data: any): void;
+/**
+ *
+ * @param {string} Event
+ * @param {KinkyDungeonEvent} e
+ * @param {any} b
+ * @param {*} data
+ */
+declare function KinkyDungeonHandleBulletEvent(Event: string, e: KinkyDungeonEvent, b: any, data: any): void;
+/**
+ *
+ * @param {string} Event
+ * @param {KinkyDungeonEvent} e
+ * @param {entity} enemy
+ * @param {*} data
+ */
+declare function KinkyDungeonHandleEnemyEvent(Event: string, e: KinkyDungeonEvent, enemy: entity, data: any): void;
+/**
+ *
+ * @param {string} Event
+ * @param {*} data
+ */
+declare function KinkyDungeonHandleGenericEvent(Event: string, data: any): void;
+declare function KDEventPrereq(e: any, item: any, tags: any): any;
+declare let KinkyDungeonAttackTwiceFlag: boolean;
+declare let KinkyDungeonSlimeParts: ({
+    group: string;
+    restraint: string;
+    noUnmasked: boolean;
+} | {
+    group: string;
+    restraint: string;
+    noUnmasked?: undefined;
+})[];
+declare let KDAlertCD: number;
+declare let KDEventDataReset: {};
+declare namespace KDEventDataBase {
+    const SlimeLevel: number;
+    const SlimeLevelStart: number;
+}
+declare namespace KDEventData { }
+/**
+ * Function mapping
+ * to expand, keep (e, item, data) => {...} as a constant API call
+ * @type {Object.<string, Object.<string, function(KinkyDungeonEvent, item, *): void>>}
+ */
+declare let KDEventMapInventory: {
+    [x: string]: {
+        [x: string]: (arg0: KinkyDungeonEvent, arg1: item, arg2: any) => void;
+    };
+};
+/**
+ * @type {Object.<string, Object.<string, function(KinkyDungeonEvent, *, entity, *): void>>}
+ */
+declare const KDEventMapBuff: {
+    [x: string]: {
+        [x: string]: (arg0: KinkyDungeonEvent, arg1: any, arg2: entity, arg3: any) => void;
+    };
+};
+/**
+ * @type {Object.<string, Object.<string, function(KinkyDungeonEvent, *, *): void>>}
+ */
+declare let KDEventMapOutfit: {
+    [x: string]: {
+        [x: string]: (arg0: KinkyDungeonEvent, arg1: any, arg2: any) => void;
+    };
+};
+/**
+ * @type {Object.<string, Object.<string, function(KinkyDungeonEvent, *, *): void>>}
+ */
+declare let KDEventMapSpell: {
+    [x: string]: {
+        [x: string]: (arg0: KinkyDungeonEvent, arg1: any, arg2: any) => void;
+    };
+};
+/**
+ * @type {Object.<string, Object.<string, function(KinkyDungeonEvent, weapon, *): void>>}
+ */
+declare let KDEventMapWeapon: {
+    [x: string]: {
+        [x: string]: (arg0: KinkyDungeonEvent, arg1: weapon, arg2: any) => void;
+    };
+};
+/**
+ * @type {Object.<string, Object.<string, function(KinkyDungeonEvent, *, *): void>>}
+ */
+declare let KDEventMapBullet: {
+    [x: string]: {
+        [x: string]: (arg0: KinkyDungeonEvent, arg1: any, arg2: any) => void;
+    };
+};
+/**
+ * @type {Object.<string, Object.<string, function(KinkyDungeonEvent, entity, *): void>>}
+ */
+declare let KDEventMapEnemy: {
+    [x: string]: {
+        [x: string]: (arg0: KinkyDungeonEvent, arg1: entity, arg2: any) => void;
+    };
+};
+/**
+ * @type {Object.<string, Object.<string, function(string, *): void>>}
+ */
+declare let KDEventMapGeneric: {
+    [x: string]: {
+        [x: string]: (arg0: string, arg1: any) => void;
+    };
+};

package/bc/Screens/MiniGame/KinkyDungeon/KinkyDungeonFactions.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Determines if the enemy (which can be hostile) is aggressive, i.e. will pursue the player or ignore
+ * @param {entity} [enemy]
+ * @returns {boolean}
+ */
+declare function KinkyDungeonAggressive(enemy?: entity): boolean;
+/**
+ * Returns whether or not the enemy is ALLIED, i.e it will follow the player
+ * @param {entity} enemy
+ * @returns {boolean}
+ */
+declare function KDAllied(enemy: entity): boolean;
+/**
+ * Returns whether the enemy is HOSTILE to the player (if no optional argument) or the optional enemy
+ * @param {entity} enemy
+ * @param {entity} [enemy2]
+ * @returns {boolean}
+ */
+declare function KDHostile(enemy: entity, enemy2?: entity): boolean;
+/**
+ * Gets the faction of the enemy, returning "Player" if its an ally, or "Enemy" if no faction
+ * @param {entity} enemy
+ * @returns {string}
+ */
+declare function KDGetFaction(enemy: entity): string;
+/**
+ * Gets the faction of the enemy, returning "Player" if its an ally, or "Enemy" if no faction
+ * @param {entity} enemy
+ * @returns {string}
+ */
+declare function KDGetFactionOriginal(enemy: entity): string;
+/**
+ * Consults the faction table and decides if the two mentioned factions are hostile
+ * @param {string} a - Faction 1
+ * @param {string | entity} b - Faction 2
+ * @returns {boolean}
+ */
+declare function KDFactionHostile(a: string, b: string | entity): boolean;
+/**
+ * Consults the faction table and decides if the two mentioned factions are allied
+ * @param {string} a - Faction 1
+ * @param {string | entity} b - Faction 2
+ * @param {number} [threshold] - Faction 2
+ * @returns {boolean}
+ */
+declare function KDFactionAllied(a: string, b: string | entity, threshold?: number): boolean;
+/**
+ * Consults the faction table and decides if the two mentioned factions are favorable (i.e no friendly fire)
+ * @param {string} a - Faction 1
+ * @param {string | entity} b - Faction 2
+ * @returns {boolean}
+ */
+declare function KDFactionFavorable(a: string, b: string | entity): boolean;