@wayward/types 2.12.3-beta.dev.20230104.1 → 2.13.0-beta

package/definitions/game/utilities/Log.d.ts

@@ -22,73 +22,77 @@ export declare enum LogSource {
     DailyChallenge = 9,
     Doodad = 10,
     DoodadManager = 11,
-    EnumManager = 12,
-    FileDataStorage = 13,
-    FlowFieldManager = 14,
-    Game = 15,
-    GameplayModifier = 16,
-    GarbageCollection = 17,
-    HookManager = 18,
-    IndexedDBDataStorage = 19,
-    Input = 20,
-    InputManager = 21,
-    InterModRegistryManager = 22,
-    Island = 23,
-    ItemManager = 24,
-    ItemReference = 25,
-    ItemStylesheet = 26,
-    Languages = 27,
-    Loading = 28,
-    LocalStorageDataStorage = 29,
-    MapGen = 30,
-    Matchmaking = 31,
-    MatchmakingServer = 32,
-    MemoryLeakDetector = 33,
-    Message = 34,
-    Mod = 35,
-    Mods = 36,
-    Multiplayer = 37,
-    NPC = 38,
-    NPCManager = 39,
-    OldUi = 40,
-    Packet = 41,
-    Player = 42,
-    PlayerManager = 43,
-    Prompts = 44,
-    Random = 45,
-    Reflow = 46,
-    Renderer = 47,
-    ReplayManager = 48,
-    ResourceLoader = 49,
-    SaveLoad = 50,
-    SaveManager = 51,
-    Serializer = 52,
-    Shaders = 53,
-    SmartConnection = 54,
-    SoundEffect = 55,
-    SpritePack = 56,
-    SshCommandManager = 57,
-    SshServer = 58,
-    SteamNetworkConnection = 59,
-    Steamworks = 60,
-    StringTokenizer = 61,
-    TemperatureManager = 62,
-    TileEventManager = 63,
-    TileUpdate = 64,
-    Timer = 65,
-    Trello = 66,
-    Ui = 67,
-    Utilities = 68,
-    WebAssembly = 69,
-    WebGlContext = 70,
-    WebRTCConnection = 71,
-    WebSocketConnection = 72,
-    WebWorkerClient = 73,
-    WebWorkerConnection = 74,
-    WebWorkerManager = 75,
-    World = 76,
-    WorldLayerRenderer = 77,
-    WorldRenderer = 78
+    Entity = 12,
+    EnumManager = 13,
+    FileDataStorage = 14,
+    FlowFieldManager = 15,
+    Game = 16,
+    GameplayModifier = 17,
+    GarbageCollection = 18,
+    HookManager = 19,
+    Human = 20,
+    IndexedDBDataStorage = 21,
+    Input = 22,
+    InputManager = 23,
+    InterModRegistryManager = 24,
+    Island = 25,
+    ItemManager = 26,
+    ItemReference = 27,
+    ItemStylesheet = 28,
+    Languages = 29,
+    Loading = 30,
+    LocalStorageDataStorage = 31,
+    MapGen = 32,
+    Matchmaking = 33,
+    MatchmakingServer = 34,
+    MemoryLeakDetector = 35,
+    Message = 36,
+    Mod = 37,
+    Mods = 38,
+    Multiplayer = 39,
+    NPC = 40,
+    NPCManager = 41,
+    OldUi = 42,
+    Packet = 43,
+    Player = 44,
+    PlayerManager = 45,
+    Prompts = 46,
+    Random = 47,
+    Reflow = 48,
+    Renderer = 49,
+    ReplayManager = 50,
+    ResourceLoader = 51,
+    SaveLoad = 52,
+    SaveManager = 53,
+    Serializer = 54,
+    Shaders = 55,
+    Shipper = 56,
+    SmartConnection = 57,
+    SoundEffect = 58,
+    SpritePack = 59,
+    SshCommandManager = 60,
+    SshServer = 61,
+    SteamNetworkConnection = 62,
+    Steamworks = 63,
+    StringTokenizer = 64,
+    TemperatureManager = 65,
+    TileEventManager = 66,
+    TileUpdate = 67,
+    Timer = 68,
+    Trello = 69,
+    Ui = 70,
+    Utilities = 71,
+    WebAssembly = 72,
+    WebGlContext = 73,
+    WebRTCConnection = 74,
+    WebSocketConnection = 75,
+    WebWorkerClient = 76,
+    WebWorkerConnection = 77,
+    WebWorkerManager = 78,
+    World = 79,
+    WorldLayer = 80,
+    WorldLayerRenderer = 81,
+    WorldRenderer = 82
 }
 export declare enum LogLineType {
     Debug = 0,

package/definitions/game/utilities/Version.d.ts

@@ -23,22 +23,28 @@ export interface IVersionInfo {
     update?: number;
 }
 declare module Version {
-    const versionInfoRegExp: RegExp;
-    const versionInfoRegExpSemver: RegExp;
+    export const versionInfoRegExp: RegExp;
+    export const versionInfoRegExpSemver: RegExp;
     /**
      * Returns whether the given version is compatible with the game's version. This is used to check, for example,
      * if a mod is compatible with the game's version.
      */
-    function isCompatible(version: IVersionInfo | string): boolean;
+    export function isCompatible(version: IVersionInfo | string): boolean;
     /**
      * Returns whether the given `version` is `atLeast` another version. This can be used, for example,
      * to see if a save or mod was created/edited after a specific thing was implemented.
      */
-    function isAtLeast(version: IVersionInfo | string, atLeast: IVersionInfo | string): boolean;
-    function create(stage: "beta" | "release", major: number, minor: number, patch?: number, date?: Date): IVersionInfo;
-    function getVersionInfo(version: string): IVersionInfo;
-    function isSameVersion(version: IVersionInfo, compareVersion: IVersionInfo): boolean;
-    function getVersionDisplayString(version?: string | IVersionInfo, development?: boolean): string;
-    function getUpdateDisplayString(version?: string | IVersionInfo): string | undefined;
+    export function isAtLeast(version: IVersionInfo | string, atLeast: IVersionInfo | string): boolean;
+    export function create(stage: "beta" | "release", major: number, minor: number, patch?: number, date?: Date): IVersionInfo;
+    export function getVersionInfo(version: string): IVersionInfo;
+    export function isSameVersion(version: IVersionInfo, compareVersion: IVersionInfo): boolean;
+    export function getVersionDisplayString(version?: string | IVersionInfo, development?: boolean): string;
+    export function getUpdateDisplayString(version?: string | IVersionInfo): string | undefined;
+    const timezones: {
+        nz: string;
+        build: string;
+    };
+    export function isBefore(date: Date, dateStr: `${string} ${number} ${number} ${number}:${number}`, timezone: keyof typeof timezones): boolean;
+    export {};
 }
 export default Version;

package/definitions/game/utilities/WebWorkerHelpers.d.ts

@@ -17,10 +17,7 @@ export declare module WebWorkerHelpers {
         getWorker(): Worker | undefined;
         free(): void;
     }
-    function create(workerFunction: (data: any) => void, messageCallbackFunction: (data: any) => void): Worker;
-    function createReusable(workerFunction: (data: any) => void): WebWorker;
-    function definitionPropertiesToBoolean(name: string, values: any): string;
-    function enumToString(name: string, values: any, withStrings?: boolean): string;
-    function moduleToString(moduleName: string, name: string | undefined, moduleToConvert: any, globalVariables?: string[]): string;
-    function biomesToString(): string;
+    export function create(workerFunction: (data: any) => void, messageCallbackFunction: (data: any) => void): Worker;
+    export function createReusable(workerFunction: (data: any) => void): WebWorker;
+    export {};
 }

