@wayward/types 2.10.9-beta.dev.20211009.1 → 2.11.0-beta.dev.20211123.4

package/definitions/game/game/milestones/MilestoneDefinition.d.ts

@@ -0,0 +1,52 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import { MilestoneDataType, MilestoneVisibility } from "game/milestones/IMilestone";
+import { GameMode } from "game/options/IGameOptions";
+export default class MilestoneDefinition {
+    dataType: MilestoneDataType;
+    amount: number;
+    /**
+     * This milestone is a milestone that will be granted the first time it's updated.
+     * Can be used for keeping track of metagame progress.
+     */
+    static event(): MilestoneDefinition;
+    /**
+     * This milestone will be granted when an `amount` of conditions happen simultaneously.
+     * For example, this could be used to check for a skill level.
+     */
+    static check(amount: number): MilestoneDefinition;
+    /**
+     * This milestone will be granted after being incremented `amount` times.
+     * It does not require each increment to have a different ID, like `counter` does.
+     * For example, this type could be used for "number of turns played".
+     */
+    static increment(amount: number): MilestoneDefinition;
+    /**
+     * This milestone type requires a number of entries, each of which must be distinct.
+     * For example, this could be used to check if the player has tamed every single creature type.
+     */
+    static counter(amount: number): MilestoneDefinition;
+    private constructor();
+    visibility: MilestoneVisibility;
+    /**
+     * @param visibility Whether the milestone is completely visible, has its name hidden, or has its required amt hidden. Defaults to `Visible`
+     */
+    setVisibility(visibility: MilestoneVisibility): this;
+    gameModeLock?: GameMode[];
+    /**
+     * @param gameModes What game modes this milestone can be unlocked in. Defaults to `[Hardcore]`
+     */
+    setGameModes(...gameModes: GameMode[]): this;
+    disabledByMods: boolean;
+    setNotDisabledByMods(): this;
+    unlockedHandler?: (tellPlayer: () => void) => any;
+    onUnlocked(handler: (tellPlayer: () => void) => any): this;
+}

package/definitions/game/game/milestones/MilestoneManager.d.ts

@@ -0,0 +1,53 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import EventEmitter from "event/EventEmitter";
+import { Milestone, MilestoneVisibility } from "game/milestones/IMilestone";
+declare type IMilestoneUpdate = [Milestone, number?];
+export interface IMilestoneEvents {
+    /**
+     * @param milestone The milestone that is being updated
+     * @param value The new value for this milestone
+     * @param max The max value for this milestone
+     */
+    update(milestone: Milestone, value: number, max: number): void;
+}
+declare class MilestonesManager extends EventEmitter.Host<IMilestoneEvents> {
+    readonly descriptions: Descriptions<Milestone, import("./MilestoneDefinition").default>;
+    private readonly milestoneUpdates;
+    /**
+     * Get whether the given milestone is completed or not.
+     */
+    isComplete(milestone: Milestone): boolean;
+    /**
+     * Get the current amount for the given milestone.
+     */
+    getCurrentAmount(milestone: Milestone): number;
+    /**
+     * Get the designed amount for the given milestone
+     */
+    getDesiredAmount(milestone: Milestone): number;
+    /**
+     * Get a `Stream` of all completed milestones
+     */
+    getCompleted(): Milestone[];
+    add(...updates: IMilestoneUpdate[]): void;
+    update(): void;
+    areUnlockable(mode?: import("../options/IGameOptions").GameMode): boolean;
+    areUnlockableInMode(mode?: import("../options/IGameOptions").GameMode): boolean;
+    isUnlockableInMode(milestone: Milestone, mode?: import("../options/IGameOptions").GameMode): boolean;
+    reset(): void;
+    getDiscovered(milestone: Milestone): number[] | undefined;
+    getVisibility(milestone: Milestone): MilestoneVisibility;
+    isDiscovered(milestone: Milestone, data: number): boolean;
+    private updateMilestone;
+}
+declare const _default: MilestonesManager;
+export default _default;

