bc-stubs 96.0.0

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

@@ -0,0 +1,160 @@
+/**
+ *
+ * @param {entity} entity
+ * @returns {boolean}
+ */
+declare function KDWettable(entity: entity): boolean;
+/**
+ *
+ * @param {entity} entity
+ * @returns {boolean}
+ */
+declare function KDConducting(entity: entity): boolean;
+declare function KinkyDungeonHandleTilesEnemy(enemy: any, delta: any): void;
+/**
+ * Applies effects based on nearby tiles. Affects only the player
+ * @param {number} delta
+ */
+declare function KDPeripheralTileEffects(delta: number): void;
+/**
+ * Applies effects based on the tile you are standing on. Affects only the player
+ * @param {number} delta
+ */
+declare function KinkyDungeonUpdateTileEffects(delta: number): void;
+declare function KinkyDungeonHandleMoveToTile(toTile: any): void;
+declare function KDCanEscape(): boolean;
+/**
+ * Creates combined record of tags
+ * @param {number} x
+ * @param {number} y
+ * @returns {Record<String, boolean>}
+ */
+declare function KDEffectTileTags(x: number, y: number): Record<string, boolean>;
+declare function KinkyDungeonHandleStairs(toTile: any, suppressCheckPoint: any): void;
+declare function KinkyDungeonHandleMoveObject(moveX: any, moveY: any, moveObject: any): boolean;
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @returns {boolean}
+ */
+declare function KDHasEffectTile(x: number, y: number): boolean;
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @returns {Record<string, effectTile>}
+ */
+declare function KDGetEffectTiles(x: number, y: number): Record<string, effectTile>;
+declare function KDGetSpecificEffectTile(x: any, y: any, tile: any): effectTile;
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {effectTileRef} tile
+ * @param {number} durationMod
+ * @returns {effectTile}
+ */
+declare function KDCreateEffectTile(x: number, y: number, tile: effectTileRef, durationMod: number): effectTile;
+declare function KDInteractNewTile(newTile: any): void;
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {effectTileRef} tile
+ * @param {number} [durationMod]
+ * @param {number} [rad]
+ * @param {{x: number, y: number}} [avoidPoint]
+ * @param {number} [density]
+ * @param {string} mod - explosion modifier
+ */
+declare function KDCreateAoEEffectTiles(x: number, y: number, tile: effectTileRef, durationMod?: number, rad?: number, avoidPoint?: {
+    x: number;
+    y: number;
+}, density?: number, mod?: string): void;
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {string[]} tagsToRemove
+ * @param {number} [rad]
+ * @param {{x: number, y: number}} [avoidPoint]
+ * @param {number} [density]
+ * @param {string} mod - explosion modifier
+ */
+declare function KDRemoveAoEEffectTiles(x: number, y: number, tagsToRemove: string[], rad?: number, avoidPoint?: {
+    x: number;
+    y: number;
+}, density?: number, mod?: string): void;
+/**
+ * Current alpha vs fade type
+ * @param {string} id
+ * @param {number} alpha
+ * @param {string} fade
+ * @param {number} delta
+ */
+declare function KDApplyAlpha(id: string, alpha: number, fade: string, delta: number): number;
+declare function KDDrawEffectTiles(canvasOffsetX: any, canvasOffsetY: any, CamX: any, CamY: any): void;
+/**
+ *
+ * @param {effectTile} tile
+ * @returns {boolean}
+ */
+declare function KDCanSeeEffectTile(tile: effectTile): boolean;
+declare function KDUpdateEffectTiles(delta: any): void;
+/**
+ *
+ * @param {number} delta
+ * @param {entity} entity
+ * @param {effectTile} tile
+ */
+declare function KinkyDungeonUpdateSingleEffectTile(delta: number, entity: entity, tile: effectTile): void;
+/**
+ *
+ * @param {number} delta
+ * @param {effectTile} tile
+ */
+declare function KinkyDungeonUpdateSingleEffectTileStandalone(delta: number, tile: effectTile): void;
+/**
+ *
+ * @param {any} b
+ * @param {effectTile} tile
+ * @param {number} d
+ */
+declare function KinkyDungeonBulletInteractionSingleEffectTile(b: any, tile: effectTile, d: number): void;
+declare function KDEffectTileInteractions(x: any, y: any, b: any, d: any): void;
+/**
+ * Moves an entity
+ * @param {entity} enemy
+ * @param {number} x
+ * @param {number} y
+ * @param {boolean} willing
+ * @param {boolean} [ignoreBlocked] - Ignore if the target is blocked--important if swapping
+ */
+declare function KDMoveEntity(enemy: entity, x: number, y: number, willing: boolean, dash: any, forceHitBullets: any, ignoreBlocked?: boolean): boolean;
+declare function KDStaggerEnemy(enemy: any): void;
+declare function KDMovePlayer(moveX: any, moveY: any, willing: any, sprint: any, forceHitBullets: any): boolean;
+declare function KDSlip(dir: any): boolean;
+/**
+ * Helper function for flammable tiles
+ */
+declare function KDInferno(existingTile: any, newTile: any, duration: any): void;
+/**
+ * Helper function for flammables
+ * @param {*} b
+ * @param {effectTile} tile
+ * @param {*} d
+ */
+declare function KDIgnition(b: any, tile: effectTile, d: any): void;
+/**
+ * Code for a conveyor tile. DY and DX enable this functionality
+ * @param {number} delta
+ * @param {number} X
+ * @param {number} Y
+ */
+declare function KDConveyor(delta: number, X: number, Y: number): void;
+declare let KinkyDungeonChestConfirm: boolean;
+declare let KinkyDungeonConfirmStairs: boolean;
+/** @type {Record<string, boolean>} */
+declare let KDTileModes: Record<string, boolean>;
+declare let KDLastEffTileUpdate: number;

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

