bc-stubs 96.0.0

package/bc/Scripts/ExtendedItem.d.ts

@@ -0,0 +1,339 @@
+/**
+ * @template {any[]} T
+ * @template RT
+ * @param {ExtendedItemData<any>} data
+ * @param {string} name
+ * @param {null | ExtendedItemCallback<T, RT>} originalFunction
+ */
+declare function ExtendedItemCreateCallback<T extends any[], RT>(data: ExtendedItemData<any>, name: string, originalFunction: ExtendedItemCallback<T, RT>): void;
+/**
+ * Construct the extended item's archetypical callbacks and place them in the main namespace.
+ * @template {ExtendedItemOption} T
+ * @param {ExtendedItemData<T>} data - The extended item data
+ * @param {ExtendedItemCallbackStruct<T>} defaults - The default archetypical callbacks
+ */
+declare function ExtendedItemCreateCallbacks<T extends ExtendedItemOption>(data: ExtendedItemData<T>, defaults: ExtendedItemCallbackStruct<T>): void;
+/**
+ * Convert that passed extended item config script hooks into their item data counterpart.
+ * @template {ExtendedItemData<any>} DataType
+ * @template {ExtendedItemOption} OptionType
+ * @param {ExtendedItemCapsScriptHooksStruct<DataType, OptionType>} scriptHooks - The extended item config script hooks
+ * @returns {ExtendedItemScriptHookStruct<DataType, OptionType>} - The extended item data script hooks
+ */
+declare function ExtendedItemParseScriptHooks<DataType extends ExtendedItemData<any>, OptionType extends ExtendedItemOption>(scriptHooks: ExtendedItemCapsScriptHooksStruct<DataType, OptionType>): ExtendedItemScriptHookStruct<DataType, OptionType>;
+/**
+ * Initialize the extended item properties
+ * @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
+ * @returns {boolean} Whether properties were updated or not
+ */
+declare function ExtendedItemInit(C: Character, Item: Item, Refresh?: boolean): boolean;
+/**
+ * Helper init function for extended items without an archetype.
+ * Note that on the long term this function should ideally be removed in favor of adding appropriate archetypes.
+ * @param {Item} Item - The item in question
+ * @param {Character} C - The character that has the item equiped
+ * @param {ItemProperties} Properties - A record that maps property keys to their default value.
+ *        The type of each value is used for basic validation.
+ * @param {boolean} Refresh - Whether the character and relevant item should be refreshed
+ * @returns {boolean} Whether properties were updated or not
+ */
+declare function ExtendedItemInitNoArch(C: Character, Item: Item, Properties: ItemProperties, Refresh?: boolean): boolean;
+/**
+ * Loads the item's extended item menu
+ * @param {ExtendedItemData<any>} data
+ * @returns {void} Nothing
+ */
+declare function ExtendedItemLoad({ functionPrefix, dialogPrefix, parentOption }: ExtendedItemData<any>): void;
+/**
+ * Draw a single button in the extended item type selection screen.
+ * @param {ExtendedItemOption | ModularItemModule} Option - The new extended item option
+ * @param {ExtendedItemOption} CurrentOption - The current extended item option
+ * @param {ElementData<ElementMetaData>} buttonData - The X coordinate of the button
+ * @param {string} DialogPrefix - The prefix to the dialog keys for the display strings describing each extended type.
+ *     The full dialog key will be <Prefix><Option.Name>
+ * @param {Item} Item - The item in question; defaults to {@link DialogFocusItem}
+ * @param {boolean | null} IsSelected - Whether the button is already selected or not. If `null` compute this value by checking if the item's current type matches `Option`.
+ * @see {@link TypedItemDraw}
+ */
+declare function ExtendedItemDrawButton(Option: ExtendedItemOption | ModularItemModule, CurrentOption: ExtendedItemOption, DialogPrefix: string, buttonData: ElementData<ElementMetaData>, Item?: Item, IsSelected?: boolean | null): void;
+/**
+ * Determine the background color for the item option's button
+ * @param {Character} C - The character wearing the item
+ * @param {ExtendedItemOption | ModularItemModule} Option - A type for the extended item
+ * @param {ExtendedItemOption} CurrentOption - The currently selected option for the item
+ * @param {boolean} Hover - TRUE if the mouse cursor is on the button
+ * @param {boolean} IsSelected - TRUE if the item's current type matches Option
+ * @param {Item} Item - The item in question; defaults to {@link DialogFocusItem}
+ * @returns {string} The name or hex code of the color
+ */
+declare function ExtendedItemGetButtonColor(C: Character, Option: ExtendedItemOption | ModularItemModule, CurrentOption: ExtendedItemOption, Hover: boolean, IsSelected: boolean, Item?: Item): string;
+/**
+ * Exit function for the extended item dialog.
+ *
+ * This function will check if there's an extended subscreen and unload it to move back
+ * to the main extended subscreen, or unload the whole extended subscreen and unfocus the item.
+ *
+ * It will cleanup the shared state from extended screens appropriately, call their unload (Exit)
+ * callback, and set either {@link DialogFocusItem} or {@link ExtendedItemSubscreen} back to `null`.
+ *
+ * Note that you shouldn't need to call this function directly. The correct way to "exit" from an
+ * extended item is to call {@link DialogLeaveFocusItem}, which will call this and refresh the dialog
+ * UI.
+ * @returns {void} - Nothing
+ */
+declare function ExtendedItemExit(): void;
+/**
+ * Sets a typed item's type and properties to the option provided.
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose type to set
+ * @param {ItemProperties} previousProperty - The typed item options for the item
+ * @param {ItemProperties} newProperty - 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.
+ * @returns {void} Nothing
+ */
+declare function ExtendedItemSetProperty(C: Character, item: Item, previousProperty: ItemProperties, newProperty: ItemProperties, push?: boolean): void;
+/**
+ * Checks whether the character meets the requirements for an extended type option. This will check against their Bondage
+ * skill if applying the item to another character, or their Self Bondage skill if applying the item to themselves.
+ * @template {ExtendedItemOption} T
+ * @param {null | ExtendedItemData<T>} data
+ * @param {Character} C - The character in question
+ * @param {Item} item - The item in question
+ * @param {T} Option - The selected type definition
+ * @param {T} CurrentOption - The current type definition
+ * @param {boolean} permitExisting - Determines whether the validation should allow the new option and previous option
+ * to be identical. Defaults to false.
+ * @returns {string|null} null if the player meets the option requirements. Otherwise a string message informing them
+ * of the requirements they do not meet
+ */
+declare function ExtendedItemRequirementCheckMessage<T extends ExtendedItemOption>(data: ExtendedItemData<T>, C: Character, item: Item, Option: T, CurrentOption: T, permitExisting?: boolean): string | null;
+/**
+ * Checks whether the player is able to select an option based on it's self-selection criteria (whether or not the
+ * wearer may select the option)
+ * @param {Character} C - The character on whom the bondage is applied
+ * @param {ExtendedItemOption} Option - The option whose requirements should be checked against
+ * @returns {string | undefined} - undefined if the
+ */
+declare function ExtendedItemCheckSelfSelect(C: Character, Option: ExtendedItemOption): string | undefined;
+/**
+ * Checks whether the player meets an option's self-bondage/bondage skill level requirements
+ * @param {Character} C - The character on whom the bondage is applied
+ * @param {Item} Item - The item whose options are being checked
+ * @param {ExtendedItemOption} Option - The option whose requirements should be checked against
+ * @returns {string|undefined} - undefined if the player meets the option's skill level requirements. Otherwise returns
+ * a string message informing them of the requirements they do not meet.
+ */
+declare function ExtendedItemCheckSkillRequirements(C: Character, Item: Item, Option: ExtendedItemOption): string | undefined;
+/**
+ * Checks whether the character meets an option's required bought items
+ * @param {ExtendedItemOption} Option - The option being checked
+ * @returns {string|undefined} undefined if the requirement is met, otherwise the error message
+ */
+declare function ExtendedItemCheckBuyGroups(Option: ExtendedItemOption): string | undefined;
+/**
+ * Checks whether a change from the given current option to the newly selected option is valid.
+ * @template {ExtendedItemOption} T
+ * @param {null | ExtendedItemData<T>} data - The extended item data
+ * @param {Character} C - The character wearing the item
+ * @param {Item} Item - The extended item to validate
+ * @param {T} newOption - The selected option
+ * @param {T} previousOption - The currently applied option on the item
+ * @param {boolean} [permitExisting] - Determines whether the validation should allow the new option and previous option
+ * to be identical. Defaults to false.
+ * @returns {string} - Returns a non-empty message string if the item failed validation, or an empty string otherwise
+ */
+declare function ExtendedItemValidate<T extends ExtendedItemOption>(data: ExtendedItemData<T>, C: Character, Item: Item, newOption: T, previousOption: T, permitExisting?: boolean): string;
+/**
+ * Simple getter for the function prefix used for the passed extended item - used for calling standard
+ * extended item functions (e.g. if the currently focused it is the hemp rope arm restraint, this will return
+ * "InventoryItemArmsHempRope", allowing functions like InventoryItemArmsHempRopeLoad to be called)
+ * @param {Item} Item - The extended item in question; defaults to {@link DialogFocusItem}
+ * @returns {string} The extended item function prefix for the currently focused item
+ */
+declare function ExtendedItemFunctionPrefix(Item?: Item): string;
+/**
+ * Simple getter for the key of the currently focused extended item in the ExtendedItemOffsets lookup
+ * @returns {string} The offset lookup key for the currently focused extended item
+ */
+declare function ExtendedItemOffsetKey(): string;
+/**
+ * Gets the pagination offset of the currently focused extended item
+ * @returns {number} The pagination offset for the currently focused extended item
+ */
+declare function ExtendedItemGetOffset(): number;
+/**
+ * Sets the pagination offset for the currently focused extended item
+ * @param {number} Offset - The new offset to set
+ * @returns {void} Nothing
+ */
+declare function ExtendedItemSetOffset(Offset: number): void;
+/**
+ * Maps a chat tag to a dictionary entry for use in item chatroom messages.
+ * @param {DictionaryBuilder} dictionary - The to-be updated dictionary builder
+ * @param {Character} C - The target character
+ * @param {Item} item - The typed item
+ * @param {CommonChatTags} tag - The tag to map to a dictionary entry
+ * @returns {DictionaryBuilder} - The originally passed dictionary builder, modified inplace
+ */
+declare function ExtendedItemMapChatTagToDictionaryEntry(dictionary: DictionaryBuilder, C: Character, { Asset, Craft }: Item, tag: CommonChatTags): DictionaryBuilder;
+/**
+ * Construct an array of inventory icons for a given asset and type
+ * @param {Character} C - The target character
+ * @param {Asset} Asset - The asset for the typed item
+ * @param {string | null} Type - The type of the asse
+ * @param {readonly EffectName[]} [Effects]
+ * @returns {InventoryIcon[]} - The inventory icons
+ */
+declare function ExtendItemGetIcons(C: Character, Asset: Asset, Type?: string | null, Effects?: readonly EffectName[]): InventoryIcon[];
+/**
+ * Creates an asset's extended item NPC dialog function
+ * @param {Asset} Asset - The asset for the typed item
+ * @param {string} FunctionPrefix - The prefix of the new `NpcDialog` function
+ * @param {string | ExtendedItemNPCCallback<ExtendedItemOption>} NpcPrefix - A dialog prefix or a function for creating one
+ * @returns {void} - Nothing
+ */
+declare function ExtendedItemCreateNpcDialogFunction(Asset: Asset, FunctionPrefix: string, NpcPrefix: string | ExtendedItemNPCCallback<ExtendedItemOption>): void;
+/**
+ * Helper click function for creating custom buttons, including extended item permission support.
+ * @param {string} Name - The name of the button and its pseudo-type
+ * @param {number} X - The X coordinate of the button
+ * @param {number} Y - The Y coordinate of the button
+ * @param {string | null} imagePath — The pa
+ * @param {boolean} IsSelected - Whether the button is selected or not
+ * @returns {void} Nothing
+ */
+declare function ExtendedItemCustomDraw(Name: string, X: number, Y: number, imagePath?: string | null, IsSelected?: boolean): void;
+/**
+ * Helper click function for creating custom buttons, including extended item permission support.
+ * @param {string} Name - The name of the button and its pseudo-type
+ * @param {() => void} Callback - A callback to be executed whenever the button is clicked and all requirements are met
+ * @param {boolean} Worn - `true` if the player is changing permissions for an item they're wearing
+ * @returns {boolean} `false` if the item's requirement check failed and `true` otherwise
+ */
+declare function ExtendedItemCustomClick(Name: string, Callback: () => void, Worn?: boolean): boolean;
+/**
+ * Helper publish + exit function for creating custom buttons whose clicks exit the dialog menu.
+ *
+ * If exiting the dialog menu is undesirable then something akin to the following example should be used instead:
+ * @example
+ * if (ServerPlayerIsInChatRoom()) {
+ *     ChatRoomPublishCustomAction(Name, false, Dictionary);
+ * }
+ * @param {string} Name - Tag of the action to send
+ * @param {ChatMessageDictionary | null} Dictionary - Dictionary of tags and data to send to the room (if any).
+ * @returns {void} Nothing
+ */
+declare function ExtendedItemCustomExit(Name: string, Dictionary?: ChatMessageDictionary | null): void;
+/**
+ * Common draw function for drawing the header of the extended item menu screen.
+ * Automatically applies any Locked and/or Vibrating options to the preview.
+ * @param {number} X - Position of the preview box on the X axis
+ * @param {number} Y - Position of the preview box on the Y axis
+ * @param {Item} Item - The item for whom the preview box should be drawn
+ * @returns {void} Nothing
+ */
+declare function ExtendedItemDrawHeader(X?: number, Y?: number, Item?: Item): void;
+/**
+ * Extract the passed item's data from one of the extended item lookup tables
+ * @template {ExtendedArchetype} Archetype
+ * @param {Asset} asset - The item whose data should be extracted
+ * @param {Archetype} Archetype - The archetype corresponding to the lookup table
+ * @param {string} Type - The item's type. Only relevant in the case of {@link VariableHeightData}
+ * @returns {null | ExtendedDataLookupStruct[Archetype]} The item's data or `null` if the lookup failed
+ */
+declare function ExtendedItemGetData<Archetype extends ExtendedArchetype>(asset: Asset, Archetype: Archetype, Type?: string): ExtendedDataLookupStruct[Archetype];
+/**
+ * Constructs the chat message dictionary for the extended item based on the items configuration data.
+ * @template {ExtendedItemOption} OptionType
+ * @param {ExtendedItemChatData<OptionType>} chatData - The chat data that triggered the message.
+ * @param {ExtendedItemData<OptionType>} data - The extended item data for the asset
+ * @param {Item} item
+ * @returns {DictionaryBuilder} - The dictionary for the item based on its required chat tags
+ */
+declare function ExtendedItemBuildChatMessageDictionary<OptionType extends ExtendedItemOption>(chatData: ExtendedItemChatData<OptionType>, { chatTags, dictionary }: ExtendedItemData<OptionType>, item: Item): DictionaryBuilder;
+/**
+ * Return {@link ExtendedItemDialog.chat} if it's a string or call it using chat data based on a fictional extended item option.
+ * Generally used for getting a chat prefix for extended item buttons with custom functionality.
+ * @param {string} Name - The name of the pseudo-type
+ * @param {ExtendedItemData} Data - The extended item data
+ * @returns {string} The dialogue prefix for the custom chatroom messages
+ */
+declare function ExtendedItemCustomChatPrefix(Name: string, Data: ExtendedItemData<any>): string;
+/**
+ * Gather and return all subscreen properties of the passed option.
+ * @param {Item} item - The item in question
+ * @param {ExtendedItemOption} option - The extended item option
+ * @returns {ItemProperties} - The item properties of the option's subscreen (if any)
+ */
+declare function ExtendedItemGatherSubscreenProperty(item: Item, option: ExtendedItemOption): ItemProperties;
+/**
+ * Sets an extended item's type and properties to the option provided.
+ * @template {ModularItemOption | TypedItemOption | VibratingItemOption} OptionType
+ * @param {ModularItemData | TypedItemData | VibratingItemData} data - The extended item data
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose type to set
+ * @param {OptionType} newOption - The to-be applied extended item option
+ * @param {OptionType} previousOption - The previously applied extended item option
+ * @param {boolean} [push] - Whether or not appearance updates should be persisted (only applies if the character is the
+ * player) - defaults to false.
+ */
+declare function ExtendedItemSetOption<OptionType extends TypedItemOption | ModularItemOption | VibratingItemOption>(data: ModularItemData | TypedItemData | VibratingItemData, C: Character, item: Item, newOption: OptionType, previousOption: OptionType, push?: boolean): void;
+/** A temporary hack for registering extra archetypes for a single screen. */
+declare function ExtendedItemManualRegister(): void;
+/**
+ * Parse the passed draw data as passed via the extended item config
+ * @template {ElementMetaData} MetaData
+ * @param {ExtendedItemConfigDrawData<Partial<MetaData>> | undefined} drawData - The to-be parsed draw data
+ * @param {Pick<ExtendedItemDrawData<MetaData>, "elementData" | "itemsPerPage">} defaults - The default draw data
+ * @return {ExtendedItemDrawData<MetaData>} - The parsed draw data
+ */
+declare function ExtendedItemGetDrawData<MetaData extends ElementMetaData>(drawData: ExtendedItemConfigDrawData<Partial<MetaData>>, defaults: Pick<ExtendedItemDrawData<MetaData>, "elementData" | "itemsPerPage">): ExtendedItemDrawData<MetaData>;
+/**
+ * Utility file for handling extended items
+ */
+/**
+ * A lookup for the current pagination offset for all extended item options. Offsets are only recorded if the extended
+ * item requires pagination. Example format:
+ * ```json
+ * {
+ *     "ItemArms/HempRope": 4,
+ *     "ItemArms/Web": 0
+ * }
+ * ```
+ * @type {Record<string, number>}
+ * @constant
+ */
+declare var ExtendedItemOffsets: Record<string, number>;
+/**
+ * The X & Y co-ordinates of each option's button, based on the number to be displayed per page.
+ * @type {[number, number][][]}
+ */
+declare const ExtendedXY: [number, number][][];
+/**
+ * The X & Y co-ordinates of each option's button, based on the number to be displayed per page.
+ * @type {[number, number][][]}
+ */
+declare const ExtendedXYWithoutImages: [number, number][][];
+/**
+ * The X & Y co-ordinates of each option's button, based on the number to be displayed per page.
+ * @type {[number, number][][]}
+ */
+declare const ExtendedXYClothes: [number, number][][];
+/** Memoization of the requirements check */
+declare const ExtendedItemRequirementCheckMessageMemo: MemoizedFunction<typeof ExtendedItemRequirementCheckMessage>;
+/**
+ * The current display mode
+ * @type {boolean}
+ */
+declare var ExtendedItemPermissionMode: boolean;
+/**
+ * Tracks whether a selected option's subscreen is active - if active, the value is the name of the current subscreen's
+ * corresponding option
+ * @type {string|null}
+ */
+declare var ExtendedItemSubscreen: string | null;
+/** @type {(item: Item) => ExtendedItemOption[]} */
+declare function ExtendedItemGatherOptions(item: Item): ExtendedItemOption[];