package/definitions/game/game/milestones/Milestones.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import { Milestone } from "game/milestones/IMilestone";
+import MilestoneDefinition from "game/milestones/MilestoneDefinition";
+import Dictionary from "language/Dictionary";
+export declare const milestoneDescriptions: Descriptions<Milestone, MilestoneDefinition>;
+export declare const milestoneDictionaries: Partial<Record<Milestone, Dictionary>>;

package/definitions/game/game/options/GameOptions.d.ts

@@ -0,0 +1,44 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { SkillType } from "game/entity/IHuman";
+import type { ItemType } from "game/item/IItem";
+import type { IGameOptions, IGameOptionsSkill } from "game/options/IGameOptions";
+import { GameMode } from "game/options/IGameOptions";
+import type { IVersionInfo } from "utilities/Version";
+declare module GameOptions {
+    export function getDefault(difficulty?: GameMode, seed?: number): IGameOptions;
+    enum TravelingEffectStrategy {
+        AllPlayers = 0,
+        OnlinePlayersOnly = 1,
+        NoPlayers = 2
+    }
+    export interface IGameOptionsOld extends IGameOptions {
+        peaceful?: boolean;
+        creatures: IGameOptions["creatures"] & {
+            globalAberrantSpawns?: boolean;
+        };
+        island: IGameOptions["island"] & {
+            applyTravelingEffects?: TravelingEffectStrategy | boolean;
+        };
+        player: IGameOptions["player"] & {
+            initialItems?: boolean | ItemType[];
+            randomSkills?: boolean;
+            globalSkills: IGameOptionsSkill;
+            skills: Map<SkillType, IGameOptionsSkill>;
+            actions?: {
+                spawnGuardiansOnLockpick?: boolean;
+            };
+        };
+    }
+    export function upgrade(difficultyOptions: IGameOptions, _version: IVersionInfo): string[];
+    export {};
+}
+export default GameOptions;

package/definitions/game/game/options/IGameOptions.d.ts

