bc-stubs 96.0.0

package/bc/Screens/MiniGame/Kidnap/Kidnap.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Generates the kidnap stats for the given character, factoring in any bonus it might have.
+ * @param {Character} C - The character for which to generate the stats for.
+ * @param {number} Bonus - The possible stat bonus a character has
+ * @returns {void} - Nothing
+ */
+declare function KidnapLoadStats(C: Character, Bonus: number): void;
+/**
+ * Builds a deck of kidnap cards for the character, the deck contains 7 random cards and must contain at least 1 card of each type
+ * @param {Character} C - The character for which to generate the cards
+ * @returns {void} - Nothing
+ */
+declare function KidnapBuildCards(C: Character): void;
+/**
+ * Builds the inventory items that are available when kidnapping
+ * @returns {void} - Nothing
+ */
+declare function KidnapInventoryBuild(): void;
+/**
+ * Sets the current battle status and its related timer
+ * @param {string} NewMode - New mode for the battle
+ * @returns {void} - Nothing
+ */
+declare function KidnapSetMode(NewMode: string): void;
+/**
+ * Generates a move value for the NPC based on the best possible options
+ * @returns {number} - Returns the move type
+ */
+declare function KidnapAIMove(): number;
+/**
+ * Validates or checks if a given upper hand move type is available.
+ * @param {number} MoveType - The type of move to check for or perform
+ * @param {boolean} DoMove - Whether or not the move is being performed
+ * @returns {boolean} - Returns TRUE if the upper hand move type is available
+ */
+declare function KidnapUpperHandMoveAvailable(MoveType: number, DoMove: boolean): boolean;
+/**
+ * Sets a random upper hand move for the NPC to use
+ * @returns {void} - Nothing
+ */
+declare function KidnapAIMoveUpperHand(): void;
+/**
+ * Draws the move text (left side) and the effect (right side)
+ * @returns {void} - Nothing
+ */
+declare function KidnapShowMove(): void;
+/**
+ * Checks if a given move is effective against a given character
+ * @param {Character} C - Character for which to check if the move is
+ * @param {number} MoveType - Type of move to check for
+ * @returns {boolean} - Returns TRUE if the move for that person is effective
+ */
+declare function KidnapMoveEffective(C: Character, MoveType: number): boolean;
+/**
+ * Processes a selected move. Triggered when the player selects their move.
+ * @param {number} CardIndex - Type of the player move (Represented by the index of the character move array)
+ * @returns {void} - Nothing
+ */
+declare function KidnapSelectMove(CardIndex: number): void;
+/**
+ * Processes a selected upper handmove. Triggered when the player selects their upper hand move.
+ * @param {number} PlayerMove - Type of the player upper hand move (Represented by the index of the character move array)
+ * @returns {void} - Nothing
+ */
+declare function KidnapSelectMoveUpperHand(PlayerMove: number): void;
+/**
+ * Triggered when the player surrenders to her opponent
+ * @returns {void} - Nothing
+ */
+declare function KidnapSurrender(): void;
+/**
+ * Starts a kidnap match
+ * @param {Character} Opponent - The NPC that will be the opponent for the fight
+ * @param {string} Background - The background for the fight, changes depending on which room the battle is happening
+ * @param {number} Difficulty - Difficulty modifier for the fight, higher is harder
+ * @param {string} ReturnFunction - The callback to execute through CommonDynamicFunction
+ * @returns {void} - Nothing
+ */
+declare function KidnapStart(Opponent: Character, Background: string, Difficulty: number, ReturnFunction: string): void;
+/**
+ * Draws the given character move.
+ * @param {Character} C - Character to draw the move for
+ * @param {string} Header - Text to display
+ * @param {number} X - Position of the text to draw on the X axis, normally the position of the character
+ * @returns {void} - Nothing
+ */
+declare function KidnapDrawMove(C: Character, Header: string, X: number, Side: any): void;
+/**
+ * Draws the upper hand moves
+ * @returns {void} - Nothing
+ */
+declare function KidnapDrawMoveUpperHand(): void;
+/**
+ * Draws a large timer in the middle of the screen based on the kidnapping timer.
+ * @returns {void} - Nothing
+ */
+declare function KidnapShowTimer(): void;
+/**
+ * Draws a large title in the center of the screen.
+ * @param {string} Title - Title to display on screen
+ * @returns {void} - Nothing
+ */
+declare function KidnapTitle(Title: string): void;
+/**
+ * Shows the items that can be used by the player.
+ * @returns {void} - Nothing
+ */
+declare function KidnapShowItem(): void;
+/**
+ * Runs and draws the kidnapping minigame
+ * @returns {void} - Nothing
+ */
+declare function KidnapRun(): void;
+/**
+ * Handles clicks in the kidnap mini game
+ * @returns {void} - Nothing
+ */
+declare function KidnapClick(): void;
+/**
+ * Returns the experience gained from having successfully fought an opponent
+ * @param {Character} opponent
+ * @returns
+ */
+declare function KidnapSuccessWillpowerProgress(opponent: Character): number;
+/**
+ * Handles the key press in the kidnap mini game, the C cheat key can help you recover some lost willpower
+ * @returns {void} - Nothing
+ */
+declare function KidnapKeyDown(): void;
+declare var KidnapVictory: boolean;
+declare var KidnapDifficulty: number;
+declare var KidnapBackground: string;
+declare var KidnapReturnFunction: string;
+/** @type {null | Character} */
+declare var KidnapOpponent: null | Character;
+/** @type {null | Item} */
+declare var KidnapPlayerCloth: null | Item;
+/** @type {null | Item} */
+declare var KidnapPlayerClothAccessory: null | Item;
+/** @type {null | Item} */
+declare var KidnapPlayerClothLower: null | Item;
+/** @type {null | Item} */
+declare var KidnapOpponentCloth: null | Item;
+/** @type {null | Item} */
+declare var KidnapOpponentClothAccessory: null | Item;
+/** @type {null | Item} */
+declare var KidnapOpponentClothLower: null | Item;
+declare var KidnapTimer: number;
+declare var KidnapMode: string;
+declare var KidnapDialog: string;
+declare var KidnapPlayerMove: number;
+declare var KidnapOpponentMove: number;
+declare var KidnapPlayerDamage: number;
+declare var KidnapOpponentDamage: number;
+declare var KidnapResultPlayer: string;
+declare var KidnapResultOpponent: string;
+declare var KidnapResultUpperHand: string;
+/** @type {null | Character} */
+declare var KidnapUpperHandVictim: null | Character;
+declare var KidnapUpperHandSelection: number;
+declare var KidnapMoveType: string[];
+declare var KidnapUpperHandMoveType: string[];
+/** @type { [number, number, number, number][] } */
+declare var KidnapMoveMap: [number, number, number, number][];
+declare var KidnapRPS: string[];

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

