bc-stubs 96.0.0

package/bc/Screens/Character/Appearance/Appearance.d.ts

@@ -0,0 +1,392 @@
+/**
+ * Builds all the assets that can be used to dress up the character
+ * @param {Character} C - The character whose appearance is modified
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceBuildAssets(C: Character): void;
+/**
+ * Makes sure the character appearance is valid from inventory and asset requirement. This function is called during the login process.
+ * @param {Character} C - The character whose appearance is checked
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceValidate(C: Character): void;
+/**
+ * Resets the character to it's default appearance
+ * @param {Character} C - The character to redress to its default appearance
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceSetDefault(C: Character): void;
+/**
+ * Checks wether an item group is required for this asset
+ * @param {Character} C - The character, whose assets are used for the check
+ * @param {AssetGroupBodyName} GroupName - The name of the group to check
+ * @returns {boolean} - Returns TRUE if the item group is required from
+ */
+declare function CharacterAppearanceRequired(C: Character, GroupName: AssetGroupBodyName): boolean;
+/**
+ * Checks, wether the item group must be hidden for a certain asset
+ * @param {Character} C - The character, whose assets are used for the check
+ * @param {AssetGroupName} GroupName - The name of the group to check
+ * @returns {boolean} - Returns TRUE if the item group must be hidden and not chosen
+ */
+declare function CharacterAppearanceMustHide(C: Character, GroupName: AssetGroupName): boolean;
+/**
+ * Sets a full random set of items for a character. Only items that do not have the "Random" property set to false will be used.
+ * @param {Character} C - The character to dress
+ * @param {boolean} [ClothOnly=false] - Defines, if only clothes should be used
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceFullRandom(C: Character, ClothOnly?: boolean): void;
+/**
+ * Removes all items that can be removed, making the character naked. Checks for a blocking of CosPlayItem removal.
+ * @param {Character} C - The character to undress
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceNaked(C: Character): void;
+/**
+ * Removes one layer of clothing: outer clothes, then underwear, then body-cosplay clothes, then nothing
+ * @param {Character} C - The character to undress
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceStripLayer(C: Character): void;
+/**
+ * Determines whether an asset layer should be rendered, assuming the asset itself is visible.
+ * @param {Character} C - The character wearing the item
+ * @param {AssetLayer} layer - The layer to check visibility for
+ * @param {Asset} asset - The asset that the layer belongs to
+ * @param {string} [type] - The item's type, if it has one
+ * @returns {boolean} - TRUE if the layer should be visible, FALSE otherwise
+ */
+declare function CharacterAppearanceIsLayerVisible(C: Character, layer: AssetLayer, asset: Asset, type?: string): boolean;
+/**
+ * Builds a filtered and sorted set of appearance layers, each representing a drawable layer of a character's current appearance. Layers
+ * that will not be drawn (because their asset is not visible or they do not permit the current asset type) are filtered out at this stage.
+ * @param {Character} C - The character to build the layers for
+ * @return {AssetLayer[]} - A sorted set of layers, sorted by layer drawing priority
+ */
+declare function CharacterAppearanceSortLayers(C: Character): AssetLayer[];
+/**
+ * Determines whether an item or a whole item group is visible or not
+ * @param {Character} C - The character whose assets are checked
+ * @param {string} AssetName - The name of the asset to check
+ * @param {AssetGroupName} GroupName - The name of the item group to check
+ * @param {boolean} Recursive - If TRUE, then other items which are themselves hidden will not hide this item. Parameterising this prevents
+ *     infinite loops.
+ * @returns {boolean} - Returns TRUE if we can show the item or the item group
+ */
+declare function CharacterAppearanceVisible(C: Character, AssetName: string, GroupName: AssetGroupName, Recursive?: boolean): boolean;
+/**
+ * Determines whether the player has set this item to not appear on screen
+ * @param {string} AssetName - The name of the asset to check
+ * @param {AssetGroupName} GroupName - The name of the item group to check
+ * @returns {boolean} - TRUE if the item is hidden
+ */
+declare function CharacterAppearanceItemIsHidden(AssetName: string, GroupName: AssetGroupName): boolean;
+/**
+ * Calculates and sets the height modifier which affects the character's vertical position on screen
+ * @param {Character} C - The character whose height modifier must be calculated
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceSetHeightModifiers(C: Character): void;
+/**
+ * Draws the character canvas
+ * @param {Character} C - The character to draw
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceBuildCanvas(C: Character): void;
+/**
+ * Returns a value from the character current appearance
+ * @param {Character} C - The character to get values from
+ * @param {AssetGroupName} Group - The name of the group, whose values we want to get
+ * @param {string} Type - The name of the value, we want to get
+ * @returns {*} - The return value
+ */
+declare function CharacterAppearanceGetCurrentValue(C: Character, Group: AssetGroupName, Type: string): any;
+/**
+ * Repositions the character horizonally to centre them, since shorter characters will shrink towards the left
+ * @param {Character} C - The character to reposition
+ * @param {number} HeightRatio - The character's height ratio
+ * @returns {number} - The amount to move the character along the X co-ordinate
+ */
+declare function CharacterAppearanceXOffset(C: Character, HeightRatio: number): number;
+/**
+ * Repositions the character vertically towards the bottom of the canvas (the 'floor'), since shorter characters will be shrunk towards the
+ * top HeightRatioProportion controls how much of this offset applies with 1 (max) positioning them on the "floor" and 0 (min) leaving them
+ * up at the 'ceiling'
+ * @param {Character} C - The character to reposition
+ * @param {number} HeightRatio - The character's height ratio
+ * @param {boolean} [IgnoreUpButton=false] - Whether or not to ignore the up button status
+ * @returns {number} - The amounnt to move the character along the Y co-ordinate
+ */
+declare function CharacterAppearanceYOffset(C: Character, HeightRatio: number, IgnoreUpButton?: boolean): number;
+/**
+ * Loads the character appearance screen and keeps a backup of the previous appearance. The function name is created dynamically.
+ * @returns {void} - Nothing
+ */
+declare function AppearanceLoad(): void;
+/**
+ * Build the buttons in the top menu
+ * @param {Character} C - The character the appearance is being set for
+ * @returns {void} - Nothing
+ */
+declare function AppearanceMenuBuild(C: Character): void;
+/**
+ * Checks if the appearance is locked for the current player
+ * @param {Character} C - The character to validate
+ * @param {String} GroupName - The group name to validate, can be "ALL" to check all groups
+ * @returns {boolean} - Return TRUE if the appearance group isn't blocked
+ */
+declare function AppearanceGroupAllowed(C: Character, GroupName: string): boolean;
+/**
+ * Run the character appearance selection screen. The function name is created dynamically.
+ * @returns {void} - Nothing
+ */
+declare function AppearanceRun(): void;
+/**
+ * Calculates the background color of the preview image for and item
+ * @param {Character} C - The character whose appearance we are viewing
+ * @param {DialogInventoryItem} item - The item to calculate the color for
+ * @param {boolean} hover - Whether or not the item is currently hovering over the preview image
+ * @returns {string} - A CSS color string determining the color that the preview icon should be drawn in
+ */
+declare function AppearanceGetPreviewImageColor(C: Character, item: DialogInventoryItem, hover: boolean): string;
+/**
+ * Draw the top-row menu buttons for the appearance screen
+ * @returns {void} - Nothing
+ */
+declare function AppearanceMenuDraw(): void;
+/**
+ * Create a list of characters with different items from the group applied, to use as the preview images
+ * @param {Character} C - The character that the dialog inventory has been loaded for
+ * @param {boolean} buildCanvases - Determines whether the preview canvases need to be (re)built, e.g. for the initial load or due to an appearance change
+ * @returns {void} - Nothing
+ */
+declare function AppearancePreviewBuild(C: Character, buildCanvases: boolean): void;
+/**
+ * Delete all characters created for preview images
+ * @returns {void} - Nothing
+ */
+declare function AppearancePreviewCleanup(): void;
+/**
+ * Returns whether the the 3x3 grid "Cloth" appearance mode should include the character in the preview images
+ * @param {AssetGroup} assetGroup - The group to check
+ * @returns {boolean} - If TRUE the previews will be drawn with the character
+ */
+declare function AppearancePreviewUseCharacter(assetGroup: AssetGroup): boolean;
+/**
+ * Sets an item in the character appearance
+ * @param {Character} C - The character whose appearance should be changed
+ * @param {AssetGroupName} Group - The name of the corresponding groupr for the item
+ * @param {Asset|null} ItemAsset - The asset collection of the item to be changed
+ * @param {string|string[]} [NewColor] - The new color (as "#xxyyzz" hex value) for that item
+ * @param {number} [DifficultyFactor=0] - The difficulty, on top of the base asset difficulty, that should be assigned
+ * to the item
+ * @param {number} [ItemMemberNumber=-1] - The member number of the player adding the item - defaults to -1
+ * @param {boolean} [Refresh=true] - Determines, wether the character should be redrawn after the item change
+ * @returns {null | Item} - Thew newly created item or `null` if the asset does not exist
+ */
+declare function CharacterAppearanceSetItem(C: Character, Group: AssetGroupName, ItemAsset: Asset | null, NewColor?: string | string[], DifficultyFactor?: number, ItemMemberNumber?: number, Refresh?: boolean): null | Item;
+/**
+ * Cycle in the appearance assets to find the next item in a group
+ * @param {Character} C - The character whose assets are used
+ * @param {AssetGroupName} Group - The name of the group to cycle
+ * @param {boolean} [Forward=true] - Sets the direction of the cycling
+ * @returns {Asset|null} - The next item to select, or null if there's none applicable
+ */
+declare function CharacterAppearanceNextItem(C: Character, Group: AssetGroupName, Forward?: boolean): Asset | null;
+/**
+ * Find the next color for the item
+ * @param {Character} C - The character whose items are cycled
+ * @param {AssetGroupName} Group - The name of the group for which we are color cycling
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceNextColor(C: Character, Group: AssetGroupName): void;
+/**
+ * Moves the offset to get new character appearance items
+ * @param {Character} C - The character whose visible groups are used for calculation
+ * @param {number} Move - The amount the next asset group should be moved before it is displayed
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceMoveGroup(C: Character, Move: number): void;
+/**
+ * Sets the color for a specific group
+ * @param {Character} C - The character whose item group should be colored
+ * @param {string} Color - The color (in the format "#rrggbb") to be applied to the group
+ * @param {AssetGroupName} Group - The name of the group, whose color should be changed
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceSetColorForGroup(C: Character, Color: string, Group: AssetGroupName): void;
+/**
+ * Handle the clicks in the character appearance selection screen. The function name is created dynamically.
+ * @returns {void} - Nothing
+ */
+declare function AppearanceClick(): void;
+/**
+ * Handles the Click events for the top-row buttons in the Appearance screen
+ * @param {Character} C - The character the appearance is being set for
+ * @returns {void} - Nothing
+ */
+declare function AppearanceMenuClick(C: Character): void;
+/**
+ * Handle the exiting of the appearance screen. The function name is created dynamically.
+ * @returns {void} - Nothing
+ */
+declare function AppearanceExit(): void;
+/**
+ * Common cleanup that must happen when the appearance editor closes
+ */
+declare function CharacterAppearanceClose(): void;
+/**
+ * Restore the characters appearance backup, if the exit button is clicked
+ * @param {Character} C - The character, whose appearance backup should be used
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceExit(C: Character): void;
+/**
+ * Handle the confirmation click in the wardrobe screen.
+ * @param {Character} C - The character who has been changed
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceReady(C: Character): void;
+/**
+ * Copy the appearance from a character to another
+ * @param {Character} FromC - The character to copy from
+ * @param {Character} ToC - The character to copy to
+ */
+declare function CharacterAppearanceCopy(FromC: Character, ToC: Character): void;
+/**
+ * Loads the appearance editing screen for a character
+ * @param {Character} C - The character for whom the appearance screen should be loaded
+ * @param {(result: boolean) => void} [resultCallback] - A callback executed when the appearance editor closes.
+ *  If not specified, it will change back to the previous screen automatically, otherwise the caller is
+ *  reponsible for screen changes, and `result` will be true if the appearance change was made, false otherwise.
+ * @returns {void} - nothing
+ */
+declare function CharacterAppearanceLoadCharacter(C: Character, resultCallback?: (result: boolean) => void): void;
+/**
+ * Load wardrobe menu in appearance selection screen
+ * @param {Character} C - The character whose wardrobe should be loaded
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceWardrobeLoad(C: Character): void;
+/**
+ * Serialises a character's appearance into an abbreviated string for backup purposes
+ * @param {Character} C - The character whose appearance should be serialised
+ * @returns {string} - A serialised version of the character's current appearance
+ */
+declare function CharacterAppearanceStringify(C: Character): string;
+/**
+ * Serialize items to JSON, breaking the cyclic link between Item, Asset & Group
+ * by serializing that into a single string representing the link.
+ * @param {Item[] | Item | any} Item
+ * @returns {string}
+ */
+declare function AppearanceItemStringify(Item: Item[] | Item | any): string;
+/**
+ * Restores a character's appearance from a serialised string generated by CharacterAppearanceStringify
+ * @param {Character} C - The character whose appearance should be restored
+ * @param {string} backup - The serialised appearance to restore
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceRestore(C: Character, backup: string): void;
+declare function AppearanceItemParse(stringified: any): any;
+/**
+ * Opens the color picker for a selected item
+ * @param {Character} C - The character the appearance is being changed for
+ * @param {Item} Item - The currently selected item
+ * @param {AssetGroupName} AssetGroup - The focused group
+ * @param {"" | "Wardrobe" | "Cloth" | "Color"} CurrentMode - The mode to revert to on exiting the color picker
+ * @returns {void}
+ */
+declare function AppearanceItemColor(C: Character, Item: Item, AssetGroup: AssetGroupName, CurrentMode: "" | "Wardrobe" | "Cloth" | "Color"): void;
+/**
+ * Combine two sets of appearance changes from the same base, favouring the newer changes where conflicting
+ * @param {readonly Item[]} BaseAppearance - The previous appearance before either of the other two sets of changes were made
+ * @param {Item[]} PrevAppearance - The first set of appearance changes
+ * @param {readonly Item[]} NewAppearance - The second set of appearance changes, overriding any conflicts with the first
+ * @returns {Item[]} - The final merged appearance
+ */
+declare function CharacterAppearanceResolveAppearance(BaseAppearance: readonly Item[], PrevAppearance: Item[], NewAppearance: readonly Item[]): Item[];
+/**
+ * Select from two potential changes to an item, preferring the newer if different to the original item
+ * @param {Item} BaseItem - The item before any changes were made
+ * @param {Item} PrevItem - The first item change
+ * @param {Item} NewItem - The second item change
+ * @return {Item} - The item to keep
+ */
+declare function CharacterAppearanceResolveItem(BaseItem: Item, PrevItem: Item, NewItem: Item): Item;
+/**
+ * Merge the incoming appearance changes from the online sync to the currently selected appearance
+ * @param {Character} C - The character with changes to merge
+ * @param {readonly Item[]} currentAppearance - The appearance before the sync's changes are applied
+ * @returns {void} - Nothing
+ */
+declare function CharacterAppearanceResolveSync(C: Character, currentAppearance: readonly Item[]): void;
+/**
+ * Returns whether an asset with a specific gender is allowed in the current chatroom space
+ * @param {Asset} asset
+ */
+declare function CharacterAppearanceGenderAllowed(asset: Asset): boolean;
+declare var AppearanceBackground: string;
+/** Offset for the group view */
+declare var CharacterAppearanceOffset: number;
+/** Number of entries per group page */
+declare var CharacterAppearanceNumGroupPerPage: number;
+/** Number of entries per cloth page */
+declare var CharacterAppearanceNumClothPerPage: number;
+/** Number of entries per wardrobe page */
+declare var CharacterAppearanceWardrobeNumPerPage: number;
+declare var CharacterAppearanceHeaderText: string;
+declare var CharacterAppearanceHeaderTextTime: number;
+/** @type {null | string} */
+declare var CharacterAppearanceBackup: null | string;
+/** @type {null | string} */
+declare var CharacterAppearanceInProgressBackup: null | string;
+/**
+ * The list of all customizable groups
+ * @type {AssetGroup[]}
+ */
+declare var CharacterAppearanceGroups: AssetGroup[];
+/**
+ * The list of all assets (owned or available)
+ *
+ * @type {Asset[]}
+ */
+declare var CharacterAppearanceAssets: Asset[];
+/** @type {AssetGroupName} */
+declare var CharacterAppearanceColorPickerGroupName: AssetGroupName;
+declare var CharacterAppearanceColorPickerBackup: string;
+declare var CharacterAppearanceColorPickerRefreshTimer: any;
+/** @type {Character | null} */
+declare var CharacterAppearanceSelection: Character | null;
+/** @type {(accept: boolean) => void} */
+declare var CharacterAppearanceResultCallback: (accept: boolean) => void;
+declare var CharacterAppearanceReturnRoom: string;
+/** @type {ModuleType} */
+declare var CharacterAppearanceReturnModule: ModuleType;
+declare var CharacterAppearanceWardrobeOffset: number;
+declare var CharacterAppearanceWardrobeText: string;
+declare var CharacterAppearanceWardrobeName: string;
+declare var CharacterAppearanceForceUpCharacter: number;
+/** @type {"" | ExpressionNameMap["Emoticon"]} */
+declare var CharacterAppearancePreviousEmoticon: "" | ExpressionNameMap["Emoticon"];
+/** @type {"" | "Wardrobe" | "Cloth" | "Color"} */
+declare var CharacterAppearanceMode: "" | "Wardrobe" | "Cloth" | "Color";
+/** @type {"" | "Wardrobe" | "Cloth" | "Color"} */
+declare var CharacterAppearanceMenuMode: "" | "Wardrobe" | "Cloth" | "Color";
+/** @type {null | Item} */
+declare var CharacterAppearanceCloth: null | Item;
+/** @type {DialogMenuButton[]} */
+declare var AppearanceMenu: DialogMenuButton[];
+/** @type {Character[]} */
+declare var AppearancePreviews: Character[];
+declare var AppearanceUseCharacterInPreviewsSetting: boolean;
+declare const CanvasUpperOverflow: 700;
+declare const CanvasLowerOverflow: 150;
+declare const CanvasDrawWidth: 500;
+declare const CanvasDrawHeight: number;
+declare namespace AppearancePermissionColors {
+    const red: string[];
+    const amber: string[];
+    const green: string[];
+}