@@ -0,0 +1,321 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { BiomeType } from "game/biome/IBiome";
+import type { CreatureType, TileGroup } from "game/entity/creature/ICreature";
+import type { AttackType, StatusType } from "game/entity/IEntity";
+import type { SkillType } from "game/entity/IHuman";
+import type { Stat } from "game/entity/IStats";
+import type { Milestone } from "game/milestones/IMilestone";
+import type { ThreeStateButtonState } from "ui/component/IThreeStateButton";
+import type DefaultMap from "utilities/collection/map/DefaultMap";
+import type RandomItem from "utilities/random/generators/RandomItem";
+import type RandomRange from "utilities/random/generators/RandomRange";
+import type { RecursivePartial } from "utilities/types/Recursive";
+export declare enum GameMode {
+    Hardcore = 0,
+    Casual = 1,
+    Challenge = 2,
+    Custom = 3
+}
+export declare const TIME_ETERNAL_NIGHT = 0.7;
+export declare const TIME_ETERNAL_DAY = 0.3;
+export interface IGameOptions {
+    /**
+     * Whether players respawn when they die
+     */
+    respawn: boolean;
+    island: {
+        /**
+         * Biome type for the first island
+         */
+        startingBiomeType: BiomeType;
+        /**
+         * Traveling effect options
+         */
+        applyTravelingEffects: boolean;
+    };
+    creatures: {
+        /**
+         * Whether creatures attack when unprovoked
+         */
+        peaceful: boolean;
+        /**
+         * @param On Only aberrants can spawn
+         * @param Off Only non-aberrants can spawn
+         * @param Null Either aberrants or non-aberrants can spawn
+         */
+        aberrantSpawns: ThreeStateButtonState;
+        /**
+         * Custom options for each creature.
+         */
+        creature: DefaultMap<CreatureType, IGameOptionsCreature>;
+        /**
+         * Multiplier for damage of creatures
+         */
+        damageMultiplier: number;
+        /**
+         * Multiplier for health of creatures
+         */
+        healthMultiplier: number;
+        /**
+         * Chance for creature to spawn as scared (uses Random.chance)
+         */
+        chanceToSpawnScared: number;
+        /**
+         * Maximum number of creatures that can spawn in a world
+         */
+        spawnLimit: number;
+    };
+    time: {
+        /**
+         * A number between `0` and `1`, where `0` is the start of the day and `1` is the end.
+         */
+        initial: number;
+        /**
+         * Whether time never passes
+         */
+        frozen: boolean;
+        /**
+         * The number of turns/ticks in a day.
+         */
+        dayLength?: number;
+        /**
+         * A number between `0` and `1` representing how much of the day is "daytime" and how much of the day is "night time".
+         */
+        dayPercent?: number;
+    };
+    rest: {
+        /**
+         * How long to delay before resting begins
+         */
+        startDelay?: number;
+        /**
+         * Delay between rest ticks
+         */
+        tickInterval?: number;
+    };
+    player: IGameOptionsPlayer;
+    npcs: {
+        merchants: {
+            /**
+             * A multiplier for the price of each merchant item.
+             */
+            priceMultiplier: number;
+            /**
+             * The number of items a merchant spawns with.
+             */
+            initialItems: RandomRange[];
+        };
+    };
+    /**
+     * Whether mods should be disabled
+     */
+    disableMods: boolean;
+    milestoneModifiers: Set<Milestone>;
+    items: {
+        /**
+         * Multiplier for decay of items.
+         */
+        decayMultiplier: number;
+    };
+}
+export declare enum UnlockedRecipesStrategy {
+    StartWithNone = 0,
+    UseUnlocks = 1,
+    AllUnlocked = 2
+}
+export interface IGameOptionsPlayer {
+    /**
+     * Whether the player should use their globally unlocked recipes in this game.
+     */
+    unlockedRecipes: UnlockedRecipesStrategy;
+    /**
+     * A map of options for each stat.
+     */
+    stats: DefaultMap<Stat, IGameOptionsStat>;
+    /**
+     * A map of options for each status effect.
+     */
+    statusEffects: DefaultMap<StatusType, IGameOptionsStatusEffect>;
+    skills: {
+        /**
+         * Amount of starting skills the player has (by default, 1 or 0, depending on mode)
+         *
+         * Note: Randomly generated skills can be overwritten by custom options in `skills`.
+         */
+        initial: RandomRange[];
+        /**
+         * Configuration that affects every skill which doesn't have its own configuration.
+         */
+        global: IGameOptionsSkill;
+        /**
+         * Custom options for each skill.
+         */
+        customs: DefaultMap<SkillType, IGameOptionsSkill>;
+    };
+    reputation: {
+        /**
+         * The initial malignity
+         */
+        initialMalignity: number;
+        /**
+         * The initial benignity
+         */
+        initialBenignity: number;
+        /**
+         * The rate at which malignity is gained
+         */
+        malignityMultiplier: number;
+        /**
+         * The rate at which benignity is gained
+         */
+        benignityMultiplier: number;
+    };
+    inventory: {
+        /**
+         * - Set to `false` to disable initial items
+         * - Set to `true` to randomly generate initial items
+         */
+        randomItems: boolean;
+        /**
+         * An additional set of items the player should spawn with.
+         */
+        additionalItems: RandomItem[];
+        /**
+         * An additional set of items the player should spawn with that should be equipped.
+         */
+        equipment: Array<{
+            type: RandomItem;
+            priority?: number;
+        }>;
+    };
+    crafting: {
+        /**
+         * A multiplier for the durability of each item.
+         */
+        durabilityMultiplier: number;
+        /**
+         * A multiplier for the difficulty of each level of craft.
+         * TODO: Set to Map<RecipeLevel, number> when we can support maps in milestone modifier overrides?
+         */
+        difficultyMultiplier: number;
+    };
+    actions: {
+        /**
+         * Guardians to attempt to spawn after successful lockpicks.
+         */
+        additionalGuardiansSpawnedOnLockpick: number;
+    };
+    damage: {
+        /**
+         * Add player damage multiplier based on attack type (used within Attack action).
+         */
+        attackMultiplier: DefaultMap<AttackType, number>;
+        /**
+         * Add player damage multiplier based on attack type (used within Attack action).
+         */
+        trapMultiplier: number;
+    };
+}
+/**
+ * "Partial" difficulty options; used to apply options over top base options. Milestone modifiers can never exist on partial difficulty options.
+ */
+export declare type IGameOptionsPartial = RecursivePartial<IGameOptions> & {
+    milestoneModifiers?: never;
+};
+export interface IGameOptionsStat {
+    /**
+     * If the given value is a decimanl number less than or equal to `1`, sets the stat value to a percentage of the max.
+     * Otherwise, sets the stat to the given value.
+     */
+    initialValue?: number;
+    /**
+     * The max value of the stat, or `undefined` if it should be generated randomly
+     */
+    maxValue?: number;
+    /**
+     * A float or number to multiply against the maxValue after being generated randomly or set via custom options.
+     * Used specifically for milestone modifiers currently.
+     */
+    maxValueMultiplier?: number;
+    /**
+     * A multiplier for the speed at which the stat changes `1` is "default", `0` is "none", `2` is "two times speed"
+     */
+    changeTimerMultiplier: number;
+    /**
+     * A bonus value to apply to the stat.
+     */
+    bonus?: number;
+    /**
+     * The number that stats increase by each gain. By default, this is "1".
+     */
+    gainAmount: number;
+}
+export interface IGameOptionsStatusEffect {
+    /**
+     * Whether every player starts with this status effect.
+     */
+    startWith: boolean;
+    /**
+     * Whether this status effect is untreatable (IE: it must pass naturally)
+     */
+    untreatable: boolean;
+    /**
+     * A multiplier for the chance of this status effect to be passed each turn.
+     */
+    passChanceMultiplier: number;
+    /**
+     * A multiplier for the number of ticks between effect ticks.
+     */
+    effectRateMultiplier: number;
+    /**
+     * Decrease or increase the effect of the... effect.
+     */
+    effectMultiplier: number;
+}
+export interface IGameOptionsSkill {
+    /**
+     * The initial value of this skill.
+     */
+    initial?: number;
+    /**
+     * A multiplier for how fast the skill is gained.
+     */
+    gainMultiplier: number;
+}
+export interface IGameOptionsCreature {
+    /**
+     * Can spawn at all.
+     */
+    allowSpawning: boolean;
+    /**
+     * @param On Only aberrants can spawn
+     * @param Off Only non-aberrants can spawn
+     * @param Null Either aberrants or non-aberrants can spawn
+     */
+    aberrantSpawns: ThreeStateButtonState;
+    /**
+     * A multiplier for the chance of this creature executing a special attack.
+     */
+    specialAttackChanceMultiplier: number;
+    /**
+     * Chance for creature to spawn as tamed (uses Random.chance)
+     */
+    chanceToSpawnTamed: number;
+    /**
+     * Forces the creature to always be present in the spawn pool, overwriting allowSpawning.
+     */
+    alwaysSpawn: boolean;
+    /**
+     * Modifies the tiles the creature can spawn on.
+     */
+    spawnTiles: TileGroup;
+}

