bc-stubs 96.0.0

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

@@ -0,0 +1,36 @@
+/**
+ *
+ * @param {item} item
+ * @returns {consumable}
+ */
+declare function KDConsumable(item: item): consumable;
+declare function KinkyDungeonFindConsumable(Name: any): consumable;
+declare function KinkyDungeonFindBasic(Name: any): {
+    name: string;
+    rarity: number;
+    shop: boolean;
+};
+declare function KinkyDungeonFindConsumableOrBasic(Name: any): consumable | {
+    name: string;
+    rarity: number;
+    shop: boolean;
+};
+declare function KinkyDungeonGetInventoryItem(Name: any, Filter?: string): {
+    name: any;
+    item: any;
+    preview: string;
+};
+declare function KinkyDungeonItemCount(Name: any): any;
+declare function KinkyDungeonGetShopItem(Level: any, Rarity: any, Shop: any): any;
+/**
+ *
+ * @param {consumable} consumable
+ * @param {number} Quantity
+ * @return {boolean}
+ */
+declare function KinkyDungeonChangeConsumable(consumable: consumable, Quantity: number): boolean;
+declare function KinkyDungeonConsumableEffect(Consumable: any, type: any): void;
+declare function KinkyDungeonPotionCollar(): boolean;
+declare function KinkyDungeonCanDrink(byEnemy: any): boolean;
+declare function KinkyDungeonAttemptConsumable(Name: any, Quantity: any): boolean;
+declare function KinkyDungeonUseConsumable(Name: any, Quantity: any): boolean;

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

@@ -0,0 +1,66 @@
+/**
+ * @type {Record<string, consumable>}
+ */
+declare let KinkyDungeonConsumables: Record<string, consumable>;
+/**
+ * @type {Record<string, consumable>}
+ */
+declare let KDCookies: Record<string, consumable>;
+declare let KDRechargeCost: number;
+declare let KinkyDungneonBasic: {
+    RedKey: {
+        name: string;
+        rarity: number;
+        shop: boolean;
+    };
+    BlueKey: {
+        name: string;
+        rarity: number;
+        costMod: number;
+        shop: boolean;
+    };
+    Lockpick: {
+        name: string;
+        rarity: number;
+        shop: boolean;
+    };
+    "3Bola": {
+        name: string;
+        consumable: string;
+        quantity: number;
+        rarity: number;
+        shop: boolean;
+    };
+    "3Bomb": {
+        name: string;
+        consumable: string;
+        quantity: number;
+        rarity: number;
+        shop: boolean;
+    };
+    MaidUniform: {
+        name: string;
+        rarity: number;
+        shop: boolean;
+        ignoreInventory: string;
+    };
+};
+declare namespace KinkyDungneonShopRestraints {
+    namespace SlimeWalkers {
+        const name: string;
+        const rarity: number;
+        const shop: boolean;
+    }
+    namespace PotionCollar {
+        const name_1: string;
+        export { name_1 as name };
+        const rarity_1: number;
+        export { rarity_1 as rarity };
+        const shop_1: boolean;
+        export { shop_1 as shop };
+    }
+}
+/** @type {Record<string, (consumable) => void>} */
+declare let KDConsumableEffects: Record<string, (consumable: any) => void>;
+/** @type {Record<string, (item: item, Quantity: number) => boolean>} */
+declare let KDConsumablePrereq: Record<string, (item: item, Quantity: number) => boolean>;

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