@@ -0,0 +1,72 @@
+/**
+ *
+ * @param {string[]} tags
+ * @param {number} count
+ * @param {string} msg
+ */
+declare function KDBasicRestraintsMachine_Player(tags: string[], count: number, msg: string): number;
+declare function KDSlimeImmuneEntity(entity: any): any;
+declare function KDSlimeWalker(entity: any): boolean;
+declare function KDSlimeImmune(enemy: any): any;
+/**
+ * Updates local tiles such as conveyors
+ * @type {Record<string, (delta: number, X?: number, Y?: number) => void>}
+ */
+declare let KDTileUpdateFunctionsLocal: Record<string, (delta: number, X?: number, Y?: number) => void>;
+/**
+ * Return value: whether or not to continue to allow peripheral tile updates
+ * @type {Record<string, KDBondageMachineFunc>}
+ */
+declare let KDBondageMachineFunctions: Record<string, KDBondageMachineFunc>;
+/**
+ * Return value: whether or not to continue to allow peripheral tile updates
+ * @type {Record<string, (delta: number) => boolean>}
+ */
+declare let KDTileUpdateFunctions: Record<string, (delta: number) => boolean>;
+/**
+ * @type {Record<string, (moveX, moveY) => boolean>}
+ */
+declare let KDMoveObjectFunctions: Record<string, (moveX: any, moveY: any) => boolean>;
+/**
+ * Return is whether or not something the player should know about happened
+ * @type {Record<string, (delta, tile: effectTile) => boolean>}
+ */
+declare let KDEffectTileFunctionsStandalone: Record<string, (delta: any, tile: effectTile) => boolean>;
+/**
+ * These happen when stepped on
+ * Return is whether or not something the player should know about happened
+ * @type {Record<string, (delta, entity: entity, tile: effectTile) => boolean>}
+ */
+declare let KDEffectTileFunctions: Record<string, (delta: any, entity: entity, tile: effectTile) => boolean>;
+/**
+ * Return is whether or not something the player should know about happened
+ * @type {Record<string, (newTile: effectTile, existingTile: effectTile) => boolean>}
+ */
+declare let KDEffectTileCreateFunctionsCreator: Record<string, (newTile: effectTile, existingTile: effectTile) => boolean>;
+/**
+ * Return is whether or not something the player should know about happened
+ * Return type is whether or not the signal should stop (true) or pass (false)
+ * @type {Record<string, (tile: any, x: number, y: number) => boolean>}
+ */
+declare let KDActivateMapTile: Record<string, (tile: any, x: number, y: number) => boolean>;
+/**
+ * Return is whether or not something the player should know about happened
+ * @type {Record<string, (newTile: effectTile, existingTile: effectTile) => boolean>}
+ */
+declare let KDEffectTileCreateFunctionsExisting: Record<string, (newTile: effectTile, existingTile: effectTile) => boolean>;
+/**
+ * Return is whether or not the move should be interrupted
+ * @type {Record<string, (entity, tile: effectTile, willing, dir, sprint) => {cancelmove: boolean, returnvalue: boolean}>}
+ */
+declare let KDEffectTileMoveOnFunctions: Record<string, (entity: any, tile: effectTile, willing: any, dir: any, sprint: any) => {
+    cancelmove: boolean;
+    returnvalue: boolean;
+}>;
+declare let KDTorchExtinguishTypes: string[];
+declare let KDSlimeExtinguishTypes: string[];
+declare let KDIgnitionSources: string[];
+/**
+ * Return is idk
+ * @type {Record<string, (b, tile: effectTile, d) => boolean>}
+ */
+declare let KDEffectTileBulletFunctions: Record<string, (b: any, tile: effectTile, d: any) => boolean>;

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