@@ -0,0 +1,99 @@
+/**
+ * Function to reset certain state variables of auto struggle
+ */
+declare function KDInitAutoStruggle(): void;
+/**
+ * Updates the wiggle point
+ * @param {entity} player
+ * @param {boolean} [force]
+ */
+declare function KDAS_UpdateWigglePoint(player: entity, force?: boolean): void;
+/**
+ * Returns if the player is on the wiggle point or not
+ * @param {entity} player
+ * @returns {boolean}
+ */
+declare function KDAS_InWigglePoint(player: entity): boolean;
+/**
+ * Returns an array of tiles the player can move near the wiggle points
+ * @param {entity} player
+ * @param {boolean} goCloser - If the player has to move closer to the wiggle point
+ * @returns {{x: number, y: number}[]}
+ */
+declare function KDAS_GetMovableWigglePoint(player: entity, goCloser: boolean): {
+    x: number;
+    y: number;
+}[];
+/**
+ *
+ * @param {string} result
+ * @returns {number}
+ */
+declare function KDAS_SwitchFavor(result: string): number;
+/**
+ *
+ * @param {string} result
+ * @returns {number}
+ */
+declare function KDAS_SwitchDelay(result: string): number;
+/**
+ * Master function for handling the Auto Struggle state machine
+ * @param {entity} player
+ */
+declare function KDHandleAutoStruggle(player: entity): void;
+/**
+ * Updates the KDAutoStruggleData state data to accurately reflect the player
+ * @param {entity} player
+ */
+declare function KDAutoStruggleEvaluate(player: entity): void;
+/**
+ * Updates the KDAutoStruggleData decidedAction variable
+ * @param {entity} player
+ */
+declare function KDAutoStruggleMakeDecision(player: entity): void;
+/**
+ * Executes the run decision
+ * @param {entity} player
+ */
+declare function KDAutoStruggleRunDecision(player: entity): KDAS_Result;
+declare function KDAutoWaitIndexID(player: any, group: any, index: any, action: any): string;
+declare namespace KDAutoStruggleData {
+    const lastTick: number;
+    const lastActionQueue: KDAS_Result[];
+    const decidedAction: string;
+    const possibleActions: {
+        action: KDAS_Action;
+        weight: number;
+    }[];
+    const totalDespair: Record<string, number>;
+    const currentFocusGroup: string;
+    const currentFocusIndex: number;
+    const currentFocusDespair: number;
+    const currentFocusDespairTarget: number;
+    const overallDespair: number;
+    const lastDelay: number;
+    const wigglePoint: {
+        x: number;
+        y: number;
+    };
+    const wiggleDist: number;
+}
+/** @type {Record<string, {itemweight?: (player: entity, item: item) => number, playerweight?: (player: entity) => number, action: (player: entity) => KDAS_Result}>} */
+declare let KDAutoStruggleActions: Record<string, {
+    itemweight?: (player: entity, item: item) => number;
+    playerweight?: (player: entity) => number;
+    action: (player: entity) => KDAS_Result;
+}>;
+type KDAS_Result = {
+    action: string;
+    id: string;
+    result: string;
+    favorability: number;
+    delay: number;
+};
+type KDAS_Action = {
+    action: string;
+    id: string;
+    group: string;
+    index: number;
+};

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

