bc-stubs 96.0.0

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

@@ -0,0 +1,55 @@
+declare let KDMagicLocks: string[];
+declare let KDKeyedLocks: string[];
+declare let KDHarnessLink: string[];
+declare let KDCorsetLink: string[];
+declare let KDBindable: string[];
+declare let KDDevices: string[];
+declare let KDElbowBind: string[];
+declare let KDBoxBind: string[];
+declare let KDWrappable: string[];
+declare let KDArmbinderLink: string[];
+declare let KDDressLink: string[];
+declare let KDJacketLink: string[];
+declare let KDJacketRender: string[];
+declare let KDLegbinderLink: string[];
+declare let KDLegbinderRender: string[];
+declare let KDLegRopesBind: string[];
+declare let KDLegRopesRender: string[];
+declare let KDTapeLink: string[];
+declare let KDTapeRender: string[];
+declare let KDRubberLink: string[];
+declare let KDBlindfoldLink: string[];
+declare let KDVisorLink: string[];
+declare let KDWrappingLink: string[];
+declare let KDMaskLink: any[];
+declare let KDStuffingLink: string[];
+declare let KDBallGagLink: string[];
+declare let KDFlatGagLink: string[];
+declare let KDPlugGagLink: string[];
+declare let KDCollarLink: string[];
+/**
+ * @type {restraint[]}
+ */
+declare const KinkyDungeonRestraints: restraint[];
+/**
+ * @type {Record<string, KDLockType>}
+ */
+declare let KDLocks: Record<string, KDLockType>;
+declare namespace KDControlHarnessCategories {
+    namespace Cuffs {
+        const activateCount: number;
+        const activateTags: string[];
+        function activateFunction(e: any, item: any, data: any, invItems: any): void;
+        function updateFunction(e: any, item: any, data: any, invItems: any): void;
+    }
+    namespace Chastity {
+        const activateCount_1: number;
+        export { activateCount_1 as activateCount };
+        const activateTags_1: string[];
+        export { activateTags_1 as activateTags };
+        export function activateFunction_1(e: any, item: any, data: any, invItems: any): void;
+        export { activateFunction_1 as activateFunction };
+        export function updateFunction_1(e: any, item: any, data: any, invItems: any): void;
+        export { updateFunction_1 as updateFunction };
+    }
+}

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

