bc-deeplib 1.0.2 → 1.0.3

package/src/Base/SettingDefinitions.ts

@@ -0,0 +1,14 @@
+import { BaseSubscreen, GUI } from '../DeepLib';
+
+export function getCurrentSubscreen(): BaseSubscreen | null {
+  return GUI.instance && GUI.instance.currentSubscreen;
+}
+
+export function setSubscreen(subscreen: BaseSubscreen | string | null): BaseSubscreen | null {
+  if (!GUI.instance) {
+    throw new Error('Attempt to set subscreen before init');
+  }
+  GUI.instance.currentSubscreen = subscreen;
+
+  return GUI.instance.currentSubscreen;
+}

package/src/DeepLib.ts

@@ -0,0 +1,33 @@
+export * from './Base/BaseModule';
+export * from './Base/BaseSubscreen';
+export * from './Base/Initialization';
+export * from './Base/Modules';
+export * from './Base/SettingDefinitions';
+
+export * from './Migrators/BaseMigrator';
+
+export * from './Models/Base';
+export * from './Models/Settings';
+
+export * from './Modules/GUI';
+export * from './Modules/Version';
+
+export * from './Screens/Debug';
+export * from './Screens/MainMenu';
+export * from './Screens/Support';
+
+export * from './Utilities/Data';
+export * from './Utilities/Elements/.AdvancedElements';
+export * from './Utilities/Elements/.ElementHelpers';
+export * from './Utilities/Elements/Button';
+export * from './Utilities/Elements/Checkbox';
+export * from './Utilities/Elements/Input';
+export * from './Utilities/Elements/Label';
+export * from './Utilities/Elements/Tooltip';
+export * from './Utilities/Logger';
+export * from './Utilities/Messages';
+export * from './Utilities/SDK';
+export * from './Utilities/String';
+export * from './Utilities/Style';
+export * from './Utilities/Translation';
+

package/src/Migrators/BaseMigrator.ts

@@ -0,0 +1,4 @@
+export abstract class BaseMigrator {
+  abstract get MigrationVersion(): string;
+  abstract Migrate(): boolean;
+}

package/src/Models/Base.ts

@@ -0,0 +1,4 @@
+export type BaseSettingsModel = {
+  modEnabled: boolean;
+  doShowNewVersionMessage: boolean;
+};

package/src/Models/Settings.ts

@@ -0,0 +1,7 @@
+import { BaseSettingsModel } from '../DeepLib';
+
+export type SettingsModel = {
+  [x: string]: any;
+  GlobalModule: BaseSettingsModel;
+  Version: string;
+};

package/src/Modules/GUI.ts

