bc-stubs 96.0.0

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

@@ -0,0 +1,178 @@
+declare function KDCloseQuickInv(): void;
+declare function KDSwitchWeapon(): void;
+declare function KinkyDungeonHandleInventory(): boolean;
+declare function KinkyDungeonInventoryAddWeapon(Name: any): void;
+declare function KinkyDungeonInventoryAddLoose(Name: any, UnlockCurse: any): void;
+declare function KinkyDungeonInventoryAddOutfit(Name: any): void;
+/**
+ *
+ * @param item {item}
+ * @return {string}
+ */
+declare function KDInventoryType(item: item): string;
+declare function KinkyDungeonFullInventory(): any[];
+declare function KinkyDungeonInventoryLength(): number;
+/**
+ *
+ * @param item {item}
+ */
+declare function KinkyDungeonInventoryAdd(item: item): void;
+/**
+ *
+ * @param item {item}
+ */
+declare function KinkyDungeonInventoryRemove(item: item): void;
+/**
+ *
+ * @param Name
+ * @return {null|item}
+ */
+declare function KinkyDungeonInventoryGet(Name: any): null | item;
+/**
+ *
+ * @param Name
+ * @return {null|item}
+ */
+declare function KinkyDungeonInventoryGetLoose(Name: any): null | item;
+/**
+ *
+ * @param Name
+ * @return {null|item}
+ */
+declare function KinkyDungeonInventoryGetConsumable(Name: any): null | item;
+/**
+ *
+ * @param Name
+ * @return {null|item}
+ */
+declare function KinkyDungeonInventoryGetWeapon(Name: any): null | item;
+/**
+ *
+ * @param Name
+ * @return {null|item}
+ */
+declare function KinkyDungeonInventoryGetOutfit(Name: any): null | item;
+/**
+ * Returns list
+ * @return {item[]}
+ */
+declare function KinkyDungeonAllRestraint(): item[];
+/**
+ * Returns list of tuples of restraints, including dynamics and their hosts
+ * @return {{item: item, host: item}[]}
+ */
+declare function KinkyDungeonAllRestraintDynamic(): {
+    item: item;
+    host: item;
+}[];
+/**
+ * Returns list
+ * @return {item[]}
+ */
+declare function KinkyDungeonAllLooseRestraint(): item[];
+/**
+ * Returns list
+ * @return {item[]}
+ */
+declare function KinkyDungeonAllConsumable(): item[];
+/**
+ * Returns list
+ * @return {item[]}
+ */
+declare function KinkyDungeonAllOutfit(): item[];
+/**
+ * Returns list
+ * @return {item[]}
+ */
+declare function KinkyDungeonAllWeapon(): item[];
+/**
+ *
+ * @param {item} item
+ * @returns {{name: any; item: any; preview: string;}}
+ */
+declare function KDGetItemPreview(item: item): {
+    name: any;
+    item: any;
+    preview: string;
+};
+/**
+ *
+ * @param {string} Filter
+ * @param {boolean} [enchanted]
+ * @param {boolean} [ignoreHidden]
+ * @param {boolean} [ignoreFilters]
+ * @returns {{name: any; item: any; preview: string;}[]}
+ */
+declare function KinkyDungeonFilterInventory(Filter: string, enchanted?: boolean, ignoreHidden?: boolean, ignoreFilters?: boolean): {
+    name: any;
+    item: any;
+    preview: string;
+}[];
+/**
+ *
+ * @param {{name: any, item: item, preview: string}} item
+ * @param {boolean} [noscroll]
+ * @param {boolean} [treatAsHover]
+ * @param {number} xOffset
+ * @returns {boolean}
+ */
+declare function KinkyDungeonDrawInventorySelected(item: {
+    name: any;
+    item: item;
+    preview: string;
+}, noscroll?: boolean, treatAsHover?: boolean, xOffset?: number): boolean;
+declare function KinkyDungeonDrawInventory(): void;
+declare function KinkyDungeonSendInventoryEvent(Event: any, data: any): void;
+declare function KinkyDungeonQuickGrid(I: any, Width: any, Height: any, Xcount: any): {
+    x: number;
+    y: number;
+};
+declare function KinkyDungeonDrawQuickInv(): void;
+declare function KinkyDungeonhandleQuickInv(NoUse: any): boolean;
+/**
+ *
+ * @param {string} name
+ * @param {entity} [player]
+ * @param {boolean} playerDropped
+ */
+declare function KDDropItemInv(name: string, player?: entity, playerDropped?: boolean): void;
+/**
+ *
+ * @param {entity} player
+ */
+declare function KDSortInventory(player: entity): void;
+declare let KinkyDungeonFilters: string[];
+/**
+ * @type {Record<string, boolean>}
+ */
+declare let KDInventoryUseIconConfig: Record<string, boolean>;
+/** List of current filters for each filter type */
+/**
+ * @type {Record<string, Record<string, boolean>>}
+ */
+declare let KDFilterFilters: Record<string, Record<string, boolean>>;
+declare let KinkyDungeonCurrentFilter: string;
+declare let KinkyDungeonCurrentPageInventory: number;
+declare let KinkyDungeonShowInventory: boolean;
+declare let KinkyDungeonInventoryOffset: number;
+declare let KinkyDungeonInvDraw: any[];
+declare namespace KDScrollOffset {
+    const Consumable: number;
+    const Restraint: number;
+    const Weapon: number;
+}
+declare namespace KDItemsPerScreen {
+    const Consumable_1: number;
+    export { Consumable_1 as Consumable };
+    const Restraint_1: number;
+    export { Restraint_1 as Restraint };
+    const Weapon_1: number;
+    export { Weapon_1 as Weapon };
+}
+declare let KDScrollAmount: number;
+declare namespace KDInventoryStatus {
+    const HideQuickInv: boolean;
+    const DropQuickInv: boolean;
+    const SortQuickInv: boolean;
+    const FilterQuickInv: boolean;
+}

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