@@ -0,0 +1,34 @@
+declare function KinkyDungeonHandleStepOffTraps(entity: any, x: any, y: any, moveX: any, moveY: any): void;
+declare function KinkyDungeonHandleTraps(entity: any, x: any, y: any, Moved: any): void;
+declare function KDTrigPanic(): void;
+/**
+ *
+ * @returns {{ Name: string; Enemy?: string; Spell?: string; Level: number; Power: number; Weight: number; strict?: true;}[]}
+ */
+declare function KinkyDungeonGetGoddessTrapTypes(): {
+    Name: string;
+    Enemy?: string;
+    Spell?: string;
+    Level: number;
+    Power: number;
+    Weight: number;
+    strict?: true;
+}[];
+declare function KinkyDungeonGetTrap(trapTypes: any, Level: any, tags: any): {
+    Name: any;
+    Restraint: any;
+    Enemy: any;
+    Spell: any;
+    Power: any;
+    extraTag: any;
+};
+declare function KDSmokePuff(x: any, y: any, radius: any, density: any, nomsg: any): void;
+declare function KDSteamPuff(x: any, y: any, radius: any, density: any, nomsg: any): void;
+/** @type {Record<string, KDTrapType>} */
+declare let KDTrapTypes: Record<string, KDTrapType>;
+declare namespace KDTrapTypesStepOff {
+    function DoorLock(tile: any, entity: any, x: any, y: any): {
+        msg: string;
+    };
+}
+declare let KinkyDungeonTrapMoved: boolean;

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