package/definitions/game/game/options/modifiers/GameplayModifier.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { IHasImagePath } from "game/IObject";
+import type { IGameOptionsPartial } from "game/options/IGameOptions";
+import type Translation from "language/Translation";
+import type { Random, SeededGenerator } from "utilities/random/Random";
+import { RandomInstance, RandomReference } from "utilities/random/Random";
+export declare abstract class GameplayModifierInstance<ID extends number> {
+    readonly id: ID;
+    readonly random: Random<SeededGenerator>;
+    constructor(id: ID, random: Random<SeededGenerator>);
+    options: IGameOptionsPartial;
+    setOptions(options: IGameOptionsPartial): this;
+    addOptions(options: IGameOptionsPartial): this;
+    private titleInitializer?;
+    getTitle(): import("../../../language/impl/TranslationImpl").default;
+    protected abstract getDefaultTitle(): Translation;
+    setTitle(initializer: (defaultTitle: Translation) => Translation): this;
+}
+export declare type GetModifierInstance<MODIFIER extends GameplayModifier<number>> = MODIFIER extends GameplayModifier<number, infer INSTANCE, any[]> ? INSTANCE : never;
+export declare type GetModifierId<MODIFIER extends GameplayModifier<number>> = MODIFIER extends GameplayModifier<infer ID, any, any[]> ? ID : never;
+export declare type GetModifierInstanceArgs<MODIFIER extends GameplayModifier<number>> = MODIFIER extends GameplayModifier<number, any, infer INSTANCE_ARGS> ? INSTANCE_ARGS : never;
+export default abstract class GameplayModifier<ID extends number, INSTANCE extends GameplayModifierInstance<ID> = GameplayModifierInstance<ID>, INSTANCE_ARGS extends any[] = []> implements IHasImagePath {
+    readonly id: ID;
+    readonly random: RandomInstance | RandomReference;
+    readonly imagePath?: string;
+    constructor(id: ID, random?: RandomInstance | RandomReference);
+    abstract instantiate(type: ID, ...args: INSTANCE_ARGS): INSTANCE;
+    abstract initialize(instance: INSTANCE, ...args: INSTANCE_ARGS): INSTANCE;
+    uninitialize(instance: INSTANCE): any;
+    protected getRandom(): Random<SeededGenerator>;
+}

