bc-stubs 96.0.0

package/bc/Scripts/MiniGame.d.ts

@@ -0,0 +1,30 @@
+declare function MiniGameLoad(): void;
+/**
+ * Starts a given mini game at a set difficulty and keeps
+ * @param {string} GameType - Name of the mini-game to launch
+ * @param {number|string} Difficulty - Difficulty Ration for the mini-game
+ * @param {string} ReturnFunction - Callback name to execute once the mini-game is over
+ * @returns {void} - Nothing
+ */
+declare function MiniGameStart(GameType: string, Difficulty: number | string, ReturnFunction: string): void;
+declare function MiniGameEnd(): void;
+/**
+ * Checks if the C key is being pressed and if cheats are available
+ * @returns {boolean} - TRUE if C and cheats are allowed
+ */
+declare function MiniGameCheatKeyDown(): boolean;
+declare var MiniGameType: string;
+declare var MiniGameVictory: boolean;
+declare var MiniGamePerfect: boolean;
+/** @type {number} */
+declare var MiniGameDifficulty: number;
+/** @type {string} */
+declare var MiniGameDifficultyMode: string;
+declare var MiniGameDifficultyRatio: number;
+declare var MiniGameAdvancedPayment: number;
+declare var MiniGameReturnFunction: string;
+declare var MiniGameProgress: number;
+declare var MiniGameTimer: number;
+declare var MiniGameEnded: boolean;
+declare var MiniGameCheatAvailable: boolean;
+declare let KDPatched: boolean;