package/bc/Screens/Character/BackgroundSelection/BackgroundSelection.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Change the current screen to the background selection screen
+ * @param {string[]} List - The list of possible Background names
+ * @param {number} Idx - The index of the current background
+ * @param {(selection: string) => void} Callback - The function to call when a new background has been selected
+ * @returns {void} - Nothing
+ */
+declare function BackgroundSelectionMake(List: string[], Idx: number, Callback: (selection: string) => void): void;
+/**
+ * Comapres two backgrounds by their description
+ * @param {object} a - The first object to compare
+ * @param {string} a.Description - The description of object a. Is used for comparision
+ * @param {object} b - The second object to compar
+ * @param {string} b.Description - The description of object b. Is used for comparision
+ * @returns {number} - Returns -1 if the description of object a is less then that of b, 1 otherwise
+ */
+declare function BackGroundSelectionSort(a: {
+    Description: string;
+}, b: {
+    Description: string;
+}): number;
+/**
+ * Initializes the Background selection screen.
+ * Function coiuld be called dynamically, so the body has to be there, even if it does nothing.
+ * @returns {void} - Nothing
+ */
+declare function BackgroundSelectionLoad(): void;
+/**
+ * Handles input in the text box in the topmost row of the selection screen
+ * and changes the offset of the background selection appropriately
+ * @returns {void} - Nothing
+ */
+declare function BackgroundSelectionInputChanged(): void;
+/**
+ * When a new value is selected in the tag selection drop-down, we refresh the displayed background
+ * @returns {void} - Nothing
+ */
+declare function BackgroundSelectionTagChanged(): void;
+/**
+ * Draws the Background selection screen:
+ * - draws all the buttons and the text input field on the topmost rows
+ * - paints the first (max) 12 possible backgrounds in the lower part of the screen
+ * The function is called dynamically
+ * @returns {void} - Nothing
+ */
+declare function BackgroundSelectionRun(): void;
+/**
+ * Handles clicks in the background selection screen:
+ * - Exit: Exit the screen without changes
+ * - Accept: Exit the screen with a new background
+ * - Prev: Paints the previous 12 backgrounds
+ * - Next: Paints the nextt 12 backgrounds
+ * - Click on any background: Sets this background for selection
+ * This function is called dynamically
+ *
+ * @returns {void} - Nothing
+ */
+declare function BackgroundSelectionClick(): void;
+/**
+ * Handles key events in the background selection screen:
+ * - When the user presses "enter", we exit
+ * @returns {void} - Nothing
+ */
+declare function BackgroundSelectionKeyDown(): void;
+/**
+ * Handles the exit of the selection screen. Sets the new background, if necessary, and
+ * calls the previously defined callback function. Then exits the screen to the screen, the player was before
+ * @param {boolean} SetBackground - Defines, wether the background must be changed (true) or not (false)
+ * @returns {void} - Nothing
+ */
+declare function BackgroundSelectionExit(SetBackground: boolean): void;
+declare var BackgroundSelectionBackground: string;
+/** @type {string[]} */
+declare var BackgroundSelectionList: string[];
+/** @type {BackgroundTag[]} */
+declare var BackgroundSelectionTagList: BackgroundTag[];
+declare var BackgroundSelectionIndex: number;
+declare var BackgroundSelectionSelect: string;
+declare var BackgroundSelectionSelectName: string;
+declare var BackgroundSelectionSize: number;
+declare var BackgroundSelectionOffset: number;
+/** @type {null | ((selection: string) => void)} */
+declare var BackgroundSelectionCallback: (selection: string) => void;
+/** @type {"" | ModuleType} */
+declare var BackgroundSelectionPreviousModule: "" | ModuleType;
+declare var BackgroundSelectionPreviousScreen: string;
+/** @type {{ Name: string, Description: string, Low: string }[]} */
+declare var BackgroundSelectionAll: {
+    Name: string;
+    Description: string;
+    Low: string;
+}[];
+/** @type {{ Name: string, Description: string, Low: string }[]} */
+declare var BackgroundSelectionView: {
+    Name: string;
+    Description: string;
+    Low: string;
+}[];