package/bc/Scripts/GLDraw.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Setup WebGL rendering
+ *
+ * This will create a drawing canvas and try to initialize it for GL rendering.
+ * In case of failure, or if the fallback is required, it will disable GL
+ * rendering entirely, switching back to the normal canvas-based rendering
+ * (see Drawing.js).
+ *
+ * @param {Event} _evt - Unused DOM event
+ * @param {boolean} [force2d] - Whether to force a fallback to 2d mode
+ * @returns {void} - Nothing
+ */
+declare function GLDrawLoad(_evt: Event, force2d?: boolean): void;
+/**
+ * Loads the graphical options from localSstorage.
+ * @returns {WebGLContextAttributes} - WebGL context attributes based on saved settings
+ */
+declare function GLDrawGetOptions(): WebGLContextAttributes;
+/**
+ * Saves the graphical options in localStorage.
+ * @param {WebGLContextAttributes} options - WebGL context attributes based on saved settings
+ */
+declare function GLDrawSetOptions(options: WebGLContextAttributes): void;
+/**
+ * Handler for WebGL context lost events
+ * @param {WebGLContextEvent} event
+ * @returns {void} - Nothing
+ */
+declare function GLDrawOnContextLost(event: WebGLContextEvent): void;
+/**
+ * Disables GLDraw rendering, and cleans up any resources.
+ * @returns {void} - Nothing
+ */
+declare function GLDrawRevertToCanvas2D(): void;
+/**
+ * Handler for WebGL context restored events
+ * @returns {void} - Nothing
+ */
+declare function GLDrawOnContextRestored(): void;
+/**
+ * Resets the GLDraw renderer
+ *
+ * This function removes the current canvas, removes cached textures from the
+ * image cache, and reloads a fresh canvas unless prevented.
+ * @returns {void} - Nothing
+ */
+declare function GLDrawResetCanvas(force2d?: boolean): void;
+/**
+ * Rebuilds the canvas for any characters that are currently on screen.
+ * @returns {void} - Nothing
+ */
+declare function GLDrawRebuildCharacters(): void;
+/**
+ * Makes all programs and shaders on the GL context
+ * @param {WebGL2RenderingContext} gl - The WebGL context of the canvas
+ * @returns {void} - Nothing
+ */
+declare function GLDrawMakeGLProgram(gl: WebGL2RenderingContext): void;
+/**
+ * Creates a shader for the current WebGL context from a given source
+ * @param {WebGL2RenderingContext} gl - WebGL context
+ * @param {string} source - Source of the shader to create
+ * @param {GLenum} type - The type of the shader to create
+ * @returns {WebGLShader} - The created WebGL shader
+ */
+declare function GLDrawCreateShader(gl: WebGL2RenderingContext, source: string, type: GLenum): WebGLShader;
+/**
+ * Creates the WebGL program from the vertex and fragment shaders
+ * @param {WebGL2RenderingContext} gl - WebGL context
+ * @param {WebGLShader} vertexShader - The vertex shader to create the program with
+ * @param {WebGLShader} fragmentShader - The fragment shader to create the program with
+ * @returns {WebGLProgram} - The created WebGL program
+ */
+declare function GLDrawCreateProgram(gl: WebGL2RenderingContext, vertexShader: WebGLShader, fragmentShader: WebGLShader): WebGLProgram;
+/**
+ * Draws an image from a given url to a WebGLRenderingContext
+ * @param {string} url - URL of the image to render
+ * @param {WebGL2RenderingContext} gl - WebGL context
+ * @param {number} dstX - Position of the image on the X axis
+ * @param {number} dstY - Position of the image on the Y axis
+ * @param {number} offsetX - Additional offset to add to the X axis (for blinking)
+ * @param {string} color - Color of the image to draw
+ * @param {boolean} fullAlpha - Whether or not the full alpha should be rendered
+ * @param {RectTuple[]} alphaMasks - A list of alpha masks to apply to the asset
+ * @param {number} [opacity=1] - The opacity at which to draw the image
+ * @param {boolean} [rotate=false] - If the image should be rotated by 180 degrees
+ * @param {GlobalCompositeOperation} [blendingMode="source-over"] - blending mode for drawing the image
+ * @returns {void} - Nothing
+ */
+declare function GLDrawImage(url: string, gl: WebGL2RenderingContext, dstX: number, dstY: number, offsetX: number, color: string, fullAlpha: boolean, alphaMasks: RectTuple[], opacity?: number, rotate?: boolean, blendingMode?: GlobalCompositeOperation): void;
+/**
+ * Chooses right program using input parameters
+ * @param {WebGL2RenderingContext} gl - WebGL context
+ * @param {string} color - Color of the image to draw
+ * @param {boolean} fullAlpha - Whether or not the full alpha should be rendered
+ * @param {GlobalCompositeOperation} blendingMode - blending mode for drawing the image
+ * @returns {WebGLProgram} - The chosen WebGL program
+ */
+declare function GLChooseProgram(gl: WebGL2RenderingContext, color: string, fullAlpha: boolean, blendingMode: GlobalCompositeOperation): WebGLProgram;
+/**
+ * Draws a canvas on the WebGL canvas
+ * @param {WebGL2RenderingContext} gl - WebGL context
+ * @param {HTMLImageElement | HTMLCanvasElement} Img - Canvas to get the data of
+ * @param {number} X - Position of the image on the X axis
+ * @param {number} Y - Position of the image on the Y axis
+ * @param {number} blinkOffset - Offset for the blink canvas
+ * @param {RectTuple[]} alphaMasks - A list of alpha masks to apply to the asset
+ */
+declare function GLDraw2DCanvas(gl: WebGL2RenderingContext, Img: HTMLImageElement | HTMLCanvasElement, X: number, Y: number, blinkOffset: number, alphaMasks: RectTuple[]): void;
+/**
+ * Sets texture info from image data
+ * @param {WebGLRenderingContext} gl - WebGL context
+ * @param {HTMLImageElement} Img - Image to get the data of
+ * @param {{ width: number; height: number; texture: WebGLTexture; }} textureInfo - Texture information
+ * @returns {void} - Nothing
+ */
+declare function GLDrawBingImageToTextureInfo(gl: WebGLRenderingContext, Img: HTMLImageElement, textureInfo: {
+    width: number;
+    height: number;
+    texture: WebGLTexture;
+}): void;
+/**
+ * Loads image texture data
+ * @param {WebGL2RenderingContext} gl - WebGL context
+ * @param {string} url - URL of the image
+ * @returns {{ width: number; height: number; texture: WebGLTexture; }} - The texture info of a given image
+ */
+declare function GLDrawLoadImage(gl: WebGL2RenderingContext, url: string): {
+    width: number;
+    height: number;
+    texture: WebGLTexture;
+};
+/**
+ * Loads alpha mask data
+ * @param {WebGL2RenderingContext} gl - The WebGL context
+ * @param {number} texWidth - The width of the texture to mask
+ * @param {number} texHeight - The height of the texture to mask
+ * @param {number} offsetX - The X offset at which the texture is to be drawn on the target canvas
+ * @param {number} offsetY - The Y offset at which the texture is to be drawn on the target canvas
+ * @param {RectTuple[]} alphaMasks - A list of alpha masks to apply to the asset
+ * @return {WebGLTexture} - The WebGL texture corresponding to the mask
+ */
+declare function GLDrawLoadMask(gl: WebGL2RenderingContext, texWidth: number, texHeight: number, offsetX: number, offsetY: number, alphaMasks: RectTuple[]): WebGLTexture;
+/**
+ * Clears a rectangle on WebGLRenderingContext
+ * @param {WebGLRenderingContext} gl - WebGL context
+ * @param {number} x - Position of the image on the X axis
+ * @param {number} y - Position of the image on the Y axis
+ * @param {number} width - Width of the rectangle to clear
+ * @param {number} height - Height of the rectangle to clear
+ * @param {number} blinkOffset - Offset in case of a blink draw
+ * @returns {void} - Nothing
+ */
+declare function GLDrawClearRect(gl: WebGLRenderingContext, x: number, y: number, width: number, height: number, blinkOffset: number): void;
+/**
+ * Converts a hex color to a RGBA color
+ * @param {string} color - Hex color code to convert to RGBA
+ * @param {number} alpha - The alpha value to use for the resulting RGBA
+ * @return {number[]} - Converted color code
+ */
+declare function GLDrawHexToRGBA(color: string, alpha?: number): number[];
+/**
+ * Creates the given character canvas with WebGL
+ * @param {Character} C - Character to build the canvas for
+ * @returns {void} - Nothing
+ */
+declare function GLDrawAppearanceBuild(C: Character): void;
+/** @type {Map<string, HTMLImageElement>} */
+declare var GLDrawImageCache: Map<string, HTMLImageElement>;
+declare var GLDrawCacheLoadedImages: number;
+declare var GLDrawCacheTotalImages: number;
+/** @type {"webgl2"|"webgl"|"No WebGL"} */
+declare var GLVersion: "webgl2" | "webgl" | "No WebGL";
+/** @type {HTMLCanvasElement} */
+declare var GLDrawCanvas: HTMLCanvasElement;
+/**
+ * How many seconds to wait before forcefully resetting the canvas after a
+ * context loss
+ */
+declare const GLDrawContextResetSeconds: 10;
+/**
+ * The cooldown in seconds after resetting the canvas. If another context loss
+ * happens in this cooldown, we'll revert to canvas2d rendering
+ */
+declare const GLDrawRevertToDraw2DSeconds: 50;
+/** @type {ReturnType<typeof setTimeout>} */
+declare let GLDrawContextLostTimeout: ReturnType<typeof setTimeout>;
+declare let GLDrawRecoveryMode: boolean;
+/** @type {ReturnType<typeof setTimeout>} */
+declare let GLDrawCrashTimeout: ReturnType<typeof setTimeout>;
+declare var GLDrawAlphaThreshold: number;
+declare var GLDrawHalfAlphaLow: number;
+declare var GLDrawHalfAlphaHigh: number;
+/**
+ * Source used for the Vertex Shader
+ * @constant
+ * @type {string}
+ */
+declare var GLDrawVertexShaderSource: string;
+/**
+ * Source used for the Fragment Shader
+ * @constant
+ * @type {string}
+ */
+declare var GLDrawFragmentShaderSource: string;
+/**
+ * Source used for the Texture Mask Fragment Shader
+ * @constant
+ * @type {string}
+ */
+declare var GLDrawFragmentShaderSourceTexMask: string;
+/**
+ * Source used for the Full Alpha Shader
+ * @constant
+ * @type {string}
+ */
+declare var GLDrawFragmentShaderSourceFullAlpha: string;
+/**
+ * Source used for the Half Alpha Shader
+ * @constant
+ * @type {string}
+ */
+declare var GLDrawFragmentShaderSourceHalfAlpha: string;

