dredless 0.2.0

package/src/protocol/outbound/ship-management.js

@@ -0,0 +1,221 @@
+const SHIP_MANAGEMENT_TYPE = 4;
+const SET_PRIVACY_ACTION = "set_privacy";
+const STARTER_RECOVERY_ACTION = "starter_recovery";
+const PLAYER_LIST_ACTION = "player_list";
+const INVITE_RESET_ACTION = "invite_reset";
+const SET_RANK_ACTION = "set_rank";
+const KICK_ACTION = "kick";
+const BAN_ACTION = "ban";
+const DEMOTE_SELF_ACTION = "demote_self";
+
+function requireNonNegativeInteger(value, name) {
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < 0) throw new RangeError(`${name} must be a non-negative integer`);
+    return number;
+}
+
+function normalizePrivacy(value) {
+    if (value === true || value === 1 || value === "private") return 1;
+    if (value === false || value === 0 || value === "public") return 0;
+    throw new RangeError(`privacy must be 0, 1, true, false, "public", or "private"`);
+}
+
+function normalizePlayerRef(value) {
+    return requireNonNegativeInteger(value, "refId");
+}
+
+function normalizePlayerRank(value) {
+    if (value === 0 || value === "guest") return 0;
+    if (value === 1 || value === "crew") return 1;
+    if (value === 3 || value === "captain") return 3;
+    throw new RangeError(`rank must be 0, 1, 3, "guest", "crew", or "captain"`);
+}
+
+export function buildShipManagementMessage(act, arg = null, extra = null) {
+    if (typeof act !== "string" || !act) throw new TypeError(`act must be a non-empty string`);
+    const message = {type: SHIP_MANAGEMENT_TYPE, act, arg};
+    if (extra && typeof extra === "object") Object.assign(message, extra);
+    return message;
+}
+
+export function buildShipPrivacyMessage(privacy) {
+    return buildShipManagementMessage(SET_PRIVACY_ACTION, normalizePrivacy(privacy));
+}
+
+export function buildStarterRecoveryMessage(itemId) {
+    return buildShipManagementMessage(STARTER_RECOVERY_ACTION, requireNonNegativeInteger(itemId, "itemId"));
+}
+
+export function buildPlayerListMessage() {
+    return buildShipManagementMessage(PLAYER_LIST_ACTION);
+}
+
+export function buildInviteResetMessage() {
+    return buildShipManagementMessage(INVITE_RESET_ACTION);
+}
+
+export function buildSetPlayerRankMessage(refId, rank) {
+    return buildShipManagementMessage(SET_RANK_ACTION, normalizePlayerRef(refId), {rank: normalizePlayerRank(rank)});
+}
+
+export function buildKickPlayerMessage(refId) {
+    return buildShipManagementMessage(KICK_ACTION, normalizePlayerRef(refId));
+}
+
+export function buildBanPlayerMessage(refId) {
+    return buildShipManagementMessage(BAN_ACTION, normalizePlayerRef(refId));
+}
+
+export function buildDemoteSelfMessage() {
+    return buildShipManagementMessage(DEMOTE_SELF_ACTION);
+}
+
+export function normalizeShipConfig(event = {}) {
+    const source = event && typeof event === "object" ? event : {};
+    const config = source.config && typeof source.config === "object" ? source.config : {};
+    return {
+        privacy: config.privacy ?? null,
+        privacyName: config.privacy === 0 ? "public" : config.privacy === 1 ? "private" : null,
+        inviteKey: config.invite_key ?? null,
+        teamId: source.team_id ?? null,
+        patronPerks: Array.isArray(source.patron_perks) ? source.patron_perks.slice() : []
+    };
+}
+
+export function normalizeCaptainSubrank(event = {}) {
+    const source = event && typeof event === "object" ? event : {};
+    return {
+        subrank: source.subrank ?? null,
+        enableCheats: Boolean(source.enable_cheats)
+    };
+}
+
+export function normalizeShipPlayerList(event = {}, previous = null, currentCaptainSubrank = null) {
+    const source = event && typeof event === "object" ? event : {};
+    const changes = Array.isArray(source.player_list) ? source.player_list.map(normalizePlayerListChange) : [];
+    const removedPlayers = changes
+        .filter((change) => change.remove && Number.isFinite(Number(change.refId)))
+        .map((change) => Number(change.refId));
+    const changedPlayers = changes.filter((change) => !change.remove).map(({remove: _remove, ...change}) => change);
+    const players = mergePlayerListChanges(previous?.players, changes);
+    const ownerCaptainRank = ownerRankForPlayers(players);
+    applyPlayerControlState(players, currentCaptainSubrank);
+    applyPlayerControlState(changedPlayers, currentCaptainSubrank);
+    return {
+        ownerCaptainRank,
+        shipOwners: players.filter((player) => player.isShipOwner),
+        players,
+        changes: changedPlayers,
+        removedPlayers
+    };
+}
+
+function mergePlayerListChanges(previousPlayers, changes) {
+    if (!Array.isArray(previousPlayers) || !previousPlayers.length) return changes.filter((change) => !change.remove).map(({
+                                                                                                                               remove: _remove,
+                                                                                                                               ...player
+                                                                                                                           }) => ({...player}));
+
+    const existing = new Map();
+    for (const player of previousPlayers) {
+        if (player?.refId == null) continue;
+        existing.set(player.refId, {...player, isShipOwner: false});
+    }
+
+    const changedRefs = new Set();
+    const merged = [];
+    for (const change of changes) {
+        if (change.refId == null) {
+            if (!change.remove) {
+                const {remove: _remove, ...player} = change;
+                merged.push({...player, isShipOwner: false});
+            }
+            continue;
+        }
+        changedRefs.add(change.refId);
+        if (change.remove) {
+            existing.delete(change.refId);
+            continue;
+        }
+        const {remove: _remove, ...changePlayer} = change;
+        const player = {...(existing.get(change.refId) || {}), ...changePlayer, isShipOwner: false};
+        existing.set(change.refId, player);
+        merged.push(player);
+    }
+
+    for (const player of previousPlayers) {
+        if (player?.refId == null || changedRefs.has(player.refId)) continue;
+        const retained = existing.get(player.refId);
+        if (retained) merged.push(retained);
+    }
+    return merged;
+}
+
+function normalizePlayerListChange(entry = {}) {
+    const source = entry && typeof entry === "object" ? entry : {};
+    if (source._removed) return {refId: source.ref_id ?? null, remove: true};
+    return {
+        refId: source.ref_id ?? null,
+        remove: false,
+        discrim: source.discrim ?? null,
+        discrimColor: source.discrim_color ?? null,
+        teamRank: source.team_rank ?? null,
+        captainRank: source.captain_rank ?? null,
+        isCaptain: Number(source.captain_rank) > 0,
+        isShipOwner: false,
+        canBeManaged: false,
+        time: source.time ?? null,
+        items: Array.isArray(source.items) ? source.items.slice() : [],
+        aliasDiscrims: Array.isArray(source.alias_discrims) ? source.alias_discrims.slice() : [],
+        extraAliasCount: normalizeNonNegativeNumber(source.extra_aliases),
+        onlineCount: source.online_count ?? null
+    };
+}
+
+function normalizeNonNegativeNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+function ownerRankForPlayers(players) {
+    const ranks = players
+        .filter((player) => Number(player.captainRank) > 0)
+        .map((player) => Number(player.captainRank))
+        .filter(Number.isFinite);
+    if (!ranks.length) return null;
+    const ownerRank = Math.min(...ranks);
+    for (const player of players) player.isShipOwner = Number(player.captainRank) === ownerRank;
+    return ownerRank;
+}
+
+function applyPlayerControlState(players, currentCaptainSubrank) {
+    const currentRank = currentCaptainRank(currentCaptainSubrank);
+    for (const player of players) player.canBeManaged = playerCanBeManagedBy(player, currentRank);
+}
+
+function currentCaptainRank(currentCaptainSubrank) {
+    const rank = Number(currentCaptainSubrank?.subrank);
+    return Number.isFinite(rank) && rank > 0 ? rank : null;
+}
+
+function playerCanBeManagedBy(player, currentRank) {
+    if (!Number.isFinite(currentRank) || !player) return false;
+    const targetCaptainRank = Number(player.captainRank);
+    if (Number.isFinite(targetCaptainRank) && targetCaptainRank > 0) return currentRank < targetCaptainRank;
+    const targetTeamRank = Number(player.teamRank);
+    return targetTeamRank === 0 || targetTeamRank === 1;
+}
+
+export {
+    BAN_ACTION,
+    DEMOTE_SELF_ACTION,
+    INVITE_RESET_ACTION,
+    KICK_ACTION,
+    PLAYER_LIST_ACTION,
+    SET_PRIVACY_ACTION,
+    SET_RANK_ACTION,
+    SHIP_MANAGEMENT_TYPE,
+    STARTER_RECOVERY_ACTION,
+    normalizePlayerRank,
+    normalizePrivacy
+};