@@ -0,0 +1,44 @@
+/**
+ *
+ * @param {restraint} restraint
+ * @param {string} newRestraintName
+ * @param {KinkyDungeonEvent[]} ev
+ * @param {number} power
+ * @param {string} lock
+ * @param {Record<string, number>} enemyTags
+ * @returns {any}
+ */
+declare function KDAddEventVariant(restraint: restraint, newRestraintName: string, ev: KinkyDungeonEvent[], power?: number, lock?: string, enemyTags?: Record<string, number>): any;
+declare function KinkyDungeonCurseInfo(item: any, Curse: any): void;
+declare function KinkyDungeonCurseStruggle(item: any, Curse: any): void;
+declare function KinkyDungeonCurseAvailable(item: any, Curse: any): boolean;
+/**
+ *
+ * @param {string} group
+ * @param {number} index
+ * @param {string} Curse
+ */
+declare function KinkyDungeonCurseUnlock(group: string, index: number, Curse: string): void;
+/**
+ * onApply: occurs when applied
+ * condition: required to remove it
+ * remove: happens when removing
+ * events: these events are added to the restraint
+ * @type {Record<string, KDCursedDef>} */
+declare let KDCurses: Record<string, KDCursedDef>;
+/**
+ * TODO
+curseInfoAnimation,"Curse of Animation: Causes loose restraints to animate and attack you!"
+curseInfoSensitivity,"Curse of Sensitivity: Makes it easier to lose control of yourself."
+ */
+/** Cursed variants of restraints
+ * @type {Record<string, KDCursedVar>}
+ */
+declare let KDCursedVars: Record<string, KDCursedVar>;
+declare namespace KDCurseVariantList {
+    const Basic: string[];
+}
+declare namespace KDCurseUnlockList {
+    const Basic_1: string[];
+    export { Basic_1 as Basic };
+}

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

