bc-deeplib 1.0.1 → 1.0.3

package/src/Utilities/Elements/.AdvancedElements.ts

@@ -0,0 +1,70 @@
+export function elementCreateSubscreenDiv() {
+  const subscreenDiv = elementGetSubscreenDiv();
+  if (subscreenDiv) {
+    console.error('Subscreen already exists');
+    return subscreenDiv;
+  }
+
+  const div = document.createElement('div');
+  div.id = 'deeplib-subscreen';
+  div.classList.add('deeplib-subscreen', 'HideOnPopup');
+
+  return document.body.appendChild(div);
+}
+
+export function elementGetSubscreenDiv() {
+  return document.getElementById('deeplib-subscreen') ?? undefined;
+}
+
+export function elementRemoveSubscreenDiv() {
+  return elementGetSubscreenDiv()?.remove();
+}
+
+export function elementAppendToSubscreenDiv(element: HTMLElement) {
+  return elementGetSubscreenDiv()?.appendChild(element);
+}
+
+export function elementCreateSettingsDiv() {
+  const settingsDiv = elementGetSettingsDiv();
+  if (settingsDiv) {
+    console.error('Settings screen already exists');
+    return settingsDiv;
+  }
+
+  const div = document.createElement('div');
+  div.id = 'deeplib-settings';
+  div.classList.add('deeplib-settings');
+
+  return div;
+}
+
+export function elementGetSettingsDiv() {
+  return document.getElementById('deeplib-settings') ?? undefined;
+}
+
+export function elementAppendToSettingsDiv(element: HTMLElement) {
+  return elementGetSettingsDiv()?.appendChild(element);
+}
+
+export function elementCreateMiscDiv() {
+  const miscDiv = elementGetMiscDiv();
+  if (miscDiv) {
+    console.error('Settings screen already exists');
+    return miscDiv;
+  }
+
+  const div = document.createElement('div');
+  div.id = 'deeplib-misc';
+  div.classList.add('deeplib-misc');
+
+  return div;
+}
+
+export function elementGetMiscDiv() {
+  return document.getElementById('deeplib-misc');
+}
+
+export function elementAppendToMiscDiv(element: HTMLElement) {
+  return elementGetMiscDiv()?.appendChild(element);
+}
+

package/src/Utilities/Elements/.ElementHelpers.ts

@@ -0,0 +1,100 @@
+import { deepLibLogger } from '../../DeepLib';
+
+type ElementOrId = { elementId?: string; element?: HTMLElement; };
+
+const mainCanvasHeight = 1000;
+const mainCanvasWidth = 2000;
+
+export function getRelativeHeight(height: number) {
+  return height * (MainCanvas.canvas.clientHeight / mainCanvasHeight);
+}
+
+export function getRelativeWidth(width: number) {
+  return width * (MainCanvas.canvas.clientWidth / mainCanvasWidth);
+}
+
+export function getRelativeY(yPos: number) {
+  return MainCanvas.canvas.offsetTop + yPos * (MainCanvas.canvas.clientHeight / mainCanvasHeight);
+}
+
+export function getRelativeX(xPos: number) {
+  return MainCanvas.canvas.offsetLeft + xPos * (MainCanvas.canvas.clientWidth / mainCanvasWidth);
+}
+
+export function elementSetPosition(_: ElementOrId, xPos: number, yPos: number) {
+  const element = elementGet(_, 'elementSetPosition');
+  if (!element) return;
+
+  const Top = getRelativeY(yPos);
+  const Left = getRelativeX(xPos);
+
+  Object.assign(element.style, {
+    position: 'fixed',
+    left: Left + 'px',
+    top: Top + 'px'
+  });
+}
+
+export function elementSetSize(_: ElementOrId, width: number, height: number) {
+  const element = elementGet(_, 'elementSetSize');
+  if (!element) return;
+
+  const Height = getRelativeHeight(height);
+  const Width = getRelativeWidth(width);
+
+  Object.assign(element.style, {
+    width: Width + 'px',
+    height: Height + 'px',
+  });
+}
+
+export function elementAdjustFontSize(_: ElementOrId) {
+  const element = elementGet(_, 'elementAdjustFontSize');
+  if (!element) return;
+
+  const Font = MainCanvas.canvas.clientWidth <= MainCanvas.canvas.clientHeight * 2 ? MainCanvas.canvas.clientWidth / 50 : MainCanvas.canvas.clientHeight / 25;
+
+  Object.assign(element.style, {
+    fontSize: Font + 'px',
+    fontFamily: CommonGetFontName()
+  });
+}
+
+export function elementSetPosSizeFont(_: ElementOrId, xPos: number, yPos: number, width: number, height: number) {
+  if (elementGet(_, 'elementSetPosSizeFont') === null) return;
+
+  elementSetPosition(_, xPos, yPos);
+  elementSetSize(_, width, height);
+  elementAdjustFontSize(_);
+}
+
+export function elementHide(_: ElementOrId) {
+  const element = elementGet(_, 'elementHide');
+  if (!element) return;
+
+  element.style.display = 'none';
+}
+
+export function elementUnhide(_: ElementOrId) {
+  const element = elementGet(_, 'elementUnhide');
+  if (!element) return;
+
+  element.style.display = '';
+}
+
+function elementGet(_: ElementOrId, funcName: string) {
+  if (!_) {
+    deepLibLogger.warn(`${funcName} called without an elementId or element`);
+    return null;
+  }
+
+  const elementId = _.elementId ?? _.element?.id;
+  const element = _.element ?? document.getElementById(_.elementId!);
+
+  if (!element) {
+    deepLibLogger.warn(`A call to ${funcName} was made on non-existent element with id ${elementId}`);
+    return null;
+  }
+
+  return element;
+}