@@ -0,0 +1,91 @@
+declare function KinkyDungeonPlaceSetPieces(POI: any, trapLocations: any, chestlist: any, shrinelist: any, chargerlist: any, spawnPoints: any, InJail: any, width: any, height: any): void;
+declare function KDGetFavoredSetpieces(POI: any, setpieces: any): any;
+declare function KDGetFavoringSetpieces(Name: any, tags: any, POI: any, POIBlacklist: any): any;
+declare function KinkyDungeonGetSetPiece(POI: any, setpieces: any, pieces: any): any;
+declare function KinkyDungeonGenerateSetpiece(POI: any, Piece: any, InJail: any, trapLocations: any, chestlist: any, shrinelist: any, chargerlist: any, spawnPoints: any, forcePOI: any, altType: any, MapParams: any): {
+    Pass: boolean;
+    Traps: any;
+};
+/**
+ * This function unblocks movement to ensure a map is pathable
+ * @param {number} x
+ * @param {number} y
+ * @returns {boolean} - whether it's possible
+ */
+declare function KDUnblock(x: number, y: number): boolean;
+declare function SetpieceSpawnPrisoner(x: any, y: any): void;
+declare function KDTorch(X: any, Y: any, altType: any, MapParams: any): void;
+declare function KDTorchUnlit(X: any, Y: any, altType: any, MapParams: any): void;
+declare function KDChest(X: any, Y: any, loot?: string, faction?: string): void;
+declare function KDCreateDoors(Left: any, Top: any, Width: any, Height: any, openChance?: number, convertDoodads?: boolean): void;
+declare function KDPlaceChest(cornerX: any, cornerY: any, radius: any, chestlist: any, spawnPoints: any, NoAddToChestList: any): string;
+declare function KDAddPipes(pipechance: any, pipelatexchance: any, thinlatexchance: any, heavylatexspreadchance: any): void;
+declare let KDSetpieceAttempts: number;
+declare let KDSetPieces: ({
+    Name: string;
+    tags: string[];
+    Radius: number;
+    xPad?: undefined;
+    yPad?: undefined;
+    xPadEnd?: undefined;
+    yPadEnd?: undefined;
+    Max?: undefined;
+    Prereqs?: undefined;
+    noPOI?: undefined;
+} | {
+    Name: string;
+    tags: string[];
+    Radius: number;
+    xPad: number;
+    yPad: number;
+    xPadEnd: number;
+    yPadEnd: number;
+    Max?: undefined;
+    Prereqs?: undefined;
+    noPOI?: undefined;
+} | {
+    Name: string;
+    tags: string[];
+    Radius: number;
+    Max: number;
+    xPad?: undefined;
+    yPad?: undefined;
+    xPadEnd?: undefined;
+    yPadEnd?: undefined;
+    Prereqs?: undefined;
+    noPOI?: undefined;
+} | {
+    Name: string;
+    tags: string[];
+    Radius: number;
+    Prereqs: string[];
+    Max: number;
+    xPad: number;
+    yPad: number;
+    xPadEnd: number;
+    yPadEnd: number;
+    noPOI?: undefined;
+} | {
+    Name: string;
+    tags: string[];
+    Radius: number;
+    Max: number;
+    xPad: number;
+    yPad?: undefined;
+    xPadEnd?: undefined;
+    yPadEnd?: undefined;
+    Prereqs?: undefined;
+    noPOI?: undefined;
+} | {
+    Name: string;
+    tags: string[];
+    noPOI: boolean;
+    Radius: number;
+    xPad: number;
+    yPad: number;
+    xPadEnd: number;
+    yPadEnd: number;
+    Max?: undefined;
+    Prereqs?: undefined;
+})[];
+declare let KDCountSetpiece: Map<any, any>;

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