@@ -0,0 +1,123 @@
+import { BaseModule, BaseSubscreen, MainMenu, modules, setSubscreen } from '../DeepLib';
+
+type ModButtonOptions = {
+  Identifier: string;
+  ButtonText: string | (()=>string);
+  Image: string | (()=>string);
+
+  load?: () => void;
+  click?: () => void;
+  run?: () => void;
+  unload?: () => void;
+  exit?: () => boolean | void;
+};
+
+export class GUI extends BaseModule {
+  static instance: GUI | null = null;
+
+  private _subscreens: BaseSubscreen[];
+  private _mainMenu: MainMenu;
+  private _currentSubscreen: BaseSubscreen | null = null;
+  private _modButtonOptions: ModButtonOptions;
+
+  get subscreens(): BaseSubscreen[] {
+    return this._subscreens;
+  }
+
+  get mainMenu(): MainMenu {
+    return this._mainMenu;
+  }
+
+  get currentSubscreen(): BaseSubscreen | null {
+    return this._currentSubscreen;
+  }
+
+  set currentSubscreen(subscreen: BaseSubscreen | string | null) {
+    if (this._currentSubscreen) {
+      this._currentSubscreen.unload();
+    }
+
+    if (typeof subscreen === 'string') {
+      const scr = this._subscreens?.find((s) => s.name === subscreen);
+      if (!scr) throw `Failed to find screen name ${subscreen}`;
+      this._currentSubscreen = scr;
+    } else {
+      this._currentSubscreen = subscreen;
+    }
+
+    PreferenceMessage = '';
+    PreferencePageCurrent = 1;
+
+    if (this._currentSubscreen) {
+      this._currentSubscreen.load();
+      this._currentSubscreen.resize(true);
+    }
+  }
+
+  constructor(modButtonOptions: ModButtonOptions) {
+    super();
+    if (GUI.instance) {
+      throw new Error('Duplicate initialization');
+    }
+
+    for (const module of modules()) {
+      if (!module.settingsScreen) continue;
+    }
+
+    this._mainMenu = new MainMenu(this);
+    this._subscreens = [this._mainMenu];
+    this._modButtonOptions = modButtonOptions;
+
+    GUI.instance = this;
+  }
+
+  get defaultSettings(): null {
+    return null;
+  }
+
+  load(): void {
+    for (const module of modules()) {
+      if (!module.settingsScreen) continue;
+
+      this._subscreens.push(new module.settingsScreen(module));
+    }
+
+    this._mainMenu.subscreens = this._subscreens;
+    PreferenceRegisterExtensionSetting({
+      Identifier: this._modButtonOptions.Identifier,
+      ButtonText: this._modButtonOptions.ButtonText,
+      Image: this._modButtonOptions.Image,
+      load: this._modButtonOptions.load || (() => {
+        setSubscreen(new MainMenu(this));
+      }),
+      run: this._modButtonOptions.run || (() => {
+        if (this._currentSubscreen) {
+          MainCanvas.textAlign = 'left';
+          this._currentSubscreen.run();
+          MainCanvas.textAlign = 'center';
+          
+          const newCanvasPosition: RectTuple = [MainCanvas.canvas.offsetLeft, MainCanvas.canvas.offsetTop, MainCanvas.canvas.clientWidth, MainCanvas.canvas.clientHeight];
+          if (!CommonArraysEqual(newCanvasPosition, DrawCanvasPosition)) {
+            DrawCanvasPosition = newCanvasPosition;
+            this._currentSubscreen.resize(false);
+          }
+        }
+      }),
+      click: this._modButtonOptions.click || (() => {
+        if (this._currentSubscreen) {
+          this._currentSubscreen.click();
+        }
+      }),
+      exit: this._modButtonOptions.exit || (() => {
+        if (this._currentSubscreen) {
+          this._currentSubscreen.exit();
+        }
+      }),
+      unload: this._modButtonOptions.unload || (() => {
+        if (this._currentSubscreen) {
+          this._currentSubscreen.unload();
+        }
+      })
+    });
+  }
+}

package/src/Modules/Version.ts

@@ -0,0 +1,89 @@
+import { BaseMigrator, BaseModule, HookPriority, PlayerStorage, bcSdkMod, dataStore, deepLibLogger, sendLocalMessage } from '../DeepLib';
+
+export class VersionModule extends BaseModule {
+  private static isItNewVersion: boolean = false;
+  static Version: string;
+  static NewVersionMessage: string = '';
+  private static Migrators: BaseMigrator[] = [];
+
+  load(): void {
+    VersionModule.Version = bcSdkMod.ModInfo.version;
+
+    bcSdkMod.prototype.hookFunction(
+      'ChatRoomSync',
+      HookPriority.Observe,
+      (args, next) => {
+        next(args);
+        if (PlayerStorage().GlobalModule.doShowNewVersionMessage && VersionModule.isItNewVersion) {
+          VersionModule.sendNewVersionMessage();
+        }
+      },
+      999
+    );
+  }
+
+  static checkVersionUpdate() {
+    const PreviousVersion = VersionModule.loadVersion();
+    const CurrentVersion = VersionModule.Version;
+
+    if (VersionModule.isNewVersion(PreviousVersion, CurrentVersion)) {
+      VersionModule.isItNewVersion = true;
+      VersionModule.saveVersion();
+    }
+  }
+
+  static checkVersionMigration() {
+    const PreviousVersion = VersionModule.loadVersion();
+
+    let saveRequired = false;
+    for (const migrator of VersionModule.Migrators) {
+      if (VersionModule.isNewVersion(PreviousVersion, migrator.MigrationVersion)) {
+        saveRequired = saveRequired || migrator.Migrate();
+        deepLibLogger.info(`Migrating ${bcSdkMod.ModInfo.name} from ${PreviousVersion} to ${migrator.MigrationVersion} with ${migrator.constructor.name}`);
+      }
+    }
+
+    if (saveRequired) {
+      dataStore();
+    }
+  }
+
+  static registerMigrator(migrator: BaseMigrator) {
+    VersionModule.Migrators.push(migrator);
+  }
+
+  static setNewVersionMessage(newVersionMessage: string) {
+    VersionModule.NewVersionMessage = newVersionMessage;
+  }
+
+  static sendNewVersionMessage() {
+    sendLocalMessage('deeplib-new-version', VersionModule.NewVersionMessage);
+  }
+
+  private static isNewVersion(current: string | undefined, candidate: string) {
+    if (current !== undefined) {
+      const CURRENT_ = current.split('.'),
+        CANDIDATE_ = candidate.split('.');
+      for (let i = 0; i < 3; i++) {
+        if (CURRENT_[i] === CANDIDATE_[i]) {
+          continue;
+        }
+        return CANDIDATE_[i] > CURRENT_[i];
+      }
+    }
+    if (current === undefined || current === '' || !current) {
+      return true;
+    }
+    return false;
+  }
+
+  private static saveVersion() {
+    if (PlayerStorage()) {
+      Player[bcSdkMod.ModInfo.name].Version = VersionModule.Version;
+    }
+  }
+
+  private static loadVersion() {
+    return PlayerStorage()?.Version;
+  }
+}