@@ -0,0 +1,98 @@
+declare function KDStopAllVibeSounds(Exceptions: any): void;
+declare function KDUpdateVibeSound(Location: any, Sound: any, Volume: any): void;
+declare function KDUpdateVibeSounds(): void;
+declare function KDSumVibeLocations(): string[];
+/** Gets a list of the groups that should be vibrating here. It is the item's group, plus any 'linked' vibrators */
+declare function KDGetVibeLocation(item: any): string[];
+/**
+ * Starts a vibration, overriding
+ * @param {string} source
+ * @param {string} name
+ * @param {number} intensity
+ * @param {number} duration
+ * @param {number} [numLoops]
+ * @param {number} [denyTime ]
+ * @param {number} [denialsLeft ]
+ * @param {number} [edgeTime ]
+ * @param {boolean} [edgeOnly ]
+ * @param {boolean} [alwaysDeny ]
+ * @param {number} [denialChance ]
+ * @param {number} [denialChanceLikely ]
+ * @param {boolean} [tickEdgeAtMaxArousal ]
+ * @param {VibeMod[]} [vibeMods ]
+ */
+declare function KinkyDungeonStartVibration(source: string, name: string, locations: any, intensity: number, duration: number, numLoops?: number, denyTime?: number, denialsLeft?: number, edgeTime?: number, edgeOnly?: boolean, alwaysDeny?: boolean, denialChance?: number, denialChanceLikely?: number, tickEdgeAtMaxArousal?: boolean, vibeMods?: VibeMod[]): void;
+/**
+ *
+ * @param {Record<string, number>} cooldown
+ * @returns {boolean}
+ */
+declare function KDIsVibeCD(cooldown: Record<string, number>): boolean;
+declare function KinkyDungeonAddVibeModifier(source: any, name: any, location: any, intensityMod: any, duration: any, intensitySetpoint: any, edgeOnly: any, forceDeny: any, bypassDeny: any, bypassEdge: any, extendDuration: any, denyChanceMod: any, denyChanceLikelyMod: any): void;
+declare function KinkyDungeonGetDenyChance(chance: any): number;
+declare function KinkyDungeonVibratorsDeny(chance: any): boolean;
+declare function KinkyDungeonCalculateVibeLevel(delta: any): void;
+declare function KinkyDungeonEndVibration(): void;
+declare function KinkyDungeonCanOrgasm(): boolean;
+declare namespace KDVibeSounds {
+    namespace ItemVulva {
+        const sound: string;
+        const Audio: any;
+        const update: boolean;
+    }
+    namespace ItemButt {
+        const sound_1: string;
+        export { sound_1 as sound };
+        const Audio_1: any;
+        export { Audio_1 as Audio };
+        const update_1: boolean;
+        export { update_1 as update };
+    }
+    namespace ItemNipples {
+        const sound_2: string;
+        export { sound_2 as sound };
+        const Audio_2: any;
+        export { Audio_2 as Audio };
+        const update_2: boolean;
+        export { update_2 as update };
+        export const vol: number;
+    }
+}
+declare namespace KDVibeSoundRedirect {
+    const ItemVulva_1: string;
+    export { ItemVulva_1 as ItemVulva };
+    export const ItemVulvaPiercings: string;
+    const ItemButt_1: string;
+    export { ItemButt_1 as ItemButt };
+    export const ItemNipplesPiercings: string;
+    const ItemNipples_1: string;
+    export { ItemNipples_1 as ItemNipples };
+    export const ItemPelvis: string;
+    export const ItemBreast: string;
+    export const ItemBoots: string;
+}
+declare namespace KDVibeSound {
+    const ItemVulva_2: string;
+    export { ItemVulva_2 as ItemVulva };
+    const ItemButt_2: string;
+    export { ItemButt_2 as ItemButt };
+    const ItemNipples_2: string;
+    export { ItemNipples_2 as ItemNipples };
+}
+declare let KDResolutionConfirm: boolean;
+declare let KDResolution: number;
+declare let KDResolutionListIndex: number;
+declare let KDResolutionList: number[];
+declare let KDVibeVolume: number;
+declare let KDVibeVolumeListIndex: number;
+declare let KDVibeVolumeList: number[];
+declare let KDMusicVolumeMult: number;
+declare let KDMusicVolume: number;
+declare let KDMusicVolumeListIndex: number;
+declare let KDMusicVolumeList: number[];
+declare let KDSfxVolume: number;
+declare let KDSfxVolumeListIndex: number;
+declare let KDSfxVolumeList: number[];
+declare let KDAnimSpeed: number;
+declare let KDAnimSpeedListIndex: number;
+declare let KDAnimSpeedList: number[];

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

