@wayward/types 2.10.9-beta.dev.20211005.1 → 2.11.0-beta.dev.20211123.2

package/definitions/game/game/entity/player/Player.d.ts

@@ -0,0 +1,285 @@
+/*!
+ * 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 { IEventEmitter } from "event/EventEmitter";
+import type Doodad from "game/doodad/Doodad";
+import { ActionType } from "game/entity/action/IAction";
+import Creature from "game/entity/creature/Creature";
+import { CreatureType } from "game/entity/creature/ICreature";
+import Human from "game/entity/Human";
+import { EntityType, IStatChangeInfo, StatusEffectChangeReason, StatusType } from "game/entity/IEntity";
+import type { ICheckUnderOptions, IRestData } from "game/entity/IHuman";
+import { EquipType, RestCancelReason, RestType, SkillType } from "game/entity/IHuman";
+import type { IStat } from "game/entity/IStats";
+import { Stat } from "game/entity/IStats";
+import type { ILoadOnIslandOptions, IMovementIntent, IPlayerEvents, IWalkPath } from "game/entity/player/IPlayer";
+import { TurnType, WeightStatus } from "game/entity/player/IPlayer";
+import MessageManager from "game/entity/player/MessageManager";
+import NoteManager from "game/entity/player/note/NoteManager";
+import QuestManager from "game/entity/player/quest/QuestManager";
+import type { StatChangeCurrentTimerStrategy, StatChangeTimerFactory } from "game/entity/StatFactory";
+import type { IMoveToIslandOptions, IslandId } from "game/island/IIsland";
+import type Island from "game/island/Island";
+import type { IContainer, RecipeLevel } from "game/item/IItem";
+import { ItemType } from "game/item/IItem";
+import type Item from "game/item/Item";
+import { Milestone } from "game/milestones/IMilestone";
+import type { IGameOptionsPlayer } from "game/options/IGameOptions";
+import Message from "language/dictionary/Message";
+import type ExploreMap from "renderer/exploreMap/ExploreMap";
+import FieldOfView from "renderer/fieldOfView/FieldOfView";
+import type { CanASeeBType } from "renderer/fieldOfView/IFieldOfView";
+import type IClientStore from "save/clientStore/IClientStore";
+import type { IOptions } from "save/data/ISaveDataGlobal";
+import type { IUnserializedCallback } from "save/serializer/ISerializer";
+import type { IContainerSortInfo, IContextMenuAction, IDialogInfo, IQuickSlotInfo } from "ui/old/IOldUi";
+import { Direction } from "utilities/math/Direction";
+import type { IVector2, IVector3 } from "utilities/math/IVector";
+export default class Player extends Human implements IUnserializedCallback {
+    event: IEventEmitter<this, IPlayerEvents>;
+    readonly entityType: EntityType.Player;
+    absentLastUsedTime: number;
+    containerSortInfo: Record<string, IContainerSortInfo>;
+    dialogContainerInfo: Record<number, IDialogInfo>;
+    dialogInfo: Record<string, IDialogInfo>;
+    hintSeen: boolean[];
+    isConnecting: boolean;
+    islandId: IslandId;
+    traveled: boolean;
+    isMoving: boolean;
+    lastAttackedBy: Human | Creature | undefined;
+    movementCompleteZ: number | undefined;
+    name: string;
+    quickSlotInfo: IQuickSlotInfo[];
+    realTimeTickActionDelay: number;
+    revealedItems: Record<number, boolean>;
+    respawnPoint: {
+        islandId: IslandId;
+    } & IVector3 | undefined;
+    tamedCreatures: Map<string, number[]>;
+    turns: number;
+    walkSoundCounter: number;
+    milestoneModifiers: Set<Milestone>;
+    quests: QuestManager;
+    messages: MessageManager;
+    notes: NoteManager;
+    walkPath: IWalkPath | undefined;
+    exploredMap: ExploreMap[] | undefined;
+    finishedMovingClientside: boolean;
+    nextX: number;
+    nextY: number;
+    movementProgress: number;
+    movementFinishTime: number;
+    nextMoveTime: number;
+    nextMoveDirection: Direction.Cardinal | Direction.None | undefined;
+    displayCreature?: CreatureType;
+    private readonly _movementIntent;
+    private readonly milestonesCollection;
+    private gameOptionsCached?;
+    private handEquippedToLast;
+    private cachedMovementPenalty?;
+    private updateTablesOnNoInput?;
+    constructor(identifier?: string);
+    onUnserialized(): void;
+    delete(): void;
+    get island(): Island;
+    get clientStore(): IClientStore;
+    setOptions(options: IOptions): void;
+    createNoteManager(): NoteManager;
+    createMessageManager(): MessageManager;
+    createQuestManager(): QuestManager;
+    getGameOptionsBeforeModifiers(): IGameOptionsPlayer;
+    getGameOptions(): IGameOptionsPlayer;
+    getDisplayCreature(): CreatureType | undefined;
+    setStatChangeTimerIgnoreDifficultyOptions(stat: Stat | IStat, timer: number, amt?: number): void;
+    setStatus(status: StatusType, hasStatus: boolean, reason: StatusEffectChangeReason): void;
+    startResting(restData: IRestData): void;
+    cancelResting(reason: RestCancelReason): boolean;
+    showRestInterrupt(restType: RestType): void;
+    /**
+     * Updates caused by status effects such as bleeding, poison, and burns.
+     */
+    tickStatuses(): void;
+    resetMovementStates(): void;
+    changeId(id: number): void;
+    setPaddling(item: Item | undefined, extinguishTorches?: boolean): boolean;
+    checkSkillMilestones(): void;
+    addMilestone(milestone: Milestone, data?: number, update?: boolean): void;
+    hasTamedCreature(creature: Creature): boolean;
+    hasHandToUse(): boolean;
+    getAndSwitchHandToUse(): EquipType | undefined;
+    /**
+     * Ensure handToUse is valid given the players options
+     */
+    updateHandToUse(): void;
+    equip(item: Item, slot: EquipType, internal?: boolean, switchingHands?: boolean): boolean;
+    unequip(item: Item, internal?: boolean, skipMessage?: boolean, skipRevertItem?: boolean): void;
+    unequipAll(): void;
+    getMovementIntent(): IMovementIntent;
+    updateMovementIntent(movementIntent: IMovementIntent): void;
+    resetStatTimers(type?: StatChangeCurrentTimerStrategy): void;
+    /**
+     * Gets the max health of the player.
+     *
+     * Returns the result of the `"getMaxHealth"` event, or the `max` in `Stat.Health`,
+     * if the result of the hook is `undefined`.
+     */
+    getMaxHealth(): number;
+    getCraftingDifficulty(level: RecipeLevel): number;
+    /**
+     * Gets the strength of the player.
+     *
+     * Returns the result of `Hook.GetPlayerStrength`, or the `max` in `Stat.Health`,
+     * if the result of the hook is `undefined`.
+     *
+     * Used internally for `Stat.Weight.max`
+     */
+    getMaxWeight(): number;
+    load(): void;
+    setup(spawnPoint: IVector3): void;
+    updateReputation(reputation: number): void;
+    getWeightStatus(): WeightStatus;
+    getWeightOrStaminaMovementPenalty(): number;
+    /**
+     * Check if there is a still in front of the player.
+     * @param withWater Check if the still has water in it?
+     * @param isLit Check if the still is lit?
+     */
+    checkForStill(withWater?: boolean, isLit?: boolean): boolean;
+    checkForWell(): boolean;
+    checkForGather(): Doodad | undefined;
+    onNoInput(): void;
+    updateTables(deferUpdate?: boolean): void;
+    updateCraftTable(adjacentContainers?: IContainer[]): void;
+    updateDismantleTable(adjacentContainers?: IContainer[]): void;
+    updateTablesAndWeight(source: string, deferTableUpdates?: boolean): void;
+    checkReputationMilestones(): void;
+    checkTravelMilestones(): void;
+    hurtHands(damageMessage: Message, toolMessage?: Message, hurtHandsMessage?: Message): boolean;
+    setTamedCreatureEnemy(enemy: Player | Creature): void;
+    setPosition(point: IVector3): void;
+    getNextPosition(): IVector3;
+    /**
+     * @param effects If true, adds a delay to the player, clears any particles, and updates the view. (Default: true)
+     */
+    setZ(z: number, effects?: boolean): void;
+    isGhost(): boolean;
+    /**
+     * Returns true if this is the special dedicated server player
+     */
+    isServer(): boolean;
+    isMultiplayerHost(): boolean;
+    getName(): import("../../../language/impl/TranslationImpl").default;
+    canSeePosition(type: CanASeeBType, tileX: number, tileY: number, tileZ: number, fieldOfView?: FieldOfView): boolean;
+    markAsExplored(points: IVector2[]): boolean | undefined;
+    updateQuickSlotInfo(quickSlot: number, itemType?: ItemType, action?: IContextMenuAction, contextActionSlot?: number, contextActionType?: ActionType, canUseProtected?: boolean): void;
+    updateDialogInfo(dialogIndex: string | number): void;
+    getDialogInfo(dialogIndex: string | number): IDialogInfo;
+    passTurn(turnType?: TurnType): void;
+    tick(isPassTurn?: boolean): void;
+    kill(): void;
+    respawn(): Promise<void>;
+    getMovementProgress(): number;
+    checkUnder(inFacingDirection?: boolean, options?: ICheckUnderOptions): ICheckUnderOptions;
+    hasWalkPath(): boolean;
+    walkAlongPath(path: IVector2[] | undefined, force?: boolean): void;
+    /**
+     * This is only ran on the server
+     */
+    processInput(timeStamp: number): IMovementIntent | undefined;
+    /**
+     * Returns true if the player changed their facing direction.
+     */
+    faceDirection(direction: Direction.Cardinal | Direction.None, turnDelay?: number): boolean;
+    revealItem(itemType: ItemType): void;
+    getMovementFinishTime(timeStamp: number): number;
+    healthSyncCheck(reason: string): void;
+    /**
+     * This needs to be called whenever the player's strength requires an update.
+     *
+     * Example usage includes:
+     * 1. When max health changes. Max health is used in calculating the strength.
+     * 2. If a mod is using the `GetPlayerStrength` hook and the calculation needs to be refreshed.
+     */
+    updateStrength(): void;
+    /**
+     * Returns the bartering bonus for a given credit value
+     */
+    getBarteringBonus(baseCredits: number): number;
+    /**
+     * Check if a position is marked as explored
+     * Only use this clientside
+     */
+    isExploredClientSide(x: number, y: number, z: number): boolean;
+    /**
+     * @deprecated Do not call this with players.
+     */
+    moveTo(): boolean;
+    protected canSkillGain(): boolean;
+    protected onSkillGain(skill: SkillType, mod: number): void;
+    protected getSkillGainMultiplier(skillType: SkillType): number;
+    protected getApplicableStatusEffects(): Set<StatusType>;
+    protected getBaseStatBonuses(): OptionalDescriptions<Stat, number>;
+    protected calculateStats(): void;
+    protected swimAndSootheCheck(): void;
+    /**
+     * Event handler for when a status effect is applied or removed.
+     */
+    protected onStatusEffectChanged(status: StatusType, has: boolean): void;
+    /**
+     * Event handler for `EntityEvent.StatChanged`. Handles special functionality when stats are increased:
+     * 1. When resting & stamina is full, resting will be cancelled.
+     * 2. Health is sync-checked.
+     * 3. When hunger > maximum, damage will be dealt, stamina will be decreased, and a message will be displayed.
+     * 4. When thirst > maximum, damage will be dealt, stamina will be decreased, and a message will be displayed.
+     */
+    protected onStatChange(stat: IStat, oldValue: number, info: IStatChangeInfo): void;
+    /**
+     * Applies stat change timer multipliers from game difficulty options
+     */
+    protected onSetStatChangeTimer(stat: Stat | IStat, change: StatChangeTimerFactory): false | undefined;
+    private slitherSuckerDamage;
+    private processMovement;
+    /**
+     * Event handler for when resting begins, weight changes, or strength changes.
+     */
+    private onStaminaUseChanged;
+    private restTick;
+    private staminaSyncCheck;
+    private canWriteInHours;
+    private canWriteNote;
+    private onWriteNote;
+    private onReadNote;
+    private shouldDisplayMessage;
+    private onDisplayMessage;
+    get asNPC(): undefined;
+    get asPlayer(): this;
+    get asLocalPlayer(): this | undefined;
+    moveTowardsIsland(direction: Direction.Cardinal | Direction.None, options?: IMoveToIslandOptions): Promise<void>;
+    moveToIslandPosition(position: IVector2, options?: IMoveToIslandOptions): Promise<void>;
+    /**
+     * Moves this player to another island
+     */
+    moveToIslandId(islandId: IslandId, options?: IMoveToIslandOptions): Promise<void>;
+    /**
+     * Loads the player onto an island
+     * Called when the game is initially loading and moving a player to another island
+     */
+    loadOnIsland(island: Island, options?: Partial<ILoadOnIslandOptions>): void;
+    /**
+     * Loads ui. Should only be called if this player is local
+     */
+    loadUi(): void;
+    /**
+     * Moves the players items to the target island
+     * This should be called before switching islands
+     */
+    private moveItemsToIsland;
+}