package/bc/Screens/Character/Cheat/Cheat.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Checks if the cheats are valid
+ * @returns {void} - Nothing
+ */
+declare function CheatValidate(): void;
+/**
+ * Checks if the cheat is currently active
+ * @param {string} CheatName - Name of the cheat to check for
+ * @returns {boolean} - Returns TRUE if the cheat is currently active
+ */
+declare function CheatActive(CheatName: string): boolean;
+/**
+ * Gets the factor for a given cheat. The bonus factor is added if active.
+ * @param {string} CheatName - Name of the cheat to check for
+ * @param {number} Factor - Bonus factor on top of the cheat
+ * @returns {number} - The total factor for the given cheat
+ */
+declare function CheatFactor(CheatName: string, Factor: number): number;
+/**
+ * Imports the cheats from local storage (only works before the game is loaded)
+ * @returns {void} - Nothing
+ */
+declare function CheatImport(): void;
+/**
+ * Exports the cheats to local storage. Each one is its own item.
+ * @returns {void} - Nothing
+ */
+declare function CheatExport(): void;
+/**
+ * Runs and draws the cheat screen
+ * @returns {void} - Nothing
+ */
+declare function CheatRun(): void;
+/**
+ * Handles clicks in the cheat screen.
+ * @returns {void} - Nothing
+ */
+declare function CheatClick(): void;
+/**
+ * Handles exiting the cheat screen by saving the cheats and going back to the login screen.
+ * @returns {void} - Nothing
+ */
+declare function CheatExit(): void;
+declare var CheatBackground: string;
+declare var CheatAllow: boolean;
+declare var CheatList: string[];
+declare var CheatBonusList: string[];
+declare var CheatBonusFactor: number;
+declare var CheatBonusTime: number;
+/** @type {string[]} */
+declare var CheatActivated: string[];
+declare var CheatBrowserName: string;
+declare var CheatBrowserVersion: string;
+declare var CheatBrowserTime: number;