package/bc/Scripts/ModularItem.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Registers a modular extended item. This automatically creates the item's load, draw and click functions. It will
+ * also generate the asset's AllowType array, as AllowType arrays on modular items can get long due to the
+ * multiplicative nature of the item's types, and also converts the AllowModuleTypes property on any asset layers into
+ * an AllowTypes property, if present.
+ * @param {Asset} asset - The asset being registered
+ * @param {ModularItemConfig} config - The item's modular item configuration
+ * @returns {ModularItemData} - The generated extended item data for the asset
+ */
+declare function ModularItemRegister(asset: Asset, config: ModularItemConfig): ModularItemData;
+/**
+ * Initialize the modular item properties
+ * @param {ModularItemData} Data - The item's extended item data
+ * @param {Item} Item - The item in question
+ * @param {Character} C - The character that has the item equiped
+ * @param {boolean} Refresh - Whether the character and relevant item should be refreshed and pushed to the server
+ * @returns {boolean} Whether properties were initialized or not
+ */
+declare function ModularItemInit(Data: ModularItemData, C: Character, Item: Item, Refresh?: boolean): boolean;
+/**
+ * @param {ModularItemData} data
+ */
+declare function ModularItemLoad(data: ModularItemData): void;
+/**
+ * @param {ModularItemData} data
+ */
+declare function ModularItemClick(data: ModularItemData): void;
+/**
+ * @param {ModularItemData} data
+ */
+declare function ModularItemDraw(data: ModularItemData): void;
+/**
+ * Parse the and pre-process the passed modules (and their options)
+ * @param {Asset} asset - The asset in question
+ * @param {readonly ModularItemModuleConfig[]} modules - An object describing a single module for a modular item.
+ * @param {boolean | undefined} [changeWhenLocked] - See {@link ModularItemConfig.ChangeWhenLocked}
+ * @returns {ModularItemModule[]} - The updated modules and options
+ */
+declare function ModularItemBuildModules(asset: Asset, modules: readonly ModularItemModuleConfig[], changeWhenLocked?: boolean | undefined): ModularItemModule[];
+/**
+ * Generates an asset's modular item data
+ * @param {Asset} asset - The asset to generate modular item data for
+ * @param {ModularItemConfig} config - The item's extended item configuration
+ * @returns {ModularItemData} - The generated modular item data for the asset
+ */
+declare function ModularItemCreateModularData(asset: Asset, { Modules, ChatSetting, ChatTags, ChangeWhenLocked, DialogPrefix, ScriptHooks, Dictionary, DrawData, BaselineProperty, DrawImages, }: ModularItemConfig): ModularItemData;
+/**
+ * Creates a modular item's base draw function (for the module selection screen)
+ * @param {ModularItemData} data - The modular item data for the asset
+ * @returns {() => void} - The modular item's base draw function
+ */
+declare function ModularItemCreateDrawBaseFunction(data: ModularItemData): () => void;
+/**
+ * Maps a modular item option to a button definition for rendering the option's button.
+ * @param {ModularItemOption} option - The option to draw a button for
+ * @param {ModularItemModule} module - A reference to the option's parent module
+ * @param {ModularItemData} data - The modular item's data
+ * @param {number} currentOptionIndex - The currently selected option index for the module
+ * @returns {ModularItemButtonDefinition} - A button definition array representing the provided option
+ */
+declare function ModularItemMapOptionToButtonDefinition(option: ModularItemOption, module: ModularItemModule, { dialogPrefix }: ModularItemData, currentOptionIndex: number): ModularItemButtonDefinition;
+/**
+ * Draws a module screen from the provided button definitions and modular item data.
+ * @param {string} moduleName - The name of the module whose page is being drawn
+ * @param {readonly ModularItemButtonDefinition[]} buttonDefinitions - A list of button definitions to draw
+ * @param {ModularItemData} data - The modular item's data
+ * @param {ExtendedItemDrawData<ElementMetaData.Modular>} drawData
+ * @returns {void} - Nothing
+ */
+declare function ModularItemDrawCommon(moduleName: string, buttonDefinitions: readonly ModularItemButtonDefinition[], data: ModularItemData, { paginate, pageCount, elementData, itemsPerPage }: ExtendedItemDrawData<ElementMetaData.Modular>): void;
+/**
+ * Draws the extended item screen for a given module.
+ * @param {ModularItemModule} module - The module whose screen to draw
+ * @param {ModularItemData} data - The modular item's data
+ * @returns {void} - Nothing
+ */
+declare function ModularItemDrawModule(module: ModularItemModule, data: ModularItemData): void;
+/**
+ * Generates a click function for a modular item's module selection screen
+ * @param {ModularItemData} data - The modular item's data
+ * @returns {function(): void} - A click handler for the modular item's module selection screen
+ */
+declare function ModularItemCreateClickBaseFunction(data: ModularItemData): () => void;
+/**
+ * A generic click handler for a module's screen
+ * @param {ModularItemModule} module - The module whose screen we are currently in
+ * @param {ModularItemData} data - The modular item's data
+ * @returns {void} - Nothing
+ */
+declare function ModularItemClickModule(module: ModularItemModule, data: ModularItemData): void;
+/**
+ * A common click handler for modular item screens. Note that pagination is not currently handled, but will be added
+ * in the future.
+ * @param {ExtendedItemDrawData<ElementMetaData.Modular>} drawData
+ * @param {function(): void} exitCallback - A callback to be called when the exit button has been clicked
+ * @param {function(number): void} itemCallback - A callback to be called when an item has been clicked
+ * @param {function(number): void} paginateCallback - A callback to be called when a pagination button has been clicked
+ * @returns {void} - Nothing
+ */
+declare function ModularItemClickCommon({ paginate, elementData }: ExtendedItemDrawData<ElementMetaData.Modular>, exitCallback: () => void, itemCallback: (arg0: number) => void, paginateCallback: (arg0: number) => void): void;
+/**
+ * Handles page changing for modules
+ * @param {string} moduleName - The name of the module whose page should be modified
+ * @param {number} delta - The page delta to apply to the module's current page
+ * @param {ModularItemData} data - The modular item's data
+ * @param {ExtendedItemDrawData<ElementMetaData.Modular>} drawData
+ * @returns {void} - Nothing
+ */
+declare function ModularItemChangePage(moduleName: string, delta: number, data: ModularItemData, { pageCount }: ExtendedItemDrawData<ElementMetaData.Modular>): void;
+/**
+ * Transitions between pages within a modular item's extended item menu
+ * @param {string} newModule - The name of the new module to transition to
+ * @param {ModularItemData} data - The modular item's data
+ * @returns {void} - Nothing
+ */
+declare function ModularItemModuleTransition(newModule: string, data: ModularItemData): void;
+/**
+ * Parses the focus item's current type into an array representing the currently selected module options
+ * @param {ModularItemData} data - The modular item's data
+ * @param {string?} type - The type string for a modular item. If null, use a type string extracted from the selected module options
+ * @returns {number[]} - An array of numbers representing the currently selected options for each of the item's modules
+ */
+declare function ModularItemParseCurrent({ asset, modules }: ModularItemData, type?: string | null): number[];
+/**
+ * Merges all of the selected module options for a modular item into a single Property object to set on the item
+ * @param {ModularItemData} data - The modular item's data
+ * @param {readonly number[]} moduleValues - The numeric values representing the current options for each module
+ * @param {ItemProperties|null} BaselineProperty - Initial properties
+ * @returns {ItemProperties} - A property object created from combining each module of the modular item
+ */
+declare function ModularItemMergeModuleValues({ asset, modules }: ModularItemData, moduleValues: readonly number[], BaselineProperty?: ItemProperties | null): ItemProperties;
+/**
+ * Sanitize and merge all modular item properties
+ * @param {ItemProperties} Property - The to-be sanitized properties
+ * @param {ItemProperties} mergedProperty - The to-be returned object with the newly sanitized properties
+ * @param {Asset} Asset - The relevant asset
+ * @returns {ItemProperties} - The updated merged properties
+ */
+declare function ModularItemSanitizeProperties(Property: ItemProperties, mergedProperty: ItemProperties, Asset: Asset): ItemProperties;
+/**
+ * Generates the type string for a modular item from its modules and their current values.
+ * @param {AssetOverrideHeight} currentValue - The OverrideHeight for the future item
+ * @param {AssetOverrideHeight} newValue - The OverrideHeight being merged
+ * @returns {AssetOverrideHeight | undefined} - A string type generated from the selected option values for each module
+ */
+declare function ModularItemMergeOverrideHeight(currentValue: AssetOverrideHeight, newValue: AssetOverrideHeight): AssetOverrideHeight | undefined;
+/**
+ * Generates the type string for a modular item from its modules and their current values.
+ * @param {ModularItemModule[]} modules - The modules array for the modular item
+ * @param {readonly number[]} [values] - The numeric values representing the current options for each module
+ * @returns {string} - A string type generated from the selected option values for each module
+ */
+declare function ModularItemConstructType(modules: ModularItemModule[], values?: readonly number[]): string;
+/**
+ * Separate a modular item type string into a list with the types of each individual module.
+ * @param {string} Type - The modular item type string
+ * @returns {string[] | null} - A list with the options of each individual module or `null` if the input type wasn't a string
+ */
+declare function ModularItemDeconstructType(Type: string): string[] | null;
+/**
+ * Sets a modular item's type based on a change in a module's option selection.
+ * @param {ModularItemModule} module - The module that changed
+ * @param {number} index - The index of the newly chosen option within the module
+ * @param {ModularItemData} data - The modular item's data
+ * @returns {void} - Nothing
+ */
+declare function ModularItemSetType(module: ModularItemModule, index: number, data: ModularItemData): void;
+/**
+ * Sets a modular item's type and properties to the option whose name matches the provided option name parameter.
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item | AssetGroupName} itemOrGroupName - The item whose type to set, or the group name for the item
+ * @param {string} optionNames - The name of the option to set
+ * @param {boolean} [push] - Whether or not appearance updates should be persisted (only applies if the character is the
+ * player) - defaults to false.
+ * @param {null | Character} [C_Source] - The character setting the new item option. If `null`, assume that it is _not_ the player character.
+ * @returns {string|undefined} - undefined or an empty string if the type was set correctly. Otherwise, returns a string
+ * informing the player of the requirements that are not met.
+ */
+declare function ModularItemSetOptionByName(C: Character, itemOrGroupName: Item | AssetGroupName, optionNames: string, push?: boolean, C_Source?: null | Character): string | undefined;
+/**
+ * Publishes the chatroom message for a modular item when one of its modules has changed.
+ * @param {ModularItemData} data
+ * @param {Character} C
+ * @param {Item} item
+ * @param {ModularItemOption} newOption
+ * @param {ModularItemOption} previousOption
+ * @returns {void} - Nothing
+ */
+declare function ModularItemPublishAction(data: ModularItemData, C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption): void;
+/**
+ * Generates an array of all types available for an asset based on its modular item data, filtered by the provided
+ * predicate function, if needed.
+ * @param {ModularItemData} data - The modular item's data
+ * @param {(typeObject: Record<string, number>) => boolean} [predicate] - An optional predicate for filtering the
+ * resulting types
+ * @returns {string[]} - The generated array of types
+ */
+declare function ModularItemGenerateTypeList({ modules }: ModularItemData, predicate?: (typeObject: Record<string, number>) => boolean): string[];
+/**
+ * Generates and sets the AllowLock and AllowLockType properties for an asset based on its modular item data. For types
+ * where two independent options declare conflicting AllowLock properties (i.e. one option declares AllowLock: false and
+ * another declares AllowLock: true), the resulting type will permit locking (i.e. true overrides false).
+ * @param {ModularItemData} data - The modular item's data
+ * @returns {void} - Nothing
+ */
+declare function ModularItemGenerateAllowLockType(data: ModularItemData): void;
+/**
+ * Generates and assigns a modular asset's AllowType, AllowEffect and AllowBlock properties, along with the AllowTypes
+ * properties on the asset layers based on the values set in its module definitions.
+ * @param {ModularItemData} data - The modular item's data
+ * @returns {void} - Nothing
+ */
+declare function ModularItemGenerateValidationProperties(data: ModularItemData): void;
+/**
+ * Hide an HTML element if a given module is not active.
+ * @param {ModularItemData} Data - The modular item data
+ * @param {string} ID - The id of the element
+ * @param {string} Module - The module that must be active
+ * @returns {boolean} Whether the module is active or not
+ */
+declare function ModularItemHideElement(Data: ModularItemData, ID: string, Module: string): boolean;
+/**
+ * ModularItem.js
+ * --------------
+ * This file contains utilities related to modular extended items (for example the High Security Straitjacket). It is
+ * generally not necessary to call functions in this file directly - these are called from Asset.js when an item is
+ * first registered.
+ *
+ * A modular item is a typed item, but each type may be comprised of several independent "modules". For example, the
+ * High Security Straitjacket has 3 different modules: crotch panel (c), arms (a), and crotch straps (s), and each
+ * module can be configured independently. The resulting type then uses an abbreviated format which represents the
+ * module values comprising that type. Each module contains a number of options that may be chosen for that module.
+ *
+ * For example "c0a1s2" - represents the type where the crotch panel module uses option 0, the arms module uses option
+ * 1, and the crotch straps module uses option 2. The properties of the type will be derived from a combination of the
+ * properties of each of the type's module options. For example, difficulty will be calculated by summing up the
+ * difficulties for each of its module options.
+ *
+ * All dialogue for modular items should be added to `Dialog_Player.csv`. To implement a modular item, you need the
+ * following dialogue entries:
+ * * "<GroupName><AssetName>SelectBase" - This is the text that will be displayed on the module selection screen (e.g.
+ *   `ItemArmsHighSecurityStraitJacketSelectBase` - "Configure Straitjacket")
+ * * For each module:
+ *   * "<GroupName><AssetName>Select<ModuleName>" - This is the text that will be displayed on the module's subscreen
+ *     (e.g. `ItemArmsHighSecurityStraitJacketSelectCrotch` - "Configure crotch panel")
+ *   * "<GroupName><AssetName>Module<ModuleName>" - This is the text that will be used to describe the module (under
+ *     the module's button) in the module selection screen (e.g. `ItemArmsHighSecurityStraitJacketModuleCrotch` -
+ *     "Crotch Panel")
+ * * For each option:
+ *   * "<GroupName><AssetName>Option<ModuleKey><OptionNumber>" - This is the text that will be used to describe the
+ *     option (under the option's button) in the module subscreen for the module containing that option (e.g.
+ *     `ItemArmsHighSecurityStraitJacketOptionc0` - "No crotch panel")
+ * * If the item's chat setting is configured to `PER_MODULE`, you will need a chatroom message for each module,
+ *   which will be sent when that module changes. It should have the format "<GroupName><AssetName>Set<ModuleName>"
+ *   (e.g. `ItemArmsHighSecurityStraitJacketSetCrotch` - "SourceCharacter changed the crotch panel on
+ *   DestinationCharacter straitjacket")
+ * * If the item's chat setting is configured to `PER_OPTION`, you will need a chatroom message for each option, which
+ *   will be sent when that option is selected. It should have the format
+ *   "<GroupName><AssetName>Set<ModuleKey><OptionNumber>" (e.g. `ItemArmsHighSecurityStraitJacketSetc0` -
+ *   "SourceCharacter removes the crotch panel from DestinationCharacter straitjacket")
+ */
+/**
+ * The keyword used for the base menu on modular items
+ * @const {string}
+ */
+declare const ModularItemBase: "Base";
+/**
+ * A lookup for the modular item configurations for each registered modular item
+ * @const
+ * @type {Record<string, ModularItemData>}
+ * @see {@link ModularItemData}
+ */
+declare const ModularItemDataLookup: Record<string, ModularItemData>;
+/**
+ * An enum encapsulating the possible chatroom message settings for modular items
+ * - PER_MODULE - The item has one chatroom message per module (messages for individual options within a module are all
+ * the same)
+ * - PER_OPTION - The item has one chatroom message per option (for finer granularity - each individual option within a
+ * module can have its own chatroom message)
+ * @type {Record<"PER_MODULE"|"PER_OPTION", ModularItemChatSetting>}
+ */
+declare const ModularItemChatSetting: Record<"PER_MODULE" | "PER_OPTION", ModularItemChatSetting>;
+/** A regular expression that knows how to split modular types into [module key, option index] components */
+declare const ModularItemTypeSplitter: RegExp;
+/** A regular expression that knows how to split a [key, index] into its parts */
+declare const ModularItemSubtypeSplitter: RegExp;