package/src/Screens/Debug.ts

@@ -0,0 +1,99 @@
+
+import { Button, Checkbox, Input, Label, SettingElement } from 'Types/elements';
+import { BaseSubscreen, deepLibLogger } from '../DeepLib';
+
+export class GuiDebug extends BaseSubscreen {
+
+  get name(): string {
+    return 'debug';
+  }
+
+  get pageStructure(): SettingElement[][] {
+    return [[
+      <Button>{
+        type: 'button',
+        roundness: 50,
+        id: 'test-deeplib-big-button',
+        size: [405, 80],
+        label: 'Big Button',
+        tooltip: 'This is a big button',
+        image: 'Icons/Exit.png',
+        onClick() {
+          deepLibLogger.info('Big Button Clicked');
+        }
+      },
+      <Button>{
+        type: 'button',
+        roundness: 5,
+        id: 'test-deeplib-small-button',
+        size: [90, 90],
+        tooltip: 'This is a small button',
+        image: 'Icons/Exit.png',
+        onClick() {
+          deepLibLogger.info('Small Button Clicked');
+        }
+      },
+      <Checkbox>{
+        type: 'checkbox',
+        id: 'test-deeplib-checkbox',
+        label: 'Checkbox',
+        description: 'This is a checkbox',
+        checked: false,
+        getSettingValue() {
+          return true;
+        },
+        setSettingValue(val: boolean) {
+          deepLibLogger.info('Checkbox value:', val);
+        },
+      },
+      <Input>{
+        type: 'text',
+        id: 'test-deeplib-text-input',
+        label: 'Input',
+        description: 'This is a text input',
+        getElementValue() {
+          return 'Input Value';
+        },
+        setSettingValue(val: string) {
+          deepLibLogger.info('Input value:', val);
+        },
+      },
+      <Input>{
+        type: 'number',
+        id: 'test-deeplib-number-input',
+        label: 'Input',
+        description: 'This is a number input',
+        getElementValue() {
+          return '123';
+        },
+        setSettingValue(val: string) {
+          deepLibLogger.info('Input value:', val);
+        },
+      },
+      <Label>{
+        type: 'label',
+        id: 'test-deeplib-label',
+        label: 'Label',
+        description: 'This is a label',
+      }
+    ]];
+  }
+
+  load(): void {
+    super.load();
+  }
+
+  run() {
+    super.run();
+  }
+
+  click() { }
+
+  exit(): void {
+    super.exit();
+  }
+
+  resize(): void {
+    super.resize();
+  }
+}

package/src/Screens/MainMenu.ts