@@ -0,0 +1,33 @@
+declare function KinkyDungeonItemDrop(x: any, y: any, dropTable: any, summoned: any): false | {
+    x: any;
+    y: any;
+    name: any;
+    amount: any;
+};
+declare function KinkyDungeonDropItem(Item: any, Origin: any, AllowOrigin: any, noMsg: any, allowEnemies: any): boolean;
+declare function KinkyDungeonItemEvent(Item: any): boolean;
+declare function KinkyDungeonItemCheck(x: any, y: any, Index: any): void;
+declare function KDCanSeeDroppedItem(item: any): boolean;
+declare function KinkyDungeonDrawItems(canvasOffsetX: any, canvasOffsetY: any, CamX: any, CamY: any): void;
+declare function KinkyDungeonDrawHeart(): void;
+declare function KinkyDungeonHandleHeart(): boolean;
+/**
+ *
+ * @param {any[]} items
+ * @param {number} offset
+ * @returns {number}
+ */
+declare function KDDrawItemsTooltip(items: any[], offset: number): number;
+declare let KinkyDungeonGroundItems: any[];
+/** Certain items, when dropped, have specific properties
+ * @type {Record<string, KDDroppedItemProp>}
+*/
+declare let KDDroppedItemProperties: Record<string, KDDroppedItemProp>;
+declare namespace KDCustomItems {
+    function LeylineMap(): {
+        sfx: any;
+        replace: any;
+        priority: any;
+        color: any;
+    };
+}

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