package/bc/Scripts/Mouse.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Check if the mouse position is within the boundaries of a given zone (Useful for UI components)
+ * @param {number} Left - Starting position on the X axis
+ * @param {number} Top - Starting position on the Y axis
+ * @param {number} Width - Width of the zone
+ * @param {number} Height - Height of the zone
+ * @returns {boolean} - Returns TRUE if the click occurred in the given zone
+ */
+declare function MouseIn(Left: number, Top: number, Width: number, Height: number): boolean;
+/**
+ * Check if the mouse position is within the boundaries of a given zone along the X axis
+ * @param {number} Left - Starting position on the X axis
+ * @param {number} Width - Width of the zone
+ * @returns {boolean} - Returns TRUE if the click occurred in the given zone
+ */
+declare function MouseXIn(Left: number, Width: number): boolean;
+/**
+ * Check if the mouse position is within the boundaries of a given zone along the Y axis
+ * @param {number} Top - Starting position on the Y axis
+ * @param {number} Height - Height of the zone
+ * @returns {boolean} - Returns TRUE if the click occurred in the given zone
+ */
+declare function MouseYIn(Top: number, Height: number): boolean;
+/**
+ * A common check for whether the specified position is being hovered over
+ * @param {number} Left - Starting position on the X axis
+ * @param {number} Top - Starting position on the Y axis
+ * @param {number} Width - Width of the zone
+ * @param {number} Height - Height of the zone
+ * @returns {boolean} - Returns TRUE if the mouse is currently hovering over the specified zone
+ */
+declare function MouseHovering(Left: number, Top: number, Width: number, Height: number): boolean;
+declare var MouseX: number;
+declare var MouseY: number;