package/src/Utilities/Elements/Button.ts

@@ -0,0 +1,54 @@
+import { Button } from 'Types/elements';
+import { BaseSubscreen, getRelativeHeight, getRelativeWidth, getRelativeX, getRelativeY } from '../../DeepLib';
+
+export function elementCreateButton(options: Button) {
+  const width = options.size ? getRelativeWidth(options.size[0]) + 'px' : '';
+  const height = options.size ? getRelativeHeight(options.size[1]) + 'px' : '';
+  const left = options.position ? getRelativeX(options.position[0]) + 'px' : '';
+  const top = options.position ? getRelativeY(options.position[1]) + 'px' : '';
+  const position = options.position ? 'fixed' : '';
+
+  const button = ElementButton.Create(options.id, () => options.onClick(),
+    {
+      tooltip: options.tooltip,
+      label: options.label,
+      labelPosition: 'center',
+    },
+    {
+      button: {
+        classList: ['deeplib-button'],
+        children: [
+          {
+            tag: 'img',
+            attributes: {
+              id: `${options.id}-image`,
+              alt: '',
+              disabled: options.disabled,
+              decoding: 'async', 
+              loading: 'lazy',
+              src: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7' // 1x1 transparent image to get rid of broken image
+            },
+            dataAttributes: {
+              'size': options.size?.join('x'),
+              'position': options.position?.join('x'),
+            },
+            style: {
+              '--image': `url("${options.image}")`,
+            }
+          },
+        ],
+        style: {
+          width: width,
+          height: height,
+          left: left,
+          top: top,
+          position: position,
+        }
+      },
+    }
+  );
+  
+  BaseSubscreen.currentElements.push([button, options]);
+
+  return button;
+}

package/src/Utilities/Elements/Checkbox.ts

@@ -0,0 +1,63 @@
+import { Checkbox } from 'Types/elements';
+import { BaseSubscreen, elementSetTooltip, getRelativeHeight, getRelativeWidth, getRelativeX, getRelativeY } from '../../DeepLib';
+
+export function elementCreateCheckbox(options: Checkbox) {
+  const elem = document.getElementById(options.id);
+
+  if (elem) return elem;
+
+  const width = options.size ? getRelativeWidth(options.size[0]) + 'px' : '';
+  const height = options.size ? getRelativeHeight(options.size[1]) + 'px' : '';
+  const left = options.position ? getRelativeX(options.position[0]) + 'px' : '';
+  const top = options.position ? getRelativeY(options.position[1]) + 'px' : '';
+  const position = options.position ? 'fixed' : '';
+
+  const retElem = ElementCreate({
+    tag: 'div',
+    classList: ['deeplib-checkbox-container'],
+    style: {
+      width: width,
+      height: height,
+      left: left,
+      top: top,
+      position: position,
+    },
+    dataAttributes: {
+      'size': options.size?.join('x'),
+      'position': options.position?.join('x'),
+    },
+    children: [
+      {
+        tag: 'input',
+        classList: ['deeplib-input'],
+        attributes: {
+          type: 'checkbox',
+          id: options.id,
+          checked: options.getSettingValue() || undefined,
+        },
+      },
+      {
+        tag: 'label',
+        classList: ['deeplib-text'],
+        attributes: {
+          for: options.id,
+        },
+        children: [options.label]
+      },
+    ]
+  });
+
+  if (options.description) {
+    retElem.addEventListener('mouseover', () => {
+      elementSetTooltip(options.description);
+    });
+
+    retElem.addEventListener('mouseout', () => {
+      elementSetTooltip('');
+    });
+  }
+
+  BaseSubscreen.currentElements.push([retElem, options]);
+
+  return retElem;
+}