@@ -0,0 +1,11 @@
+declare namespace KDClassReqs {
+    function Trainee(): boolean;
+}
+declare namespace KDClassStart {
+    export function Fighter(): void;
+    export function Rogue(): void;
+    export function Mage(): void;
+    export function Peasant(): void;
+    export function Trainee_1(): void;
+    export { Trainee_1 as Trainee };
+}

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

@@ -0,0 +1,17 @@
+/** Prunes delayed actions with tags
+ * @param {string[]} tags
+*/
+declare function KDDelayedActionPrune(tags: string[]): void;
+/**
+ * Adds a delayed action
+ * @param {KDDelayedAction} action
+ */
+declare function KDAddDelayedAction(action: KDDelayedAction): void;
+/** This is processed for delayed actions
+ * @type {Record<string, (action: KDDelayedAction) => void>}
+ */
+declare let KDDelayedActionUpdate: Record<string, (action: KDDelayedAction) => void>;
+/** This is processed for delayed actions
+ * @type {Record<string, (action: KDDelayedAction) => void>}
+ */
+declare let KDDelayedActionCommit: Record<string, (action: KDDelayedAction) => void>;

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

@@ -0,0 +1,11 @@
+declare let StandalonePatched: boolean;
+declare let KDCurrentModels: Map<any, any>;
+/** @type {HTMLCanvasElement} */
+declare let PIXICanvas: HTMLCanvasElement;
+declare const EYEPOSES: any[];
+declare const EYE2POSES: any[];
+declare const BROWPOSES: any[];
+declare const BROW2POSES: any[];
+declare const MOUTHPOSES: any[];
+declare const BLUSHPOSES: any[];
+declare const STANDPOSES: any[];

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