package/definitions/game/game/entity/player/PlayerManager.d.ts

@@ -0,0 +1,58 @@
+/*!
+ * 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 { Events, IEventEmitter } from "event/EventEmitter";
+import EntityManager from "game/entity/EntityManager";
+import Player from "game/entity/player/Player";
+import type { IPlayerOptions, IPlayOptions } from "game/IGame";
+export interface IPlayerManagerEvents extends Events<EntityManager<Player>> {
+    /**
+     * Called when a player is about to be removed
+     * The player is going to be added into absentPlayers
+     * @param player The player object
+     */
+    preRemove?(player: Player): void;
+    /**
+     * Called when a player joins the server
+     * @param player The player object
+     */
+    join?(player: Player): void;
+    /**
+     * Called when a player leaves the server
+     * Note: This hook is not called for the player who left the server (player will never be localPlayer)
+     * @param player The player object
+     */
+    leave?(player: Player): void;
+}
+export default class PlayerManager extends EntityManager<Player> {
+    event: IEventEmitter<this, IPlayerManagerEvents>;
+    constructor();
+    getAll(includeGhosts?: boolean, includeConnecting?: boolean): Player[];
+    getByPid(pid: number): Player | undefined;
+    getByIdentifier(identifier: string, includeAbsent?: boolean): Player | undefined;
+    getByName(name: string): Player | undefined;
+    getValidName(name: string | undefined): string;
+    setLocal(player: Player, setLocalIsland?: boolean): void;
+    add(playerOptions?: Partial<IPlayerOptions>, allowSetup?: boolean): Player;
+    remove(player: Player): void;
+    remove(pid: number): void;
+    /**
+     * Support loading dedicated server saves & backups in single player games
+     * Support loading single player saves in dedicated servers
+     * All while not losing data for any players - regardless of if the player was in the server or not at the time of the backup
+     */
+    repair(options: Partial<IPlayOptions>): void;
+    /**
+     * Removes and deletes a player.
+     * Use with caution!
+     */
+    delete(player: Player): void;
+    private removeAndFixIds;
+}