package/bc/Scripts/NPC.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Sets a specific trait for a NPC
+ * @param {NPCCharacter} C - NPC to set the trait for
+ * @param {string} TraitName - Name of the trait to set
+ * @param {number} TraitValue - Value of the trait to set
+ * @returns {void} - Nothing
+ */
+declare function NPCTraitSet(C: NPCCharacter, TraitName: string, TraitValue: number): void;
+/**
+ * Generate random traits for a NPC (70% odds for each traits, can switch on both sides, strength is from 1 to 100). Will generate at least one trait.
+ * @param {NPCCharacter} C - NPC to generate the trait for
+ * @returns {void} - Nothing
+ */
+declare function NPCTraitGenerate(C: NPCCharacter): void;
+/**
+ * Get the opposite trait of a specified trait.
+ * @param {string} Trait - Name of the trait to find the opposite of.
+ * @returns {string} - Name of the opposite trait.
+ */
+declare function NPCTraitReverse(Trait: string): string;
+/**
+ * Returns the weight value of the specified option (The higher the value, the higher the chances the option will be picked, an opposite trait will always result as an option that's not picked)
+ * @param {string} Dialog - Specified dialog line with the affecting traits.
+ * @param {readonly NPCTrait[]} Trait - List of traits of the NPC.
+ * @returns {number} - Weight of the dialog option
+ */
+declare function NPCTraitGetOptionValue(Dialog: string, Trait: readonly NPCTrait[]): number;
+/**
+ * Finds and keeps the best possible option for a specified NPC dialog group. A group is a list of similar options where each option is influenced by a specified trait.
+ * @param {NPCCharacter} C - NPC to get the dialog of
+ * @param {string} Group - Name of the dialog group to look for
+ * @returns {void} - Nothing.
+ */
+declare function NPCTraitKeepBestOption(C: NPCCharacter, Group: string): void;
+/**
+ * Picks the dialog group option that fits mosts with the NPC traits
+ * @param {Character} C - NPC to get the dialog options of
+ * @returns {void} - Nothing.
+ */
+declare function NPCTraitDialog(C: Character): void;
+/**
+ * Sets the arousal settings for a NPC if it's not already done
+ * @param {Character} C - NPC to set the arousal stats of
+ * @returns {void} - Nothing.
+ */
+declare function NPCArousal(C: Character): void;
+/**
+ * Returns the trait value of an NPC. If the opposite trait is found, it will return a negative value.
+ * @param {NPCCharacter} C - NPC to get the trait of
+ * @param {string} TraitType - Name of the trait to get the value of
+ * @returns {number} - Value of the trait, returns 0 if it was never set.
+ */
+declare function NPCTraitGet(C: NPCCharacter, TraitType: string): number;
+/**
+ * Adds a new event in a specified NPC log or updates an existing event if it was previously logged.
+ * @param {NPCCharacter} C - NPC for which to add the event to
+ * @param {string} EventName - Name of the even to add
+ * @param {number} EventValue - Value of the even to add (time in ms)
+ * @returns {void} - Nothing
+ */
+declare function NPCEventAdd(C: NPCCharacter, EventName: string, EventValue: number): void;
+/**
+ * Deletes a specified NPC event from the log
+ * @param {NPCCharacter} C - NPC for which to delete the event
+ * @param {string} EventName - Name of the even to delete
+ * @returns {void} - Nothing
+ */
+declare function NPCEventDelete(C: NPCCharacter, EventName: string): void;
+/**
+ * Returns a specified NPC event value.
+ * @param {NPCCharacter} C - NPC to get the event value of
+ * @param {string} EventName - Name of the even to get the value of
+ * @returns {number} - Value of the event as the time in ms, returns 0 if it was never logged
+ */
+declare function NPCEventGet(C: NPCCharacter, EventName: string): number;
+/**
+ * For longer events like a collaring, the serious trait will dictate the time (1 day if playful, 3 days if nothing, 7 days if serious)
+ * @param {NPCCharacter} C - NPC to get the event delay of
+ * @returns {number} - Delay required for the event.
+ */
+declare function NPCLongEventDelay(C: NPCCharacter): number;
+/**
+ * The horny / frigid trait comes into play when a NPC decides if it can take the player as a lover. (1 week if horny, 2 weeks if nothing, 4 weeks if frigid)
+ * @param {NPCCharacter} C - NPC to get the event delay of
+ * @returns {number} - Delay required for the lover event.
+ */
+declare function NPCLongLoverEventDelay(C: NPCCharacter): number;
+/**
+ * Changes the love factor for a specified NPC, will stay within the -100 to 100 range
+ * @param {NPCCharacter} C - NPC to change the love factor of
+ * @param {number} LoveFactor - Amount to add to the current love factor (can be negative).
+ * @returns {void} - Nothing
+ */
+declare function NPCLoveChange(C: NPCCharacter, LoveFactor: number): void;
+/**
+ * Raises the love factor progressively with interaction time
+ * @returns {void} - Nothing
+ */
+declare function NPCInteraction(): void;
+/**
+ * List for all possible pairs of NPC traits. A pair defines opposites.
+ * @constant
+ * @type {[string, string][]}
+ */
+declare var NPCTrait: [string, string][];