package/src/Utilities/Elements/Input.ts

@@ -0,0 +1,72 @@
+import { Input } from 'Types/elements';
+import { BaseSubscreen, elementSetTooltip, getRelativeHeight, getRelativeWidth, getRelativeX, getRelativeY } from '../../DeepLib';
+
+export function elementCreateInput(options: Input) {
+  const elem = document.getElementById(options.id);
+
+  if (elem) return elem;
+
+  const width = options.size ? getRelativeWidth(options.size[0]) + 'px' : '';
+  const height = options.size ? getRelativeHeight(options.size[1]) + 'px' : '';
+  const left = options.position ? getRelativeX(options.position[0]) + 'px' : '';
+  const top = options.position ? getRelativeY(options.position[1]) + 'px' : '';
+  const position = options.position ? 'fixed' : '';
+
+  const retElem = ElementCreate({
+    tag: 'div',
+    classList: ['deeplib-input-container'],
+    style: {
+      width: width,
+      height: height,
+      left: left,
+      top: top,
+      position: position,
+    },
+    dataAttributes: {
+      'size': options.size?.join('x'),
+      'position': options.position?.join('x'),
+    },
+    children: [
+      {
+        tag: 'input',
+        classList: ['deeplib-input'],
+        attributes: {
+          type: options.type,
+          id: options.id,
+          placeholder: ' ',
+        },
+      },
+      {
+        tag: 'label',
+        classList: ['deeplib-text'],
+        attributes: {
+          for: options.id,
+        },
+        children: [options.label]
+      },
+      {
+        tag: 'div',
+        classList: ['deeplib-underline'],
+      }
+    ]
+  });
+
+  if (options.getElementValue?.()) {
+    const input = document.getElementById(options.id) as HTMLInputElement;
+    if (input) input.value = options.getElementValue();
+  }
+  
+  if (options.description) {
+    retElem.addEventListener('mouseover', () => {
+      elementSetTooltip(options.description);
+    });
+
+    retElem.addEventListener('mouseout', () => {
+      elementSetTooltip('');
+    });
+  }
+
+  BaseSubscreen.currentElements.push([retElem, options]);
+
+  return retElem;
+}

package/src/Utilities/Elements/Label.ts

@@ -0,0 +1,50 @@
+import { Label } from 'Types/elements';
+import { BaseSubscreen, elementSetTooltip, getRelativeHeight, getRelativeWidth, getRelativeX, getRelativeY } from '../../DeepLib';
+
+export function elementCreateLabel(options: Label) {
+  const elem = document.getElementById(options.id);
+
+  if (elem) return elem;
+
+  const width = options.size ? getRelativeWidth(options.size[0]) + 'px' : '';
+  const height = options.size ? getRelativeHeight(options.size[1]) + 'px' : '';
+  const left = options.position ? getRelativeX(options.position[0]) + 'px' : '';
+  const top = options.position ? getRelativeY(options.position[1]) + 'px' : '';
+  const position = options.position ? 'fixed' : '';
+
+  const retElem = ElementCreate({
+    tag: 'span',
+    classList: ['deeplib-label', 'deeplib-text'],
+    attributes: {
+      id: options.id
+    },
+    style: {
+      width: width,
+      height: height,
+      left: left,
+      top: top,
+      position: position,
+    },
+    dataAttributes: {
+      'size': options.size?.join('x'),
+      'position': options.position?.join('x'),
+    },
+    children: [
+      options.label,
+    ],
+  });
+  
+  if (options.description) {
+    retElem.addEventListener('mouseover', () => {
+      elementSetTooltip(options.description as string);
+    });
+
+    retElem.addEventListener('mouseout', () => {
+      elementSetTooltip('');
+    });
+  }
+
+  BaseSubscreen.currentElements.push([retElem, options]);
+
+  return retElem;
+}

package/src/Utilities/Elements/Tooltip.ts