@@ -0,0 +1,24 @@
+declare function KinkyDungeonCheckProjectileClearance(xx: any, yy: any, x2: any, y2: any): boolean;
+declare function KinkyDungeonCheckPath(x1: any, y1: any, x2: any, y2: any, allowBars: any, blockEnemies: any, maxFails: any, blockOnlyLOSBlock: any): boolean;
+declare function KinkyDungeonResetFog(): void;
+declare function KinkyDungeonMakeBrightnessMap(width: any, height: any, mapBrightness: any, Lights: any, delta: any): void;
+/** Averages two hex colors according to weights w1 and w2
+ * @param {number} color1
+ * @param {number} color2
+ * @param {number} w1 - Weight of color1
+ * @param {number} w2 - Weight of color2
+ * @returns {number}
+ */
+declare function KDAvgColor(color1: number, color2: number, w1: number, w2: number): number;
+declare function KinkyDungeonMakeVisionMap(width: any, height: any, Viewports: any, Lights: any, delta: any, mapBrightness: any): void;
+declare function KDDrawFog(CamX: any, CamY: any, CamX_offset: any, CamY_offset: any): void;
+/**
+ * Allows fog of war to be rendered
+ */
+declare function KDAllowFog(): boolean;
+declare let KinkyDungeonSeeAll: boolean;
+declare let KDVisionBlockers: Map<any, any>;
+declare let KDLightBlockers: Map<any, any>;
+declare let KDPlayerLight: number;
+declare let KDMapBrightnessMult: number;
+declare let KDLightCropValue: number;

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

@@ -0,0 +1,5 @@
+declare let KinkyDungeonStatStaminaCostAttack: number;
+/**
+ * @type {Record<string, weapon>}
+ */
+declare let KinkyDungeonWeapons: Record<string, weapon>;

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

@@ -0,0 +1,73 @@
+/**
+ * Start a magic battle against an opponent
+ * @param {Character} Opponent
+ * @param {number} Difficulty
+ * @param {string} Background
+ * @param {string} FunctionName
+ * @returns {void} - Nothing
+ */
+declare function MagicBattleStart(Opponent: Character, Difficulty: number, Background: string, FunctionName: string): void;
+/**
+ * Loads the magic battle
+ * @returns {void} - Nothing
+ */
+declare function MagicBattleLoad(): void;
+/**
+ * Returns a difficulty factor based on the character nakedness and predicament
+ * @param {Character} C
+ * @returns {number} - Difficulty from 0 (full cloth, no restrain) to 10 (naked, fully restrained)
+ */
+declare function MagicBattleGetDifficulty(C: Character): number;
+/**
+ * Returns the spells that are available based on opponent (C) clothing and restraints
+ * @param {Character} C
+ * @returns {Array<number>} - Nothing
+ */
+declare function MagicBattleGetAvailSpells(C: Character): Array<number>;
+/**
+ * Runs the magic battle, 1 player vs 1 opponent
+ * @returns {void} - Nothing
+ */
+declare function MagicBattleRun(): void;
+/**
+ * Handles clicks during the game
+ * @returns {void} - Nothing
+ */
+declare function MagicBattleClick(): void;
+/**
+ * Starts the magic puzzle mini-game for a specific spell (S)
+ * @param {number} S
+ * @returns {void} - Nothing
+ */
+declare function MagicBattleSpellStart(S: number): void;
+/**
+ * Applies the effect of a magic spell (Spell) on a character (C)
+ * @param {Character} C
+ * @param {number} Spell
+ * @returns {void} - Nothing
+ */
+declare function MagicSpellEffect(C: Character, Spell: number): void;
+/**
+ * When the spell ends, we apply the effect of the spell on the loser
+ * @returns {void} - Nothing
+ */
+declare function MagicBattleSpellEnd(): void;
+/**
+ * Handles the key press in the game, the C key for cheats
+ * @returns {void} - Nothing
+ */
+declare function MagicBattleKeyDown(): void;
+declare var MagicBattleBackground: string;
+/** @type {null | Character} */
+declare var MagicBattleOpponent: null | Character;
+declare var MagicBattleReturnFunction: string;
+declare var MagicBattleDifficulty: number;
+declare var MagicBattleVictory: boolean;
+/** @type {number[]} */
+declare var MagicBattleAvailSpell: number[];
+declare var MagicBattleOpponentSpell: number;
+/** @type {null | string} */
+declare var MagicBattlePlayerAppearance: null | string;
+/** @type {null | string} */
+declare var MagicBattleOpponentAppearance: null | string;
+declare var MagicBattleSpellDifficulty: number[];

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