package/definitions/game/game/entity/player/note/Corpse.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 Player from "game/entity/player/Player";
+import type { ITile } from "game/tile/ITerrain";
+export default function writeCorpseNote(player: Player, tile: ITile): void;

package/definitions/game/game/entity/player/note/NoteManager.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 Island from "game/island/Island";
+import type { PartOfDay } from "game/time/ITimeManager";
+import Note from "language/dictionary/Note";
+import type { IModdable } from "mod/ModRegistry";
+import { HelpArticle } from "ui/screen/screens/menu/menus/help/HelpArticleDescriptions";
+export interface INoteDescription extends IModdable {
+    learnMore?: HelpArticle;
+}
+export declare const noteDescriptions: OptionalDescriptions<Note, INoteDescription>;
+export declare type Time = PartOfDay | string;
+export interface INote {
+    id: keyof typeof Note;
+    time: {
+        day: number;
+        time: number;
+        skilled: boolean;
+    };
+    args: any[];
+    unread?: boolean;
+}
+export interface INoteHost {
+    getIsland(): Island;
+    canWriteInHours(): boolean;
+    canWriteNote(note: INote): boolean;
+    onWriteNote(index: number, note: Note): any;
+    onReadNote(index: number): any;
+}
+export default class NoteManager {
+    private readonly host;
+    private readonly _notes;
+    constructor(host: INoteHost);
+    get notes(): INote[];
+    getNote(id: number): INote | undefined;
+    wasWritten(note: Note): boolean;
+    write(note: Note, ...args: any[]): void;
+    getUnread(): INote[];
+    markRead(noteId: number): void;
+}