@@ -0,0 +1,138 @@
+
+import { BaseSubscreen, GUI, GuiDebug, GuiSupport, elementAppendToMiscDiv, elementAppendToSettingsDiv, elementAppendToSubscreenDiv, elementCreateButton, elementCreateMiscDiv, elementSetPosSizeFont, getText } from '../DeepLib';
+
+export class MainMenu extends BaseSubscreen {
+  subscreens: BaseSubscreen[] = [];
+
+  static wikiLink: string = '';
+  static resetSubscreen: BaseSubscreen | null = null;
+
+  get name(): string {
+    return 'mainmenu';
+  }
+
+  constructor(module: GUI) {
+    super(module);
+
+    this.subscreens = module.subscreens;
+  }
+
+  load(): void {
+    if (!GUI.instance?.currentSubscreen) {
+      this.setSubscreen(this);
+      return;
+    }
+
+    super.load();
+
+    const exitButton = elementCreateButton({
+      type: 'button',
+      id: 'exit',
+      position: [1815, 75],
+      size: [90, 90],
+      image: 'Icons/Exit.png',
+      onClick: () => {
+        this.exit();
+      },
+      tooltip: getText('settings.button.back_button_hint')
+    });
+    elementAppendToSubscreenDiv(exitButton);
+
+    for (const screen of this.subscreens) {
+
+      if (screen.name == 'mainmenu') continue;
+
+      const button = elementCreateButton({
+        type: 'button',
+        id: `${screen.name}-button`,
+        image: screen.icon,
+        label: getText(`mainmenu.button.${screen.name}`),
+        onClick: () => {
+          this.setSubscreen(screen);
+        },
+        size: [450, 90],
+      });
+
+      elementAppendToSettingsDiv(button);
+    }
+
+    const miscDiv = elementCreateMiscDiv();
+    elementAppendToSubscreenDiv(miscDiv);
+
+    if (MainMenu.resetSubscreen) {
+      const resetButton = elementCreateButton({
+        type: 'button',
+        id: 'deeplib-reset-button',
+        image: 'Icons/ServiceBell.png',
+        label: 'Reset',
+        onClick: () => {
+          this.setSubscreen(MainMenu.resetSubscreen);
+        },
+        size: [405, 80],
+      });
+      elementAppendToMiscDiv(resetButton);
+    }
+
+    if (MainMenu.wikiLink) {
+      const wikiButton = elementCreateButton({
+        type: 'button',
+        id: 'deeplib-wiki-button',
+        image: 'Icons/Introduction.png',
+        label: 'Wiki',
+        onClick: () => {
+          window.open(MainMenu.wikiLink, '_blank');
+        },
+        size: [405, 80],
+      });
+      elementAppendToMiscDiv(wikiButton);
+    }
+
+    const supportButton = elementCreateButton({
+      type: 'button',
+      id: 'deeplib-support-button',
+      image: 'Assets/Female3DCG/Emoticon/Coffee/Icon.png',
+      label: 'Support',
+      onClick: () => {
+        this.setSubscreen(new GuiSupport());
+      },
+      size: [405, 80],
+    });
+    elementAppendToMiscDiv(supportButton);
+    elementSetPosSizeFont({ elementId: 'deeplib-misc' }, 1500, 670, 405, 260);
+
+    const debugButton = elementCreateButton({
+      type: 'button',
+      id: 'deeplib-debug-button',
+      image: 'Assets/Female3DCG/Emoticon/Coffee/Icon.png',
+      onClick: () => {
+        this.setSubscreen(new GuiDebug());
+      },
+      size: [90, 90],
+      position: [75, 75],
+    });
+    elementAppendToMiscDiv(debugButton);
+  }
+
+  run() {
+    super.run();
+  }
+
+  click() { }
+
+  exit(): void {
+    CharacterAppearanceForceUpCharacter = -1;
+    CharacterLoadCanvas(Player);
+    this.setSubscreen(null);
+    PreferenceSubscreenExtensionsClear();
+  }
+
+  resize(): void {
+    super.resize();
+    elementSetPosSizeFont({ elementId: 'deeplib-misc' }, 1500, 670, 405, 260);
+  }
+}
+
+export function setMainMenuOptions(wikiLink: string, resetSubscreen: BaseSubscreen | null) {
+  MainMenu.wikiLink = wikiLink;
+  MainMenu.resetSubscreen = resetSubscreen;
+}

package/src/Screens/Support.ts

