@wayward/types 2.15.0-beta.dev.20251008.1 → 2.15.0-beta.dev.20251010.1

package/definitions/game/audio/IAudio.d.ts

@@ -71,7 +71,8 @@ export declare enum SfxType {
     UiUnstack = 59,
     Walk = 60,
     Water = 61,
-    Wheelbarrow = 62
+    Wheelbarrow = 62,
+    CraftFail = 63
 }
 export type SfxUi = Extract<keyof typeof SfxType, `Ui${string}`> extends `Ui${infer RESULT}` ? Lowercase<RESULT> : never;
 export declare enum Music {

package/definitions/game/game/curse/Curse.d.ts

@@ -16,13 +16,24 @@ import { SkillType } from "@wayward/game/game/entity/IHuman";
 import type Island from "@wayward/game/game/island/Island";
 import type { IVector2 } from "@wayward/game/utilities/math/IVector";
 import { IRange, IRangeRange } from "@wayward/utilities/math/Range";
-export declare const CURSE_WEIGHTS: PartialRecord<CurseComponent, number>;
-export declare const CURSE_ATTACK_MAX = 50;
-export declare const CURSE_DEFENSE_MAX = 100;
-export declare const CURSE_CRAFTING_MAX = 100;
-export declare const CURSE_KILLING_MAX = 100;
-export declare const CURSE_SKILL_MAX = 100;
-export declare const CURSE_COMPONENTS: Record<CurseComponent, (human: Human) => number>;
+import DataComponent from "@wayward/game/game/entity/data/DataComponent";
+export declare const CURSE_CAP = 10000;
+export declare const CURSE_COMPONENT_ATTACK_CAP = 50;
+export declare const CURSE_COMPONENT_DEFENSE_CAP = 100;
+export declare const CURSE_COMPONENT_CRAFTING_CAP = 3000;
+export declare const CURSE_COMPONENT_KILLING_CAP = 500;
+export declare const CURSE_COMPONENT_SKILL_CAP = 100;
+export declare const CURSE_COMPONENT_SLEEPLESSNESS_CAP_DAYS = 6;
+interface CurseComponentDefinition {
+    readonly maxCurseContribution: number | null;
+    compute(human: Human): number;
+}
+export declare const CURSE_COMPONENTS: Record<CurseComponent, CurseComponentDefinition>;
+export declare const CumulativeEvilCrafting: DataComponent<number, number>;
+export declare const CumulativeKilling: DataComponent<number, number>;
+export declare const Sleeplessness: DataComponent<number, number>;
+export declare const HighestAttack: DataComponent.Live<number>;
+export declare const HighestDefense: DataComponent.Live<number>;
 /**
  * Gets the highest value of either current or max skill multiplied by the "evilness" of each skill (from rune chance)
  * (Basically, high values in any of the evil-er skills make curse go brrrr)
@@ -34,6 +45,7 @@ declare function getSkillValue(human: Human): {
 declare namespace Curse {
     const getSkill: typeof getSkillValue;
     function getComponentValue(human: Human, component: CurseComponent): number;
+    function getComponentCap(component: CurseComponent): number | null;
     function getValue(human: Human): number;
 }
 /**
@@ -90,6 +102,7 @@ declare namespace Curse {
 }
 declare const SYMBOL_CURSE_EVENT_SUBSCRIBER_INSTANCES: unique symbol;
 declare const SYMBOL_CURSE_EVENT_GLOBAL_SUBSCRIBER_INSTANCE: unique symbol;
+declare const SYMBOL_CURSE_EVENT_ACTIVE_SUBSCRIBER_INSTANCE: unique symbol;
 interface Curse {
     night?: true;
     events?: CurseEventInstance[];
@@ -97,6 +110,7 @@ interface Curse {
     warned?: true;
     ephemeralCreatures?: number[];
     [SYMBOL_CURSE_EVENT_GLOBAL_SUBSCRIBER_INSTANCE]?: CurseEventSubscriber;
+    [SYMBOL_CURSE_EVENT_ACTIVE_SUBSCRIBER_INSTANCE]?: CurseEventSubscriber;
 }
 interface CurseEventInstance {
     type: CurseEventType;

package/definitions/game/game/curse/ICurse.d.ts

@@ -63,12 +63,11 @@ export declare enum CursePosition {
 }
 export declare enum CurseComponent {
     Skill = 0,
-    HighestAttack = 1,
-    HighestDefense = 2,
-    CumulativeEvilCrafting = 3,
-    Equipment = 4,
-    Modifier = 5,
-    CumulativeKilling = 6
+    AttackDefense = 1,
+    CumulativeEvilCrafting = 2,
+    Modifier = 3,
+    CumulativeKilling = 4,
+    Sleeplessness = 5
 }
 export declare enum CurseSystemDiscovery {
     CurseFactors = 0,

package/definitions/game/game/doodad/Doodad.d.ts

@@ -398,6 +398,11 @@ export default class Doodad extends EntityMovable<IDoodadDescription, DoodadType
      * Gets the skill type associated with the doodad, or choose a random one if the description is an array.
      */
     getSkillUse(): SkillType;
+    /**
+     * Checks if a solar still can work in the current temperature.
+     * @returns True if the solar still can work in the current temperature, false if not.
+     */
+    willStillWorkInTemperature(): boolean;
     /**
      * Decay over time
      */

package/definitions/game/game/doodad/DoodadManager.d.ts

@@ -86,7 +86,7 @@ export default class DoodadManager extends EntityManager<Doodad> {
      */
     updateAllAsync(ticks: number, playingHumans: Human[], playerHumanTiles: Set<Tile>, onProgress: (progess: number) => Promise<void>): Promise<void>;
     verifyAndFixItemWeights(): void;
-    getScarecrowInRange(tile: Tile): Doodad | undefined;
+    getScarecrowInRange(tile: Tile, group?: DoodadTypeGroup): Doodad | undefined;
     getScarecrowInLineOfSight(creature: Creature, isClientside: boolean): Doodad | undefined;
     addScarecrow(doodad: Doodad): void;
     removeScarecrow(doodad: Doodad): void;

package/definitions/game/game/doodad/IDoodad.d.ts

@@ -17,6 +17,7 @@ import type { SkillType } from "@wayward/game/game/entity/IHuman";
 import type { IDecayTemperatureRange } from "@wayward/game/game/IGame";
 import type { ILootItem } from "@wayward/game/game/ILoot";
 import type { IObjectDescription, IObjectOptions } from "@wayward/game/game/IObject";
+import type { WaterType } from "@wayward/game/game/island/IIsland";
 import type Island from "@wayward/game/game/island/Island";
 import type { IContainer, IItemOld, ItemType, ItemTypeExtra, ItemTypeGroup } from "@wayward/game/game/item/IItem";
 import type Item from "@wayward/game/game/item/Item";
@@ -528,7 +529,8 @@ export declare enum DoodadTypeGroup {
     Altar = -9978,
     OpenFireSource = -9977,
     RequiresCandleToLight = -9976,
-    ContainsFuelSource = -9975
+    ContainsFuelSource = -9975,
+    CurseWard = -9974
 }
 export declare enum DoorOrientation {
     /**
@@ -559,6 +561,7 @@ export interface IHasBuilder {
 export interface IHasWater {
     top?: true;
     bottom?: true;
+    waterType?: WaterType;
 }
 export interface IDoodadGetNameOptions {
     count: number;

package/definitions/game/game/entity/Human.d.ts

@@ -127,10 +127,6 @@ export default abstract class Human<DescriptionType = unknown, TypeType extends
     quests: IQuestManager;
     messages: IMessageManager;
     notes: INoteManager;
-    highestAttack?: number;
-    highestDefense?: number;
-    cumulativeEvilCrafting: number;
-    cumulativeKilling: number;
     itemDiscovered: ItemType[];
     private _humanTags?;
     /** @deprecated (use the entity itself) */

package/definitions/game/game/entity/creature/CreatureManager.d.ts

@@ -10,8 +10,8 @@
  */
 import CombatStrengthManager from "@wayward/game/game/entity/CombatStrengthManager";
 import Creature from "@wayward/game/game/entity/creature/Creature";
-import type { ICreatureCheckMoveOptions } from "@wayward/game/game/entity/creature/ICreature";
-import { CreatureType, TileGroup } from "@wayward/game/game/entity/creature/ICreature";
+import type { ICreatureCheckMoveOptions, ICreatureSpawnOptions } from "@wayward/game/game/entity/creature/ICreature";
+import { CreatureType } from "@wayward/game/game/entity/creature/ICreature";
 import type { IEntityRemoveOptions } from "@wayward/game/game/entity/EntityManager";
 import EntityManager from "@wayward/game/game/entity/EntityManager";
 import type Human from "@wayward/game/game/entity/Human";
@@ -48,12 +48,8 @@ export default class CreatureManager extends EntityManager<Creature, IEntityRemo
      * Spawns a creature.
      * @param type The type of creature to spawn.
      * @param tile The tile
-     * @param bypass Whether to bypass checks for whether the creature can spawn there naturally. Defaults to false, if the creature can't spawn naturally, it won't.
-     * @param forceAberrant If provided, forces the spawned creature's aberrant state to be the passed boolean. True = aberrant, false = not aberrant. If not provided, the aberrant state is decided based on chance.
-     * @param spawnTiles If set, this will overwrite the creature's description for which tiles it can spawn on
-     * @param bypassCreatureLimit If set, the creature limit will be ignored and spawn the creature over the set limit
      */
-    spawn(type: CreatureType, tile: Tile, bypass?: boolean, forceAberrant?: boolean, spawnTiles?: TileGroup, bypassCreatureLimit?: boolean, bypassAll?: boolean): Creature | undefined;
+    spawn(type: CreatureType, tile: Tile, options?: ICreatureSpawnOptions): Creature | undefined;
     spawnFromZone(tile: Tile, bypassCreatureLimit?: boolean, checkTerrainType?: boolean): Creature | undefined;
     createFake(type: CreatureType, aberrant: boolean, tile?: Tile, id?: number): Creature;
     exists(creature: Creature): boolean;

package/definitions/game/game/entity/creature/ICreature.d.ts

@@ -521,3 +521,29 @@ export interface ICreatureCheckMoveOptions {
     ignoreScareCrow: boolean;
     ignoreMoveTypeNone: boolean;
 }
+export interface ICreatureSpawnOptions {
+    /**
+     * If set to true, the creature will ignore blocked or full tile checks as well as ignore spawnTiles definitions set on the creature.
+     */
+    bypassTiles?: boolean;
+    /**
+     * If provided, forces the spawned creature's aberrant state to be the passed boolean. True = aberrant, false = not aberrant. If not provided, the aberrant state is decided based on chance.
+     */
+    forceAberrant?: boolean;
+    /**
+     * If set, this will overwrite the creature's description for which tiles it can spawn on. This will also change which tiles it can path on to, differing from its set definitions.
+     */
+    spawnTiles?: TileGroup;
+    /**
+     * If set to true, this will bypass the current zone's creature limit and spawn it regardless.
+     */
+    bypassCreatureLimit?: boolean;
+    /**
+     * If set to true, the creatures will ignore scarecrows when spawning. Note that this does NOT ignore the chance of being scared by a scarecrow when moving, just the initial spawn checks.
+     */
+    bypassScarecrows?: boolean;
+    /**
+     * If set to true, all checks will be bypassed and the creature will spawn no matter what.
+     */
+    bypassAll?: boolean;
+}

package/definitions/game/game/entity/data/DataComponent.d.ts

@@ -0,0 +1,38 @@
+/*!
+ * Copyright 2011-2025 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 Entity from "@wayward/game/game/entity/Entity";
+export declare enum DataComponentType {
+    None = 0,
+    CurseSleeplessness = 1,
+    CurseCumulativeEvilCrafting = 2,
+    CurseCumulativeKilling = 3,
+    CurseHighestAttack = 4,
+    CurseHighestDefense = 5
+}
+interface DataComponent<T, DEFAULT_VALUE extends T | undefined = undefined> {
+    readonly type: DataComponentType;
+    has(entity: Entity): boolean;
+    get(entity: Entity): T | DEFAULT_VALUE;
+    compute(entity: Entity, compute: (defaultValue: DEFAULT_VALUE) => T): T;
+    set(entity: Entity, value: T): void;
+    modify(entity: Entity, modify: (current: T | DEFAULT_VALUE) => T): T;
+    remove(entity: Entity): void;
+}
+declare function DataComponent<T>(type: DataComponentType, defaultValue: T): DataComponent<T, T>;
+declare function DataComponent<T>(type: DataComponentType, defaultValue?: T): DataComponent<T>;
+declare namespace DataComponent {
+    interface Live<T> {
+        get(entity: Entity): T;
+        update(entity: Entity): void;
+    }
+    function Live<T>(type: DataComponentType, compute: (entity: Entity, current: T | undefined) => T): Live<T>;
+}
+export default DataComponent;

package/definitions/game/game/inspection/infoProviders/doodad/StillWater.d.ts

@@ -16,6 +16,7 @@ export default class StillWaterInfoProvider extends InfoProvider {
     private readonly waterTopMessage;
     private readonly waterBottomMessage;
     private readonly waterContainerMessage;
+    private readonly willStillWorkInTemperature;
     private constructor();
     getClass(): string[];
     hasContent(): boolean;

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

@@ -29,6 +29,7 @@ import type Corpse from "@wayward/game/game/entity/creature/corpse/Corpse";
 import type NPC from "@wayward/game/game/entity/npc/NPC";
 import type Player from "@wayward/game/game/entity/player/Player";
 import type { IMobCheck, IslandId } from "@wayward/game/game/island/IIsland";
+import { WaterType } from "@wayward/game/game/island/IIsland";
 import type { ContainerReference, DisplayableItemType, IConstructedInfo, IContainable, IContainer, IItemChangeIntoOptions, IItemDescription, IItemDisassembleResult, IItemDisassembly, IItemGetNameOptions, IItemUsed, IItemVehicle, IMagicalPropertyInfo, IItemMovementResult as IMoveToTileMobCheckResult, IMoveToTileOptions, ItemTag } from "@wayward/game/game/item/IItem";
 import { ItemTypeExtra } from "@wayward/game/game/item/IItem";
 import { BookType, ContainerSort, ItemDamageResult, ItemType, ItemTypeGroup, ItemWeightChange, SYMBOL_CONTAINER_CACHED_REFERENCE } from "@wayward/game/game/item/IItem";
@@ -525,6 +526,11 @@ export default class Item extends EntityMovable<IItemDescription, ItemType, Refe
      */
     getReturnType(): ItemType;
     createReturnItem(returnType: ItemType, container?: IContainer): Item | undefined;
+    /**
+     * Returns the type of water contained in the item in the case of containers of liquid.
+     * @returns WaterType enum value.
+     */
+    getWaterType(): WaterType;
     private checkIfItemsMatch;
     private checkIfItemArraysMatch;
 }