@wayward/types 2.12.0-beta.dev.20220921.1 → 2.12.0-beta.dev.20220923.1

package/definitions/game/game/IObject.d.ts

@@ -21,6 +21,7 @@ export interface IObject<T> {
     renamed?: string | ISerializedTranslation;
 }
 export interface IObjectDescription extends IHasImagePath {
+    storeDecay?: boolean;
     decayMax?: number;
     skillUse?: SkillType;
     weightCapacity?: number;

package/definitions/game/game/entity/action/actions/Cast.d.ts

@@ -9,12 +9,15 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import { Action } from "game/entity/action/Action";
+import TreasureGathering from "game/entity/action/actions/helper/TreasureGathering";
 import type { IActionUsable } from "game/entity/action/IAction";
 import { ActionArgument } from "game/entity/action/IAction";
 import type { IRanged } from "game/item/IItem";
-import type Item from "game/item/Item";
 export interface ICastCanUse extends IActionUsable {
     ranged: IRanged;
+    itemRange: number;
+    maxFishingRange: number;
+    canGatherTreasure?: TreasureGathering.ICanGather;
 }
-declare const _default: Action<[ActionArgument.ItemInventory], import("../../Human").default, void, ICastCanUse, [Item]>;
+declare const _default: Action<[ActionArgument.ItemInventory], import("../../Human").default, void, ICastCanUse, [import("../../../item/Item").default]>;
 export default _default;

package/definitions/game/game/entity/action/actions/helper/TreasureGathering.d.ts

@@ -0,0 +1,48 @@
+/*!
+ * 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 { IActionHandlerApi } from "game/entity/action/IAction";
+import type Human from "game/entity/Human";
+import type Item from "game/item/Item";
+import type DrawnMap from "game/mapping/DrawnMap";
+import type { ITreasure } from "game/mapping/DrawnMap";
+import type { IVector3 } from "utilities/math/IVector";
+declare namespace TreasureGathering {
+    interface IGatherable {
+        map: DrawnMap;
+        mapItem?: Item;
+        toolRange?: number;
+        maxRange?: number;
+        treasure: ITreasure;
+        position: IVector3;
+    }
+    enum GatherablesResult {
+        Blocked = 0,
+        NoTreasure = 1,
+        NoMapsForTreasure = 2
+    }
+    interface ICanGather {
+        gatherables?: IGatherable[];
+        result?: GatherablesResult;
+    }
+    function canGather(executor: Human, itemRange: number, requireMap: boolean, maxRange?: number): ICanGather;
+    enum Result {
+        NoTreasure = 0,
+        NotYet = 1,
+        Gathered = 2
+    }
+    interface IGatherResult {
+        result: Result;
+        position?: IVector3;
+        treasure?: ITreasure;
+    }
+    function gather(action: IActionHandlerApi<Human>, itemRange: number, requireMap: boolean, tool?: Item, canGather?: ICanGather): IGatherResult;
+}
+export default TreasureGathering;

package/definitions/game/game/entity/action/usable/UsableAction.d.ts

@@ -10,7 +10,7 @@
  */
 import type Doodad from "game/doodad/Doodad";
 import type { ActionDisplayLevel, ActionType, IActionNotUsable, IActionUsable } from "game/entity/action/IAction";
-import type UsableActionRegistrar from "game/entity/action/usable/UsableActionRegistrar";
+import UsableActionRegistrar from "game/entity/action/usable/UsableActionRegistrar";
 import type { UsableActionTypePlaceholder } from "game/entity/action/usable/UsableActionType";
 import { UsableActionType } from "game/entity/action/usable/UsableActionType";
 import type Creature from "game/entity/creature/Creature";
@@ -107,6 +107,7 @@ export declare type UsableActionIconReference = ActionType | UsableActionType |
 export declare type ReturnableUsableActionUsability = IActionUsable | IActionNotUsable | boolean;
 export interface IUsableActionUsable<REQUIREMENTS extends IUsableActionRequirements> extends IActionUsable {
     using: IUsableActionUsing<REQUIREMENTS>;
+    forceDisplay?: true;
 }
 export interface IUsableActionNotUsable extends IActionNotUsable {
     sendMessage(): void;
@@ -220,16 +221,19 @@ export interface IUsableActionDefinitionBase<REQUIREMENTS extends IUsableActionR
      */
     onlySlotItemType?: true;
     tooltip?(tooltip: Tooltip): any;
+    forceDisplayWhenEmpty?: true;
 }
 export interface IUsableActionDefinitionSubmenu<REQUIREMENTS extends IUsableActionRequirements = IUsableActionRequirements> extends IUsableActionDefinitionBase<REQUIREMENTS> {
     submenu(registrar: UsableActionRegistrar, using: IUsableActionUsing<REQUIREMENTS>): UsableActionRegistrar | void;
     execute?: undefined;
     isUsable?(player: Player, using: IUsableActionUsing<REQUIREMENTS>): ReturnableUsableActionUsability;
     slottable?: undefined;
+    forceDisplayWhenEmpty?: true;
 }
 export interface IUsableActionDefinitionExecutable<REQUIREMENTS extends IUsableActionRequirements = IUsableActionRequirements> extends IUsableActionDefinitionBase<REQUIREMENTS> {
     slottable?: boolean;
     submenu?: undefined;
+    forceDisplayWhenEmpty?: undefined;
     execute(player: Player, using: IUsableActionUsing<REQUIREMENTS>, context: IUsableActionExecutionContext): any;
     isUsable?(player: Player, using: IUsableActionUsing<REQUIREMENTS>): ReturnableUsableActionUsability;
 }
@@ -272,17 +276,22 @@ declare class UsableAction<REQUIREMENTS extends IUsableActionRequirements = IUsa
     getIcon(provided: IUsableActionPossibleUsing): IIcon | undefined;
     getHighlightSelectors(using?: IUsableActionPossibleUsing): HighlightSelector[];
     private translator?;
-    getTranslation(using?: IUsableActionUsing<REQUIREMENTS>, which?: ActionTranslation): Translation | undefined;
+    getTranslation(using?: IUsableActionPossibleUsing, which?: ActionTranslation, context?: UsableActionTranslationContext): Translation | undefined;
     getOrder(using?: IUsableActionPossibleUsing): number;
 }