@@ -0,0 +1,171 @@
+/**
+ *
+ * @param {number} Min
+ * @param {number} Avg
+ * @param {number} Max
+ * @param {entity} [Enemy]
+ * @returns {number}
+ */
+declare function KDPersonalitySpread(Min: number, Avg: number, Max: number, Enemy?: entity): number;
+declare function KinkyDungeonCanPutNewDialogue(): boolean;
+declare function KDBasicCheck(PositiveReps: any, NegativeReps: any, Modifier?: number): number;
+declare function KDDialogueApplyPersonality(allowed: any): void;
+declare function KDGetDialogue(): KinkyDialogue;
+declare function KDDrawDialogue(): void;
+declare function KDIncreaseOfferFatigue(Amount: any): void;
+declare function KDEnemyHelpfulness(enemy: any): 1 | 1.75 | 0.33;
+declare function KDGetSpeaker(): entity;
+/**
+ *
+ * @param {number} Amount
+ */
+declare function KDPleaseSpeaker(Amount: number): void;
+/**
+ *
+ * @param {entity} enemy
+ * @param {number} Amount
+ */
+declare function KDAddOpinion(enemy: entity, Amount: number): void;
+declare function KDAllySpeaker(Turns: any, Follow: any): void;
+declare function KDAggroSpeaker(Turns?: number): void;
+declare function KDBasicDialogueSuccessChance(checkResult: any): number;
+declare function KDAgilityDialogueSuccessChance(checkResult: any): number;
+declare function KDOffensiveDialogueSuccessChance(checkResult: any): number;
+/**
+ *
+ * @param {string} Dialogue
+ * @param {string} [Speaker]
+ * @param {boolean} [Click]
+ * @param {string} [Personality]
+ * @param {entity} [enemy]
+ */
+declare function KDStartDialog(Dialogue: string, Speaker?: string, Click?: boolean, Personality?: string, enemy?: entity): void;
+declare function KDDoDialogue(data: any): void;
+/**
+ *
+ * @param {string} Dialogue
+ * @param {string} [Speaker]
+ * @param {boolean} [Click]
+ * @param {string} [Personality]
+ * @param {entity} [enemy]
+ */
+declare function KDStartDialogInput(Dialogue: string, Speaker?: string, Click?: boolean, Personality?: string, enemy?: entity): void;
+declare function KDDialogueGagged(): boolean;
+declare function KDHandleDialogue(): boolean;
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {string} Name
+ * @returns {entity}
+ */
+declare function DialogueCreateEnemy(x: number, y: number, Name: string): entity;
+/**
+ *
+ * @returns {entity}
+ */
+declare function KDDialogueEnemy(): entity;
+declare function KDAllyDialogue(name: any, requireTags: any, requireSingleTag: any, excludeTags: any, weight: any): KinkyDialogue;
+/**
+ *
+ * @param {string} name
+ * @param {string} faction
+ * @param {string[]} enemytypes
+ * @returns {KinkyDialogue}
+ */
+declare function KDPrisonerRescue(name: string, faction: string, enemytypes: string[]): KinkyDialogue;
+declare function KDRecruitDialogue(name: any, faction: any, outfitName: any, goddess: any, restraints: any, restraintscount: any, restraintsAngry: any, restraintscountAngry: any, requireTags: any, requireSingleTag: any, excludeTags: any, chance: any): KinkyDialogue;
+declare function KDShopDialogue(name: any, items: any, requireTags: any, requireSingleTag: any, chance: any): KinkyDialogue;
+/**
+ *
+ * @param {(firstRefused) => boolean} setupFunction - firstRefused is if the player said no first. Happens after the user clicks
+ * @param {(firstRefused) => boolean} yesFunction - firstRefused is if the player said no then yes. Happens whenever the user submits
+ * @param {(firstRefused) => boolean} noFunction - firstRefused is if the player said no then no. Happens whenever the user successfully avoids
+ * @param {(firstRefused) => boolean} domFunction - firstRefused is if the player said no then no. Happens when the user clicks the Dominant response
+ * @returns {KinkyDialogue}
+ */
+declare function KDYesNoTemplate(setupFunction: (firstRefused: any) => boolean, yesFunction: (firstRefused: any) => boolean, noFunction: (firstRefused: any) => boolean, domFunction: (firstRefused: any) => boolean): KinkyDialogue;
+/**
+ *
+ * @param {string} name
+ * @param {string[]} goddess
+ * @param {string[]} antigoddess
+ * @param {string[]} restraint
+ * @param {number[]} diffSpread - 0 is yesfunction diff, 2 is nofunction diff, 1 is yesfunction dom (should be lower), 3 is nofunction dom (should be lower)
+ * @param {number[]} OffdiffSpread - 0 is submissive diff, 1 is normal diff, 2 is dom diff, 3 is dom diff if you have dom personality (should be between 1 and 2)
+ * @param {number} count
+ * @param {number} countAngry
+ * @param {string} countAngry
+ * @param {boolean} Ally
+ * @param {{name: string, duration: number, floors?: number}[]} Flags - Sets flags on setup
+ * @returns {KinkyDialogue}
+ */
+declare function KDYesNoBasic(name: string, goddess: string[], antigoddess: string[], restraint: string[], diffSpread: number[], OffdiffSpread: number[], count?: number, countAngry?: number, Lock?: string, Ally?: boolean, Flags?: {
+    name: string;
+    duration: number;
+    floors?: number;
+}[]): KinkyDialogue;
+/**
+ * A shop where the seller sells items
+ * @returns {KinkyDialogue}
+ */
+declare function KDSaleShop(name: any, items: any, requireTags: any, requireSingleTag: any, chance: any, markup: any): KinkyDialogue;
+/** Yoinks a nearby enemy and brings them next to x */
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @returns {entity}
+ */
+declare function DialogueBringNearbyEnemy(x: number, y: number, radius: number): entity;
+/** Yoinks a nearby enemy and brings them next to x */
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {entity} enemy
+ * @returns {entity}
+ */
+declare function DialogueBringSpecific(x: number, y: number, enemy: entity): entity;
+/**
+ * Returns if you are submissive enough to be played with by this enemy
+ * @param {entity} enemy
+ * @returns {boolean}
+ */
+declare function KDIsSubmissiveEnough(enemy: entity): boolean;
+/**
+ *
+ * @param {entity} enemy
+ * @returns {number}
+ */
+declare function KDGetModifiedOpinion(enemy: entity): number;
+/**
+ *
+ * @param {number} Amount
+ */
+declare function KDAddOffer(Amount: number): void;
+/**
+ * @returns {number}
+ */
+declare function KDGetOfferLevelMod(): number;
+/**
+ *
+ * @param {entity} player
+ */
+declare function KDRunChefChance(player: entity): void;
+declare namespace KDDialogueData {
+    const CurrentDialogueIndex: number;
+}
+declare let KDMaxDialogue: number;
+declare let KDOptionOffset: number;
+declare let KinkyDungeonDialogueTimer: number;
+/**
+ * @type {Record<string, {speaker: string, faction: string}>}
+ */
+declare let KDPrisonRescues: Record<string, {
+    speaker: string;
+    faction: string;
+}>;
+declare let KDMaxSellItems: number;
+declare let KDOfferCooldown: number;

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