package/definitions/game/utilities/class/Inject.d.ts

@@ -41,12 +41,8 @@ export declare enum InjectionPosition {
      */
     Post = "post"
 }
-export declare function InjectObject<T extends {
-    [key in K]: AnyFunction;
-}, K extends keyof T>(injectInto: T, property: K, position: InjectionPosition, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptor<InjectionMethod<T, K>>) => any;
-export declare function Inject<T extends {
-    [key in K]: AnyFunction;
-}, K extends keyof T>(injectInto: AnyClass<T>, property: K, position: InjectionPosition, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptor<InjectionMethod<T, K>>) => any;
+export declare function InjectObject<T extends Record<K, AnyFunction>, K extends keyof T>(injectInto: T, property: K, position: InjectionPosition, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptor<InjectionMethod<T, K>>) => any;
+export declare function Inject<T extends Record<K, AnyFunction>, K extends keyof T>(injectInto: AnyClass<T>, property: K, position: InjectionPosition, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptor<InjectionMethod<T, K>>) => any;
 /**
  * Classes decorated with `Injector` will have their methods automatically injected using `inject`.
  *

package/definitions/game/utilities/collection/Arrays.d.ts

@@ -8,48 +8,6 @@
  * 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
  */
-export declare function TupleType<T>(): {
-    create: <T2 extends T[]>(...items: T2) => T2;
-};
-export declare function Tuple<T extends any[]>(...items: T): T;
-export declare module Tuple {
-    export function is<T extends any[]>(value: unknown): value is T;
-    export type TupleFilterNot<I extends 0 | 1 | 2 | 3 | 4 | 5, NOT> = <A extends any[]>(value: A) => value is Extract<[...Slice<A>[I], Exclude<A[I], NOT>, ...SliceAfter<A>[IAddOne[I]]], A>;
-    export type TupleNullishFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, undefined | null>;
-    export function filterNullish<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleNullishFilter<I>;
-    export type TupleFalsyFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, Falsy>;
-    export function filterFalsy<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleFalsyFilter<I>;
-    export type TupleGetter<I extends 0 | 1 | 2 | 3 | 4 | 5> = <A extends readonly any[]>(value: A) => A[I];
-    export function getter<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleGetter<I>;
-    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[], R extends A[I]>(index: I, predicate: (value: A[I], i: number) => value is R): (value: A) => value is Extract<[...Slice<A>[I], R, ...SliceAfter<A>[IAddOne[I]]], A>;
-    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[]>(index: I, predicate: (value: A[I], i: number) => any): (value: A, i: number) => any;
-    interface Slice<A extends any[]> {
-        [0]: [];
-        [1]: [A[0]];
-        [2]: [A[0], A[1]];
-        [3]: [A[0], A[1], A[2]];
-        [4]: [A[0], A[1], A[2], A[3]];
-        [5]: [A[0], A[1], A[2], A[3], A[4]];
-    }
-    interface SliceAfter<A extends any[]> {
-        [1]: A extends [any, ...infer R] ? R : never;
-        [2]: A extends [any, any, ...infer R] ? R : never;
-        [3]: A extends [any, any, any, ...infer R] ? R : never;
-        [4]: A extends [any, any, any, any, ...infer R] ? R : never;
-        [5]: A extends [any, any, any, any, any, ...infer R] ? R : never;
-        [6]: A extends [any, any, any, any, any, any, ...infer R] ? R : never;
-    }
-    interface IAddOne {
-        [0]: 1;
-        [1]: 2;
-        [2]: 3;
-        [3]: 4;
-        [4]: 5;
-        [5]: 6;
-    }
-    export type Twice<T> = [T, T];
-    export {};
-}
 declare module Arrays {
     type Value<A extends any[]> = A extends Array<infer T> ? T : never;
     const EMPTY: readonly undefined[];
@@ -91,5 +49,6 @@ declare module Arrays {
     function arrayOr<T>(value: T | T[]): T[];
     function tupleOr<A>(value: A): A extends any[] ? A : [A];
     function concat<T>(...arrays: T[][]): T[];
+    function lerp<T>(array: readonly T[], t: number): T;
 }
 export default Arrays;

package/definitions/game/utilities/collection/Tuple.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
+ */
+export declare const SYMBOL_TUPLE: unique symbol;
+export declare function Tuple<T extends any[]>(...items: T): T;
+export declare function TupleType<T>(): {
+    create: <T2 extends T[]>(...items: T2) => T2;
+};
+export declare module Tuple {
+    export function is<T extends any[]>(value: unknown): value is T;
+    export type TupleFilterNot<I extends 0 | 1 | 2 | 3 | 4 | 5, NOT> = <A extends any[]>(value: A) => value is Extract<[...Slice<A>[I], Exclude<A[I], NOT>, ...SliceAfter<A>[IAddOne[I]]], A>;
+    export type TupleNullishFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, undefined | null>;
+    export function filterNullish<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleNullishFilter<I>;
+    export type TupleFalsyFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, Falsy>;
+    export function filterFalsy<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleFalsyFilter<I>;
+    export type TupleGetter<I extends 0 | 1 | 2 | 3 | 4 | 5> = <A extends readonly any[]>(value: A) => A[I];
+    export function getter<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleGetter<I>;
+    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[], R extends A[I]>(index: I, predicate: (value: A[I], i: number) => value is R): (value: A) => value is Extract<[...Slice<A>[I], R, ...SliceAfter<A>[IAddOne[I]]], A>;
+    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[]>(index: I, predicate: (value: A[I], i: number) => any): (value: A, i: number) => any;
+    interface Slice<A extends any[]> {
+        [0]: [];
+        [1]: [A[0]];
+        [2]: [A[0], A[1]];
+        [3]: [A[0], A[1], A[2]];
+        [4]: [A[0], A[1], A[2], A[3]];
+        [5]: [A[0], A[1], A[2], A[3], A[4]];
+    }
+    interface SliceAfter<A extends any[]> {
+        [1]: A extends [any, ...infer R] ? R : never;
+        [2]: A extends [any, any, ...infer R] ? R : never;
+        [3]: A extends [any, any, any, ...infer R] ? R : never;
+        [4]: A extends [any, any, any, any, ...infer R] ? R : never;
+        [5]: A extends [any, any, any, any, any, ...infer R] ? R : never;
+        [6]: A extends [any, any, any, any, any, any, ...infer R] ? R : never;
+    }
+    interface IAddOne {
+        [0]: 1;
+        [1]: 2;
+        [2]: 3;
+        [3]: 4;
+        [4]: 5;
+        [5]: 6;
+    }
+    export type Twice<T> = [T, T];
+    export {};
+}

package/definitions/game/utilities/collection/map/PriorityMap.d.ts

@@ -12,7 +12,7 @@
  * Used for ordering a list of items by "priority". Higher priorities come before lower priorities.
  */
 export declare class PriorityMap<T> {
-    static streamAll<T extends Iterable<any>>(...lists: Array<PriorityMap<T>>): import("@wayward/goodstream").default<T>;
+    static orderMultiple<T extends Iterable<any>>(lists: Array<PriorityMap<T>>): T[];
     private readonly priorities;
     private readonly map;
     get size(): number;
@@ -37,6 +37,7 @@ export declare class PriorityMap<T> {
      * Returns an iterator of the items in this list.
      */
     stream(direction?: PriorityListStreamDirection): import("@wayward/goodstream").default<T>;
+    array(direction?: PriorityListStreamDirection): T[];
     getInternalMap(): Record<number, T>;
 }
 export declare enum PriorityListStreamDirection {

package/definitions/game/utilities/enum/EnumCursor.d.ts

@@ -28,9 +28,7 @@ declare class EnumCursor<E, K extends string = string> extends EventEmitter.Host
      * @param enumObject The full enumeration.
      * @param n The starting position of the cursor. Defaults to `0`.
      */
-    constructor(enumObject: {
-        [key in K]: E;
-    }, n?: number);
+    constructor(enumObject: Record<K, E>, n?: number);
     /**
      * Refreshes the internal list of enum entries. If the full enumeration has changed,
      * the cursor may be moved to a different entry.

package/definitions/game/utilities/enum/Enums.d.ts

@@ -18,9 +18,7 @@ declare module Enums {
      * @param enumObject The full enumeration. EG: ItemType, CreatureType, DoodadType, etc
      * @param entry The entry in the enum. Usually its index.
      */
-    function isModded<E, K extends string>(enumObject: {
-        [key in K]: E;
-    }, entry: E): boolean;
+    function isModded<E, K extends string>(enumObject: Record<K, E>, entry: E): boolean;
     function getMod<O>(enumObject: O, entry: O[keyof O], isGlobalEnum?: boolean): IModInfo | undefined;
     /**
      * Returns an enum entry by its name, case-insensitive.
@@ -28,18 +26,14 @@ declare module Enums {
      * @param name The name of the enum entry. Case-insensitive.
      * @returns The enum entry, if found; otherwise `undefined`.
      */
-    function findByName<E, K extends string>(enumObject: {
-        [key in K]: E;
-    }, name: K): E;
+    function findByName<E, K extends string>(enumObject: Record<K, E>, name: K): E;
     /**
      * Returns an enum entry by its index. The order is not guaranteed.
      * @param enumObject The full enumeration. EG: ItemType, CreatureType, DoodadType, etc
      * @param n The index of the enum entry.
      * @returns The enum entry, or if out of bounds, `undefined`.
      */
-    function getNth<E, K extends string>(enumObject: {
-        [key in K]: E;
-    }, n: number): Exclude<E, AnyFunction> | undefined;
+    function getNth<E, K extends string>(enumObject: Record<K, E>, n: number): Exclude<E, AnyFunction> | undefined;
     /**
      * Returns the number of entries in this enum.
      * @param enumObject The full enumeration. EG: ItemType, CreatureType, DoodadType, etc
@@ -69,21 +63,18 @@ declare module Enums {
     /**
      * Iterate over the entries in an enum. Yields a tuple containing the name and value of each entry.
      */
-    function entries<T>(enumObject: T): readonly [keyof T, Exclude<T[keyof T], AnyFunction<any>>][];
+    function entries<T>(enumObject: T): ReadonlyArray<[keyof T, Exclude<T[keyof T], AnyFunction>]>;
     function entryStream<T>(enumObject: T): import("@wayward/goodstream").default<[keyof T, Exclude<T[keyof T], AnyFunction<any>>]>;
+    function lerp<T>(enumObject: T, t: number): Exclude<T[keyof T], AnyFunction<any>>;
     /**
      * Returns whether the given number is a valid entry in an enum.
      * @param enumObject The enum object to check for the entry.
      * @param entry The value to check.
      * @param isBasicEnum Whether the enum is a "basic" enum; IE, every entry is a number between `0` and `Infinity`. (Default: `true`)
      */
-    function isValid<E, K extends string>(enumObject: {
-        [key in K]: E;
-    }, entry: unknown, isBasicEnum?: boolean): entry is E;
+    function isValid<E, K extends string>(enumObject: Record<K, E>, entry: unknown, isBasicEnum?: boolean): entry is E;
     function toString(enumObject: any, n: number, exlude?: number): string;
-    function sortKeysByOrdinal<E extends number, K extends string>(enumObject: {
-        [key in K]: E;
-    }): (keyA: K, keyB: K) => number;
+    function sortKeysByOrdinal<E extends number, K extends string>(enumObject: Record<K, E>): (keyA: K, keyB: K) => number;
     /**
      * Creates a "merged" enum which can be used in `Enums.keys`, `values`, `entries`, etc with the same performance.
      *

package/definitions/game/utilities/enum/IEnum.d.ts

@@ -85,5 +85,6 @@ export declare enum EnumId {
     ItemTag = 43,
     DoodadTag = 44,
     EntityTag = 45,
-    ItemTypeExtra = 46
+    ItemTypeExtra = 46,
+    DoodadTypeExtra = 47
 }

package/definitions/game/utilities/generic/GenericManager.d.ts

@@ -9,11 +9,13 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import EventEmitter from "event/EventEmitter";
+import type { Game } from "game/Game";
 import type { IGenericManager, IGenericRegistration } from "utilities/generic/IGenericManager";
 import type { LogSource } from "utilities/Log";
 export default abstract class GenericManager<T extends IGenericRegistration> extends EventEmitter.Host<{}> implements IGenericManager<T> {
+    readonly game: Game;
     private readonly registered;
-    constructor();
+    constructor(game: Game);
     abstract setup(instance: GenericManager<T>): void;
     has(type: number): boolean;
     add(registration: T): void;

package/definitions/game/utilities/math/Bound3.d.ts

@@ -18,7 +18,7 @@ export default class Bound3 implements IBound3 {
     min: Vector2;
     max: Vector2;
     z: number;
-    static contains(bound: IBound3, x: number, y: number, z: number): boolean;
-    static containsIgnoreZ(bound: IBound3, x: number, y: number): boolean;
+    static contains(mapSize: number, bound: IBound3, x: number, y: number, z: number): boolean;
+    static containsIgnoreZ(mapSize: number, bound: IBound3, x: number, y: number): boolean;
     constructor(min: Vector2, max: Vector2, z: number);
 }

package/definitions/game/utilities/math/IVector.d.ts

@@ -8,17 +8,22 @@
  * 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 Tile from "game/tile/Tile";
+import type { WorldZ } from "game/WorldZ";
 export interface IVector2 {
     x: number;
     y: number;
 }
+export declare namespace IVector2 {
+    function hash(v2: IVector2): number;
+}
 export interface IVector3 extends IVector2 {
-    z: number;
+    z: WorldZ;
 }
 export declare module IVector3 {
     function is(value: unknown): value is IVector3;
 }
-export declare function objectIsOrWasInTile(tile: IVector3, object: IVector3 & {
+export declare function objectIsOrWasInTile(tile: Tile, object: IVector3 & {
     fromX?: number;
     fromY?: number;
 }): boolean;

package/definitions/game/utilities/math/Math2.d.ts

@@ -60,6 +60,72 @@ declare module Math2 {
      * Given a number between `from` and `to`, returns a decimal how far it is, `t`.
      */
     function unlerp(from: number, to: number, lerped: number): number;
+    /**
+     * Curve the value t exponentially (IE, starts gentle, ends steep)
+     * @param from Rather than starting the curve at 0, start it here
+     * @param to Rather than ending the curve at 1, end it here
+     * @param t A decimal value from 0 to 1 representing how far along the curve's x axis to return the y position of
+     * @param steepness A value representing how steep the curve should be. Defaults to 4 (this value does not behave the same as it does for `logarithmicLerp`)
+     *
+     * ### Also see:
+     * - {@link logarithmicLerp} — Steep to gentle, logarithmically
+     * - {@link curve2} — Steep to gentle, shaped like the circumference of a quarter circle
+     * - {@link curve4} — Gentle to steep, shaped like the circumference of a quarter circle
+     *
+     * See this suite of curves [graphed on desmos](https://www.desmos.com/calculator/rqx0u7xjtm)
+     */
+    function exponentialLerp(from: number, to: number, t: number, steepness?: number): number;
+    /**
+     * Curve the value t exponentially (IE, starts steep, ends gentle)
+     * @param from Rather than starting the curve at 0, start it here
+     * @param to Rather than ending the curve at 1, end it here
+     * @param t A decimal value from 0 to 1 representing how far along the curve's x axis to return the y position of
+     * @param steepness A value representing how steep the curve should be. Defaults to 50 (this value does not behave the same as it does for `exponentialLerp`)
+     *
+     * ### Also see:
+     * - {@link exponentialLerp} — Gentle to steep, exponentially
+     * - {@link curve2} — Steep to gentle, shaped like the circumference of a quarter circle
+     * - {@link curve4} — Gentle to steep, shaped like the circumference of a quarter circle
+     *
+     * See this suite of curves [graphed on desmos](https://www.desmos.com/calculator/rqx0u7xjtm)
+     */
+    function logarithmicLerp(from: number, to: number, t: number, steepness?: number): number;
+    /**
+     * Curve the value t (0-1) along the second quadrant of a rounded square/circle. (IE, starts steep, ends gentle)
+     * @param from Rather than starting the curve at 0, start it here
+     * @param to Rather than ending the curve at 1, end it here
+     * @param t A decimal value from 0 to 1 representing how far along the curve's x axis to return the y position of
+     * @param steepness How rounded the square/circle is.
+     * - `1` — linear/a diamond
+     * - `2` (default) — a circle
+     * - Further reduces the curve's portion of the square
+     *
+     * ### Also see:
+     * - {@link curve4} — Gentle to steep, shaped like the circumference of a quarter circle
+     * - {@link exponentialLerp} — Gentle to steep, exponentially
+     * - {@link logarithmicLerp} — Steep to gentle, logarithmically
+     *
+     * See this suite of curves [graphed on desmos](https://www.desmos.com/calculator/rqx0u7xjtm)
+     */
+    function curve2(from: number, to: number, t: number, steepness?: number): number;
+    /**
+     * Curve the value t (0-1) along the fourth quadrant of a rounded square/circle. (IE, starts gentle, ends steep)
+     * @param from Rather than starting the curve at 0, start it here
+     * @param to Rather than ending the curve at 1, end it here
+     * @param t A decimal value from 0 to 1 representing how far along the curve's x axis to return the y position of
+     * @param steepness How rounded the square/circle is.
+     * - `1` — linear/a diamond
+     * - `2` (default) — a circle
+     * - Further reduces the curve's portion of the square
+     *
+     * ### Also see:
+     * - {@link curve2} — Steep to gentle, shaped like the circumference of a quarter circle
+     * - {@link exponentialLerp} — Gentle to steep, exponentially
+     * - {@link logarithmicLerp} — Steep to gentle, logarithmically
+     *
+     * See this suite of curves [graphed on desmos](https://www.desmos.com/calculator/rqx0u7xjtm)
+     */
+    function curve4(from: number, to: number, t: number, steepness?: number): number;
     function mod(n1: number, n2: number): number;
     function average(...ns: number[]): number;
     function sum(...ns: number[]): number;

package/definitions/game/utilities/math/Range.d.ts

@@ -30,4 +30,7 @@ export declare module IRange {
     function add(...rangesOrNumbers: Array<IRange | number>): IRange;
     function flatten(rangeOrNumber: IRange | number): IRange | number;
     function flatten(rangeOrNumber: IRange | number | undefined): IRange | number | undefined;
+    function multiply(range: IRange, by: number, into?: IRange): IRange;
+    function ceil(range: IRange, into?: IRange): IRange;
+    function average(range: IRange): number;
 }

package/definitions/game/utilities/math/Rectangle.d.ts

@@ -9,6 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { IBox } from "ui/component/IComponent";
+import type { IVector2 } from "utilities/math/IVector";
 import Vector2 from "utilities/math/Vector2";
 export default class Rectangle implements IBox {
     readonly position: Vector2;
@@ -27,5 +28,6 @@ export default class Rectangle implements IBox {
     get bottom(): number;
     constructor(position: Vector2, size: Vector2);
     getCenter(): Vector2;
-    intersects(rect2: Rectangle): boolean;
+    intersects(v2: IVector2): boolean;
+    intersects(rect2: IBox): boolean;
 }

package/definitions/game/utilities/memory/MemoryLeakDetector.d.ts

@@ -23,6 +23,7 @@ declare class MemoryLeakDetector {
     registerMultiple<T extends object>(prefix: string, objects: SaferArray<T>, objectNamer: (object: T) => string, expectedLifetime: ExpectedLifetime): void;
     onStopPlay(): void;
     onScreenShow(_: any, screen: Screen): Promise<any>;
+    private onReset;
     private runCheck;
     garbageCollect(): Promise<void>;
     private checkObjects;

package/definitions/game/utilities/object/Objects.d.ts

@@ -18,7 +18,7 @@ declare module Objects {
     function keys<O extends object>(o: O): Array<keyof O>;
     function values<O extends object>(o: O): Array<O[keyof O]>;
     function entries<O extends object>(o: O): Array<[keyof O, O[keyof O]]>;
-    function fromEntries<K extends string | number | symbol, V>(entriesIterable: Iterable<[K, V] | readonly [K, V]>): { [key in K]: V; };
+    function fromEntries<K extends string | number | symbol, V>(entriesIterable: Iterable<[K, V] | readonly [K, V]>): Record<K, V>;
     function windowKeysToObject(windowKeys: string[]): any;
     function windowKeysToParentObject(windowKeys: string[]): any;
     function anyAreObjects(things: any[]): boolean;

package/definitions/game/utilities/random/IRandom.d.ts

@@ -0,0 +1,36 @@
+/*!
+ * 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
+ */
+export interface IRandomPushed<T> {
+    seed: T;
+    history?: Array<IRandomHistory<T>>;
+}
+export interface IRandomHistory<T> {
+    stack: string;
+    seeds: T[];
+}
+export interface IRandomGenerator<T = any> {
+    clone(requiresSynchronization?: boolean, initialState?: T): this;
+    getSeed(): T;
+    pushSeed(seed?: T): void;
+    popSeed(): T;
+    get(): number;
+    advance?(): this;
+}
+export declare enum RandomInstance {
+    Seeded = 0,
+    MilestoneModifiers = 1,
+    IslandModifier = 2
+}
+export type WeightedOption<T> = [number, T];
+export declare enum SeedType {
+    Legacy = 0,
+    PCG = 1
+}