@@ -0,0 +1,30 @@
+export function elementCreateTooltip() {
+  const element = ElementCreate({
+    tag: 'div',
+    classList: ['deeplib-tooltip'],
+    attributes: {
+      id: 'deeplib-tooltip'
+    },
+    style: {
+      display: 'none'
+    }
+  });
+
+  return element;
+}
+
+export function elementGetTooltip() {
+  return document.getElementById('deeplib-tooltip') ?? undefined;
+}
+
+export function elementSetTooltip(text: string) {
+  const element = document.getElementById('deeplib-tooltip');
+
+  if (!element) return false;
+  
+  element.innerHTML = text;
+  if (text === '') element.style.display = 'none';
+  else element.style.display = '';
+
+  return true;
+}

package/src/Utilities/Logger.ts

@@ -0,0 +1,79 @@
+type LogLevel = 'info' | 'log' | 'warn' | 'error' | 'debug';
+
+interface LogEntry {
+  readonly args: readonly any[];
+  readonly date: Date;
+  readonly logLevel: LogLevel;
+}
+
+export class Logger extends Array<LogEntry> {
+  private ModName: string = 'DeepLib';
+
+  constructor(modName?: string) {
+    super();
+
+    if (modName) {
+      this.ModName = modName;
+    }
+  }
+
+  private _Log(level: LogLevel, ...args: any[]): void {
+    const logEntry: LogEntry = {
+      logLevel: level,
+      args: [...args],
+      // trace: arguments.callee.caller.toString().split('\n'), 
+      date: new Date(Date.now())
+      // `[${this.ModName}] ${formattedArgs}` 
+    };
+
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (userAgent.includes('chrome') || userAgent.includes('firefox')) {
+      const color = Logger.colorizeLog(level);
+      args.forEach(arg => {
+        if (typeof arg === 'string') {
+          arg = `\n%c${arg}`;
+          // args.splice(args.indexOf(arg), 1, arg, color);
+        }
+      });
+      console.log(`%c${this.ModName}:`, color, ...args);
+    } else {
+      console.log(`${this.ModName}:`, ...args);
+    }
+
+    this.push(logEntry);
+  }
+
+  info(...args: any[]): void {
+    this._Log('info', ...args);
+  }
+
+  log(...args: any[]): void {
+    this._Log('log', ...args);
+  }
+
+  warn(...args: any[]): void {
+    this._Log('warn', ...args);
+  }
+
+  error(...args: any[]): void {
+    this._Log('error', ...args);
+  }
+
+  debug(...args: any[]): void {
+    this._Log('debug', ...args);
+  }
+
+  static colorizeLog(logLevel: LogLevel): string {
+    const colors: Record<LogLevel, string> = {
+      info: 'color: #32CCCC',
+      log: 'color: #CCCC32',
+      warn: 'color: #eec355',
+      error: 'color: #750b0b',
+      debug: 'color: #9E4BCF',
+    };
+
+    return colors[logLevel];
+  }
+}
+
+export const deepLibLogger = new Logger();

package/src/Utilities/Messages.ts

@@ -0,0 +1,36 @@
+export function sendLocalMessage(id: string, message: string, timeoutInSeconds?: number) {
+  const div = document.createElement('div');
+  div.id = id;
+  const specialId = id + Date.now();
+  div.classList.add('ChatMessage', 'deeplib-message', specialId);
+  div.setAttribute('data-time', ChatRoomCurrentTime());
+  div.setAttribute('data-sender', Player?.MemberNumber + '');
+
+  const messageContent = message.replaceAll('\n\t', '') + '<br>';
+  const closeButton = document.createElement('a');
+  closeButton.classList.add('deeplib-text');
+  closeButton.addEventListener('click', () => {
+    div?.remove();
+  });
+  closeButton.innerHTML = '<b>Close (Click)</b>';
+
+  div.innerHTML = messageContent;
+  div.append(closeButton);
+
+  ChatRoomAppendChat(div);
+  if (!timeoutInSeconds) return;
+  setTimeout(() => div?.remove(), timeoutInSeconds * 1000);
+}
+
+export function sendActionMessage(msg: string, target: undefined | number = undefined, dictionary: ChatMessageDictionaryEntry[] = []) {
+  if (!msg) return;
+  ServerSend('ChatRoomChat', {
+    Content: 'DEEPLIB_CUSTOM_ACTION',
+    Type: 'Action',
+    Target: target ?? undefined,
+    Dictionary: [
+      { Tag: 'MISSING TEXT IN "Interface.csv": DEEPLIB_CUSTOM_ACTION', Text: msg },
+      ...dictionary,
+    ],
+  });
+}

package/src/Utilities/SDK.ts