package/definitions/game/game/entity/player/quest/QuestManager.d.ts

@@ -0,0 +1,93 @@
+/*!
+ * 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 Stream from "@wayward/goodstream/Stream";
+import EventEmitter from "event/EventEmitter";
+import type Player from "game/entity/player/Player";
+import type PlayerManager from "game/entity/player/PlayerManager";
+import type { IQuest } from "game/entity/player/quest/quest/IQuest";
+import { QuestType } from "game/entity/player/quest/quest/IQuest";
+import type { RequirementInstance } from "game/entity/player/quest/quest/Quest";
+import type { Game } from "game/Game";
+export default class QuestManager extends EventEmitter.Host<IQuestManagerEvents> {
+    private readonly host;
+    static reset(): void;
+    private readonly quests;
+    private readonly eventBusTriggers;
+    private readonly hostTriggers;
+    private readonly initializedQuests;
+    constructor(host: Player);
+    /**
+     * Get all quests
+     */
+    getQuests(): QuestInstance[];
+    /**
+     * Get all quests of the given type
+     */
+    getQuests(type: QuestType): QuestInstance[];
+    add(type: QuestType): this;
+    /**
+     * Removes all quests & disposes of any quest requirement triggers
+     */
+    reset(): this;
+    complete(questInstance: QuestInstance): boolean;
+    onPlayerJoin(manager: PlayerManager, player: Player): void;
+    onGameStart(game: Game, _isLoadingSave: boolean, _playedCount: number): void;
+    private init;
+    private onUpdateRequirement;
+    private onCompleteRequirement;
+}
+export interface IQuestManagerEvents {
+    /**
+     * Emitted when a quest is completed.
+     * @param quest The completed `IQuestInstance`
+     */
+    questComplete(quest: QuestInstance): any;
+    /**
+     * Emitted when a new quest is added.
+     * @param quest The `IQuestInstance` that was added
+     */
+    questGet(quest: QuestInstance): any;
+    /**
+     * Emitted when a quest is updated (a requirement is updated)
+     * @param quest The `IQuestInstance` that was updated
+     */
+    questUpdate(quest: QuestInstance): any;
+    /**
+     * Emitted when a quest requirement is completed
+     * @param quest The `IQuestInstance` of the requirement which was updated
+     * @param requirement The `IRequirementInstance` that was updated
+     */
+    requirementMet(quest: QuestInstance, requirement: RequirementInstance): any;
+    /**
+     * Called when the quest manager is reset
+     */
+    reset(): any;
+}
+export declare class QuestInstance extends EventEmitter.Host<IQuestInstanceEvents> {
+    readonly host: Player;
+    readonly data: IQuest;
+    readonly id: number;
+    constructor(host: Player, data: IQuest, id: number);
+    getTitle(): import("../../../../language/impl/TranslationImpl").default | undefined;
+    getDescription(): import("../../../../language/impl/TranslationImpl").default | undefined;
+    getRequirements(): Stream<RequirementInstance>;
+    needsManualCompletion(): boolean;
+    complete(): this;
+    getChildren(): Stream<QuestType>;
+    getCompletionAmount(): number;
+}
+interface IQuestInstanceEvents {
+    dispose(): any;
+    update(): any;
+    manualCompletion(): any;
+    complete(): any;
+}
+export {};

