bc-stubs 96.0.0

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

@@ -0,0 +1,37 @@
+declare function KinkyDungeonNewLore(): boolean;
+declare function KinkyDungeonUpdateTabs(exploredLore: any): void;
+declare function KinkyDungeonDrawLore(): void;
+declare function KinkyDungeonUpdateLore(exploredLore: any): void;
+declare function KinkyDungeonHandleLore(): boolean;
+declare let KinkyDungeonCurrentLore: number;
+/**
+ * @type {any}
+ */
+declare let KinkyDungeonCurrentLoreTab: any;
+/**
+ * @type {any[]}
+ */
+declare let KinkyDungeonCurrentLoreTabs: any[];
+declare let KinkyDungeonCurrentLoreItems: any[];
+declare let KinkyDungeonCurrentLoreItemOffset: number;
+declare let KinkyDungeonCurrentLoreTabOffset: number;
+declare let KinkyDungeonLore: number[];
+declare namespace KinkyDungeonCheckpointLore {
+    const Combat: number[];
+    const School: number[];
+    const History: number[];
+    const Enemy: number[];
+    const grv: number[];
+    const tmb: number[];
+    const cat: number[];
+    const lib: number[];
+    const jng: number[];
+    const cry: number[];
+    const tmp: number[];
+    const ore: number[];
+    const bel: number[];
+}
+declare let KinkyDungeonLoreScale: number;
+declare let KinkyDungeonRepeatLoreChance: number;
+declare let KinkyDungeonGenericLoreChance: number;
+declare let KinkyDungeonNewLoreList: any;

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