package/bc/Screens/Character/Creation/Creation.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Loads the character login screen. Imports data from the Bondage College if necessary
+ * and creates the input fields. This function is called dynamically.
+ * @returns {void} - Nothing
+ */
+declare function CreationLoad(): void;
+/**
+ * Runs the character creation screen. Draws all needed input fields and buttons.
+ * If the import of Bondage College data is possible, an appropriate check box is drawn.
+ * The function is called dynamically.
+ * @returns {void} - Nothing
+ */
+declare function CreationRun(): void;
+/**
+ * Handles the server response to a creation request. Creates the character, if possible,
+ * initializes the basic data and sends the newborn to the maid in the main hall.
+ * @param {object} data - The set of data, received from the server
+ * @param {string} data.ServerAnswer - The outcome of the creation request: should always be "AccountCreated"
+ * @param {string} data.OnlineID - The ID of the newly created account
+ * @param {number} data.MemberNumber - The member number of the newly created account
+ * @returns {void} - Nothing
+ */
+declare function CreationResponse(data: {
+    ServerAnswer: string;
+    OnlineID: string;
+    MemberNumber: number;
+}): void;
+/**
+ * Handles click events in the creation dialog.
+ * Imports data from Bondage College and creates a character.
+ * @returns {void} - Nothing
+ */
+declare function CreationClick(): void;
+/**
+ * Does the cleanup, if the user exits the screen
+ * @returns {void} - Nothing
+ */
+declare function CreationExit(): void;
+declare var CreationBackground: string;
+declare var CreationMessage: string;

package/bc/Screens/Character/Disclaimer/Disclaimer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Loads the disclaimer screen
+ * @returns {void} - Nothing
+ */
+declare function DisclaimerLoad(): void;
+/**
+ * Runs & draws the disclaimer screen
+ * @returns {void} - Nothing
+ */
+declare function DisclaimerRun(): void;
+/**
+ * Handles click events in the disclaimer screen
+ * @returns {void} - Nothing
+ */
+declare function DisclaimerClick(): void;
+/**
+ * Does the cleanup, if the user exits the screen
+ * @returns {void} - Nothing
+ */
+declare function DisclaimerExit(): void;
+declare var DisclaimerBackground: string;