package/definitions/game/game/entity/player/quest/quest/Challenge.d.ts

@@ -0,0 +1,47 @@
+/*!
+ * 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 Stream from "@wayward/goodstream/Stream";
+import type { RequirementInstance } from "game/entity/player/quest/quest/Quest";
+import { Quest } from "game/entity/player/quest/quest/Quest";
+import type { QuestInstance } from "game/entity/player/quest/QuestManager";
+import type { IQuestRequirement } from "game/entity/player/quest/requirement/IRequirement";
+import type Island from "game/island/Island";
+export default class Challenge extends Quest {
+    static getCreaturesOfRequirements(): Stream<any>;
+    private static readonly possibleRequirements;
+    /**
+     * These are the only items that can be requested to collect
+     */
+    private static readonly itemCollectWhitelist;
+    /**
+     * These are the only skills that can be requested to learn
+     */
+    private static readonly skillLearnWhitelist;
+    /**
+     * These creatures will always be excluded from the possible creatures to be requested to kill, even if they're spawnable
+     */
+    private static readonly creatureKillBlacklist;
+    /**
+     * These creatures will always be excluded from the possible creatures to be requested to tame, even if they're spawnable
+     *
+     * Creatures that can't be tamed will already be excluded by default
+     */
+    private static readonly creatureTameBlacklist;
+    private readonly existingRequirements;
+    private readonly possibleRequirements;
+    constructor();
+    reset(): void;
+    protected createRequirements(island: Island): Stream<IQuestRequirement<any[], {}>>;
+    protected onUpdate(quest: QuestInstance): void;
+    protected onRequirementComplete(quest: QuestInstance, completedRequirement: RequirementInstance): void;
+    private createRandomRequirement;
+    private getSpawnableCreatures;
+}