@@ -0,0 +1,142 @@
+declare function KDAssignGuardAction(guard: any, xx: any, yy: any): void;
+declare function KDGetJailEvent(guard: any, xx: any, yy: any): (g: any, x: any, y: any) => void;
+declare function KinkyDungeonLoseJailKeys(Taken: any, boss: any, enemy: any): void;
+declare function KinkyDungeonUpdateJailKeys(): void;
+declare function KinkyDungeonAggroFaction(faction: any, noAllyRepPenalty: any): boolean;
+declare function KinkyDungeonPlayerIsVisibleToJailers(): entity;
+/**
+ *
+ * @param {entity} enemy
+ * @returns {boolean}
+ */
+declare function KinkyDungeonCanPlay(enemy: entity): boolean;
+declare function KinkyDungeonCheckRelease(): number;
+/**
+ *
+ * @param {string} action
+ * @param {{enemy?: entity, x?: number, y?: number, faction?: string}} data
+ */
+declare function KinkyDungeonAggroAction(action: string, data: {
+    enemy?: entity;
+    x?: number;
+    y?: number;
+    faction?: string;
+}): void;
+/**
+ *
+ * @param {entity} enemy
+ * @param {string} Type
+ * @param {string} [faction]
+ * @param {boolean} [force]
+ */
+declare function KinkyDungeonStartChase(enemy: entity, Type: string, faction?: string, force?: boolean): void;
+/**
+ *
+ * @param {entity} enemy
+ * @param {string} Type
+ */
+declare function KinkyDungeonPlayExcuse(enemy: entity, Type: string): void;
+/**
+ *
+ * @param {entity} enemy
+ * @param {number} mult
+ * @param {number} base
+ */
+declare function KDSetPlayCD(enemy: entity, mult: number, base?: number): void;
+/**
+ *
+ * @param {string} Group
+ * @returns {restraint}
+ */
+declare function KinkyDungeonGetJailRestraintForGroup(Group: string): restraint;
+declare function KinkyDungeonGetJailRestraintLevelFor(Name: any): number;
+/**
+ *
+ * @param {string[]} [filter] - Have to be in a jail, not a dropoff
+ * @returns {boolean}
+ */
+declare function KinkyDungeonInJail(filter?: string[]): boolean;
+declare function KinkyDungeonPlaceJailKeys(): boolean;
+declare function KinkyDungeonHandleJailSpawns(delta: any): void;
+declare function KinkyDungeonLockableItems(): string[];
+declare function KinkyDungeonMissingJailUniform(): string[];
+declare function KinkyDungeonTooMuchRestraint(): string[];
+/**
+ *
+ * @param {number} xx
+ * @param {number} yy
+ * @param {string} type
+ */
+declare function KinkyDungeonHandleLeashTour(xx: number, yy: number, type: string): void;
+/**
+ *
+ * @param {number} xx
+ * @param {number} yy
+ * @param {string} type
+ */
+declare function KinkyDungeonJailGuardGetLeashWaypoint(xx: number, yy: number, type: string): void;
+declare function KinkyDungeonJailGetLeashPoint(xx: any, yy: any, enemy: any): {
+    x: any;
+    y: any;
+};
+/**
+ * @param {boolean} [any]
+ * @param {boolean} [qualified] - Makes sure the player is qualified
+ * @param {string[]} [filter]
+ * @returns {boolean} - Returns if the player is inside the nearest jail cell
+ */
+declare function KinkyDungeonPlayerInCell(any?: boolean, qualified?: boolean, filter?: string[]): boolean;
+declare function KinkyDungeonPointInCell(x: any, y: any): boolean;
+declare function KinkyDungeonPassOut(noteleport: any): void;
+declare function KDGetJailDoor(x: any, y: any): {
+    tile: any;
+    x: any;
+    y: any;
+};
+declare function KDDefeatedPlayerTick(): void;
+declare function KDEnterDollTerminal(willing: any, cancelDialogue?: boolean): void;
+declare function KinkyDungeonDefeat(PutInJail: any): void;
+/**
+ *
+ * @param {entity} enemy
+ * @returns {boolean}
+ */
+declare function KDEnemyIsTemporary(enemy: entity): boolean;
+/** Kicks enemies away, and also out of offlimits zones if they are aware */
+declare function KDKickEnemies(nearestJail: any): void;
+declare function KDResetAllIntents(): void;
+declare function KDResetAllAggro(): void;
+/**
+ * Moves an enemy to a random position on the map
+ * @param {entity} e
+ */
+declare function KDKickEnemy(e: entity): void;
+/**
+ * Moves an enemy to a random position on the map
+ * @param {entity} e
+ */
+declare function KDKickEnemyLocal(e: entity): void;
+declare function KinkyDungeonStripInventory(KeepPicks: any): void;
+declare function KDExpireFlags(enemy: any): void;
+/**
+ * Gets the jail outfit of the guard, or using overrideTags instead of the guard's taggs
+ * @param {string[]} [overrideTags]
+ * @param {boolean} [requireJail]
+ * @param {boolean} [requireParole]
+ * @returns {{Name: string, Level: number}[]}
+ */
+declare function KDGetJailRestraints(overrideTags?: string[], requireJail?: boolean, requireParole?: boolean): {
+    Name: string;
+    Level: number;
+}[];
+/** Time spent in cage before guards start getting teleported */
+declare let KDMaxCageTime: number;
+/** Only these have jail events */
+declare let KDJailFilters: string[];
+/** Max turns for the alert timer until the whole map becomes hostile */
+declare let KDMaxAlertTimer: number;
+declare let KDMaxAlertTimerAggro: number;
+/**
+ * @type {string[]}
+ */
+declare let KDLocalChaseTypes: string[];

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