package/definitions/game/game/options/modifiers/GameplayModifiersManager.d.ts

@@ -0,0 +1,33 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type GameplayModifier from "game/options/modifiers/GameplayModifier";
+import type { GameplayModifierInstance, GetModifierId, GetModifierInstance, GetModifierInstanceArgs } from "game/options/modifiers/GameplayModifier";
+export default abstract class GameplayModifiersManager<MODIFIER extends GameplayModifier<number, GameplayModifierInstance<number>, any[]>, ID extends GetModifierId<MODIFIER> = GetModifierId<MODIFIER>, INSTANCE_ARGS extends GetModifierInstanceArgs<MODIFIER> = GetModifierInstanceArgs<MODIFIER>> {
+    private readonly enumObject;
+    private readonly classes;
+    private _instances;
+    protected getInstances(): Map<ID, MODIFIER>;
+    constructor(enumObject: any, classes: OptionalDescriptions<ID, Class<MODIFIER, [ID]>>);
+    getImage(id: ID): string | undefined;
+    getModifierInstance(id: ID): MODIFIER | undefined;
+    createCollection(...args: INSTANCE_ARGS): GameplayModifiersCollection<MODIFIER, ID>;
+}
+export declare class GameplayModifiersCollection<MODIFIER extends GameplayModifier<number, GameplayModifierInstance<number>, any[]>, ID extends GetModifierId<MODIFIER> = GetModifierId<MODIFIER>, INSTANCE extends GetModifierInstance<MODIFIER> = GetModifierInstance<MODIFIER>, INSTANCE_ARGS extends GetModifierInstanceArgs<MODIFIER> = GetModifierInstanceArgs<MODIFIER>> {
+    protected readonly manager: GameplayModifiersManager<MODIFIER>;
+    readonly initializedModifiers: Map<ID, INSTANCE>;
+    protected readonly args: INSTANCE_ARGS;
+    constructor(manager: GameplayModifiersManager<MODIFIER>, ...args: INSTANCE_ARGS);
+    hasAny(): boolean;
+    initialize(id: ID): INSTANCE | undefined;
+    uninitialize(): void;
+    options(): import("@wayward/goodstream").default<import("../IGameOptions").IGameOptionsPartial>;
+    initialized(): IterableIterator<ID>;
+}