package/definitions/game/game/entity/player/quest/quest/IQuest.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * 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 { IQuestRequirement } from "game/entity/player/quest/requirement/IRequirement";
+export declare enum QuestType {
+    Challenge = 0
+}
+export interface IQuest {
+    type: QuestType;
+    requirements: IQuestRequirement[];
+    complete: boolean;
+    reset?(): void;
+}

package/definitions/game/game/entity/player/quest/quest/Quest.d.ts

@@ -0,0 +1,62 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import EventEmitter from "event/EventEmitter";
+import type Player from "game/entity/player/Player";
+import type { IQuest, QuestType } from "game/entity/player/quest/quest/IQuest";
+import type { QuestInstance } from "game/entity/player/quest/QuestManager";
+import type { IQuestRequirement, IQuestRequirementApi, IQuestRequirementEvents, QuestRequirementType } from "game/entity/player/quest/requirement/IRequirement";
+import type { RequirementArgs } from "game/entity/player/quest/Requirements";
+import type Island from "game/island/Island";
+import Translation from "language/Translation";
+export interface IQuestEvents {
+    update(quest: QuestInstance, requirement: RequirementInstance): any;
+    requirementCompleted(quest: QuestInstance, requirement: RequirementInstance): any;
+    complete(quest: IQuest): any;
+}
+export declare class Quest extends EventEmitter.Host<IQuestEvents> {
+    type?: QuestType | undefined;
+    title?: Translation | ((quest: IQuest) => Translation);
+    description?: Translation | ((quest: IQuest) => Translation);
+    private readonly requirements;
+    private readonly children;
+    private readonly requirementInstances;
+    private _needsManualCompletion;
+    constructor(type?: QuestType | undefined);
+    reset(): void;
+    addRequirement<R extends QuestRequirementType>(type: R, ...args: RequirementArgs<R>): this;
+    addRequirement<RA extends any[]>(type: QuestRequirementType, ...args: RA): this;
+    setNeedsManualCompletion(): this;
+    addChildQuests(...children: QuestType[]): this;
+    getChildren(): import("@wayward/goodstream").default<QuestType>;
+    setTitle(translation?: Translation | ((quest: IQuest) => Translation)): this;
+    setDescription(translation?: Translation): this;
+    create(island: Island, type?: QuestType | undefined): IQuest;
+    getTitle(quest: IQuest): import("../../../../../language/impl/TranslationImpl").default | undefined;
+    getDescription(quest: IQuest): import("../../../../../language/impl/TranslationImpl").default | undefined;
+    getEventBusTriggers(instance: IQuest): import("@wayward/goodstream").default<[IQuestRequirement<any[], {}>, import("@wayward/goodstream").default<readonly [import("../../../../../event/EventManager").EmitterOrBus, string | number | symbol, (api: IQuestRequirementApi<[], {}>, ...args: any[]) => boolean]>]>;
+    getHostTriggers(instance: IQuest): import("@wayward/goodstream").default<[IQuestRequirement<any[], {}>, IterableIterator<[keyof import("../../IPlayer").IPlayerEvents, (api: IQuestRequirementApi<[], {}>, player: Player, ...args: any[]) => boolean]>]>;
+    getRequirements(host: Player, instance: IQuest): import("@wayward/goodstream").default<RequirementInstance>;
+    getRequirement(host: Player, quest: IQuest, requirement: IQuestRequirement): RequirementInstance | undefined;
+    needsManualCompletion(): boolean;
+    protected createRequirements(island: Island): import("@wayward/goodstream").default<IQuestRequirement<any[], {}>>;
+    protected createRequirement<R extends QuestRequirementType>(type: R, ...options: RequirementArgs<R>): IQuestRequirement<RequirementArgs<R>>;
+}
+export declare class RequirementInstance extends EventEmitter.Host<IQuestRequirementEvents> {
+    readonly data: IQuestRequirement;
+    readonly id: number;
+    private readonly api;
+    constructor(host: Player, data: IQuestRequirement, id: number);
+    triggerInitialization(): boolean;
+    getTranslation(): import("../../../../../language/impl/TranslationImpl").default;
+    getCompletionAmount(): number;
+    getRelations(): import("../../../../../ui/component/IComponent").HighlightSelector[];
+    setVisible(): this;
+}

package/definitions/game/game/entity/player/quest/requirement/BuildRequirement.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import { QuestRequirement } from "game/entity/player/quest/requirement/Requirement";
+import type { ItemType } from "game/item/IItem";
+import { ItemTypeGroup } from "game/item/IItem";
+declare const _default: QuestRequirement<[(ItemType | ItemTypeGroup)[]], {}>;
+export default _default;

package/definitions/game/game/entity/player/quest/requirement/CollectItemRequirement.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * 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 { QuestRequirement } from "game/entity/player/quest/requirement/Requirement";
+import type { ItemType, ItemTypeGroup } from "game/item/IItem";
+declare const _default: QuestRequirement<[(ItemType | ItemTypeGroup)[], number], {}>;
+export default _default;