@@ -0,0 +1,105 @@
+/**
+ *
+ * @param {boolean} [override] - Override jailing requirement
+ * @returns {boolean}
+ */
+declare function KDCanSpawnShopkeeper(override?: boolean): boolean;
+/**
+ * @type {Record<string, {weight: (guard: any, xx: any, yy: any) => number, trigger: (guard: any, xx: any, yy: any) => void}>}
+ */
+declare let KDJailEvents: Record<string, {
+    weight: (guard: any, xx: any, yy: any) => number;
+    trigger: (guard: any, xx: any, yy: any) => void;
+}>;
+declare namespace KDGuardActions {
+    namespace jailWander {
+        function weight(guard: any, xx: any, yy: any): number;
+        function assignable(guard: any, xx: any, yy: any): boolean;
+        function assign(guard: any, xx: any, yy: any): void;
+        function handle(guard: any, xx: any, yy: any): void;
+    }
+    namespace release {
+        export function weight_1(guard: any, xx: any, yy: any): 0 | 1000;
+        export { weight_1 as weight };
+        export function assign_1(guard: any, xx: any, yy: any): void;
+        export { assign_1 as assign };
+        export function handle_1(guard: any, xx: any, yy: any): void;
+        export { handle_1 as handle };
+    }
+    namespace jailTease {
+        export function weight_2(guard: any, xx: any, yy: any): number;
+        export { weight_2 as weight };
+        export function assign_2(guard: any, xx: any, yy: any): void;
+        export { assign_2 as assign };
+        export function handle_2(guard: any, xx: any, yy: any, delta: any): void;
+        export { handle_2 as handle };
+    }
+    namespace bindings {
+        export function weight_3(guard: any, xx: any, yy: any): number;
+        export { weight_3 as weight };
+        export function assign_3(guard: any, xx: any, yy: any): void;
+        export { assign_3 as assign };
+        export function handle_3(guard: any, xx: any, yy: any, delta: any): void;
+        export { handle_3 as handle };
+    }
+    namespace jailRemoveRestraints {
+        export function weight_4(guard: any, xx: any, yy: any): number;
+        export { weight_4 as weight };
+        export function assign_4(guard: any, xx: any, yy: any): void;
+        export { assign_4 as assign };
+        export function handle_4(guard: any, xx: any, yy: any, delta: any): void;
+        export { handle_4 as handle };
+    }
+    namespace jailAddRestraints {
+        export function weight_5(guard: any, xx: any, yy: any): number;
+        export { weight_5 as weight };
+        export function assign_5(guard: any, xx: any, yy: any): void;
+        export { assign_5 as assign };
+        export function handle_5(guard: any, xx: any, yy: any, delta: any): void;
+        export { handle_5 as handle };
+    }
+    namespace jailLockRestraints {
+        export function weight_6(guard: any, xx: any, yy: any): number;
+        export { weight_6 as weight };
+        export function assign_6(guard: any, xx: any, yy: any): void;
+        export { assign_6 as assign };
+        export function handle_6(guard: any, xx: any, yy: any, delta: any): void;
+        export { handle_6 as handle };
+    }
+    namespace jailLeashTour {
+        export function weight_7(guard: any, xx: any, yy: any): number;
+        export { weight_7 as weight };
+        export function assign_7(guard: any, xx: any, yy: any): void;
+        export { assign_7 as assign };
+        export function handle_7(guard: any, xx: any, yy: any, delta: any): void;
+        export { handle_7 as handle };
+    }
+    namespace jailLeashTransfer {
+        export function weight_8(guard: any, xx: any, yy: any): 0 | 5;
+        export { weight_8 as weight };
+        export function assign_8(guard: any, xx: any, yy: any): void;
+        export { assign_8 as assign };
+        export function handle_8(guard: any, xx: any, yy: any, delta: any): void;
+        export { handle_8 as handle };
+    }
+}
+declare let KinkyDungeonJailRemoveRestraintsTimerMin: number;
+declare let KinkyDungeonJailedOnce: boolean;
+declare let KDJailReleaseTurns: {
+    minSub: number;
+    releaseTurns: number;
+}[];
+declare let KDSecurityLevelHiSec: number;
+/**
+ * @type {Record<string, {overridelowerpriority: boolean, priority: number, jail: boolean, parole: boolean, restraints: {Name: string, Level: number}[]}>}
+*/
+declare let KDJailOutfits: Record<string, {
+    overridelowerpriority: boolean;
+    priority: number;
+    jail: boolean;
+    parole: boolean;
+    restraints: {
+        Name: string;
+        Level: number;
+    }[];
+}>;

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