package/bc/Scripts/Notification.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Initialise notification variables on startup
+ * @returns {void} - Nothing
+ */
+declare function NotificationLoad(): void;
+/**
+ * Create a handler instance to track and handle notifications of that event type
+ * @param {NotificationEventType} eventType
+ * @param {NotificationSetting} setting
+ */
+declare function NotificationEventHandlerSetup(eventType: NotificationEventType, setting: NotificationSetting): void;
+/**
+ * Create a new notification
+ * @param {NotificationEventType} eventType - The type of event that occurred
+ * @param {NotificationData} [data={}] - Data relating to the event that can be passed into a popup
+ * @returns {void} - Nothing
+ */
+declare function NotificationRaise(eventType: NotificationEventType, data?: NotificationData): void;
+/**
+ * Clear all raised notifications of the specified type
+ * @param {NotificationEventType} eventType - The type of event to be cleared
+ * @returns {void} - Nothing
+ */
+declare function NotificationReset(eventType: NotificationEventType): void;
+/**
+ * Clear all raised notifications
+ * @returns {void} - Nothing
+ */
+declare function NotificationResetAll(): void;
+/**
+ * Returns whether popup notifications are permitted
+ * @param {NotificationEventType} eventType - The type of event that occurred
+ * @param {NotificationData} [data={}] - Data relating to the event that can be passed into a popup
+ * @returns {boolean} - Whether popups can appear
+ */
+declare function NotificationPopupsEnabled(eventType: NotificationEventType, data?: NotificationData): boolean;
+/**
+ * Returns the total number of notifications raised for a particular alert type
+ * @param {NotificationAlertType} alertType - The type of alert to check
+ * @returns {number} - The total number of notifications
+ */
+declare function NotificationGetTotalCount(alertType: NotificationAlertType): number;
+/**
+ * Sets or clears the notification number in the document header
+ * @returns {void} - Nothing
+ */
+declare function NotificationTitleUpdate(): void;
+/**
+ * Redraws the icon in the tab/window header to show a red circle with the notification count
+ * @param {boolean} resetingAll - If resetting all notifications, no need to redraw as the total decreases
+ * @returns {void} - Nothing
+ */
+declare function NotificationDrawFavicon(resetingAll: boolean): void;
+/**
+ * An enum for the events in the game that notifications can be raised for
+ * @type {{ CHATMESSAGE: "ChatMessage", CHATJOIN: "ChatJoin", BEEP: "Beep", DISCONNECT: "Disconnect", TEST: "Test", LARP: "Larp" }}
+ */
+declare const NotificationEventType: {
+    CHATMESSAGE: "ChatMessage";
+    CHATJOIN: "ChatJoin";
+    BEEP: "Beep";
+    DISCONNECT: "Disconnect";
+    TEST: "Test";
+    LARP: "Larp";
+};
+/**
+ * An enum for the types of notifications that can be raised
+ * @type {Record<"NONE"|"TITLEPREFIX"|"FAVICON"|"POPUP",NotificationAlertType>}
+ */
+declare const NotificationAlertType: Record<"NONE" | "TITLEPREFIX" | "FAVICON" | "POPUP", NotificationAlertType>;
+/**
+ * An enum for the audio settings for notifications
+ * @type {Record<"NONE"|"FIRST"|"REPEAT", NotificationAudioType>}
+ */
+declare const NotificationAudioType: Record<"NONE" | "FIRST" | "REPEAT", NotificationAudioType>;
+/**
+ * A class to track the state of each notification event type and handle actions based on the player's settings
+ */
+declare class NotificationEventHandler {
+    /**
+     * Creates a new NotificationEventHandler for the specified event type
+     * @param {NotificationEventType} eventType - The
+     * @param {NotificationSetting} settings - The player settings corresponding to the event type
+     */
+    constructor(eventType: NotificationEventType, settings: NotificationSetting);
+    eventType: NotificationEventType;
+    settings: NotificationSetting;
+    raisedCount: number;
+    popup: Notification;
+    /**
+     * Raise a notification
+     * @param {NotificationData} data - Data relating to the event that can be passed into a popup
+     * @returns {void} - Nothing
+     */
+    raise(data: NotificationData): void;
+    /**
+     * Raise a popup notification
+     * @param {NotificationData} data - Data relating to the event passed into the popup
+     * @returns {void} - Nothing
+     */
+    raisePopup(data: NotificationData): void;
+    /**
+     * Determines whether an audio alert shoud be played
+     * @param {boolean} usingPopup - If TRUE this indicates that the audio will be played by a popup, rather than an in-game alert
+     * @returns {boolean} - Whether audio should be played
+     */
+    playAudio(usingPopup: boolean): boolean;
+    /**
+     * Resets all raised notifications for this event
+     * @param {boolean} resetingAll - Indicates if all notifications are being reset, to avoid unnecessarily repeating steps for each event type
+     * @returns {void} - Nothing
+     */
+    reset(resetingAll: boolean): void;
+}
+/** @type {Record<NotificationEventType, NotificationEventHandler>} */
+declare let NotificationEventHandlers: Record<NotificationEventType, NotificationEventHandler>;
+/** @type {NotificationAlertType[]} */
+declare var NotificationAlertTypeList: NotificationAlertType[];
+/** @type {NotificationAudioType[]} */
+declare var NotificationAudioTypeList: NotificationAudioType[];