package/src/protocol/outbound/sign.d.ts

@@ -0,0 +1,18 @@
+export const SignDisplayMode: {
+    readonly Always: "always";
+    readonly WhenNear: "when-near";
+    readonly OnHover: "on-hover";
+};
+export type SignDisplayMode = typeof SignDisplayMode[keyof typeof SignDisplayMode];
+
+export interface SignTextMessage {
+    type: 5;
+    cmd: "sign_text";
+    args: [string, 0 | 1 | 2];
+}
+
+export function buildSignTextMessage(text?: string, mode?: SignDisplayMode): SignTextMessage;
+export function normalizeSignDisplayMode(mode?: SignDisplayMode): 0 | 1 | 2;
+export function signDisplayModeName(mode: number): SignDisplayMode | null;
+export const SIGN_TEXT_COMMAND: "sign_text";
+export const SIGN_DISPLAY_MODES: Map<0 | 1 | 2, SignDisplayMode>;

package/src/protocol/outbound/sign.js

@@ -0,0 +1,45 @@
+const SIGN_TEXT_COMMAND = "sign_text";
+const SignDisplayMode = Object.freeze({
+    Always: "always",
+    WhenNear: "when-near",
+    OnHover: "on-hover"
+});
+const SIGN_DISPLAY_MODES = new Map([
+    [0, SignDisplayMode.Always],
+    [1, SignDisplayMode.WhenNear],
+    [2, SignDisplayMode.OnHover]
+]);
+const SIGN_DISPLAY_MODE_VALUES = new Map([
+    [SignDisplayMode.Always, 0],
+    [SignDisplayMode.WhenNear, 1],
+    [SignDisplayMode.OnHover, 2]
+]);
+
+function normalizeSignDisplayMode(mode = SignDisplayMode.Always) {
+    const normalized = SIGN_DISPLAY_MODE_VALUES.get(mode);
+    if (normalized == null) {
+        throw new RangeError(`sign display mode must be SignDisplayMode.Always, SignDisplayMode.WhenNear, or SignDisplayMode.OnHover`);
+    }
+    return normalized;
+}
+
+function signDisplayModeName(mode) {
+    return SIGN_DISPLAY_MODES.get(mode) ?? null;
+}
+
+function buildSignTextMessage(text = "", mode = SignDisplayMode.Always) {
+    return {
+        type: 5,
+        cmd: SIGN_TEXT_COMMAND,
+        args: [String(text), normalizeSignDisplayMode(mode)]
+    };
+}
+
+export {
+    SIGN_DISPLAY_MODES,
+    SIGN_TEXT_COMMAND,
+    SignDisplayMode,
+    buildSignTextMessage,
+    normalizeSignDisplayMode,
+    signDisplayModeName
+};