@@ -0,0 +1,66 @@
+/**
+ * @param {item[]} list
+ * @param {boolean} excludeBound - bound weapons, i.e. magic knives and weapons
+ */
+declare function KinkyDungeonAddLostItems(list: item[], excludeBound: boolean): void;
+declare function KinkyDungeonLoot(Level: any, Index: any, Type: any, roll: any, tile: any, returnOnly: any, noTrap: any): any;
+declare function KinkyDungeonGetUnlearnedSpells(minlevel: any, maxlevel: any, SpellList: any): any[];
+declare function KinkyDungeonLootEvent(Loot: any, Floor: any, Replacemsg: any, Lock: any): any;
+declare function KinkyDungeonAddGold(value: any): void;
+declare function KDSpawnLootTrap(x: any, y: any, trap: any, mult: any, duration: any): void;
+declare function KDGenChestTrap(guaranteed: any, x: any, y: any, chestType: any, lock: any, noTrap: any): any;
+declare function KDTriggerLoot(Loot: any, Type: any): void;
+/**
+ *
+ * @param {Record<string, object>} WeightList - contains values that have a weight param
+ */
+declare function KDGetWeightedString(WeightList: Record<string, object>, params: any): string;
+/** @type {item[]} */
+declare let KinkyDungeonLostItems: item[];
+declare let KDTightRestraintsMod: number;
+declare let KDTightRestraintsMult: number;
+declare let cursedRestraintCache: {};
+declare let KinkyDungeonSpecialLoot: boolean;
+declare let KinkyDungeonLockedLoot: boolean;
+declare namespace KDChestTrapWeights {
+    namespace metalTrap {
+        function weight(): number;
+        const mult: number;
+    }
+    namespace leatherTrap {
+        export function weight_1(): number;
+        export { weight_1 as weight };
+        const mult_1: number;
+        export { mult_1 as mult };
+    }
+    namespace latexTrap {
+        export function weight_2(): number;
+        export { weight_2 as weight };
+        const mult_2: number;
+        export { mult_2 as mult };
+    }
+    namespace ropeTrap {
+        export function weight_3(): number;
+        export { weight_3 as weight };
+        const mult_3: number;
+        export { mult_3 as mult };
+    }
+    namespace illusionTrap {
+        export function weight_4(): number;
+        export { weight_4 as weight };
+        const mult_4: number;
+        export { mult_4 as mult };
+    }
+}
+declare namespace KDTrapChestType {
+    function _default(guaranteed: any, x: any, y: any, chestType: any, lock: any, noTrap: any): {
+        trap: string;
+        mult: any;
+    };
+    export { _default as default };
+    export function shadow(guaranteed: any, x: any, y: any, chestType: any, lock: any, noTrap: any): {
+        trap: string;
+        mult: number;
+        duration: number;
+    };
+}