@@ -0,0 +1,113 @@
+declare function KinkyDungeonSearchSpell(list: any, name: any): any;
+declare function KinkyDungeonFindSpell(name: any, SearchEnemies: any): any;
+declare function KinkyDungeonDisableSpell(Name: any): void;
+declare function KinkyDungeonResetMagic(): void;
+/**
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+declare function KDHasSpell(name: string): boolean;
+/**
+ *
+ * @param {string} name
+ * @param {number} Level - Spell level. Set to -1 to allow any level
+ * @returns {spell}
+ */
+declare function KDGetUpcast(name: string, Level: number): spell;
+/**
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+declare function KDHasUpcast(name: string): boolean;
+/**
+ *
+ * @returns {boolean}
+ */
+declare function KDCanUpcast(): boolean;
+declare function KDEmpower(data: any, entity: any): void;
+declare function KinkyDungeoCheckComponents(spell: any, x: any, y: any): string[];
+declare function KinkyDungeonHandleSpellChoice(SpellChoice: any): any;
+declare function KDSpellIgnoreComp(spell: any): boolean;
+declare function KinkyDungeonHandleSpellCast(spell: any): any;
+declare function KinkyDungeonClickSpell(i: any): {
+    spell: any;
+    clicked: boolean;
+};
+declare function KinkyDungeonHandleSpell(): boolean;
+declare function KinkyDungeonGetManaCost(Spell: any): any;
+declare function KinkyDungeonGetCost(Spell: any): any;
+declare function KinkyDungeonMakeNoise(radius: any, noiseX: any, noiseY: any): void;
+/**
+ *
+ * @param {number} targetX
+ * @param {number} targetY
+ * @param {spell} spell
+ * @param {*} enemy
+ * @param {*} player
+ * @param {*} bullet
+ * @param {string} [forceFaction]
+ * @param {any} [castData]
+ * @returns {{result: string, data: any}}
+ */
+declare function KinkyDungeonCastSpell(targetX: number, targetY: number, spell: spell, enemy: any, player: any, bullet: any, forceFaction?: string, castData?: any): {
+    result: string;
+    data: any;
+};
+declare function KinkyDungeonClickSpellChoice(I: any, CurrentSpell: any): void;
+declare function KinkyDungeonHandleMagic(): boolean;
+declare function KDGetPrerequisite(spell: any): string;
+declare function KinkyDungeonCheckSpellPrerequisite(spell: any): boolean;
+declare function KinkyDungeonDetectLanguageForMaxWidth(str: any, maxWidthTranslate: any, maxWidthEnglish: any): any;
+declare function KinkyDungeonWordWrap(str: any, maxWidthTranslate: any, maxWidthEnglish: any): string;
+declare function KinkyDungeonTestWhite(x: any, language: any): any;
+declare function KDSchoolColor(school: any): string;
+declare function KinkyDungeonDrawMagic(): void;
+declare function KDFilterSpellPages(): string[][][];
+declare function KDFilterSpellPageNames(): string[];
+declare function KDCorrectCurrentSpellPage(pages: any): number;
+declare function KinkyDungeonListSpells(Mode: any): any;
+declare function KinkyDungeonDrawMagicSpells(): void;
+declare function KinkyDungeonHandleMagicSpells(): boolean;
+declare function KinkyDungeonSpellIndex(Name: any): number;
+declare function KinkyDungeonSetPreviewSpell(spell: any): void;
+declare function KinkyDungeonGetCompList(spell: any): string;
+declare function KinkyDungeonSendMagicEvent(Event: any, data: any, forceSpell: any): void;
+declare function KDCastSpellToEnemies(fn: any, tX: any, tY: any, spell: any): boolean;
+/**
+ * Returns true if the enemy matches one of the tags
+ * @param {string[]} tags
+ * @param {entity} entity
+ * @returns {boolean}
+ */
+declare function KDMatchTags(tags: string[], entity: entity): boolean;
+declare let KinkyDungeonManaCost: number;
+declare let KDEmpowerSprite: string;
+declare let KDMaxEmpower: number;
+declare let KinkyDungeonBookScale: number;
+declare let KinkyDungeonMysticSeals: number;
+declare let KinkyDungeonCurrentBook: string;
+declare let KinkyDungeonCurrentPage: number;
+declare let KinkyDungeonCurrentSpellsPage: number;
+declare let KinkyDungeonBooks: string[];
+declare let KinkyDungeonPreviewSpell: any;
+declare let KinkyDungeonSpellChoices: number[];
+declare let KinkyDungeonSpellChoicesToggle: boolean[];
+declare let KinkyDungeonSpellChoiceCount: number;
+declare let KinkyDungeonSpellChoiceCountPerPage: number;
+declare let KDSpellPage: number;
+declare let KinkyDungeonSpellOffset: number;
+declare let KinkyDungeonSpellChoiceOffset: number;
+declare let KDPlayerHitBy: any[];
+declare let KinkyDungeonMiscastPityModifier: number;
+declare let KinkyDungeonMiscastPityModifierIncrementPercentage: number;
+declare let KinkyDungeonSpellPress: string;
+declare let KDSwapSpell: number;
+declare let selectedFilters: string[];
+declare let genericfilters: string[];
+declare let KDSpellListIndex: number;
+declare let KDSpellListIndexVis: number;
+declare let KDMaxSpellPerColumn: number;
+declare let KDMaxSpellYY: number;
+declare let MagicSpellsUIShift: number;

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