@@ -0,0 +1,89 @@
+declare function KinkyDungeonShrineInit(): void;
+/**
+ *
+ * @param {string} Name
+ * @returns {string}
+ */
+declare function KDGoddessColor(Name: string): string;
+declare function KinkyDungeonShrineAvailable(type: any): boolean;
+/**
+ *
+ * @param {number} Level
+ */
+declare function KinkyDungeonGenerateShop(Level: number): void;
+/**
+ *
+ * @param {any} item
+ * @param {boolean} [noScale]
+ * @param {boolean} [sell]
+ * @returns {number}
+ */
+declare function KinkyDungeonItemCost(item: any, noScale?: boolean, sell?: boolean): number;
+declare function KinkyDungeonShrineCost(type: any): number;
+declare function KDAddBasic(item: any): void;
+declare function KinkyDungeonPayShrine(type: any): void;
+declare function KinkyDungeonHandleShrine(): boolean;
+declare function KinkyDungeonDrawShrine(): void;
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {string} Goddess
+ * @param {number} [mult]
+ * @param {number} [LevelBoost]
+ * @returns {number}
+ */
+declare function KDSummonRevengeMobs(x: number, y: number, Goddess: string, mult?: number, LevelBoost?: number): number;
+/**
+ *
+ * @param {boolean} Bottle - Is this bottling or drinking?
+ * @returns {boolean}
+ */
+declare function KDCanDrinkShrine(Bottle: boolean): boolean;
+declare function KinkyDungeonShrineAngerGods(Type: any): void;
+declare function KinkyDungeonGetSetPieces(Dict: any): any[];
+declare function KinkyDungeonGetMapShrines(Dict: any): any[];
+declare function KinkyDungeonTakeOrb(Amount: any, X: any, Y: any): void;
+declare function KinkyDungeonDrawOrb(): void;
+declare function KinkyDungeonHandleOrb(): boolean;
+declare function KinkyDungeonTakePerk(Amount: any, X: any, Y: any): void;
+declare function KinkyDungeonDrawPerkOrb(): void;
+declare function KDGetPosNegColor(value: any): string;
+declare function KDGetGoddessBonus(shrine: any): number;
+declare function KDDrawRestraintBonus(shrine: any, x: any, y: any, width: number, FontSize: any, align: any, zIndex: any, alpha: any, forceColor: any): void;
+/**
+ * Base costs for all the shrines. Starts at this value, increases thereafter
+ * @type {Record<string, number>}
+ */
+declare let KinkyDungeonShrineBaseCosts: Record<string, number>;
+declare let KDWillShrineWill: number;
+declare let KinkyDungeonOrbAmount: number;
+declare let KDShrineRemoveCount: number;
+declare let KDMaxGoddessBonus: number;
+declare let KDMinGoddessBonus: number;
+/**
+ * Cost growth, overrides the default amount
+ * @type {Record<string, number>}
+ */
+declare let KinkyDungeonShrineBaseCostGrowth: Record<string, number>;
+declare let KinkyDungeonShopIndex: number;
+declare let KinkyDungeonShrinePoolChancePerUse: number;
+/**
+ * Current costs multipliers for shrines
+ * @type {Record<string, number>}
+ */
+declare let KinkyDungeonShrineCosts: Record<string, number>;
+declare let KinkyDungeonShrineTypeRemove: string[];
+declare let KDLevelsPerCheckpoint: number;
+/**
+ * @type {Record<string, {require: string[], requireSingle: string[], filter?: string[]}>}
+ */
+declare let KDGoddessRevengeMobTypes: Record<string, {
+    require: string[];
+    requireSingle: string[];
+    filter?: string[];
+}>;
+declare let KDOrbX: number;
+declare let KDOrbY: number;
+declare let KDPerkConfirm: boolean;
+declare let KDPerkOrbPerks: any[];

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

@@ -0,0 +1,49 @@
+declare function KinkyDungeonAddTags(tags: any, Floor: any): any[];
+/**
+ *
+ * @param {string[]} enemytags
+ * @param {number} Level
+ * @param {string} Index
+ * @param {string} Tile
+ * @param {string[]} [requireTags]
+ * @param {boolean} [requireHostile]
+ * @param {Record<string, {bonus: number, mult: number}>} [bonusTags]
+ * @param {string[]} [filterTags]
+ * @param {string[]} [requireSingleTag]
+ * @returns {enemy}
+ */
+declare function KinkyDungeonGetEnemy(enemytags: string[], Level: number, Index: string, Tile: string, requireTags?: string[], requireHostile?: boolean, bonusTags?: Record<string, {
+    bonus: number;
+    mult: number;
+}>, filterTags?: string[], requireSingleTag?: string[]): enemy;
+declare function KinkyDungeonGetEnemyByName(Name: string): enemy;
+/**
+ *
+ * @param {string} name
+ * @returns {enemy}
+ */
+declare function KinkyDungeonGetEnemyByName(name: string): enemy;
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {boolean} noTransgress
+ * @param {boolean} normalDrops
+ * @param {string[]} [requireTags]
+ * @returns {entity}
+ */
+declare function KinkyDungeonCallGuard(x: number, y: number, noTransgress: boolean, normalDrops: boolean, requireTags?: string[]): entity;
+declare function KinkyDungeonHandleWanderingSpawns(delta: any): void;
+declare let KDPerkToggleTags: string[];
+declare let KinkyDungeonTotalSleepTurns: number;
+declare let KinkyDungeonSearchTimer: number;
+declare let KinkyDungeonSearchTimerMin: number;
+declare let KinkyDungeonFirstSpawn: boolean;
+declare let KinkyDungeonSearchStartAmount: number;
+declare let KinkyDungeonSearchHuntersAmount: number;
+declare let KinkyDungeonSearchEntranceAdjustAmount: number;
+declare let KinkyDungeonSearchEntranceChaseAmount: number;
+/** The defauilt interval between hunter checks */
+declare let HunterPulse: number;
+/** Cooldown for hunter spawns */
+declare let HunterSpawnTimer: number;

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

