manager.ts

import type { Packet } from '../../util/packet.js';
import type { AsyncVoid } from '../../util/types.js';
import inventory from '../ddg.inventory/local.js';
import proxy from '../internal.proxy/local.js';

interface UpstreamUseItemPacketData {
  hand: number;
  sequence: number;
}

interface UpstreamUseEntityPacketData {
  target: number;
  mouse: number;
  x: number | undefined;
  y: number | undefined;
  z: number | undefined;
  hand: number | undefined;
  sneaking: boolean;
}

export interface ItemModifier {
  onUse?: (packet: Packet<UpstreamUseItemPacketData>) => AsyncVoid;
  onUseEntity?: (packet: Packet<UpstreamUseEntityPacketData>) => AsyncVoid;
}

const modifiers: Map<string, ItemModifier> = new Map();

export function registerModifier(id: string, modifier: ItemModifier): void {
  modifiers.set(id, modifier);
}

async function broadcast<T extends keyof ItemModifier>(
  event: T,
  // TODO: Do this differently
  // (I tried everything but couldn't, ts is being gay today)
  ...args: Parameters<Required<ItemModifier>[T]>
): Promise<void> {
  const selected = inventory.client.getSelectedSlot();
  const nbtData = selected.nbtData;

  if (nbtData === undefined) return;
  if (nbtData.type !== 'compound') return;
  const modifiersData = nbtData.value.modifiers;
  if (modifiersData === undefined) return;
  if (modifiersData.type !== 'list') return;

  for (const id of modifiersData.value.value) {
    if (typeof id !== 'string') continue;

    const modifier = modifiers.get(id);
    if (modifier === undefined) continue;

    const f = modifier[event];
    if (f === undefined) continue;

    await f(...args);
  }
}

proxy.upstream.on('use_item', async (packet) => {
  await broadcast('onUse', packet as Packet<UpstreamUseItemPacketData>);
});

proxy.upstream.on('use_entity', async (packet) => {
  await broadcast('onUseEntity', packet as Packet<UpstreamUseEntityPacketData>);
});