@@ -0,0 +1,23 @@
+/**
+ * @type {Record<string, (spell: any, data: any, targetX: any, targetY: any, tX: any, tY: any, entity: any, enemy: any, moveDirection: any, bullet: any, miscast: any, faction: any, cast: any, selfCast: any) => void | string>}
+ */
+declare let KinkyDungeonSpellSpecials: Record<string, (spell: any, data: any, targetX: any, targetY: any, tX: any, tY: any, entity: any, enemy: any, moveDirection: any, bullet: any, miscast: any, faction: any, cast: any, selfCast: any) => void | string>;
+declare namespace KDCommandCaptureBindings {
+    function vine(spell: any, entity: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    function rope(spell: any, entity: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    function fabric(spell: any, entity: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    function belt(spell: any, entity: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    function chain(spell: any, entity: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+}
+declare namespace KDCommandBindBindings {
+    export function vine_1(spell: any, x: any, y: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    export { vine_1 as vine };
+    export function rope_1(spell: any, x: any, y: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    export { rope_1 as rope };
+    export function fabric_1(spell: any, x: any, y: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    export { fabric_1 as fabric };
+    export function chain_1(spell: any, x: any, y: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    export { chain_1 as chain };
+    export function belt_1(spell: any, x: any, y: any, faction: any, bullet: any, miscast: any, attacker: any, counter: any): void;
+    export { belt_1 as belt };
+}

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

@@ -0,0 +1,62 @@
+declare namespace KDCommandWord {
+    const name: string;
+    const tags: string[];
+    const sfx: string;
+    const school: string;
+    const manacost: number;
+    const components: string[];
+    const level: number;
+    const type: string;
+    const special: string;
+    const noMiscast: boolean;
+    const onhit: string;
+    const time: number;
+    const power: number;
+    const range: number;
+    const size: number;
+    const damage: string;
+}
+/**
+ * These are starting spells
+ */
+declare let KinkyDungeonSpellsStart: any[];
+declare let filters: string[];
+/** Extra filters, indexed according to the learnable spells menu */
+declare let filtersExtra: string[][];
+declare let KDColumnLabels: string[][];
+declare let KinkyDungeonSpellPages: string[];
+/**
+ * These spells occur in the menu and the player can learn them
+ * Spells with NoBuy cannot be bought, but can be looked at.
+ * Spells with NoMenu do not appear in the menu until the player has them
+ */
+declare let KinkyDungeonLearnableSpells: string[][][];
+/**
+ * Spells that the player can choose
+ * @type {Record<string, spell[]>}
+ */
+declare let KinkyDungeonSpellList: Record<string, spell[]>;
+/**
+ * Spells that are not in the base spell lists
+ * @type {spell[]}
+ */
+declare let KinkyDungeonSpellListEnemies: spell[];
+/** @type {Record<string, KDBondage>} */
+declare let KDSpecialBondage: Record<string, KDBondage>;
+declare namespace KDMagicDefs {
+    const RopeKraken_TentacleCost: number;
+    const RopeKraken_TentacleThreshold: number;
+    const RopeKraken_TentacleCountMin: number;
+    const RopeKraken_TentacleCountShare: number;
+    const SarcoKraken_TentacleCost: number;
+    const SarcoKraken_TentacleThreshold: number;
+    const SarcoKraken_TentacleCountMin: number;
+    const SarcoKraken_TentacleCountMax: number;
+    const SarcoKraken_TentacleCountShare: number;
+    const SlimeKraken_TentacleCost: number;
+    const SlimeKraken_TentacleThreshold: number;
+    const SlimeKraken_TentacleCountMin: number;
+    const SlimeKraken_TentacleCountShare: number;
+}
+/** @type {Record<string, (enemy: entity, target: entity, spell?: spell) => boolean>} */
+declare let KDCastConditions: Record<string, (enemy: entity, target: entity, spell?: spell) => boolean>;

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

@@ -0,0 +1,5 @@
+declare function KDGetMapGenList(count: any, mods: any): any[];
+/**
+ * @type {Record<string, MapMod>}
+ */
+declare let KDMapMods: Record<string, MapMod>;

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

@@ -0,0 +1,10 @@
+declare let Ally: string;
+declare let Sub: string;
+declare let Enemy: string;
+declare let Jailer: string;
+declare let KDMistress: {
+    Adventurer: {
+        name: string;
+        alignment: string;
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Sends a multiplayer update, trimming off stuff that doesnt need to get sent yet
+ * @returns {void}
+ */
+declare function KinkyDungeonMultiplayerUpdate(Delay: any): void;
+/**
+ * Converts a string into Kinky Game Data
+ * @returns {void}
+ */
+declare function KinkyDungeonUnpackData(KinkyData: any): void;
+declare function KinkyDungeonUpdateFromData(): boolean;
+/**
+ * Turns the game state into a string that can be sent over
+ * @returns {string} - String containing game data
+ */
+declare function KinkyDungeonPackData(IncludeMap: any, IncludeItems: any, IncludeInventory: any, IncludeStats: any): string;
+/**
+ * Sends kinky dungeon data to the target member
+ * @returns {void}
+ */
+declare function KinkyDungeonSendData(data: any): void;
+/**
+ * Handles kinky dungeon data after receiving it from another player
+ * @returns {void}
+ */
+declare function KinkyDungeonHandleData(data: any, SourceMemberNumber: any): void;

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

@@ -0,0 +1,28 @@
+declare function KDGetCheckpoint(): string;
+declare function KDUpdateMusic(): void;
+declare function KDPlayMusic(Sound: any, Volume: any): void;
+declare function KDEndMusic(): void;
+/** These tracks will loop with a certain chance of forcibly continuing the loop. 0 = no loop*/
+declare let KDMusicLoopTracksChance: {
+    "AREA1-GRAVEYARD.ogg": number;
+    "AREA2-ANCIENTTOMBS.ogg": number;
+    "GENERIC-DOLLRACK.ogg": number;
+    "AREA4-MAGICLIBRARY.ogg": number;
+    "AREA5-UNDERGROUNDJUNGLE.ogg": number;
+    "AREA6-CRYSTALCAVE.ogg": number;
+    "AREA7-LOSTTEMPLE.ogg": number;
+    "AREA8-ORRERY.ogg": number;
+    "AREA9-BELLOWS.ogg": number;
+};
+declare let KDCurrentSong: string;
+declare let KDNewSong: string;
+declare let KDLastSong: string;
+declare let KDCurrentLoops: number;
+declare let KDCurrentFade: number;
+declare let KDMusicFadeTime: number;
+declare let KDMusicFadeInTime: number;
+declare let KDMusicTickRate: number;
+/** @type {HTMLAudioElement} */
+declare let KDCurrentMusicSound: HTMLAudioElement;
+declare let KDCurrentMusicSoundUpdate: any;
+declare let lastKDMusicTick: number;

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

@@ -0,0 +1,42 @@
+declare function KinkyDungeonDrawDoor(): void;
+/** Chest lock */
+declare function KinkyDungeonDrawLock(): void;
+declare function KinkyDungeonDrawGhost(): void;
+declare function KinkyDungeonDrawAngel(): void;
+declare function KinkyDungeonGhostMessage(): void;
+declare function KinkyDungeonAngelMessage(): void;
+declare function KinkyDungeonFoodMessage(Tile: any): void;
+declare function KinkyDungeonMakeGhostDecision(): void;
+declare function KinkyDungeonDrawCharger(): void;
+declare function KinkyDungeonDrawTablet(): void;
+declare function KinkyDungeonDrawFood(): void;
+declare function KinkyDungeonHandleCharger(): boolean;
+/**
+ * Script happens when you display an object message
+ * @type {Record<string,() => void>}
+ */
+declare let KDObjectMessages: Record<string, () => void>;
+/**
+ * Script happens when you move to an object
+ * MUTUALLY exclusive with KDObjectDraw, as this
+ * overrides the default behavior of clicking on the object and bringing up a modal
+ * @type {Record<string,(x: number, y: number) => void>}
+ */
+declare let KDObjectClick: Record<string, (x: number, y: number) => void>;
+/**
+ * Script to handle click in an object's modal
+ * tbh should remove this soon
+ * @type {Record<string,() => boolean>}
+ */
+declare let KDObjectHandle: Record<string, () => boolean>;
+/**
+ * Determines if an object has an interface and also if it pauses the game when you click on it
+ * You dont need an interface (for example the updated food table) but then you need
+ * an entry in KDObjectClick instead.
+ * @type {Record<string,() => void>}
+ */
+declare let KDObjectDraw: Record<string, () => void>;
+declare let KDChargerLight: number;
+declare let KDChargerColor: number;
+declare let KDLeylineLightColor: number;
+declare let KDLeylineLight: number;

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

@@ -0,0 +1,4 @@
+/**
+ * @type {Record<mapKey,floorParams>}
+ */
+declare const KinkyDungeonMapParams: Record<mapKey, floorParams>;

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

@@ -0,0 +1,36 @@
+declare function KDUpdateDoorNavMap(): void;
+/**
+ * @param {number} startx - the start position
+ * @param {number} starty - the start position
+ * @param {number} endx - the end positon
+ * @param {number} endy - the end positon
+ * @param {boolean} blockEnemy - Do enemies block movement?
+ * @param {boolean} blockPlayer - Does player block movement?
+ * @param {string} Tiles - Allowed move tiles!
+ * @param {entity} [Enemy] - Enemy trying to pathfind
+ * @param {boolean} [trimLongDistance] - Give up after 1000 or so tiles checked
+ * @returns {any} - Returns an array of x, y points in order
+ */
+declare function KinkyDungeonFindPath(startx: number, starty: number, endx: number, endy: number, blockEnemy: boolean, blockPlayer: boolean, ignoreLocks: any, Tiles: string, RequireLight: any, noDoors: any, needDoorMemory: any, Enemy?: entity, trimLongDistance?: boolean): any;
+declare function KinkyDungeonGetPath(closed: any, xx: any, yy: any, endx: any, endy: any): {
+    x: any;
+    y: any;
+}[];
+declare function KDSetPathfindCache(PathMap: any, newPath: any, endx: any, endy: any, Tiles: any, Finalindex: any): void;
+/**
+ * @type {Map<string, {x: number, y: number}[]>}
+ */
+declare let KDPathCache: Map<string, {
+    x: number;
+    y: number;
+}[]>;
+/**
+ * @type {Map<string, {x: number, y: number}[]>}
+ */
+declare let KDPathCacheIgnoreLocks: Map<string, {
+    x: number;
+    y: number;
+}[]>;
+declare let KDPathfindingCacheHits: number;
+declare let KDPathfindingCacheFails: number;
+declare let KDPFTrim: number;

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

@@ -0,0 +1,147 @@
+declare function KDGetPerkCost(perk: any): any;
+declare function KinkyDungeonGetStatPoints(Stats: any): number;
+/**
+ * Determine if a perk can be picked with a certain number of points remaining
+ * @param {string} Stat
+ * @param {number} [points]
+ * @returns {boolean}
+ */
+declare function KinkyDungeonCanPickStat(Stat: string, points?: number): boolean;
+/**
+ * General validation for a perk
+ * @param {KDPerk} stat
+ * @returns {boolean}
+ */
+declare function KDValidatePerk(stat: KDPerk): boolean;
+/**
+ * @param {string} perk1
+ * @param {string} perk2
+ * @returns {boolean}
+ * Determines if perk1 is blocked by another perk or in general */
+declare function KDPerkBlocked(perk1: string, perk2: string): boolean;
+declare function KinkyDungeonCanUnPickStat(Stat: any): boolean;
+declare function KinkyDungeonDrawPerks(NonSelectable: any): boolean;
+/**
+ *
+ * @param {any[]} list
+ * @param {number} x
+ * @param {number} y
+ * @param {number} w
+ * @param {number} h
+ * @param {number} max
+ * @param {number} fontSize
+ * @param {(any) => ((any) => boolean)} clickfnc
+ * @param {string} prefix
+ */
+declare function drawVertList(list: any[], x: number, y: number, w: number, h: number, max: number, fontSize: number, clickfnc: (any: any) => (any: any) => boolean, prefix: string): void;
+/**
+ *
+ * @param {Record<string, boolean>} existing
+ * @returns {string[]}
+ */
+declare function KDGetRandomPerks(existing: Record<string, boolean>): string[];
+declare let KDDoorKnobChance: number;
+declare let KDDoorKnobChanceArms: number;
+declare let KDDoorAttractChance: number;
+declare let KDDoorAttractChanceArms: number;
+/** These weapons can get removed if you start the game with them*/
+declare let kdStartWeapons: string[];
+declare namespace KDPerkParams {
+    const KDEnemyDamageMult: number;
+    const KDEnemyResistBuff: number;
+    const KDEnemyArmorBoost: number;
+}
+declare let KDCategoriesStart: {
+    name: string;
+    buffs: any[];
+    debuffs: any[];
+}[];
+declare namespace KDPerkIcons {
+    function Pacifist(): boolean;
+    function BerserkerRage(): boolean;
+    function BoundPower(): boolean;
+    function UnstableMagic(): boolean;
+    function BurningDesire(): boolean;
+    function FrigidPersonality(): boolean;
+    function ImmovableObject(): boolean;
+    function GroundedInReality(): boolean;
+    function LikeTheWind(): boolean;
+    function LeastResistance(): boolean;
+}
+declare namespace KDPerkUpdateStats {
+    export function Rigger(): void;
+    export function Ticklish(): void;
+    export function Stoic(): void;
+    export function Lascivious(): void;
+    export function Unperturbed(): void;
+    export function PainTolerance(): void;
+    export function Sticky(): void;
+    export function EnemyResist(): void;
+    export function BoundPower_1(): void;
+    export { BoundPower_1 as BoundPower };
+    export function BerserkerRage_1(): void;
+    export { BerserkerRage_1 as BerserkerRage };
+    export function Dodge(): void;
+    export function UnstableMagic_1(): void;
+    export { UnstableMagic_1 as UnstableMagic };
+    export function CommonLatex(): void;
+    export function CommonLeather(): void;
+    export function CommonMaid(): void;
+    export function CommonWolf(): void;
+    export function CommonDress(): void;
+    export function CommonFuuka(): void;
+    export function CommonCyber(): void;
+    export function CommonExp(): void;
+    export function CommonKitty(): void;
+}
+/**
+ * @type {Record<string, () => string>}
+ */
+declare let KDPerkCount: Record<string, () => string>;
+/**
+ * @type {Record<string, KDPerk>}
+ */
+declare let KinkyDungeonStatsPresets: Record<string, KDPerk>;
+declare namespace KDPerkStart {
+    export function Studious(): void;
+    export function Submissive(): void;
+    export function Pacifist_1(): void;
+    export { Pacifist_1 as Pacifist };
+    export function Rigger_1(): void;
+    export { Rigger_1 as Rigger };
+    export function Unchained(): void;
+    export function FuukaCollar(): void;
+    export function Prisoner(): void;
+    export function Slayer(): void;
+    export function Conjurer(): void;
+    export function Magician(): void;
+    export function Brawler(): void;
+    export function SelfBondage(): void;
+    export function StartLatex(): void;
+    export function DollmakerVisor(): void;
+    export function DollmakerMask(): void;
+    export function StartCyberDoll(): void;
+    export function StartMaid(): void;
+    export function StartWolfgirl(): void;
+    export function StartObsidian(): void;
+    export function Hogtied(): void;
+    export function Stranger(): void;
+    export function WrongNeighborhood(): void;
+    export function Cursed(): void;
+    export function MC_Trainee(): void;
+}
+declare let KDPerksFilter: string;
+declare let KDPerksButtonWidth: number;
+declare let KDPerksButtonWidthPad: number;
+declare let KDPerksButtonHeight: number;
+declare let KDPerksButtonHeightPad: number;
+declare let KDPerksXPad: number;
+declare let KDPerksYPad: number;
+declare let KDPerksYStart: number;
+declare let KDPerksXStart: number;
+declare let KDPerksMaxY: number;
+declare let KDPerksScroll: number;
+declare let KDPerksIndex: number;
+declare let KDPerksIndexUI: number;
+declare let KDPerksIndexUIWeight: number;
+declare let KDCategories: any[];

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

@@ -0,0 +1,83 @@
+/**
+ *
+ * @param {entity} enemy
+ * @returns {string}
+ */
+declare function KDGetPersonality(enemy: entity): string;
+/**
+ *
+ * @param {entity} enemy
+ * @returns {string}
+ */
+declare function KDJailPersonality(enemy: entity): string;
+declare namespace KDJailPersonalities {
+    const Robot: boolean;
+    const Dom: boolean;
+    const Sub: boolean;
+}
+declare let KDStrictPersonalities: string[];
+declare let KDLoosePersonalities: string[];
+declare let KDEnemyPersonalities: {
+    "": {
+        weight: number;
+        loose: boolean;
+        strict: boolean;
+        brat: boolean;
+        domVariance: number;
+        tags: {
+            robot: number;
+        };
+    };
+    Robot: {
+        weight: number;
+        loose: boolean;
+        strict: boolean;
+        brat: boolean;
+        tags: {
+            robot: number;
+            cyborg: number;
+        };
+    };
+    Dom: {
+        weight: number;
+        loose: boolean;
+        strict: boolean;
+        brat: boolean;
+        tags: {
+            minor: number;
+            alchemist: number;
+            elite: number;
+            boss: number;
+            robot: number;
+            cyborg: number;
+        };
+    };
+    Sub: {
+        weight: number;
+        loose: boolean;
+        strict: boolean;
+        brat: boolean;
+        tags: {
+            minor: number;
+            human: number;
+            elite: number;
+            boss: number;
+            robot: number;
+            cyborg: number;
+        };
+    };
+    Brat: {
+        weight: number;
+        loose: boolean;
+        strict: boolean;
+        brat: boolean;
+        domMod: number;
+        tags: {
+            minor: number;
+            human: number;
+            boss: number;
+            robot: number;
+            cyborg: number;
+        };
+    };
+};

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

@@ -0,0 +1,35 @@
+/**
+ *
+ * @param {any} spell
+ * @param {number} count
+ * @param {string[]} tags
+ * @param {string} faction
+ * @param {boolean} [noDeep]
+ * @param {boolean} [bypass] - Bypass inaccessible things
+ * @returns {restraint[]}
+ */
+declare function KDPlayerEffectRestrain(spell: any, count: number, tags: string[], faction: string, noDeep?: boolean, bypass?: boolean, allowEvade?: boolean, allowBlock?: boolean, allowBondageResist?: boolean): restraint[];
+declare function KDTestSpellHits(spell: any, allowEvade?: number, allowBlock?: number): boolean;
+declare function KinkyDungeonPlayerEffect(target: any, damage: any, playerEffect: any, spell: any, faction: any, bullet: any): boolean;
+/**
+ * For those 'three strikes you're out' effects
+ * @param {string} Name
+ * @param {entity} Target
+ * @param {number} time - Time for the buff to wear off
+ * @param {(target: entity) => void} FinalEffect
+ * @param {string} buffType - Buff effect
+ */
+declare function KDTripleBuffKill(Name: string, Target: entity, time: number, FinalEffect?: (target: entity) => void, buffType?: string): void;
+/**
+ *
+ * @param {boolean} resetSlimeLevel
+ * @param {string} restraint
+ */
+declare function KDAdvanceSlime(resetSlimeLevel: boolean, restraint?: string): boolean;
+/**
+ * @type {Record<string, (target, damage, playerEffect, spell, faction, bullet) => {sfx: string, effect: boolean}>}
+ */
+declare let KDPlayerEffects: Record<string, (target: any, damage: any, playerEffect: any, spell: any, faction: any, bullet: any) => {
+    sfx: string;
+    effect: boolean;
+}>;

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

@@ -0,0 +1,10 @@
+declare function KDQuestList(count: any, mods: any, RoomType: any, MapMod: any, data: any): any[];
+declare function KDQuestTick(quests: any): void;
+declare function KDRemoveQuest(quest: any): void;
+declare function KDAddQuest(quest: any): void;
+declare function KDHasQuest(quest: any): boolean;
+declare let QuestCompleteWeight: number;
+/**
+ * @type {Record<string, any>}
+ */
+declare let KDQuests: Record<string, any>;