package/bc/Scripts/Game.d.ts

@@ -0,0 +1,61 @@
+declare function GameStart(): void;
+/**
+ * Main game running state, runs the drawing
+ * @param {number} Timestamp
+ */
+declare function GameRun(Timestamp: number): void;
+/**
+ * When the user presses a key, we send the KeyDown event to the current screen if it can accept it
+ * @param {KeyboardEvent} event
+ */
+declare function GameKeyDown(event: KeyboardEvent): void;
+/**
+ * Handler for document-wide keydown event
+ * @param {KeyboardEvent} event
+ */
+declare function DocumentKeyDown(event: KeyboardEvent): void;
+/**
+ * When mouse move, we keep the mouse position for other scripts
+ * @param {MouseEvent} event
+ */
+declare function MouseMove(event: MouseEvent): void;
+/**
+ * When the user clicks, we fire the click event for other screens
+ * @param {MouseEvent} event
+ */
+declare function MouseClick(event: MouseEvent): void;
+/**
+ * When the user touches the screen (mobile only), we fire the click event for other screens
+ * @param {TouchEvent} event
+ */
+declare function TouchStart(event: TouchEvent): void;
+/**
+ * When the user touches the screen (mobile only), we fire the click event for other screens
+ * @param {TouchEvent} event
+ */
+declare function TouchEnd(event: TouchEvent): void;
+/**
+ * When touch moves, we keep it's position for other scripts
+ * @param {TouchEvent} event
+ */
+declare function TouchMove(event: TouchEvent): void;
+/**
+ * When the mouse is away from the control, we stop keeping the coordinates,
+ * we also check for false positives with "relatedTarget"
+ * @param {MouseEvent} event
+ */
+declare function MouseLeave(event: MouseEvent): void;
+/** @deprecated */
+declare function KeyDown(event: any): void;
+/** @deprecated */
+declare function MainRun(Timestamp: any): void;
+/** @deprecated */
+declare function Click(event: any): void;
+/** @deprecated */
+declare function LoseFocus(event: any): void;
+/** BC's version */
+declare var GameVersion: string;
+declare const GameVersionFormat: RegExp;
+declare var CommonVersionUpdated: boolean;
+/** @type {TouchList | null} */
+declare var CommonTouchList: TouchList | null;