@@ -0,0 +1,99 @@
+import { Button, SettingElement } from '../../.types/elements';
+import { BaseSubscreen, elementSetPosSizeFont, getText } from '../DeepLib';
+
+export class SupportHelper {
+  private static thankYouList: string[] = ['Ellena', 'weboos', 'Jamie'];
+  private static thankYouNext = 0;
+  private static thankYou = '';
+
+  static getSupporter() {
+    if (SupportHelper.thankYouNext < CommonTime()) SupportHelper.doNextThankYou();
+    return `${getText('support.other.thankyou')}, ${SupportHelper.thankYou}`;
+  }
+
+  static doNextThankYou() {
+    if (SupportHelper.thankYou && SupportHelper.thankYouList.length < 2) return;
+    SupportHelper.thankYou = CommonRandomItemFromList(SupportHelper.thankYou, SupportHelper.thankYouList);
+    SupportHelper.thankYouNext = CommonTime() + 5000;
+  }
+}
+
+export class GuiSupport extends BaseSubscreen {
+  get name(): string {
+    return 'Support';
+  }
+
+  get currentPage(): SettingElement[] {
+    return [
+      <Button>{
+        type: 'button',
+        id: 'deeplib-support-kofi',
+        size: [405, 80],
+        label: getText('support.button.ko-fi'),
+        image: 'https://storage.ko-fi.com/cdn/nav-logo-stroke.png',
+        onClick() {
+          window.open('https://ko-fi.com/monikka_bc', '_blank');
+        }
+      },
+      <Button>{
+        type: 'button',
+        id: 'deeplib-support-patreon',
+        size: [405, 80],
+        label: getText('support.button.patreon'),
+        image: 'https://c5.patreon.com/external/favicon/rebrand/favicon-32.png?v=af5597c2ef',
+        onClick() {
+          window.open('https://patreon.com/monikka_bc', '_blank');
+        }
+      }
+    ];
+  }
+
+  load() {
+    SupportHelper.doNextThankYou();
+    super.load();
+    ElementRemove('deeplib-settngs');
+
+    ElementCreateDiv('deeplib-gratitude');
+    const elm = document.getElementById('deeplib-gratitude') as HTMLElement;
+    ElementContent('deeplib-gratitude', gratitudeHtml);
+    elementSetPosSizeFont({ element: elm }, 1000, 250, 400, 400);
+
+  }
+
+  run() {
+    super.run();
+  }
+
+  click() {
+    super.click();
+  }
+
+  exit() {
+    ElementRemove('deeplib-gratitude');
+    super.exit();
+  }
+
+  resize(): void {
+    super.resize();
+    elementSetPosSizeFont({ elementId: 'deeplib-gratitude' }, 1000, 250, 400, 400);
+  }
+}
+
+const gratitudeHtml = /*html*/ `
+<h1>Dear Supporters!</h1>
+<p>
+  I want to take a moment to express my heartfelt gratitude for considering supporting me. Your willingness to stand by
+  my side in this creative journey means the world to me, and I am truly humbled by your generosity.
+</p>
+<p>
+  Your support goes far beyond the financial contributions; it represents belief in my work and a shared passion for
+  what I do. Your encouragement inspires me to continue developing.
+</p>
+<p>
+  Your support not only helps me sustain and grow as a developer, but also enables me to dedicate more time and
+  resources to producing high-quality mods. It allows me to explore new ideas, enhance my skills, and bring even more
+  meaningful and enjoyable content to you.
+</p>
+<p>Thank you all~</p>
+<p>With love, Monikka♥</p>
+`;

package/src/Utilities/Data.ts

@@ -0,0 +1,40 @@
+import { SettingsModel, _String, bcSdkMod, modules } from '../DeepLib';
+
+export const PlayerStorage = (): Readonly<SettingsModel> => (
+  typeof Player?.[bcSdkMod.ModInfo.name] === 'object' ?
+    CommonCloneDeep(Player?.[bcSdkMod.ModInfo.name]) :
+    undefined
+);
+export const ExtensionStorage = (): Readonly<string> => Player.ExtensionSettings[bcSdkMod.ModInfo.name];
+
+export function dataTake(modName: string = bcSdkMod.ModInfo.name) {
+  if (ExtensionStorage()) {
+    const parsed = JSON.parse(LZString.decompressFromBase64(ExtensionStorage()) || '');
+    Player[modName] = Object.hasOwn(parsed, 'Version') ? parsed : undefined;
+  } else {
+    Player[modName] = {};
+  }
+}
+
+export function dataStore() {
+  const modName = bcSdkMod.ModInfo.name;
+  const modVersion = bcSdkMod.ModInfo.version;
+
+  if (!ExtensionStorage()) Player.ExtensionSettings[modName] = '';
+  const Data: SettingsModel = {
+    GlobalModule: {
+      modEnabled: false,
+      doShowNewVersionMessage: false
+    },
+    Version: modVersion
+  };
+
+  for (const module of modules()) {
+    if (!module.settingsStorage) continue;
+
+    Data[module.settingsStorage] = PlayerStorage()[module.settingsStorage];
+  }
+
+  Player.ExtensionSettings[modName] = _String.encode(Data);
+  ServerPlayerExtensionSettingsSync(modName);
+}