nitro/apps/frontend/src/api/avatar/AvatarEditorGridPartItem.ts

import {
  AvatarFigurePartType,
  IAvatarImageListener,
  IAvatarRenderManager,
  IFigurePart,
  IFigurePartSet,
  IGraphicAsset,
  IPartColor,
  NitroAlphaFilter,
  NitroContainer,
  NitroSprite,
  TextureUtils,
} from "@nitro/renderer";

import {GetAvatarRenderManager} from "../nitro";
import {FigureData} from "./FigureData";

export class AvatarEditorGridPartItem implements IAvatarImageListener {
  private static ALPHA_FILTER: NitroAlphaFilter = new NitroAlphaFilter(0.2);
  private static THUMB_DIRECTIONS: number[] = [2, 6, 0, 4, 3, 1];
  private static DRAW_ORDER: string[] = [
    AvatarFigurePartType.LEFT_HAND_ITEM,
    AvatarFigurePartType.LEFT_HAND,
    AvatarFigurePartType.LEFT_SLEEVE,
    AvatarFigurePartType.LEFT_COAT_SLEEVE,
    AvatarFigurePartType.BODY,
    AvatarFigurePartType.SHOES,
    AvatarFigurePartType.LEGS,
    AvatarFigurePartType.CHEST,
    AvatarFigurePartType.CHEST_ACCESSORY,
    AvatarFigurePartType.COAT_CHEST,
    AvatarFigurePartType.CHEST_PRINT,
    AvatarFigurePartType.WAIST_ACCESSORY,
    AvatarFigurePartType.RIGHT_HAND,
    AvatarFigurePartType.RIGHT_SLEEVE,
    AvatarFigurePartType.RIGHT_COAT_SLEEVE,
    AvatarFigurePartType.HEAD,
    AvatarFigurePartType.FACE,
    AvatarFigurePartType.EYES,
    AvatarFigurePartType.HAIR,
    AvatarFigurePartType.HAIR_BIG,
    AvatarFigurePartType.FACE_ACCESSORY,
    AvatarFigurePartType.EYE_ACCESSORY,
    AvatarFigurePartType.HEAD_ACCESSORY,
    AvatarFigurePartType.HEAD_ACCESSORY_EXTRA,
    AvatarFigurePartType.RIGHT_HAND_ITEM,
  ];

  private _renderManager: IAvatarRenderManager;
  private _partSet: IFigurePartSet;
  private _partColors: IPartColor[];
  private _useColors: boolean;
  private _isDisabled: boolean;
  private _thumbContainer: NitroContainer;
  private _imageUrl: string;
  private _maxColorIndex: number;
  private _isValidFigure: boolean;
  private _isHC: boolean;
  private _isSellable: boolean;
  private _isClear: boolean;
  private _isSelected: boolean;
  private _disposed: boolean;
  private _isInitalized: boolean;
  private _notifier: () => void;

  constructor(partSet: IFigurePartSet, partColors: IPartColor[], useColors: boolean = true, isDisabled: boolean = false) {
    this._renderManager = GetAvatarRenderManager();
    this._partSet = partSet;
    this._partColors = partColors;
    this._useColors = useColors;
    this._isDisabled = isDisabled;
    this._thumbContainer = null;
    this._imageUrl = null;
    this._maxColorIndex = 0;
    this._isValidFigure = false;
    this._isHC = false;
    this._isSellable = false;
    this._isClear = false;
    this._isSelected = false;
    this._disposed = false;
    this._isInitalized = false;

    if (partSet) {
      const colors = partSet.parts;

      for (const color of colors) this._maxColorIndex = Math.max(this._maxColorIndex, color.colorLayerIndex);
    }
  }

  public init(): void {
    if (this._isInitalized) return;

    this._isInitalized = true;

    this.update();
  }

  public dispose(): void {
    if (this._disposed) return;

    this._renderManager = null;
    this._partSet = null;
    this._partColors = null;
    this._imageUrl = null;
    this._disposed = true;
    this._isInitalized = false;

    if (this._thumbContainer) {
      this._thumbContainer.destroy();

      this._thumbContainer = null;
    }
  }

  public update(): void {
    this.updateThumbVisualization();
  }