package/definitions/game/game/options/modifiers/challenge/ChallengeModifier.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { Challenge } from "game/options/modifiers/challenge/IChallenge";
+import GameplayModifier, { GameplayModifierInstance } from "game/options/modifiers/GameplayModifier";
+import type Tooltip from "ui/tooltip/Tooltip";
+export declare class ChallengeModifierInstance extends GameplayModifierInstance<Challenge> {
+    /**
+     * How much "challenge" this modifier adds (or subtracts!). Defaults to `0`. Added to the result of `apply`.
+     */
+    challenge: number;
+    setChallenge(challenge: number): this;
+    addChallenge(challenge: number): this;
+    getTooltip(tooltip: Tooltip): Tooltip;
+    protected getDefaultTitle(): import("../../../../language/impl/TranslationImpl").default;
+}
+export default abstract class ChallengeModifier extends GameplayModifier<Challenge, ChallengeModifierInstance> {
+    /**
+     * How often this modifier should be chosen compared to the others
+     */
+    readonly weight: number;
+    instantiate(id: Challenge): ChallengeModifierInstance;
+}

package/definitions/game/game/options/modifiers/challenge/ChallengeModifiers.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type ChallengeModifier from "game/options/modifiers/challenge/ChallengeModifier";
+import { Challenge } from "game/options/modifiers/challenge/IChallenge";
+import GameplayModifiersManager, { GameplayModifiersCollection } from "game/options/modifiers/GameplayModifiersManager";
+import type Tooltip from "ui/tooltip/Tooltip";
+export declare const EXCLUSIVE_MODIFIERS: Challenge[][];
+declare class ChallengeModifiersManager extends GameplayModifiersManager<ChallengeModifier> {
+    constructor();
+    createCollection(seed?: number): ChallengeModifiersCollection;
+}
+declare const _default: ChallengeModifiersManager;
+export default _default;
+export declare class ChallengeModifiersCollection extends GameplayModifiersCollection<ChallengeModifier> {
+    getTooltip(challenge: Challenge, tooltip: Tooltip): Tooltip;
+}

package/definitions/game/game/options/modifiers/challenge/IChallenge.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { StatusType } from "game/entity/IEntity";
+import type { IGameOptionsPlayer } from "game/options/IGameOptions";
+export declare enum Challenge {
+    NoHealthRegeneration = 0,
+    NoStaminaRegeneration = 1,
+    EternalNight = 2,
+    ThirstRate = 3,
+    HungerRate = 4,
+    PermanentlyBleeding = 5,
+    PermanentlyBurning = 6,
+    PermanentlyPoisoned = 7,
+    NoStartingItems = 8,
+    StartingMalignity = 9,
+    BenignityRate = 10,
+    MalignityRate = 11
+}
+export declare function isPermanentEffect(effect: StatusType, options: IGameOptionsPlayer): boolean;
+export declare function isEternal(time: number): (options?: import("game/options/IGameOptions").IGameOptions) => boolean;
+export declare function getMultiplierChallengeValue(multiplier: number, value?: number): number;
+export declare function getDailyChallengeSeed(): number;

package/definitions/game/game/options/modifiers/challenge/modifiers/BenignityRate.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { ChallengeModifierInstance } from "game/options/modifiers/challenge/ChallengeModifier";
+import ChallengeModifier from "game/options/modifiers/challenge/ChallengeModifier";
+export default class BenignityRate extends ChallengeModifier {
+    readonly weight = 0.25;
+    initialize(instance: ChallengeModifierInstance): ChallengeModifierInstance;
+}