+export declare enum UsableActionTranslationContext {
+    None = 0,
+    Use = 1
+}
+export declare type UsableActionTranslationArguments = [using: IUsableActionPossibleUsing, action: UsableAction, context: UsableActionTranslationContext];
 export declare class UsableActionTranslator {
     readonly id: ActionId;
     private nameSupplier?;
     private descriptionSupplier?;
     constructor(id: ActionId);
-    name(supplier: SupplierOr<Translation, [using: IUsableActionPossibleUsing, action: UsableAction]>): this;
-    description(supplier: SupplierOr<Translation, [using: IUsableActionPossibleUsing, action: UsableAction]>): this;
-    get(action: UsableAction, using?: IUsableActionPossibleUsing, which?: ActionTranslation): Translation | undefined;
+    name(supplier: SupplierOr<Translation, UsableActionTranslationArguments>): this;
+    description(supplier: SupplierOr<Translation, UsableActionTranslationArguments>): this;
+    get(action: UsableAction, using?: IUsableActionPossibleUsing, which?: ActionTranslation, context?: UsableActionTranslationContext): Translation | undefined;
 }
 export interface IUsableActionFactory<REQUIREMENTS extends IUsableActionRequirements> {
     create: <DEFINITION extends IUsableActionDefinition<REQUIREMENTS>>(action: DEFINITION) => UsableAction<REQUIREMENTS, DEFINITION>;

package/definitions/game/game/inspection/InfoProviderContext.d.ts

@@ -11,11 +11,12 @@
 import type { IInspector, InfoDisplayLevel } from "game/inspection/IInfoProvider";
 import { TextContext } from "language/ITranslation";
 export declare class InfoProviderContext {
-    readonly textContext: TextContext;
-    readonly maxDisplayLevel: InfoDisplayLevel;
     static readonly UI: new (inspector: IInspector, maxDisplayLevel: InfoDisplayLevel) => InfoProviderContext;
     static readonly RAW: new (inspector: IInspector, maxDisplayLevel: InfoDisplayLevel) => InfoProviderContext;
-    private readonly _inspector;
+    protected readonly _inspector: WeakRef<IInspector>;
+    readonly textContext: TextContext;
+    readonly maxDisplayLevel: InfoDisplayLevel;
+    constructor(context: InfoProviderContext);
     constructor(textContext: TextContext, inspector: IInspector, maxDisplayLevel: InfoDisplayLevel);
     get inspector(): IInspector | undefined;
 }

package/definitions/game/game/inspection/InspectionTypeMap.d.ts

@@ -30,6 +30,30 @@ import StatInspection from "game/inspection/inspections/StatInspection";
 import TileEventInspection from "game/inspection/inspections/TileEventInspection";
 import TileInspection from "game/inspection/inspections/TileInspection";
 import type { IVector3 } from "utilities/math/IVector";
+declare const inspectionTypeMap: {
+    12: typeof ActionInspection;
+    14: typeof CorpseInspection;
+    15: typeof CorpsesInspection;
+    3: typeof CreatureInspection;
+    10: typeof ItemInspection;
+    4: typeof DoodadInspection;
+    7: typeof EquipSlotInspection;
+    6: typeof PlayerInspection;
+    21: typeof IslandInspection;
+    8: typeof ItemInspection;
+    13: typeof ItemsInspection;
+    11: typeof ItemInspection;
+    19: typeof MilestoneInspection;
+    2: typeof NPCInspection;
+    1: typeof PlayerInspection;
+    9: typeof RecipeInspection;
+    0: typeof SelfInspection;
+    18: typeof SkillInspection;
+    20: typeof StatInspection;
+    17: typeof TileInspection;
+    5: typeof TileEventInspection;
+    16: typeof TileEventInspection.Minors;
+};
 export declare type InspectionClass = Class<Inspection<any>> & {
     isWorldInspection?(inspectType: InspectType): boolean;
     getFromTile?(position: IVector3, context: InfoProviderContext, inspectType: InspectType): ArrayOr<Inspection<any>>;
@@ -67,6 +91,7 @@ declare const _default: {
     16: typeof TileEventInspection.Minors;
 } & Record<InspectType, InspectionClass>;
 export default _default;
+export declare type ResolvedInspection<TYPE extends InspectType> = InstanceOf<(typeof inspectionTypeMap)[TYPE]>;
 export declare module Inspections {
     function get(...args: any[]): Inspection<any> | undefined;
     function isWorldInspection(type: InspectType): boolean;

package/definitions/game/game/inspection/InspectionsHandler.d.ts

@@ -21,7 +21,30 @@ export default abstract class InspectionsHandler extends EventEmitter.Host<IInsp
     protected readonly inspectionsMap: Map<InspectType, HashSet<Inspection<any>>>;
     static makeInspectionsSet(...values: Array<IterableOr<Inspection<any> | undefined>>): HashSet<Inspection<any>>;
     constructor(context: InfoProviderContext, inspectionsMap?: Map<InspectType, HashSet<Inspection<any>>>);
-    get(inspectType: InspectType): HashSet<Inspection<any>> | undefined;
+    get<TYPE extends InspectType>(inspectType: InspectType): HashSet<InstanceOf<{
+        12: typeof import("./inspections/ActionInspection").default;
+        14: typeof import("./inspections/CorpseInspection").default;
+        15: typeof import("./inspections/CorpsesInspection").default;
+        3: typeof import("./inspections/CreatureInspection").default;
+        10: typeof import("./inspections/ItemInspection").default;
+        4: typeof import("./inspections/DoodadInspection").default;
+        7: typeof import("./inspections/EquipSlotInspection").default;
+        6: typeof import("./inspections/PlayerInspection").default;
+        21: typeof import("./inspections/IslandInspection").default;
+        8: typeof import("./inspections/ItemInspection").default;
+        13: typeof import("./inspections/ItemsInspection").default;
+        11: typeof import("./inspections/ItemInspection").default;
+        19: typeof import("./inspections/MilestoneInspection").default;
+        2: typeof import("./inspections/NPCInspection").default;
+        1: typeof import("./inspections/PlayerInspection").default;
+        9: typeof import("./inspections/RecipeInspection").default;
+        0: typeof import("./inspections/SelfInspection").default;
+        18: typeof import("./inspections/SkillInspection").default;
+        20: typeof import("./inspections/StatInspection").default;
+        17: typeof import("./inspections/TileInspection").default;
+        5: typeof import("./inspections/TileEventInspection").default;
+        16: typeof import("./inspections/TileEventInspection").default.Minors;
+    }[TYPE]>> | undefined;
     set(inspectType: InspectType, inspections: HashSet<Inspection<any>>): Map<InspectType, HashSet<Inspection<any>>>;
     [Symbol.iterator](): IterableIterator<[InspectType, HashSet<Inspection<any>>]>;
     types(): import("@wayward/goodstream").default<InspectType>;

package/definitions/game/game/inspection/infoProviders/item/ItemDetails.d.ts

@@ -19,7 +19,7 @@ export default class ItemDetailsInfoProvider extends InfoProvider {
     private readonly description;
     constructor(item: Item | ItemType);
     getClass(): string[];
-    get(): (0 | LabelledValue | import("game/inspection/InfoProvider").SimpleInfoProvider | ItemWorthInfoProvider)[];
+    get(): (0 | import("game/inspection/InfoProvider").SimpleInfoProvider | LabelledValue | ItemWorthInfoProvider)[];
     private getInsulation;
     private getPreservation;
     private getGroupings;

package/definitions/game/game/inspection/infoProviders/stat/AttackInfo.d.ts

@@ -15,7 +15,7 @@ export default class AttackInfo extends InfoProvider {
     private readonly human?;
     constructor(human?: Human | undefined);
     getClass(): string[];
-    get(): (LabelledValue | import("game/inspection/InfoProvider").SimpleInfoProvider)[];
+    get(): (import("game/inspection/InfoProvider").SimpleInfoProvider | LabelledValue)[];
     private getTactics;
     private getMainHand;
     private getOffHand;

package/definitions/game/game/inspection/inspections/ActionInspection.d.ts

@@ -10,9 +10,10 @@
  */
 import { ActionType } from "game/entity/action/IAction";
 import type { IUsableActionPossibleUsing } from "game/entity/action/usable/UsableAction";
+import { UsableActionTranslationContext } from "game/entity/action/usable/UsableAction";
 import { InspectType } from "game/inspection/IInspection";
 import { InfoProvider } from "game/inspection/InfoProvider";
-import type { InfoProviderContext } from "game/inspection/InfoProviderContext";
+import { InfoProviderContext } from "game/inspection/InfoProviderContext";
 import Inspection from "game/inspection/Inspection";
 import type { EnumReferenceResolved } from "game/reference/IReferenceManager";
 import { ReferenceType } from "game/reference/IReferenceManager";
@@ -24,7 +25,8 @@ export default class ActionInspection extends Inspection<ActionType | string | u
     private readonly item?;
     using?: IUsableActionPossibleUsing;
     constructor(value?: string | EnumReferenceResolved<ReferenceType.Action>, slot?: ActionSlot | undefined);
-    setUsing(using?: IUsableActionPossibleUsing): void;
+    setUsing(using?: IUsableActionPossibleUsing): this;
+    setContext(context: UsableActionTranslationContext): this;
     getId(): string;
     get(context: InfoProviderContext): ArrayOr<TranslationGenerator | InfoProvider>;
     private getTranslation;

package/definitions/game/game/inspection/inspections/CorpseInspection.d.ts

@@ -19,7 +19,7 @@ export default class CorpseInspection extends Inspection<Corpse> {
     static getFromTile(position: IVector3): CorpseInspection[];
     static handles(type: InspectType, corpse: unknown): boolean;
     constructor(corpse: Corpse);
-    get(context: InfoProviderContext): (0 | LabelledValue | import("game/inspection/InfoProvider").SimpleInfoProvider)[];
+    get(context: InfoProviderContext): (0 | import("game/inspection/InfoProvider").SimpleInfoProvider | LabelledValue)[];
     private getDecay;
     private decay;
     private shouldRefreshDecay;

package/definitions/game/game/island/Island.d.ts

@@ -159,9 +159,13 @@ export default class Island extends EventEmitter.Host<IIslandEvents> implements
     getDefaultTerrainType(tile: ITile): TerrainType;
     checkForHiddenMob(human: Human, x: number, y: number, z: number): void;
     isMapEdge(x: number, y: number): boolean;
+    /**
+     * Ensures a point is valid and is not the edge of the map
+     */
     ensureValidPoint<T extends IVector2>(point?: T): T | undefined;
     getTileFromPoint(point: IVector3): ITile;
     getTile(x: number, y: number, z: number): ITile;
+    getTileSafe(x: number, y: number, z: number): ITile | undefined;
     setTile(x: number, y: number, z: number, tile: ITile): ITile;
     setTiles(tiles: ITile[]): void;
     getOrCreateTile(index: number): ITile;
@@ -312,7 +316,7 @@ export default class Island extends EventEmitter.Host<IIslandEvents> implements
     /**
      * @returns a range value for the weapon being shot based on the weapon range and the players skill with that weapon type. This value then becomes the maximum potential range of the current shot.
      */
-    rangeFinder(weaponRange: number, playerSkillLevel: number, useMaxRange?: boolean): number;
+    rangeFinder(weaponRange: number, playerSkillLevel: number, get?: "random" | "min" | "max"): number;
     getRandomQuality(bonusQuality?: number): Quality.None | Quality.Superior | Quality.Remarkable | Quality.Exceptional;
     getQualityDurabilityBonus(quality: Quality, itemDurability: number, getMax?: boolean): number;
     /**

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

@@ -249,6 +249,10 @@ export interface IItemDescription extends IObjectDescription, IModdable, ITemper
      */
     firedWith?: ItemTypeGroup;
     vehicle?: IItemVehicle;
+    /**
+     * If set to true, this item will not grant quality bonuses (durability/quality bonuses) when used in a craft. Aptitude and tiers will still apply.
+     */
+    noCraftingQualityBonus?: boolean;
     onEquip?(item: Item): void;
     onUnequip?(item: Item): void;
 }

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

@@ -174,10 +174,10 @@ export default class Item extends EventEmitter.Host<IItemEvents> implements IRef
     getVisualDecay(): number;
     private getVisualBarValue;
     /**
-     * Returns the maximum decay of an item, or undefined if the item does not have the decayMax property.
+     * Returns the maximum decay of an item, or undefined if the item does not have the decayMax or storeDecay property.
      * @returns A number or undefined.
      */
-    canDecay(): number | undefined;
+    canDecay(): 1 | undefined;
     getDecayRate(isClientSide: boolean): number;
     getPreservationDecayMultiplier(): number;
     getTemperatureDecayMultiplier(isClientSide: boolean): number;