@@ -0,0 +1,282 @@
+declare function KDGetSleepWillFraction(): number;
+declare function KDInitInventory(): void;
+declare function KinkyDungeonDefaultStats(Load: any): void;
+declare function KinkyDungeonGetVisionRadius(): number;
+/** Returns if the player is automatically doing stuff
+ * @returns {boolean}
+ */
+declare function KDIsAutoAction(): boolean;
+/**
+ * Disables all automatic actions
+ */
+declare function KDDisableAutoWait(): void;
+declare function KinkyDungeonInterruptSleep(): void;
+declare function KDGetStamDamageThresh(): number;
+declare function KinkyDungeonDealDamage(Damage: any, bullet: any, noAlreadyHit: any, noInterrupt: any): {
+    happened: any;
+    string: string;
+};
+declare function KinkyDungeonUpdateDialogue(entity: any, delta: any): void;
+/**
+ *
+ * @param {entity} entity
+ * @param {string} dialogue
+ * @param {string} color
+ * @param {number} duration
+ * @param {number} priority
+ * @param {boolean} [force]
+ * @param {boolean} [nooverride]
+ */
+declare function KinkyDungeonSendDialogue(entity: entity, dialogue: string, color: string, duration: number, priority: number, force?: boolean, nooverride?: boolean): void;
+declare function KinkyDungeonChangeDistraction(Amount: any, NoFloater: any, lowerPerc: any, minimum?: number): void;
+declare function KinkyDungeonChangeStamina(Amount: any, NoFloater: any, Pause: any, NoSlow: any, minimum?: number, slowFloor?: number): void;
+/**
+ *
+ * @param {number} Amount]
+ * @param {boolean} [NoFloater]
+ * @param {number} [PoolAmount]
+ * @param {boolean} [Pause]
+ * @param {boolean} [spill]
+ */
+declare function KinkyDungeonChangeMana(Amount: number, NoFloater?: boolean, PoolAmount?: number, Pause?: boolean, spill?: boolean, minimum?: number): void;
+declare function KinkyDungeonChangeWill(Amount: any, NoFloater: any, minimum?: number): void;
+declare function KinkyDungeonChangeCharge(Amount: any, NoFloater: any): void;
+declare function KinkyDungeonHasStamina(Cost: any, AddRate: any): boolean;
+declare function KinkyDungeonHasWill(Cost: any, AddRate: any): boolean;
+declare function KinkyDungeonHasMana(Cost: any, AddRate: any): boolean;
+declare function KinkyDungeonSetMaxStats(delta: any): {
+    distractionRate: number;
+    staminaRate: number;
+};
+declare function KinkyDungeonCanUseWeapon(NoOverride: any, e: any): boolean;
+declare function KDGetDistractionRate(delta: any): number;
+/**
+ *
+ * @param {number} delta
+ */
+declare function KinkyDungeonUpdateStats(delta: number): void;
+declare function KDGetEnvironmentalDmg(): number;
+declare function KDUpdatePerksBonus(): void;
+declare function KinkyDungeonCalculateMiscastChance(): void;
+declare function KinkyDungeonGetBlindLevel(): number;
+declare function KinkyDungeonCapStats(): void;
+declare function KinkyDungeonLegsBlocked(): boolean;
+declare function KinkyDungeonCanStand(): boolean;
+declare function KinkyDungeonCanKneel(): boolean;
+declare function KinkyDungeonCalculateSlowLevel(delta: any): void;
+/**
+ * Returns the total level of gagging, 1.0 or higher meaning "fully gagged" and 0.0 being able to speak.
+ * @param   {boolean} [AllowFlags] - Whether or not flags such as allowPotions and blockPotions should override the final result
+ * @return  {number} - The gag level, sum of all gag properties of worn restraints
+ */
+declare function KinkyDungeonGagTotal(AllowFlags?: boolean): number;
+declare function KinkyDungeonCanTalk(Loose: any): boolean;
+declare function KinkyDungeonCalculateSubmissiveMult(): number;
+declare function KinkyDungeonCanPlayWithSelf(): boolean;
+declare function KinkyDungeonCanTryOrgasm(): boolean;
+declare function KDGetOrgasmCost(): number;
+/**
+ * @param {number} [tease] - The teasing power
+ * @returns {{orig: number, final: number}}
+ */
+declare function KDGetPlaySelfPower(tease?: number): {
+    orig: number;
+    final: number;
+};
+declare function KinkyDungeonDoPlayWithSelf(tease: any): number;
+/**
+ * Try to let go...
+ * @param {number} [Bonus]
+ */
+declare function KinkyDungeonDoTryOrgasm(Bonus?: number): void;
+declare function KinkyDungeonIsChaste(Breast: any): boolean;
+declare function KinkyDungeonChastityMult(): number;
+/**
+ *
+ * @param {any} buffs
+ * @param {string} type
+ * @returns {number}
+ */
+declare function KDBuffResist(buffs: any, type: string): number;
+/**
+ *
+ * @param {entity} player
+ * @returns {boolean}
+ */
+declare function KDIsEdged(player: entity): boolean;
+declare let KinkyDungeonPlayerEntity: any;
+declare let KDSleepWillFraction: number;
+declare let KDSleepWillFractionJail: number;
+declare let KDMaxStat: number;
+declare let KDMaxStatStart: number;
+declare let KDMaxStatStartPool: number;
+declare let KDStamDamageThresh: number;
+declare let KDStamDamageThreshBonus: number;
+declare let KDSleepRegenWill: number;
+declare let KinkyDungeonStatDistractionMax: number;
+declare let KinkyDungeonStatDistractionLower: number;
+declare let KinkyDungeonStatDistractionLowerCap: number;
+declare let KinkyDungeonStatArousalLowerRegenSleep: number;
+declare let KinkyDungeonDistractionUnlockSuccessMod: number;
+declare let KinkyDungeonStatDistraction: number;
+declare let KinkyDungeonCrotchRopeDistraction: number;
+declare let KinkyDungeonStatDistractionRegen: number;
+declare let KinkyDungeonStatDistractionRegenPerUpgrade: number;
+declare let KDNoUnchasteBraMult: number;
+declare let KDNoUnchasteMult: number;
+declare let KDDistractionDecayMultDistractionMode: number;
+declare let KDDistractedAmount: number;
+declare let KinkyDungeonStatDistractionMiscastChance: number;
+declare let KinkyDungeonMiscastChance: number;
+declare let KinkyDungeonVibeLevel: number;
+declare let KinkyDungeonTeaseLevel: number;
+declare let KinkyDungeonTeaseLevelBypass: number;
+declare let KinkyDungeonOrgasmVibeLevel: number;
+declare let KinkyDungeonDistractionPerVibe: number;
+declare let KinkyDungeonDistractionPerPlug: number;
+declare let KinkyDungeonVibeCostPerIntensity: number;
+declare let KinkyDungeonStatWillpowerExhaustion: number;
+declare let KinkyDungeonSleepTurnsMax: number;
+declare let KinkyDungeonSlowMoveTurns: number;
+declare let KinkyDungeonStatStaminaMax: number;
+declare let KinkyDungeonStatStamina: number;
+declare let KinkyDungeonStatStaminaRegen: number;
+declare let KinkyDungeonStatStaminaRegenPerUpgrade: number;
+declare let KinkyDungeonStatStaminaRegenPerUpgradeWill: number;
+declare let KDNarcolepticRegen: number;
+declare let KinkyDungeonStatStaminaRegenJail: number;
+declare let KinkyDungeonStatStaminaRegenSleep: number;
+declare let KinkyDungeonStatStaminaRegenSleepBedMultiplier: number;
+declare let KinkyDungeonStatStaminaRegenWait: number;
+declare let KinkyDungeoNStatStaminaLow: number;
+declare let KDSprintCostBase: number;
+declare let KDSprintCostSlowLevel: number[];
+declare let KinkyDungeonStatWillMax: number;
+declare let KinkyDungeonStatWill: number;
+declare let KinkyDungeonStatWillRate: number;
+declare let KinkyDungeonStatManaMax: number;
+declare let KinkyDungeonStatMana: number;
+declare let KinkyDungeonStatManaPool: number;
+declare let KinkyDungeonStatManaPoolMax: number;
+declare let KDManaPoolRatio: number;
+declare let KinkyDungeonStatManaRate: number;
+declare let KinkyDungeonStatManaRegen: number;
+declare let KinkyDungeonStatManaLowRegen: number;
+declare let KDMeditationRegen: number;
+declare let KinkyDungeonStatManaRegenLowThreshold: number;
+declare let KinkyDungeonStatManaPoolRegen: number;
+declare let KinkyDungeonStatStaminaRegenPerSlowLevel: number;
+declare let KinkyDungeonStatStaminaCostStruggle: number;
+declare let KinkyDungeonStatStaminaCostRemove: number;
+declare let KinkyDungeonStatStaminaCostTool: number;
+declare let KinkyDungeonStatStaminaCostPick: number;
+declare let KinkyDungeonStatWillCostStruggle: number;
+declare let KinkyDungeonStatWillCostRemove: number;
+declare let KinkyDungeonStatWillCostTool: number;
+declare let KinkyDungeonStatWillCostPick: number;
+declare let KinkyDungeonStatWillCostUnlock: number;
+declare let KinkyDungeonStatWillCostEscape: number;
+declare let KinkyDungeonStatWillBonusEscape: number;
+declare let KinkyDungeonStaminaRate: number;
+declare let KinkyDungeonStatBeltLevel: number;
+declare let KinkyDungeonStatPlugLevel: number;
+declare let KinkyDungeonPlugCount: number;
+declare let KinkyDungeonStatVibeLevel: number;
+declare let KinkyDungeonStatEdged: boolean;
+declare let KinkyDungeonStatDistractionGainChaste: number;
+declare let KinkyDungeonSlowLevel: number;
+declare let KinkyDungeonMovePoints: number;
+declare let KinkyDungeonBlindLevelBase: number;
+declare let KinkyDungeonBlindLevel: number;
+declare let KinkyDungeonStatBlind: number;
+declare let KinkyDungeonStatFreeze: number;
+declare let KinkyDungeonStatBind: number;
+declare let KinkyDungeonDeaf: boolean;
+declare let KinkyDungeonSleepiness: number;
+declare let KinkyDungeonSleepinessMax: number;
+declare let KinkyDungeonGold: number;
+declare let KinkyDungeonLockpicks: number;
+declare let KinkyDungeonRedKeys: number;
+declare let KinkyDungeonBlueKeys: number;
+declare let KinkyDungeonHasCrotchRope: boolean;
+declare let KinkyDungeonTorsoGrabChance: number;
+declare let KinkyDungeonTorsoGrabChanceBonus: number;
+declare let KinkyDungeonWeaponGrabChance: number;
+/**
+ * Your inventory contains items that are on you
+ * @type {Map<string, Map<string, item>>}
+ */
+declare let KinkyDungeonInventory: Map<string, Map<string, item>>;
+declare let KinkyDungeonPlayerTags: Map<any, any>;
+declare let KinkyDungeonCurrentDress: string;
+declare let KinkyDungeonUndress: number;
+/**
+ * @type {spell[]}
+ */
+declare let KinkyDungeonSpells: spell[];
+declare let KinkyDungeonPlayerBuffs: {};
+declare let KinkyDungeonPlayers: any[];
+declare let KinkyDungeonDifficulty: number;
+declare let KinkyDungeonSubmissiveMult: number;
+declare let KinkyDungeonSpellPoints: number;
+declare let KDMaxVisionDist: number;
+declare namespace KDBaseDamageTypes {
+    const arouseTypes: string[];
+    const bypassTeaseTypes: string[];
+    const distractionTypesWeakNeg: string[];
+    const distractionTypesWeak: string[];
+    const distractionTypesStrong: string[];
+    const teaseTypes: string[];
+    const staminaTypesWeak: string[];
+    const staminaTypesStrong: string[];
+    const manaTypesWeak: string[];
+    const manaTypesStrong: any[];
+    const willTypesVeryWeak: string[];
+    const willTypesWeak: string[];
+    const willTypesStrong: string[];
+}
+declare let KDOrigStamina: number;
+declare let KDOrigMana: number;
+declare let KDOrigWill: number;
+declare let KDOrigCharge: number;
+declare let KDOrigDistraction: number;
+declare let KDBlindnessCap: number;
+declare let KDBoundPowerLevel: number;
+declare let KDNoRegenFlag: boolean;
+declare let KDDamageAmpPerks: number;
+declare let KDDamageAmpPerksMelee: number;
+declare let KDDamageAmpPerksMagic: number;
+declare let KDDamageAmpPerksSpell: number;
+declare let KDDamageAmpEnvironmental: number;
+declare let KDExtraEnemyTags: {};
+/** Percentage of vibe level that is turned into playSelfPower to try to have an orgasm*/
+declare let KinkyDungeonOrgasmVibeLevelPlayPowerMult: number;
+declare let KinkyDungeonOrgasmChanceBase: number;
+declare let KinkyDungeonOrgasmChanceScaling: number;
+declare let KinkyDungeonMaxOrgasmStage: number;
+declare let KinkyDungeonOrgasmStageVariation: number;
+/** Threshold at which the player can play with herself */
+declare let KinkyDungeonDistractionSleepDeprivationThreshold: number;
+/** Threshold at which the player will automatically play with herself if able*/
+declare let KinkyDungeonDistractionPlaySelfThreshold: number;
+declare let KinkyDungeonPlaySelfOrgasmThreshold: number;
+declare let KinkyDungeonOrgasmTurnsMax: number;
+declare let KinkyDungeonOrgasmTurnsCrave: number;
+declare let KinkyDungeonPlayWithSelfPowerMin: number;
+declare let KinkyDungeonPlayWithSelfPowerMax: number;
+declare let KinkyDungeonPlayWithSelfPowerVibeWand: number;
+declare let KinkyDungeonPlayWithSelfChastityPenalty: number;
+declare let KinkyDungeonPlayWithSelfBoundPenalty: number;
+declare let KinkyDungeonOrgasmExhaustionAmount: number;
+declare let KinkyDungeonOrgasmExhaustionAmountWillful: number;
+declare let KDOrgasmStageTimerMax: number;
+declare let KDOrgasmStageTimerMaxChance: number;
+declare let KDWillpowerMultiplier: number;
+declare let KinkyDungeonOrgasmCost: number;
+declare let KinkyDungeonOrgasmCostPercent: number;
+declare let KinkyDungeonOrgasmWillpowerCost: number;
+declare let KinkyDungeonEdgeCost: number;
+declare let KinkyDungeonEdgeWillpowerCost: number;
+declare let KinkyDungeonPlayCost: number;
+declare let KinkyDungeonOrgasmStunTime: number;
+declare let KinkyDungeonPlayWithSelfMult: number;

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

@@ -0,0 +1,5 @@
+declare function KDRunTests(): void;
+declare function KDTestMapGen(count: any, Ranges: any, Checkpoints: any): boolean;
+declare function KDTestFullRunthrough(GameLoops: any, Init: any, NGP: any): boolean;
+declare function KDTestjailer(iter: any): void;
+declare function KDExportTranslationFile(): Promise<void>;