@wayward/types 2.11.3-beta.dev.20220117.1 → 2.11.3-beta.dev.20220123.1

package/definitions/cplusplus/index.d.ts

@@ -79,6 +79,7 @@ export interface IWorldLayerCPP {
 }
 export interface IDijkstraMap {
     getNode(x: number, y: number): INavigationNode;
+    updateNode(x: number, y: number, penalty: number, disabled: boolean): void;
     updateOrigin(origin: INavigationNode): void;
     findPath(end: INavigationNode): {
         success: boolean;

package/definitions/game/game/Game.d.ts

@@ -13,7 +13,7 @@ import EventEmitter from "event/EventEmitter";
 import type Entity from "game/entity/Entity";
 import type { Defense } from "game/entity/IEntity";
 import { DamageType } from "game/entity/IEntity";
-import { Delay, SkillType } from "game/entity/IHuman";
+import { Delay } from "game/entity/IHuman";
 import type { TurnType } from "game/entity/player/IPlayer";
 import type Player from "game/entity/player/Player";
 import type { IGameEvents, IPlayOptions, ISynchronizeState } from "game/IGame";
@@ -115,14 +115,6 @@ export declare class Game extends EventEmitter.Host<IGameEvents> {
     updateGameUpdates(gameOptions: IGameOptions): void;
     initializeGameOptions(seed: string | number, mode?: GameMode, options?: IGameOptions, milestoneModifiers?: Set<Milestone>): void;
     initializeModifiers(): void;
-    getReputation(): number;
-    getMalignity(): number;
-    getBenignity(): number;
-    getMaxHealth(): number;
-    getMaxWeight(): number;
-    getTactics(): number;
-    getSkillPercent(skill: SkillType): number;
-    getPlayerAverage(calc: (player: Player) => number | undefined, round?: boolean): number;
     getMovementFinishTime(delay?: Delay | number): number;
     getMovementProgress(timeStamp: number, finishTime: number | undefined, delay?: Delay | number): number;
     getAnimationProgress(timeStamp: number, finishTime: number | undefined, delay: Delay | number): number;

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

@@ -16,7 +16,7 @@ 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 { EquipType, RestCancelReason, 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";
@@ -102,7 +102,6 @@ export default class Player extends Human implements IUnserializedCallback {
     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.
      */

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

@@ -9,8 +9,8 @@
  * https://github.com/WaywardGame/types/wiki
  */
 export declare enum DurabilityLevel {
-    Undamaged = 0,
-    SlightlyDamaged = 1,
-    Damaged = 2,
-    VeryDamaged = 3
+    VeryDamaged = 0,
+    Damaged = 1,
+    SlightlyDamaged = 2,
+    Undamaged = 3
 }

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

@@ -76,6 +76,7 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     private static cachedWeights;
     private static cachedDefaultItemForGroup;
     private static cachedBestItemForTier;
+    private static cachedHighestItemActionTierForAction;
     private static cachedItemGroups;
     private static cachedItemsThatAreAcceptedAsOffer;
     private static cachedItemsThatAreUsedInRecipes;
@@ -85,6 +86,7 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     static getItemTypes(): readonly ItemType[];
     static getItemsWithRecipes(): readonly ItemType[];
     static getBestItemForTier(item: ItemType | ItemTypeGroup): ItemType | undefined;
+    static getHighestItemActionTierForAction(action: ActionType): number | undefined;
     static isItemAcceptedAsOffer(item: ItemType): boolean | undefined;
     static isItemUsedInRecipe(item: ItemType): boolean | undefined;
     static isGroup(item: ItemType | ItemTypeGroup): item is ItemTypeGroup;
@@ -188,13 +190,13 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
      */
     getBestSafeItemInContainerByUse(container: IContainer, action: ActionType, allowProtectedItems?: boolean, actionMayDamageItem?: boolean, consumable?: boolean): Item | undefined;
     getItemInContainer(container: IContainer, itemTypeSearch: ItemType, ignoreItem?: Item, allowProtectedItems?: boolean): Item | undefined;
-    getItemForHuman(human: Human, search: ItemType | ItemTypeGroup, allowProtectedItems?: boolean): Item | undefined;
-    getItemInContainerByGroup(container: IContainer, itemTypeGroupSearch: ItemTypeGroup, ignoreItemId?: number, allowProtectedItems?: boolean): Item | undefined;
+    getItemForHuman(human: Human, search: ItemType | ItemTypeGroup, ignoreItem?: Item, allowProtectedItems?: boolean): Item | undefined;
+    getItemInContainerByGroup(container: IContainer, itemTypeGroupSearch: ItemTypeGroup, ignoreItem?: Item, allowProtectedItems?: boolean): Item | undefined;
     getItemInAdjacentContainersByGroup(position: IVector3, itemTypeGroupSearch: ItemTypeGroup): Item | undefined;
     getItemsInContainer(container: IContainer, includeSubContainers?: boolean, allowProtectedItems?: boolean): Item[];
     getItemsInContainerByType(container: IContainer, itemType: ItemType, includeSubContainers?: boolean, filterText?: string): Item[];
     getItemsInContainerByGroup(container: IContainer, itemGroup: ItemTypeGroup, includeSubContainers?: boolean): Item[];
-    getItemInInventoryByGroup(human: Human, itemTypeGroupSearch: ItemTypeGroup, ignoreItemId?: number): Item | undefined;
+    getItemInInventoryByGroup(human: Human, itemTypeGroupSearch: ItemTypeGroup, ignoreItem?: Item): Item | undefined;
     isItemInContainer(container: IContainer, itemTypeSearch: ItemType, ignoreItem?: Item): boolean;
     isContainableInContainer(containable: IContainable, container: IContainer): boolean;
     getAdjacentContainers(humanOrPosition: Human | IVector3, includeNpcs?: boolean, ignoreOptions?: boolean): IContainer[];

package/definitions/game/game/temperature/TemperatureManager.d.ts

@@ -36,7 +36,6 @@ export default class TemperatureManager extends EventEmitter.Host<ITempManagerEv
     private readonly scheduledContainerInvalidations;
     private readonly cacheCalculated;
     private readonly cacheProduced;
-    private processingScheduledUpdates;
     constructor(island: Island);
     delete(): void;
     preSerializeObject(): void;

package/definitions/game/multiplayer/IMultiplayer.d.ts

@@ -134,8 +134,8 @@ export interface IMultiplayerNetworkingOptions {
     enableWebRtcConnections: boolean;
     enablePacketNumberChecks: boolean;
     logPackets: boolean;
-    logSyncChecks: boolean;
     recentPacketTracking: number;
+    recentHashedSyncCheckTracking: number;
     joinServerTimeout: number;
     steamNetworkTimeout: number;
     webRtcTimeout: number;

package/definitions/game/multiplayer/Multiplayer.d.ts

@@ -16,6 +16,7 @@ import { DisconnectReason, JoinServerRetryReason, MultiplayerSyncCheck, UnableTo
 import type { IMatchmakingInfo } from "multiplayer/matchmaking/IMatchmaking";
 import type { IConnection } from "multiplayer/networking/IConnection";
 import type { IPacket } from "multiplayer/packets/IPacket";
+import DesyncPacket from "multiplayer/packets/server/DesyncPacket";
 export default class Multiplayer extends EventEmitter.Host<IMultiplayerEvents> {
     /**
      * Static steam account id when steam support is on
@@ -47,11 +48,12 @@ export default class Multiplayer extends EventEmitter.Host<IMultiplayerEvents> {
     private _currentPacketProcessing;
     private _currentSyncPacketsWaiting;
     private _currentSyncPacketsProcessing;
-    private _syncCheckStack;
     private _activeSyncCheck;
-    private _syncChecksSuppressed;
-    private _recentPackets;
     private _enabledSyncChecks;
+    private readonly _recentHashedSyncChecks;
+    private _recentPackets;
+    private _syncChecksSuppressed;
+    private _syncCheckStack;
     private _disconnectingFromSyncIssue;
     private _reportedSyncHashMismatch;
     private readonly _autojoinEnabled;
@@ -140,14 +142,20 @@ export default class Multiplayer extends EventEmitter.Host<IMultiplayerEvents> {
     addKeepAliveTimeouts(): void;
     updateGlobalServerDirectory(): void;
     checkConnection(): Promise<void>;
-    isSyncCheckEnabled(syncCheck: MultiplayerSyncCheck, failIfNotActiveOrSurpressed?: boolean): boolean;
+    isSyncCheckEnabled(syncCheck: MultiplayerSyncCheck): boolean;
     addSyncCheck(syncCheck: MultiplayerSyncCheck, value: any, addStackTrace?: boolean): void;
     addMiscSeedSyncCheck(island: Island, ...messages: any[]): void;
     addBeforeSyncChecks(packet: IPacket): void;
     addAfterSyncChecks(packet: IPacket): void;
     sendChatMessage(sender: Player, message: string): void;
     private addDefaultSyncChecks;
+    /**
+     * Returns sync check hashes
+     * @returns [all sync checks hash, enabled sync checks hash]
+     */
     private getPacketSyncChecks;
+    private recordHashedSyncCheck;
+    private filterEnabledSyncChecks;
     private hashSyncCheckHash;
     private clearJoinServerRetryTimeout;
     createOrExtendSteamNetworkConnectionWebRTCFallbackTimer(timeoutTime: number): void;
@@ -169,6 +177,8 @@ export default class Multiplayer extends EventEmitter.Host<IMultiplayerEvents> {
     private processPacket;
     private synchronizationCheck;
     private logSyncCheckErrors;
+    private sendDesyncPacket;
+    processDesyncPacket(connection: IConnection, desyncPacket: DesyncPacket): void;
     private sendPacketInternal;
     private onStateChange;
     private convertToMatchmakingInfo;

package/definitions/game/multiplayer/packets/IPacket.d.ts

@@ -17,12 +17,16 @@ export declare enum PacketType {
 }
 export interface ISynchronizationCheckData {
     packetNumber?: number;
-    beforeSyncChecks?: ISyncCheck;
-    afterSyncChecks?: ISyncCheck;
+    beforeEnabledSyncChecksHash?: number;
+    afterEnabledSyncChecksHash?: number;
     beforeSyncChecksHash?: number;
     afterSyncChecksHash?: number;
 }
 export declare type ISyncCheck = Record<number, Array<number | string>>;
+export interface IHashedSyncCheck {
+    hash: number;
+    syncCheck: ISyncCheck;
+}
 export interface IPacket<T = any> {
     getAllowedStates(): ConnectionState;
     getArrayBuffer(id?: number): ArrayBuffer;

package/definitions/game/multiplayer/packets/server/DesyncPacket.d.ts

@@ -8,11 +8,17 @@
  * 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 { IHashedSyncCheck } from "multiplayer/packets/IPacket";
 import ServerPacket from "multiplayer/packets/ServerPacket";
 /**
  * The player sends this to the server when they have desynced
  */
 export default class DesyncPacket extends ServerPacket {
+    packetId: number;
+    packetDebugInfo: string;
+    hashedSyncCheck: IHashedSyncCheck;
+    checkBefore: boolean;
+    shouldDisconnect: boolean;
     logs: string;
     getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;

package/definitions/game/multiplayer/packets/{shared → server}/UpdateMovementIntentPacket.d.ts

@@ -9,8 +9,8 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { IMovementIntent } from "game/entity/player/IPlayer";
-import PlayerTargetedSharedPacket from "multiplayer/packets/PlayerTargetedSharedPacket";
-export default class UpdateMovementIntentPacket extends PlayerTargetedSharedPacket {
+import PlayerTargetedServerPacket from "multiplayer/packets/PlayerTargetedServerPacket";
+export default class UpdateMovementIntentPacket extends PlayerTargetedServerPacket {
     intent: IMovementIntent;
     getDebugInfo(): string;
     isAllowedWhenPaused(): boolean;

package/definitions/game/multiplayer/packets/{server → shared}/LogsPacket.d.ts

@@ -8,10 +8,11 @@
  * 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 PlayerTargetedServerPacket from "multiplayer/packets/PlayerTargetedServerPacket";
-export default class LogsPacket extends PlayerTargetedServerPacket {
+import PlayerTargetedSharedPacket from "multiplayer/packets/PlayerTargetedSharedPacket";
+import { LogLineType } from "utilities/Log";
+export default class LogsPacket extends PlayerTargetedSharedPacket {
     logs: string;
-    containsServerGameState: boolean | undefined;
+    logType: LogLineType;
     getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;

package/definitions/game/renderer/fieldOfView/FieldOfView.d.ts

@@ -59,6 +59,10 @@ export default class FieldOfView extends EventEmitter.Host<IFieldOfViewEvents> {
      */
     static updateExplored(fieldOfView: FieldOfView | undefined, updateForGhosts?: boolean): void;
     private static processExploredMapBounds;
+    /**
+     * Gets the field of view radius based on either the field of view object, player, or the default value
+     */
+    private static getRadius;
     /**
      * Marks a set of tiles as exploreed
      */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@wayward/types",
 	"description": "TypeScript declarations for Wayward, used for modding.",
-	"version": "2.11.3-beta.dev.20220117.1",
+	"version": "2.11.3-beta.dev.20220123.1",
 	"license": "MIT",
 	"repository": {
 		"type": "git",