@@ -0,0 +1,93 @@
+declare function addTextKey(Name: any, Text: any): void;
+/**
+ * Creates a restraint using a set of reasonable defaults and adds it to the list of restraints.
+ *
+ * @param {KDRestraintProps} props
+ * A list of restraint props to be applied.  At minimum, the "name", "Group" and "Asset" props should be provided.
+ *
+ * @param {string} [displayName]
+ * The name displayed to the user for the restraint.
+ *
+ * @param {string} [flavorText]
+ * Text that describes the "look and feel" of the restraint.
+ *
+ * @param {string} [functionText]
+ * Text that describes how the restraint operates.
+ * @returns The created restraint.
+ */
+declare function KinkyDungeonCreateRestraint(props: KDRestraintProps, displayName?: string, flavorText?: string, functionText?: string): any;
+/**
+ * This function adds cursed variants to the restraint list
+ * @param {restraint} Restraint - The restraint to have extra variants added onto
+ * @param {string[]} Variants - Names of the cursed variants to apply. Must be from KDCursedVars
+ */
+declare function KinkyDungeonAddCursedVariants(Restraint: restraint, Variants: string[]): void;
+/**
+ * Gets a list of curses applied to the item
+ * @param {string} Restraint
+ * @param {boolean} [includeOrig] - includes thje original item
+ * @param {number} [minLevel] - for gating curse severity
+ * @param {number} [maxLevel] - for gating curse severity
+ * @returns {string[]}
+ */
+declare function KinkyDungeonGetCurses(Restraint: string, includeOrig?: boolean, minLevel?: number, maxLevel?: number): string[];
+/**
+ * Creates a restraint using an existing restraint as a base and adds it to the list of restraints.
+ *
+ * @param {string} clonedName
+ * The name of the restraint to be cloned.
+ *
+ * @param {string} newName
+ * The name of the newly created restraint.
+ *
+ * @param {object} props
+ * A list of restraint props to be applied.  Anything that isn't supplied with be identical to the base object.
+ *
+ * @returns The created restraint.
+ */
+declare function KinkyDungeonCloneRestraint(clonedName: string, newName: string, props: object): any;
+/**
+ * Registers text for a named restraint.
+ *
+ * @param {string} name
+ * The name of the restraint used by the system.
+ *
+ * @param {string} displayName
+ * The name displayed to the user for the restraint.
+ *
+ * @param {string} flavorText
+ * Text that describes the "look and feel" of the restraint.
+ *
+ * @param {string} functionText
+ * Text that describes how the restraint operates.
+ */
+declare function KinkyDungeonAddRestraintText(name: string, displayName: string, flavorText: string, functionText: string): void;
+/**
+ * Registers text for a named restraint.
+ *
+ * @param {string} restraint - The name of the restraint used by the system.
+ * @param {string} newRestraint - The name of the new restraint used by the system.
+ *
+ */
+declare function KinkyDungeonDupeRestraintText(restraint: string, newRestraint: string): void;
+declare function cloneDeep(obj: any): any;
+declare namespace defaultRestraint {
+    const inventory: boolean;
+    const power: number;
+    const weight: number;
+    const minLevel: number;
+    const allFloors: boolean;
+    namespace escapeChance {
+        const Struggle: number;
+        const Cut: number;
+        const Remove: number;
+    }
+    const events: any[];
+    const enemyTags: any[];
+    const playerTags: any[];
+    const shrine: any[];
+}
+/**
+ * @type {Record<string, Record<string, number>>}
+ */
+declare let KDCursedVariantsCreated: Record<string, Record<string, number>>;

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

@@ -0,0 +1,37 @@
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {string} img
+ * @param {string} type
+ * @param {KDParticleData} data
+ */
+declare function KDAddParticle(x: number, y: number, img: string, type: string, data: KDParticleData): void;
+declare function KDUpdateParticles(delta: any): void;
+declare function KDRemoveParticle(id: any): void;
+/**
+ * Draws arousal heart particles
+ * @param {number} pinkChance - 0 to 1
+ * @param {number} density - 0 to 1
+ * @param {number} purpleChance - 0 to 1
+ */
+declare function KDDrawArousalParticles(pinkChance: number, density: number, purpleChance: number): void;
+declare function KDDrawVibeParticles(density: any): void;
+/**
+ *
+ */
+declare function KDCreateVibeParticle(): void;
+/**
+ *
+ * @param {number} pinkChance - 0 to 1
+ * @param {number} purpleChance - 0 to 1
+ */
+declare function KDCreateArousalParticle(pinkChance: number, purpleChance: number): void;
+/** @type {Map<Number, {info: any, sprite: any}>} */
+declare let KDParticles: Map<number, {
+    info: any;
+    sprite: any;
+}>;
+declare let KDParticleid: number;
+declare let lastArousalParticle: number;
+declare let lastVibeParticle: number;