@@ -0,0 +1,104 @@
+import bcModSdkRef, { ModSDKModAPI, ModSDKModInfo, ModSDKModOptions } from 'bondage-club-mod-sdk';
+
+export enum HookPriority {
+  Observe = 0,
+  AddBehavior = 1,
+  ModifyBehavior = 5,
+  OverrideBehavior = 10,
+  Top = 100
+}
+
+export type ModuleCategory = number;
+
+export declare type AnyFunction = (...args: any) => any;
+type PatchHook<TFunction extends AnyFunction = AnyFunction> = (args: [...Parameters<TFunction>], next: (args: [...Parameters<TFunction>]) => ReturnType<TFunction>) => ReturnType<TFunction>;
+
+interface IPatchedFunctionData {
+  name: string;
+  hooks: {
+    hook: PatchHook;
+    priority: number;
+    module: ModuleCategory | null;
+    removeCallback: () => void;
+  }[];
+}
+
+type GetDotedPathType<Base, DotedKey extends string> = DotedKey extends `${infer Key1}.${infer Key2}` ? GetDotedPathType<GetDotedPathType<Base, Key1>, Key2> : DotedKey extends keyof Base ? Base[DotedKey] : never;
+
+export class bcSdkMod {
+  private static SDK: ModSDKModAPI;
+  private static patchedFunctions: Map<string, IPatchedFunctionData> = new Map();
+
+  public static ModInfo: ModSDKModInfo;
+
+  constructor(info: ModSDKModInfo, options?: ModSDKModOptions) {
+    bcSdkMod.SDK = bcModSdkRef.registerMod(info, options);
+    bcSdkMod.ModInfo = info;
+  }
+
+  initPatchableFunction(target: string): IPatchedFunctionData {
+    let result = bcSdkMod.patchedFunctions.get(target);
+    if (!result) {
+      result = {
+        name: target,
+        hooks: []
+      };
+      bcSdkMod.patchedFunctions.set(target, result);
+    }
+    return result;
+  }
+
+  hookFunction<TargetName extends string>(
+    target: TargetName,
+    priority: number,
+    hook: PatchHook<GetDotedPathType<typeof globalThis, TargetName>>,
+    module: ModuleCategory | null = null
+  ): () => void {
+    const data = this.initPatchableFunction(target);
+
+    if (data.hooks.some((h) => h.hook === hook)) {
+      return () => null;
+    }
+
+    const removeCallback = bcSdkMod.SDK?.hookFunction(target, priority, hook);
+
+    data.hooks.push({
+      hook,
+      priority,
+      module,
+      removeCallback
+    });
+    data.hooks.sort((a, b) => b.priority - a.priority);
+    return removeCallback;
+  }
+
+  patchFunction(target: string, patches: Record<string, string>): void {
+    this.patchFunction(target, patches);
+  }
+
+  removeHookByModule(target: string, module: ModuleCategory): boolean {
+    const data = this.initPatchableFunction(target);
+
+    for (let i = data.hooks.length - 1; i >= 0; i--) {
+      if (data.hooks[i].module === module) {
+        data.hooks[i].removeCallback();
+        data.hooks.splice(i, 1);
+      }
+    }
+
+    return true;
+  }
+
+  removeAllHooksByModule(module: ModuleCategory): boolean {
+    for (const data of bcSdkMod.patchedFunctions.values()) {
+      for (let i = data.hooks.length - 1; i >= 0; i--) {
+        if (data.hooks[i].module === module) {
+          data.hooks[i].removeCallback();
+          data.hooks.splice(i, 1);
+        }
+      }
+    }
+
+    return true;
+  }
+}

package/src/Utilities/String.ts

@@ -0,0 +1,31 @@
+import { deepLibLogger } from './Logger';
+
+export class _String {
+  static encode(string: string | object) {
+    return LZString.compressToBase64(JSON.stringify(string));
+  }
+
+  static decode(string: string | undefined) {
+    const d = LZString.decompressFromBase64(string as string);
+    let data = {};
+
+    try {
+      const decoded = JSON.parse(d as string);
+      data = decoded;
+    } catch (error) {
+      deepLibLogger.error(error);
+    }
+    if (data) return data;
+  }
+
+  static shuffle(string: string[]) {
+    const temp: string[] = JSON.parse(JSON.stringify(string));
+    const ret: string[] = [];
+    while (temp.length > 0) {
+      const d = Math.floor(Math.random() * temp.length);
+      ret.push(temp[d]);
+      temp.splice(d, 1);
+    }
+    return ret;
+  }
+}