  private analyzeFigure(): boolean {
    if (!this._renderManager || !this._partSet || !this._partSet.parts || !this._partSet.parts.length) return false;

    const figureContainer = this._renderManager.createFigureContainer(this.partSet.type + "-" + this.partSet.id);

    if (!this._renderManager.isFigureContainerReady(figureContainer)) {
      this._renderManager.downloadAvatarFigure(figureContainer, this);

      return false;
    }

    this._isValidFigure = true;

    return true;
  }

  private renderThumb(): NitroContainer {
    if (!this._renderManager || !this._partSet) return null;

    if (!this._isValidFigure) {
      if (!this.analyzeFigure()) return null;
    }

    const parts = this._partSet.parts.concat().sort(this.sortByDrawOrder);
    const container = new NitroContainer();

    for (const part of parts) {
      if (!part) continue;

      let asset: IGraphicAsset = null;
      let direction = 0;
      let hasAsset = false;

      while (!hasAsset && direction < AvatarEditorGridPartItem.THUMB_DIRECTIONS.length) {
        const assetName =
          FigureData.SCALE +
          "_" +
          FigureData.STD +
          "_" +
          part.type +
          "_" +
          part.id +
          "_" +
          AvatarEditorGridPartItem.THUMB_DIRECTIONS[direction] +
          "_" +
          FigureData.DEFAULT_FRAME;

        asset = this._renderManager.getAssetByName(assetName);

        if (asset && asset.texture) {
          hasAsset = true;
        } else {
          direction++;
        }
      }

      if (!hasAsset) continue;

      const x = asset.offsetX;
      const y = asset.offsetY;
      let partColor: IPartColor = null;

      if (this._useColors && part.colorLayerIndex > 0) {
        const color = this._partColors[part.colorLayerIndex - 1];

        if (color) partColor = color;
      }

      const sprite = new NitroSprite(asset.texture);

      sprite.position.set(x, y);

      if (partColor) sprite.tint = partColor.rgb;

      container.addChild(sprite);
    }

    return container;
  }

  private updateThumbVisualization(): void {
    if (!this._isInitalized) return;

    let container = this._thumbContainer;

    if (!container) container = this.renderThumb();

    if (!container) return;

    if (this._partSet) {
      this._isHC = this._partSet.clubLevel > 0;
      this._isSellable = this._partSet.isSellable;
    } else {
      this._isHC = false;
      this._isSellable = false;
    }

    if (this._isDisabled) this.setAlpha(container, 0.2);

    this._imageUrl = TextureUtils.generateImageUrl(container);

    if (this.notify) this.notify();
  }

  private setAlpha(container: NitroContainer, alpha: number): NitroContainer {
    container.filters = [AvatarEditorGridPartItem.ALPHA_FILTER];

    return container;
  }

  private sortByDrawOrder(a: IFigurePart, b: IFigurePart): number {
    const indexA = AvatarEditorGridPartItem.DRAW_ORDER.indexOf(a.type);
    const indexB = AvatarEditorGridPartItem.DRAW_ORDER.indexOf(b.type);

    if (indexA < indexB) return -1;

    if (indexA > indexB) return 1;

    if (a.index < b.index) return -1;

    if (a.index > b.index) return 1;

    return 0;
  }

  public resetFigure(figure: string): void {
    if (!this.analyzeFigure()) return;

    this.update();
  }

  public get disposed(): boolean {
    return this._disposed;
  }

  public get id(): number {
    if (!this._partSet) return -1;

    return this._partSet.id;
  }

  public get partSet(): IFigurePartSet {
    return this._partSet;
  }

  public set partColors(partColors: IPartColor[]) {
    this._partColors = partColors;

    this.update();
  }

  public get isDisabled(): boolean {
    return this._isDisabled;
  }

  public set thumbContainer(container: NitroContainer) {
    this._thumbContainer = container;

    this.update();
  }

  public get imageUrl(): string {
    return this._imageUrl;
  }

  public get maxColorIndex(): number {
    return this._maxColorIndex;
  }

  public get isHC(): boolean {
    return this._isHC;
  }

  public get isSellable(): boolean {
    return this._isSellable;
  }

  public get isClear(): boolean {
    return this._isClear;
  }

  public set isClear(flag: boolean) {
    this._isClear = flag;
  }

  public get isSelected(): boolean {
    return this._isSelected;
  }

  public set isSelected(flag: boolean) {
    this._isSelected = flag;

    if (this.notify) this.notify();
  }

  public get notify(): () => void {
    return this._notifier;
  }

  public set notify(notifier: () => void) {
    this._notifier = notifier;
  }
}