@@ -0,0 +1,45 @@
+declare namespace KDDialogueParams {
+    const ShopkeeperFee: number;
+    const ShopkeeperFeePerLevel: number;
+    const ShopkeeperFeePunishThresh: number;
+    const ChefChance: number;
+}
+/**
+ * Tags that are deleted on ng++
+ * @type {string[]}
+ */
+declare let KDResertNGTags: string[];
+/**
+ * @type {Record<string, {name: string, tags: string[], singletag: string[], chance: number, items?: string[]}>}
+ */
+declare let KDShops: Record<string, {
+    name: string;
+    tags: string[];
+    singletag: string[];
+    chance: number;
+    items?: string[];
+}>;
+/**
+ * @type {Record<string, {name: string, outfit: string, tags: string[], singletag: string[], excludeTags: string[], chance: number}>}
+ */
+declare let KDRecruitDialog: Record<string, {
+    name: string;
+    outfit: string;
+    tags: string[];
+    singletag: string[];
+    excludeTags: string[];
+    chance: number;
+}>;
+/**
+ * @type {Record<string, {name: string, tags: string[], singletag: string[], excludeTags: string[], weight: number}>}
+ */
+declare let KDAllyDialog: Record<string, {
+    name: string;
+    tags: string[];
+    singletag: string[];
+    excludeTags: string[];
+    weight: number;
+}>;
+declare let KDSleepBedPercentage: number;
+/** @type {Record<string, KinkyDialogue>} */
+declare let KDDialogue: Record<string, KinkyDialogue>;

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

@@ -0,0 +1,48 @@
+/**
+ * Generic condition for Bondage Offers
+ * @param {entity} enemy
+ * @param {any} AIData
+ * @param {number} dist - Current player dist, its sent as a param for faster runtime
+ * @param {number} maxdist
+ * @param {number} chance
+ * @param {string[]} restraintTags - Tags of required restraints
+ * @returns {boolean}
+ */
+declare function KDDefaultPrereqs(enemy: entity, AIData: any, dist: number, maxdist: number, chance: number, restraintTags: string[]): boolean;
+declare function KDShopTrigger(name: any): {
+    dialogue: any;
+    allowedPrisonStates: string[];
+    nonHostile: boolean;
+    noCombat: boolean;
+    excludeTags: string[];
+    blockDuringPlaytime: boolean;
+    prerequisite: (enemy: any, dist: any, AIData: any) => boolean;
+    weight: (enemy: any, dist: any) => number;
+};
+/**
+ *
+ * @param {string} name
+ * @param {KinkyDialogue} name
+ * @returns {KinkyDialogueTrigger}
+ */
+declare function KDRecruitTrigger(name: string, dialogue: any): KinkyDialogueTrigger;
+/** Boss intro dialogue */
+declare function KDBossTrigger(name: any, enemyName: any): {
+    dialogue: any;
+    nonHostile: boolean;
+    prerequisite: (enemy: any, dist: any, AIData: any) => boolean;
+    weight: (enemy: any, dist: any) => number;
+};
+/**
+ * Lose to a boss
+ * @param {string} name
+ * @param {string[]} enemyName
+ * @param {string[]} tags
+ * @returns {KinkyDialogueTrigger}
+ */
+declare function KDBossLose(name: string, enemyName: string[], tags: string[]): KinkyDialogueTrigger;
+declare function KinkyDungeonGetShopForEnemy(enemy: any, guaranteed: any): string;
+/** No dialogues will trigger when the player dist is higher than this */
+declare let KinkyDungeonMaxDialogueTriggerDist: number;
+/** @type {Record<string, KinkyDialogueTrigger>} */
+declare let KDDialogueTriggers: Record<string, KinkyDialogueTrigger>;