package/src/protocol/outbound/ui-config.d.ts

@@ -0,0 +1,157 @@
+export interface NavigationUnitConfig {
+    destination: number;
+    page?: number;
+    warp?: boolean | "start" | "idle" | "cancel";
+    autoWarpOnShieldFailure?: boolean;
+    autoWarpOnNoCaptains?: boolean;
+}
+
+export const PusherMode: {
+    readonly Push: "push";
+    readonly Pull: "pull";
+    readonly DoNothing: "do-nothing";
+};
+export type PusherMode = typeof PusherMode[keyof typeof PusherMode];
+export const LoaderPosition: {
+    readonly TopLeft: "top-left";
+    readonly TopMiddle: "top-middle";
+    readonly TopRight: "top-right";
+    readonly MiddleLeft: "middle-left";
+    readonly MiddleRight: "middle-right";
+    readonly BottomLeft: "bottom-left";
+    readonly BottomMiddle: "bottom-middle";
+    readonly BottomRight: "bottom-right";
+};
+export type LoaderPosition = typeof LoaderPosition[keyof typeof LoaderPosition];
+export const LoaderFilterMode: {
+    readonly AllowAll: "allow-all";
+    readonly BlockFilter: "block-filter";
+    readonly AllowFilter: "allow-filter";
+    readonly BlockAll: "block-all";
+};
+export type LoaderFilterMode = typeof LoaderFilterMode[keyof typeof LoaderFilterMode];
+export const LoaderPriority: {
+    readonly Low: "low";
+    readonly Normal: "normal";
+    readonly High: "high";
+};
+export type LoaderPriority = typeof LoaderPriority[keyof typeof LoaderPriority];
+export type ClipboardTarget =
+    number
+    | "loader"
+    | "loader-config"
+    | "loaderConfig"
+    | "hatch"
+    | "cargo-hatch"
+    | "cargoHatch"
+    | "ejector"
+    | "cargo-ejector"
+    | "cargoEjector"
+    | "expando"
+    | "expando-box"
+    | "expandoBox"
+    | "generator"
+    | "shield-generator"
+    | "shieldGenerator"
+    | "navigation"
+    | "navigation-unit"
+    | "navigationUnit"
+    | "nav"
+    | "nav-unit"
+    | "navUnit";
+export const FixedAngleDirection: {
+    readonly Right: "right";
+    readonly Up: "up";
+    readonly Left: "left";
+    readonly Down: "down";
+};
+export type FixedAngleDirection = typeof FixedAngleDirection[keyof typeof FixedAngleDirection];
+
+export interface PusherConfig {
+    mode?: PusherMode;
+    filteredMode?: PusherMode;
+    angle?: number;
+    speed?: number;
+    filterInventory?: boolean;
+    length?: number;
+}
+
+export interface LoaderConfig {
+    pick?: LoaderPosition;
+    place?: LoaderPosition;
+    priority?: LoaderPriority;
+    stack?: number;
+    cycle?: number;
+    requireOutput?: boolean;
+    waitForStack?: boolean;
+}
+
+export interface LoaderFullConfig extends LoaderConfig {
+    filterMode?: LoaderFilterMode;
+    filterSlots?: Array<number | null | undefined>;
+}
+
+export function buildNavigationUnitConfigData(entity: number, config: NavigationUnitConfig): Uint8Array;
+
+export function buildNavigationUnitClipboardConfigData(config: NavigationUnitConfig): Uint8Array;
+
+export function buildNavigationUnitPasteConfigData(entity: number, config: NavigationUnitConfig): Uint8Array;
+
+export function buildGeneratorMazePuzzleData(entity: number, solution: string | number): Uint8Array;
+
+export function buildCargoHatchFilterConfigData(entity: number, filterMode?: LoaderFilterMode): Uint8Array;
+
+export function buildCargoHatchFilterItemsData(entity: number, filterSlots?: Array<number | null | undefined>): Uint8Array;
+
+export function buildCargoHatchFullConfigData(entity: number, config?: Pick<LoaderFullConfig, "filterMode" | "filterSlots">): Uint8Array;
+
+export function buildCargoHatchCopyConfigData(config?: Pick<LoaderFullConfig, "filterMode" | "filterSlots">): Uint8Array;
+
+export function buildClipboardConfigData(target: ClipboardTarget, commandName: string, values?: Iterable<number>): Uint8Array;
+
+export function buildClipboardFixedAngleData(target: ClipboardTarget, direction: FixedAngleDirection): Uint8Array;
+
+export function buildGeneratorClipboardDirectionData(direction: FixedAngleDirection): Uint8Array;
+
+export function buildCargoEjectorDirectionData(entity: number, direction: FixedAngleDirection): Uint8Array;
+
+export function buildCargoEjectorPasteConfigData(entity: number, direction: FixedAngleDirection): Uint8Array;
+
+export function buildCargoEjectorCopyConfigData(direction: FixedAngleDirection): Uint8Array;
+
+export function buildCargoEjectorClipboardDirectionData(direction: FixedAngleDirection): Uint8Array;
+
+export function buildExpandoClipboardAngleData(angle: number): Uint8Array;
+
+export function buildLoaderClipboardConfigData(config?: LoaderConfig): Uint8Array;
+
+export function buildLoaderConfigData(entity: number, config?: LoaderConfig): Uint8Array;
+
+export function buildLoaderCopyConfigData(config?: LoaderFullConfig): Uint8Array;
+
+export function buildLoaderFilterConfigData(entity: number, filterMode?: LoaderFilterMode): Uint8Array;
+
+export function buildLoaderFilterItemsData(entity: number, filterSlots?: Array<number | null | undefined>): Uint8Array;
+
+export function buildLoaderFullConfigData(entity: number, config?: LoaderFullConfig): Uint8Array;
+
+export function buildPusherConfigData(entity: number, config?: PusherConfig): Uint8Array;
+
+export function buildPusherFilterItemsData(entity: number, filterSlots?: Array<number | null | undefined>): Uint8Array;
+
+export const CLIPBOARD_ACTION: 1;
+export const CLIPBOARD_ANGLE_COMMAND: "angle";
+export const CLIPBOARD_FIXED_ANGLE_COMMAND: "angle_fixed";
+export const CLIPBOARD_TARGET_VALUES: Map<string, number>;
+export const FIXED_ANGLE_VALUES: Map<FixedAngleDirection, 0 | 1 | 2 | 3>;
+export const GENERATOR_MAZE_PUZZLE_COMMAND: "maze_puzzle";
+export const LOADER_CONFIG_COMMAND: "config_loader";
+export const LOADER_FALSE: 0x8e;
+export const LOADER_FILTER_CONFIG_COMMAND: "filter_config";
+export const LOADER_FILTER_ITEMS_COMMAND: "filter_items";
+export const LOADER_TRUE: 0x8d;
+export const NAV_UNIT_COMMAND: "config_nav_unit";
+export const NAV_UNIT_FALSE: 0x8d;
+export const NAV_UNIT_TRUE: 0x8e;
+export const PUSHER_CONFIG_COMMAND: "config_pusher";
+export const PUSHER_FILTER_ITEMS_COMMAND: "filter_items";