@@ -0,0 +1,75 @@
+/**
+ * Loads the magic puzzle mini game and sets the difficulty ratio
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleLoad(): void;
+/**
+ * Returns the time in seconds with 3 digits milliseconds
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleTime(Time: any): void;
+/**
+ * Validates where the puzzle square is, validated 4 times for each end of the square
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleValidate(X: any, Y: any): void;
+/**
+ * Prevents cheats in the mini-game by validating the last X and Y positions
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleAntiCheat(): void;
+/**
+ * Runs the magic puzzle mini game
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleRun(): void;
+/**
+ * Add the current square position onto the trail and trim the end
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleBuildTrail(): void;
+/**
+ * Draw a trail of faded past squares following the current square's position
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleDrawTrail(): void;
+/**
+ * Adjust one colour to be closer to another
+ * @param {HexColor} startingColor - Hex code of the starting colour
+ * @param {HexColor} targetColor - Hex code of the colour to transition to
+ * @param {number} progressPercentage - The percentage the colour should transition, with 0 = none and 1 = fully
+ * @returns {HexColor} - The final composed colour
+ */
+declare function MagicPuzzleTransitionToColor(startingColor: HexColor, targetColor: HexColor, progressPercentage: number): HexColor;
+/**
+ * Handles clicks during the mini game, the bottom part will end the game
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleClick(): void;
+/**
+ * Handles the key press in the mini game, the C key for cheats adds 5 seconds to the enemy timer
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleKeyDown(): void;
+/**
+ * When the magic puzzle must end
+ * @returns {void} - Nothing
+ */
+declare function MagicPuzzleEnd(): void;
+declare var MagicPuzzleBackground: string;
+declare var MagicPuzzleStart: number;
+declare var MagicPuzzleFinish: number;
+declare var MagicPuzzleSize: number;
+declare var MagicPuzzleSpell: number;
+declare var MagicPuzzleAutoExit: boolean;
+declare var MagicPuzzleStarted: boolean;
+declare var MagicPuzzleTimer: number;
+declare var MagicPuzzleLastMouseX: number;
+declare var MagicPuzzleLastMouseY: number;
+/** @type { { X: number, Y: number }[] } */
+declare var MagicPuzzleTrail: {
+    X: number;
+    Y: number;
+}[];
+declare var MagicPuzzleTrailLimit: number;
+declare var MagicPuzzleTrailRainbow: boolean;

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

