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

package/definitions/game/game/item/ItemFinder.d.ts

@@ -39,8 +39,8 @@ export default class ItemFinder extends EventEmitter.Host<IItemFinderEvents> {
     markDirty(): void;
     private compute;
     protected onItemStateChange(item: Item): void;
-    protected onContainerItemAdd(items: ItemManager, itemAdded: Item, containerAddedTo: IContainer): void;
-    protected onContainerItemRemove(items: ItemManager, itemRemoved: Item, containerRemovedFrom?: IContainer): void;
+    protected onContainerItemAdd(items: ItemManager, itemsAdded: Item[], containerAddedTo: IContainer): void;
+    protected onContainerItemRemove(items: ItemManager, itemsRemoved: Item[], containerRemovedFrom?: IContainer): void;
     protected onLoadOnIsland(player: Player): void;
     private trackContainer;
     private untrackContainer;

package/definitions/game/game/item/ItemManager.d.ts

@@ -8,64 +8,57 @@
  * 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 Doodad from "game/doodad/Doodad";
+import type { BiomeType } from "game/biome/IBiome";
+import Doodad from "game/doodad/Doodad";
 import type { IActionHandlerApi } from "game/entity/action/IAction";
 import { ActionType } from "game/entity/action/IAction";
 import Human from "game/entity/Human";
 import type NPC from "game/entity/npc/NPC";
 import type Player from "game/entity/player/Player";
-import { CreationId } from "game/IGame";
 import { Quality } from "game/IObject";
-import type { ContainerReference, IContainable, IContainer, IItemDescription, IItemWeightComponent, IMoveToTileOptions, IRecipe } from "game/item/IItem";
-import { CraftResult, ItemType, ItemTypeGroup, ItemTypeExtra } from "game/item/IItem";
-import type { IAddToContainerOptions, IDoodadsUsed, IGetBestItemsOptions, IGetItemOptions, IGetItemsOptions, IRequirementInfo } from "game/item/IItemManager";
+import type { ContainerReference, IContainable, IContainer, IItemDescription, IItemWeightComponent, IRecipe } from "game/item/IItem";
+import { ContainerType, CraftResult, ItemType, ItemTypeExtra, ItemTypeGroup } from "game/item/IItem";
+import type { IAddToContainerResult, IDoodadsUsed, IGetBestItemsOptions, IGetItemOptions, IGetItemsOptions, IMoveItemOptions, IRequirementInfo } from "game/item/IItemManager";
 import { ContainerReferenceSource, CraftStatus, ICraftResultChances, WeightType } from "game/item/IItemManager";
 import Item from "game/item/Item";
-import type ItemRecipeRequirementChecker from "game/item/ItemRecipeRequirementChecker";
 import { ObjectManager } from "game/ObjectManager";
-import type { ITile } from "game/tile/ITerrain";
 import { TerrainType } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
+import { WorldZ } from "game/WorldZ";
 import Message from "language/dictionary/Message";
 import type TranslationImpl from "language/impl/TranslationImpl";
 import type { ListEnder } from "language/ITranslation";
-import Translation from "language/Translation";
-import type { IVector3 } from "utilities/math/IVector";
-import Vector3 from "utilities/math/Vector3";
+import Translation, { Article } from "language/Translation";
 import type { Random } from "utilities/random/Random";
 export interface IItemManagerEvents {
     create(item: Item): any;
     remove(item: Item): any;
-    canMoveItem(human: Human | undefined, item: Item, toContainer: IContainer): boolean | undefined;
-    canMoveItems(human: Human | undefined, fromContainer: IContainer, toContainer: IContainer, itemType: ItemType | undefined, ofQuality: Quality | undefined): boolean | undefined;
     /**
-     * Called when an item is removed from a container.
-     * @param item The item object.
-     * @param container The container object the item was removed from.
-     * @param containerPosition The psoition of that container when the remove occurred.
+     * Called before moving items to another container
      */
-    containerItemRemove(item: Item, container: IContainer | undefined, containerPosition: Vector3 | undefined): any;
+    canMoveItems(human: Human | undefined, itemsToMove: Item[], fromContainer: IContainer | undefined, toContainer: IContainer, options?: IMoveItemOptions): boolean | undefined;
     /**
-     * Called when an item is moved from one container to another.
-     * @param item The item object.
-     * @param containerFrom The container object the item was moved from. This container might be inventory or a container within the inventory.
-     * @param containerFromPosition The position of containerFrom when the update occurred.
-     * @param containerTo The container object the item was moved to. This container might be inventory or a container within the inventory.
+     * Called when items are removed from a container.
+     * @param items The items.
+     * @param container The container object the item was removed from.
+     * @param containerTile The tile of that container when the remove occurred.
      */
-    containerItemUpdate(item: Item, containerFrom: IContainer | undefined, containerFromPosition: Vector3 | undefined, containerTo: IContainer): any;
+    containerItemRemove(items: Item[], container: IContainer | undefined, containerTile: Tile | undefined): any;
     /**
-     * Called when an item is added to a container.
-     * @param item The item object.
-     * @param container The container object the item was added to. This container might be inventory or a container within the inventory.
+     * Called when items are moved from one container to another.
+     * @param items The items.
+     * @param containerFrom The container object the items were moved from. This container might be inventory or a container within the inventory.
+     * @param containerFromTile The tile of containerFrom when the update occurred.
+     * @param containerTo The container object the items were moved to. This container might be inventory or a container within the inventory.
      */
-    containerItemAdd(item: Item, container: IContainer): any;
+    containerItemUpdate(items: Item[], containerFrom: IContainer | undefined, containerFromTile: Tile | undefined, containerTo: IContainer): any;
     /**
-     * Called when a craft is "requested". This currently happens when clicking an item in the crafting dialog.
-     * @param requirementsMet Whether the requirements are currently met. This hook is a `reduce` hook, so this will contain
-     * whatever the result of the last hook host was, or the value of `checker.requirementsMet()`, by default.
-     * @param item The item to be crafted.
-     * @param checker The recipe requirement checker for this craft.
+     * Called when items are added to a container.
+     * @param items The items.
+     * @param container The container object the items were added to. This container might be inventory or a container within the inventory.
+     * @param options Move item options.
      */
-    shouldCraft(requirementsMet: boolean, item: ItemType, checker: ItemRecipeRequirementChecker): boolean | undefined;
+    containerItemAdd(items: Item[], container: IContainer, options?: IMoveItemOptions): any;
     /**
      * Called when an item is crafted
      * @param human The human object
@@ -74,37 +67,41 @@ export interface IItemManagerEvents {
     craft?(human: Human, item: Item): void;
 }
 export default class ItemManager extends ObjectManager<Item, IItemManagerEvents> {
-    protected readonly creationId: CreationId;
     readonly worldContainer: IContainer;
-    private static cachedBestItemForTier;
-    private static cachedDefaultItemForGroup;
-    private static cachedEquippables;
-    private static cachedHighestItemActionTierForAction;
-    private static cachedItemGroups;
-    private static cachedItemSpawns;
-    private static cachedItemsThatAreAcceptedAsOffer;
-    private static cachedItemsThatAreUsedForGrowingPlants;
-    private static cachedItemsThatAreUsedInRecipes;
+    private static cachedItemTypeGroups;
     private static cachedItemTypes;
     private static cachedItemTypesWithRecipes;
-    private static cachedWeights;
+    private static cachedUseItemActions;
+    private static readonly cachedBestItemForTier;
+    private static readonly cachedDefaultItemForGroup;
+    private static readonly cachedEquippables;
     private static readonly cachedGroupItems;
-    private static readonly cachedUseItemActions;
+    private static readonly cachedHighestItemActionTierForAction;
+    private static readonly cachedItemGroups;
+    private static readonly cachedItemGroupsUsedInRecipes;
+    private static readonly cachedItemsThatAreAcceptedAsOffer;
+    private static readonly cachedItemsThatAreUsedForGrowingPlants;
+    private static readonly cachedItemsThatAreUsedInRecipes;
+    private static readonly cachedWeights;
+    static readonly cachedItemSpawns: Map<BiomeType, Map<WorldZ, Map<TerrainType, Set<ItemType>>>>;
     static getItemTypes(): readonly ItemType[];
     static getItemsWithRecipes(): readonly ItemType[];
     static getBestItemForTier(item: ItemType | ItemTypeGroup): ItemType | undefined;
     static getHighestItemActionTierForAction(action: ActionType): number;
-    static isItemAcceptedAsOffer(item: ItemType): boolean | undefined;
-    static isItemUsedInRecipe(item: ItemType): boolean | undefined;
-    static isItemUsedForGrowingPlants(item: ItemType): boolean | undefined;
+    static isItemAcceptedAsOffer(item: ItemType): boolean;
+    static isItemUsedInRecipe(item: ItemType): boolean;
+    static isItemUsedForGrowingPlants(item: ItemType): boolean;
     static isContainer(obj: unknown): obj is IContainer;
     isContainer(obj: unknown): obj is IContainer;
     static isGroup(item: ItemType | ItemTypeGroup): item is ItemTypeGroup;
     static isInGroup(itemType: ItemType, itemGroup: ItemTypeGroup | ItemType): boolean;
+    static isItemExtra(type: number): type is ItemTypeExtra;
     static getGroupItems(itemGroup: ItemType | ItemTypeGroup): Set<ItemType>;
-    private static getGroupItemsWithoutCache;
-    static getPlayerFromInventoryContainer(containable: IContainable): Player | undefined;
-    static getItemTypeGroupName(itemType: ItemType | ItemTypeGroup, article?: false | "definite" | "indefinite", count?: number): Translation;
+    /**
+     * Gets a set of additional item types that belong to the specified group
+     */
+    private static getAdditionalGroupItemsWithoutCache;
+    static getItemTypeGroupName(itemType: ItemType | ItemTypeGroup, article?: Article, count?: number): Translation;
     static getGroupDefault(itemGroup: ItemTypeGroup, weightType?: WeightType, ancestorGroups?: ItemTypeGroup[]): ItemType;
     /**
      * Returns the "processed" weight of the given item.
@@ -120,52 +117,83 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     static weightTree(itemType: ItemType, random: Random | undefined, weightType?: WeightType, debug?: boolean, depth?: number): number;
     static getGroups(itemType: ItemType): ItemTypeGroup[];
     static generateLookups(): void;
+    private static cacheEquippables;
+    private static cacheGroupItems;
+    private static cacheItemRecipes;
+    private static cacheItemTypes;
+    private static cacheItemWeights;
+    private static cacheCreatureOfferingsAndResources;
+    private static cacheRemainingItemStuff;
     static clearCaches(): void;
     static getUseItemActions(): ReadonlySet<ActionType>;
     private static getDefaultWeightRange;
     load(): void;
-    getPoint(itemOrContainer?: Item | IContainer): Vector3 | undefined;
-    resolveContainer(container?: IContainer): Doodad | Item | Player | NPC | IContainer | ITile | undefined;
+    /**
+     * Gets the tile the item/container is on
+     * @param itemOrContainer Item or container
+     * @returns Tile or undefined
+     */
+    getTile(itemOrContainer?: Item | IContainer): Tile | undefined;
+    resolveContainer(container?: IContainer): Player | Doodad | Item | NPC | IContainer | Tile | undefined;
     getContainerReference(containable: IContainable | undefined, source: ContainerReferenceSource | undefined): ContainerReference;
     derefenceContainerReference(containerReference: ContainerReference, showWarnings?: boolean): IContainable | undefined;
     hashContainer(containable: IContainable, containerReferenceSource?: ContainerReferenceSource): string;
     hashContainerReference(containerReference: ContainerReference): string;
     updateContainedWithin(containable: IContainable, containedWithin: IContainer | undefined): void;
-    addToContainerInternal(item: Item, container: IContainer, options?: IAddToContainerOptions): boolean;
+    /**
+     * Moves an item into a container
+     * @param human Human causing the item movement
+     * @param item Item to move
+     * @param toContainer Container to move the item to
+     * @param options Item move options
+     * @returns Result that tells you what moved
+     */
+    moveItemToContainer(human: Human | undefined, item: Item, toContainer: IContainer, options?: IMoveItemOptions): IAddToContainerResult;
+    /**
+     * Moves items from one container into another container
+     * @param human Human causing the item movement
+     * @param fromContainer Source container
+     * @param toContainer Destination container
+     * @param options Item move options
+     * @returns Result that tells you what moved
+     */
+    moveItemsFromContainer(human: Human | undefined, fromContainer: IContainer, toContainer: IContainer, options?: IMoveItemOptions): IAddToContainerResult;
+    /**
+     * Moves items to a container.
+     * Note: All the items must be contained within the same container.
+     * @param human Human causing the item movement
+     * @param item Items to move
+     * @param toContainer Destination container
+     * @param options Item move options
+     * @returns Result that tells you what moved
+     */
+    moveItemsToContainer(human: Human | undefined, items: Item[], toContainer: IContainer, options?: IMoveItemOptions): IAddToContainerResult;
     removeContainerItems(container: IContainer, removeContainedItems?: boolean): void;
-    isItemExtra(type: number): type is ItemTypeExtra;
     exists(item: Item): boolean;
     remove(item: Item, removeContainedItems?: boolean, extinguishTorches?: boolean): void;
     getDisassemblyComponents(description: IItemDescription, quality: Quality | undefined): Item[];
     getDisassemblyComponentsAsItemTypes(description: IItemDescription): Array<ItemType | ItemTypeGroup>;
     getWeightCapacity(container: IContainer, includeMagic?: boolean): number | undefined;
-    create(itemType: ItemType | ItemTypeGroup | Array<ItemType | ItemTypeGroup>, container: IContainer | undefined, quality?: Quality, human?: Human, movingMultiple?: boolean, updateTables?: boolean): Item;
+    create(itemType: ItemType | ItemTypeGroup | Array<ItemType | ItemTypeGroup>, container: IContainer | undefined, quality?: Quality, human?: Human, updateTables?: boolean): Item;
     createFake(itemType: ItemType | ItemTypeGroup | Array<ItemType | ItemTypeGroup>, quality?: Quality, human?: Human): Item;
     getContainedContainers(container: IContainer): IContainer[];
-    moveAllFromContainerToInventory(human: Human, container: IContainer, ofQuality?: Quality): Item[];
     computeContainerWeight(container: IContainer): number;
     getMagicalWeightCapacity(container: IContainer): number;
-    moveAllFromContainerToContainer(human: Human | undefined, fromContainer: IContainer, toContainer: IContainer, itemType?: ItemType | undefined, ofQuality?: Quality | undefined, checkWeight?: boolean, filterText?: string | undefined, onMoveItem?: (item: Item) => void, moveToTileOptions?: IMoveToTileOptions): Item[];
-    /**
-     * Moves an item into a container when the container has enough room for it
-     * @param human Human causing the item movement
-     * @param item Item to move
-     * @param container Container to move the item to
-     * @param moveToTileOptions When set, the movement will be animated
-     * @returns True if the item was moved, false if it wasn't
-     */
-    moveToContainer(human: Human | undefined, item: Item, container: IContainer, moveToTileOptions?: IMoveToTileOptions): boolean;
     hasRoomInContainer(targetContainer: IContainer, itemToMove: Item): boolean;
     /**
      * Gets the name of a container
      * @returns Name of the container or undefined if it's ending up on the ground
      */
     getContainerName(container: IContainer): Translation | undefined;
-    breakContainerOnTile(itemContainer: Item, x: number, y: number, z: number): void;
     /**
-     * Drop items in a 3x3 square around the location
+     * Will break a container item on a tile, and remove it after (whether or not if it's a container)
+     */
+    breakContainerOnTile(itemContainer: Item, tile: Tile): void;
+    /**
+     * Drop items in a 3x3 square around the location.
+     * This will ensure all items in the container are removed
      */
-    placeItemsAroundLocation(container: IContainer, x: number, y: number, z: number, skipMessage?: boolean): void;
+    placeItemsAroundTile(container: IContainer, tile: Tile, skipMessage?: boolean): void;
     /**
      * Returns the "processed" weight of the given item.
      * - If the item is a "raw" item — ie, it was not created from other items, this is the `weightFraction` lerping the item's min & max weight.
@@ -180,26 +208,18 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     getItemTypes(): readonly ItemType[];
     getItemsWithRecipes(): readonly ItemType[];
     getBestItemForTier(item: ItemType | ItemTypeGroup): ItemType | undefined;
-    isItemAcceptedAsOffer(item: ItemType): boolean | undefined;
-    isItemUsedInRecipe(item: ItemType): boolean | undefined;
-    isItemUsedForGrowingPlants(item: ItemType): boolean | undefined;
+    isItemAcceptedAsOffer(item: ItemType): boolean;
+    isItemUsedInRecipe(item: ItemType): boolean;
+    isItemUsedForGrowingPlants(item: ItemType): boolean;
     getHighestItemActionTierForAction(action: ActionType): number;
     isGroup(item: ItemType | ItemTypeGroup): item is ItemTypeGroup;
     isInGroup(itemType: ItemType, itemGroup: ItemTypeGroup | ItemType): boolean;
+    isItemExtra(type: number): type is ItemTypeExtra;
     getGroupItems(itemGroup: ItemType | ItemTypeGroup): Set<ItemType>;
-    getItemTypeGroupName(itemType: ItemType | ItemTypeGroup, article?: false | "definite" | "indefinite", count?: number): Translation;
+    getItemTypeGroupName(itemType: ItemType | ItemTypeGroup, article?: Article, count?: number): Translation;
     getGroupDefault(itemGroup: ItemTypeGroup, weightType?: WeightType, ancestorGroups?: ItemTypeGroup[]): ItemType;
     getGroups(itemType: ItemType): ItemTypeGroup[];
     getPlayerFromInventoryContainer(containable: IContainable): Player | undefined;
-    /**
-     * Used to spawn a random item on the current biome type and at a set location (and terrain type) based on spawnOnWorldGen properties in item descriptions.
-     * @param terrainType The terrain type to check.
-     * @param x The x coordinate to check.
-     * @param y The y coordinate to check.
-     * @param z The z coordinate to check.
-     */
-    spawn(terrainType: TerrainType, x: number, y: number, z: number): void;
-    getTileContainer(x: number, y: number, z: number, tile?: ITile): IContainer | undefined;
     getRandomQuality(bonusQuality?: number, relicChance?: boolean): Quality;
     hasAdditionalRequirements(actionOrHuman: IActionHandlerApi<Human> | Human, craftType: ItemType, actionNotUsableMessage?: Message, isRepairOrDisassembly?: boolean): IRequirementInfo;
     /**
@@ -247,7 +267,7 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     getItemInContainer(container: IContainer, itemTypeSearch: ItemType, options?: Partial<IGetItemOptions>): Item | undefined;
     getItemForHuman(human: Human, search: ItemType | ItemTypeGroup, options?: Partial<IGetItemOptions>): Item | undefined;
     getItemInContainerByGroup(container: IContainer, itemTypeGroupSearch: ItemTypeGroup, options?: Partial<IGetItemOptions>): Item | undefined;
-    getItemInAdjacentContainersByGroup(position: IVector3, itemTypeGroupSearch: ItemTypeGroup, options?: Partial<IGetItemsOptions>): Item | undefined;
+    getItemInAdjacentContainersByGroup(human: Human, itemTypeGroupSearch: ItemTypeGroup, options?: Partial<IGetItemsOptions>): Item | undefined;
     getItemsInContainer(container: IContainer, options?: Partial<IGetItemsOptions>): Item[];
     getItemsInContainerByType(container: IContainer, itemType: ItemType, options?: Partial<IGetItemsOptions>, filterText?: string): Item[];
     getItemsInContainerByGroup(container: IContainer, itemGroup: ItemTypeGroup, options?: Partial<IGetItemsOptions>): Item[];
@@ -261,8 +281,9 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
      * @returns whether the given containable is, or is contained within, a trade container
      */
     isContainableInTradeContainer(containable: IContainable): boolean;
-    getTradeContainerForContainer(containable: IContainer | undefined): IContainer | undefined;
-    getAdjacentContainers(humanOrPosition: Human | IVector3, includeNpcs?: boolean, ignoreOptions?: boolean): IContainer[];
+    getTradeContainerForContainer(containable: IContainable | undefined): IContainable | undefined;
+    getContainerTypeForContainer(containable: IContainable | undefined, containerType: ContainerType): IContainable | undefined;
+    getAdjacentContainers(human: Human, includeNpcs?: boolean, ignoreOptions?: boolean): IContainer[];
     isContainableInAdjacentContainer(human: Human, containable: IContainable, includeNpcs?: boolean, ignoreOptions?: boolean): boolean;
     isInInventory(containable: IContainable): boolean;
     isTileContainer(container: IContainer | undefined): boolean;
@@ -274,23 +295,22 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     capWeightOfItems(createdItems: Item[], itemWeight: number): void;
     getItemTypeTranslation(itemType: ItemType | ItemTypeGroup): Translation;
     getItemTypeTranslation(itemType: ItemType | ItemTypeGroup, count: number): Translation;
-    getItemTypeTranslation(itemType: ItemType | ItemTypeGroup, article: false | "definite" | "indefinite"): Translation;
-    getItemTypeTranslation(itemType: ItemType | ItemTypeGroup, count: number, article: false | "definite" | "indefinite"): Translation;
-    getItemTypeTranslation(itemType: ItemType | ItemTypeGroup, count?: number, article?: false | "definite" | "indefinite"): Translation;
+    getItemTypeTranslation(itemType: ItemType | ItemTypeGroup, article: Article): Translation;
+    getItemTypeTranslation(itemType: ItemType | ItemTypeGroup, count: number, article: Article): Translation;
+    getItemTypeTranslation(itemType: ItemType | ItemTypeGroup, count?: number, article?: Article): Translation;
     getItemTypeListTranslation(itemTypes: Array<ItemType | ItemTypeGroup>): TranslationImpl;
     /**
      * Maps each item in the given array to its name translation.
      * @param article Whether the item name translation should include an article
      * @param formatter A formatting translation that should be used for each item translation
      */
-    getItemTranslations(items: Item[], article?: false | "definite" | "indefinite", formatter?: Translation): TranslationImpl[];
+    getItemTranslations(items: Item[], article?: Article, formatter?: Translation): TranslationImpl[];
     /**
      * Formats a list translation out of an array of items.
      * @param listEnder The way the list should end (ie `and`, `or`, etc)
      */
     getItemListTranslation(items: Item[], listEnder?: ListEnder | false): TranslationImpl;
     saveTileReferences(): void;
-    checkMilestones(human: Human, item: Item): void;
     getDefaultDurability(human: Human | undefined, weight: number, itemType: ItemType, getMax?: boolean): number;
     updateItemOrder(container: IContainer, itemOrder: number[] | undefined): void;
     /**
@@ -304,7 +324,7 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     getNPCFromInventoryContainer(containable: IContainable): NPC | undefined;
     getItemsByWeight(a: number, b: number): number;
     getItemsWeight(items: Item[]): number;
-    copyProperties(item: Item, item2: Item): void;
+    copyProperties(toItem: Item, fromItem: Item): void;
     getCraftQualityBonus(item: Item, required?: boolean): number;
     /**
      * Checks if the item type or item is filtered from inventory/crafting/container dialogs.
@@ -317,10 +337,10 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
      * Summons a void dweller based on item worth and chance or provides a hint message.
      * @param item Item to get the worth of.
      * @param human The human that is dropping the item.
-     * @param point The point in which we are dropping the item.
+     * @param tile The tile in which we are dropping the item.
      * @returns True or false based on if we get a message or not.
      */
-    summonVoidDweller(item: Item, human: Human, point: IVector3): boolean;
+    summonVoidDweller(item: Item, human: Human, tile: Tile): boolean;
     /**
      * Note: don't print items to the console because the console will hold the item indefinitely
      */
@@ -332,4 +352,13 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     getCraftChance(human: Human, recipe: IRecipe, qualityBonus: number, returnQuality?: boolean): number;
     getCraftResultChances(human: Human, recipe: IRecipe, qualityBonus: number): Readonly<ICraftResultChances>;
     isCraftSuccessful(human: Human, recipe: IRecipe, qualityBonus: number): CraftResult;
+    /**
+     * Get the civilization score based on contained books/text
+     * @returns number that corresponds to how much civilization score is contained within.
+     */
+    getCivilizationContentsScore(container: Item | Doodad): number;
+    /**
+     * Runs a thing the container + parent containers
+     */
+    private forEachContainer;
 }

package/definitions/game/game/item/ItemMapManager.d.ts

@@ -20,8 +20,9 @@ export default class ItemMapManager {
     static getMapsInContainer(island: Island, container: IContainer): Item[];
     private map?;
     private subscribedToDiscoverTreasure;
-    private readonly host;
-    constructor(host: Item);
+    private host;
+    constructor(item?: Item);
+    setHost(item: Item): void;
     has(): boolean;
     /**
      * Sets the map associated with this item.

package/definitions/game/game/item/WorldContainer.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 { IContainer } from "game/item/IItem";
+import type Item from "game/item/Item";
+export declare class WorldContainer implements IContainer {
+    readonly containedItems: Item[];
+    toString(): string;
+}

package/definitions/game/game/item/recipe/Crafter.d.ts

@@ -44,11 +44,11 @@ export default class Crafter {
     private quality?;
     constructor(recipe: Recipe, crafter: Entity, accessibleItems: Item[]);
     /**
-     * Gets a stream of the tiles around the crafter entity.
+     * Gets an array of the tiles around the crafter entity.
      * @param includeCrafterTile Whether the tile the crafter is on should be included. Defaults to `true`.
      */
-    tilesAroundCrafter(includeCrafterTile?: boolean): Stream<import("../../tile/ITerrain").ITile>;
-    getCrafter(): Entity;
+    tilesAroundCrafter(includeCrafterTile?: boolean): import("../../tile/Tile").default[];
+    getCrafter(): Entity<unknown, number, unknown, unknown>;
     getUsable<R extends RecipeRequirementType>(type: R, requirement: InstanceType<RecipeRequirementClass<R>>): Set<RecipeInputType<R>>;
     getUsed<R extends RecipeRequirementType>(type: R, requirement?: InstanceType<RecipeRequirementClass<R>>): Stream<RecipeInputType<R>>;
     /**

package/definitions/game/game/item/recipe/RecipeRequirement.d.ts

@@ -11,7 +11,7 @@
 import type Doodad from "game/doodad/Doodad";
 import type Item from "game/item/Item";
 import type Crafter from "game/item/recipe/Crafter";
-import type { ITile } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
 export declare enum RecipeRequirementType {
     Item = 0,
     Tool = 1,
@@ -22,7 +22,7 @@ export interface RecipeInputTypeMap {
     [RecipeRequirementType.Item]: Item;
     [RecipeRequirementType.Tool]: Item;
     [RecipeRequirementType.Doodad]: Doodad;
-    [RecipeRequirementType.Fire]: ITile;
+    [RecipeRequirementType.Fire]: Tile;
 }
 export type RecipeInputType<R extends RecipeRequirementType = RecipeRequirementType> = RecipeInputTypeMap[R];
 export interface IRecipeInputUseStrategy<R extends RecipeRequirementType> {

package/definitions/game/game/item/recipe/requirement/FireRequirement.d.ts

@@ -10,11 +10,11 @@
  */
 import type Crafter from "game/item/recipe/Crafter";
 import RecipeRequirement, { RecipeRequirementType } from "game/item/recipe/RecipeRequirement";
-import type { ITile } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
 export default class FireRequirement extends RecipeRequirement<RecipeRequirementType.Fire> {
     static readonly BASE: FireRequirement;
     constructor();
-    getUsable(api: Crafter): import("@wayward/goodstream").default<ITile>;
+    getUsable(api: Crafter): Tile[];
     isMet(api: Crafter): boolean;
     private onCraft;
 }

package/definitions/game/game/magic/MagicalPropertyManager.d.ts

@@ -14,7 +14,7 @@ import { MagicalPropertyType } from "game/magic/MagicalPropertyType";
 import type { ListEnder } from "language/ITranslation";
 import Translation from "language/Translation";
 export interface IHasMagic {
-    magic: MagicalPropertyManager;
+    magic?: MagicalPropertyManager;
 }
 export interface IMagicalProperty {
     value: number;
@@ -105,6 +105,7 @@ export default class MagicalPropertyManager extends EventEmitter.Host<IMagicalPr
     private cachedNormalTypes?;
     private cachedSubTypes?;
     private cachedHash?;
+    static inherit(source: IHasMagic | MagicalPropertyManager | undefined, target: IHasMagic): void;
     constructor(properties?: Partial<Record<MagicalPropertyType, AnyMagicalProperty>>);
     /**
      * @returns the number of magical properties on this object
@@ -194,14 +195,6 @@ export default class MagicalPropertyManager extends EventEmitter.Host<IMagicalPr
      * @returns a list of all the magical properties on this object,
      */
     all(intersectionType: true): MagicalPropertyEntryIntersection[];
-    /**
-     * Alias of `.all().stream()`
-     */
-    stream(): import("@wayward/goodstream").default<MagicalPropertyEntry>;
-    /**
-     * Alias of `.types().stream()`
-     */
-    typeStream(): import("@wayward/goodstream").default<MagicalPropertyType>;
     /**
      * Translates a list of the magical properties on this object, including sub-properties
      * @param ender The way to end this list translation, ie and/or

package/definitions/game/game/magic/MagicalPropertyType.d.ts

@@ -8,6 +8,7 @@
  * 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 { DamageType } from "game/entity/IEntity";
 import { SkillType } from "game/entity/IHuman";
 import { Stat } from "game/entity/IStats";
 import type { IItemDescription, IMagicalPropertyInfo } from "game/item/IItem";
@@ -56,7 +57,16 @@ export declare enum MagicalPropertyType {
     /**
      * Adds a bonus to the growth speed for plants and mushrooms planted on it.
      */
-    GrowingSpeed = 25
+    GrowingSpeed = 25,
+    /**
+     * Adds "light" to any piece of equipment/weapon.
+     */
+    Glowing = 26,
+    /**
+     * Adds a property that emits skill bonus to anybody within range (3x3 square) of the doodad.
+     */
+    DoodadSkill = 27,
+    ElementalDamage = 28
 }
 export interface IMagicalPropertyDescription {
     /**
@@ -77,5 +87,7 @@ export interface MagicalPropertyTypeSubTypeMap {
     [MagicalPropertyType.Stat]: Stat;
     [MagicalPropertyType.Skill]: SkillType;
     [MagicalPropertyType.Reputation]: Stat;
+    [MagicalPropertyType.DoodadSkill]: SkillType;
+    [MagicalPropertyType.ElementalDamage]: DamageType;
 }
 export declare const magicalPropertyDescriptions: PartialRecord<MagicalPropertyType, IMagicalPropertyDescription>;

package/definitions/game/game/mapgen/IMapGen.d.ts

@@ -9,13 +9,21 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { BiomeTypes } from "game/biome/IBiome";
+import type { ITemplateBiomeOptions } from "game/biome/template/Template";
 import type { MapGenDoodadTrees } from "game/doodad/IDoodad";
 import type Island from "game/island/Island";
 import type MapGenHelpers from "game/mapgen/MapGenHelpers";
-import type { Load } from "game/meta/Loading";
-import type { TileTemplateType } from "game/tile/ITerrain";
+import type { Load, MultiplayerLoadingDescription } from "game/meta/Loading";
+import type { ITemplate, TileTemplateType } from "game/tile/ITerrain";
 import type { IVector3 } from "utilities/math/IVector";
 export type MapGenVersions<T> = Descriptions<string, T>;
+export interface IMapGenGenerateWorldOptions {
+    island: Island;
+    generateNewWorld: boolean;
+    templateBiomeOptions?: ITemplateBiomeOptions;
+    multiplayerLoadingDescription?: MultiplayerLoadingDescription;
+    disableLoadingScreen?: boolean;
+}
 export interface IMapGen {
     generateWorld(options: IMapGenOptions): void;
 }
@@ -23,8 +31,9 @@ export interface IMapGenOptions {
     island: Island;
     generateNewWorld: boolean;
     biomeType: BiomeTypes;
+    templateBiomeOptions?: ITemplateBiomeOptions;
     mapGenVersion: string;
-    load: Load;
+    load: Load | undefined;
     loadArgs: any[];
 }
 export interface IBiomeMapGen {
@@ -40,6 +49,7 @@ export interface IBiomeMapGen {
 }
 export interface IMapGenGenerateInput {
     mapSize: number;
+    templateBiomeOptions?: ITemplateBiomeOptions;
     tileTypeDoodadOffset: number;
     zMin: number;
     zMax: number;
@@ -51,7 +61,7 @@ export interface IMapGenGenerateInput {
     getBiomeHeightMap(x: number, y: number): number;
     getRandomQuality(tileType: number): number;
     setTileGen(x: number, y: number, z: number, value: number): void;
-    setDoodad(type: MapGenDoodadTrees, override?: number): number;
+    setDoodad(type: MapGenDoodadTrees, compatOverride?: boolean): number;
     setTileVein(x: number, y: number, z: number, value: number, terrainType: number): void;
     setCaveOres(dValue: number, tileData: number, x: number, y: number, z: number): void;
 }
@@ -60,6 +70,7 @@ export interface IMapGenPostProcessInput {
     tileTypeDoodadOffset: number;
     tileGenArray: Uint16Array;
     tileGenQualityArray: Uint16Array;
+    templateBiomeOptions?: ITemplateBiomeOptions;
 }
 export interface IMapGenGenerateOutput {
     spawnCoords: IVector3;
@@ -69,7 +80,7 @@ export interface IMapGenGenerateOutput {
 }
 export type CaveSpawns = Array<[number, number]>;
 export type WaterSpawns = Array<[number, number, number]>;
-export type TemplateSpawn = [TileTemplateType, number, number, number, MapGenHelpers.ITemplateOptions?];
+export type TemplateSpawn = [TileTemplateType | ITemplate, number, number, number, MapGenHelpers.ITemplateOptions?];
 export type TemplateSpawns = TemplateSpawn[];
 export declare const tileTypeDoodadOffset = 256;
 export default IMapGen;

package/definitions/game/game/mapgen/MapGen.d.ts

@@ -8,10 +8,5 @@
  * 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 Island from "game/island/Island";
-import type { MultiplayerLoadingDescription } from "game/meta/Loading";
-export declare function generateWorld({ island, generateNewWorld, multiplayerLoadingDescription }: {
-    island: Island;
-    generateNewWorld: boolean;
-    multiplayerLoadingDescription?: MultiplayerLoadingDescription;
-}): Promise<void>;
+import type { IMapGenGenerateWorldOptions } from "game/mapgen/IMapGen";
+export declare function generateWorld(options: IMapGenGenerateWorldOptions): Promise<void>;