@@ -0,0 +1,51 @@
+/**
+ * Generates all the spots to clean for the main cleaning minigame
+ * @param {number} MaxSpot - Maximum amount of spots to generate
+ * @returns {void} - Nothing
+ */
+declare function MaidCleaningGenerateSpots(MaxSpot: number): void;
+/**
+ * Draw the cleaning spots for the maid cleaning mini game
+ * @returns {void} - Nothing
+ */
+declare function MaidCleaningDrawSpots(): void;
+/**
+ * Loads the maid cleaning mini game. It will select a random background and generate spots based on the difficulty
+ * @returns {void} - Nothing
+ */
+declare function MaidCleaningLoad(): void;
+/**
+ * Runs the maid cleaning mini game
+ * @returns {void} - Nothing
+ */
+declare function MaidCleaningRun(): void;
+/**
+ * Ends the game and sends the result back to the screen
+ * @param {boolean} Victory - Whether or not the game was won
+ * @returns {void} - Nothing
+ */
+declare function MaidCleaningEnd(Victory: boolean): void;
+/**
+ * Handles moving the player on the screen with a click, used for mobile users
+ * @returns {void} - Nothing
+ */
+declare function MaidCleaningDoMove(): void;
+/**
+ * The player can use the C key to cheat and add 10 extra seconds to win the game
+ * @returns {void} - Nothing
+ */
+declare function MaidCleaningKeyDown(): void;
+/**
+ * Handles clicks during the maid cleaning minigame. On mobile, we need to move the player on a click.
+ */
+declare function MaidCleaningClick(): void;
+declare var MaidCleaningBackground: string;
+/** @type {null | { X: number, Y: number, T: number }[]} */
+declare var MaidCleaningSpots: null | {
+    X: number;
+    Y: number;
+    T: number;
+}[];
+declare var MaidCleaningPlayerX: number;
+declare var MaidCleaningPlayerY: number;
+declare var MaidCleaningSpotSize: number;

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

@@ -0,0 +1,82 @@
+/**
+ * Generates a full sequence
+ * @param {number} StartTime - Start time of the sequence
+ */
+declare function MaidDrinksGenerateMove(StartTime: number): void;
+/**
+ * Loads the maid drinks mini game and its NPCs
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksLoad(): void;
+/**
+ * Draws the icons for the mini game
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksDrawIcons(): void;
+/**
+ * Draws the bars to tell when the moves will hit
+ * @param {number} SquareType - Type of the bar to draw (0 to 3)
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksDrawBar(SquareType: number): void;
+/**
+ * Generates random customers for the mini game (makes them visible for a random amount of time)
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksCustomers(): void;
+/**
+ * Runs and draws the maid drinks mini game
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksRun(): void;
+/**
+ * Ends the maid drinks mini game and sends the result back to the screen
+ * @param {boolean} Victory - Whether or not the player one the mini game
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksEnd(Victory: boolean): void;
+/**
+ * Used when the player hits, at 100 progress the player wins and the game ends
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksHit(): void;
+/**
+ * Used when the player misses, the penalty is bigger on higher difficulties. When below zero progress, the player fails the mini game.
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksMiss(): void;
+/**
+ * Used when the player tries to do a specific move type
+ * @param {number} MoveType - Type of move made by the player
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksDoMove(MoveType: number): void;
+/**
+ * Handles key presses during the maid drinks mini game. (Both keyboard and mobile)
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksKeyDown(): void;
+/**
+ * Handles clicks during the maid drinks mini game (only on mobile, to replace the keyboard)
+ * @returns {void} - Nothing
+ */
+declare function MaidDrinksClick(): void;
+declare var MaidDrinksBackground: string;
+/** @type {null | NPCCharacter} */
+declare var MaidDrinksCustomerLeft: null | NPCCharacter;
+/** @type {null | NPCCharacter} */
+declare var MaidDrinksCustomerRight: null | NPCCharacter;
+declare var MaidDrinksCustomerLeftTimer: number;
+declare var MaidDrinksCustomerRightTimer: number;
+declare var MaidDrinksCustomerLeftVisible: boolean;
+declare var MaidDrinksCustomerRightVisible: boolean;
+declare var MaidDrinksMaxSequence: number;
+/** @type {{ Type: number, Time: number }[]} */
+declare var MaidDrinksMove: {
+    Type: number;
+    Time: number;
+}[];
+declare var MaidDrinksLastMoveType: number;
+declare var MaidDrinksLastMoveTypeTimer: number;
+declare var MaidDrinksKeyUpper: number[];
+declare var MaidDrinksKeyLower: number[];