boardgame-core/src/core/region.ts

import {batch, computed, ReadonlySignal, SignalOptions} from "@preact/signals-core";
import {Entity} from "@/utils/entity";
import {Part} from "./part";
import {RNG} from "@/utils/rng";

export type Region = {
  id: string;
  axes: RegionAxis[];
  children: Entity<Part>[];
}

export type RegionAxis = {
  name: string;
  min?: number;
  max?: number;
  align?: 'start' | 'end' | 'center';
}

export class RegionEntity extends Entity<Region> {
  public readonly partsMap: ReadonlySignal<Record<string, Entity<Part>>>;

  public constructor(id: string, t?: Region, options?: SignalOptions<Region>) {
    super(id, t, options);
    this.partsMap = computed(() => {
      const result: Record<string, Entity<Part>> = {};
      for (const child of this.value.children) {
        const key = child.value.position.join(',');
        result[key] = child;
      }
      return result;
    });
  }
}

export function applyAlign(region: Entity<Region>) {
  batch(() => {
    region.produce(applyAlignCore);
  });
}

function applyAlignCore(region: Region) {
  if (region.children.length === 0) return;

  for (let axisIndex = 0; axisIndex < region.axes.length; axisIndex++) {
    const axis = region.axes[axisIndex];
    if (!axis.align) continue;

    const positionValues = new Set<number>();
    for (const child of region.children) {
      positionValues.add(child.value.position[axisIndex] ?? 0);
    }

    const sortedPositions = Array.from(positionValues).sort((a, b) => a - b);
    const positionMap = new Map<number, number>();

    if (axis.align === 'start' && axis.min !== undefined) {
      sortedPositions.forEach((pos, index) => {
        positionMap.set(pos, axis.min! + index);
      });
    } else if (axis.align === 'end' && axis.max !== undefined) {
      const count = sortedPositions.length;
      sortedPositions.forEach((pos, index) => {
        positionMap.set(pos, axis.max! - (count - 1 - index));
      });
    } else if (axis.align === 'center') {
      const count = sortedPositions.length;
      const min = axis.min ?? 0;
      const max = axis.max ?? count - 1;
      const range = max - min;
      const center = min + range / 2;

      sortedPositions.forEach((pos, index) => {
        const offset = index - (count - 1) / 2;
        positionMap.set(pos, center + offset);
      });
    }

    for (const child of region.children) {
      child.produce(draft => {
        const currentPos = draft.position[axisIndex] ?? 0;
        draft.position[axisIndex] = positionMap.get(currentPos) ?? currentPos;
      });
    }
  }

  region.children.sort((a, b) => {
    for (let i = 0; i < region.axes.length; i++) {
      const diff = (a.value.position[i] ?? 0) - (b.value.position[i] ?? 0);
      if (diff !== 0) return diff;
    }
    return 0;
  });
}

export function shuffle(region: Entity<Region>, rng: RNG) {
  batch(() => {
    region.produce(region => shuffleCore(region, rng));
  });
}

function shuffleCore(region: Region, rng: RNG){
  if (region.children.length <= 1) return;

  const children = [...region.children];
  for (let i = children.length - 1; i > 0; i--) {
    const j = rng.nextInt(i + 1);
    const posI = [...children[i].value.position];
    const posJ = [...children[j].value.position];
    children[i].produce(draft => {
      draft.position = posJ;
    });
    children[j].produce(draft => {
      draft.position = posI;
    });
  }
}

export function moveToRegion(part: Entity<Part>, targetRegion: Entity<Region>, position?: number[]) {
  const sourceRegion = part.value.region;
  batch(() => {
    sourceRegion.produce(draft => {
      draft.children = draft.children.filter(c => c.id !== part.id);
    });
    targetRegion.produce(draft => {
      draft.children.push(part);
    });
    part.produce(draft => {
      draft.region = targetRegion;
      if (position) draft.position = position;
    });
  });
}

export function moveToRegionAll(parts: Entity<Part>[], targetRegion: Entity<Region>, positions?: number[][]) {
  batch(() => {
    for (let i = 0; i < parts.length; i++) {
      const part = parts[i];
      const sourceRegion = part.value.region;
      sourceRegion.produce(draft => {
        draft.children = draft.children.filter(c => c.id !== part.id);
      });
      targetRegion.produce(draft => {
        draft.children.push(part);
      });
      part.produce(draft => {
        draft.region = targetRegion;
        if (positions && positions[i]) draft.position = positions[i];
      });
    }
  });
}

export function removeFromRegion(part: Entity<Part>) {
  const region = part.value.region;
  batch(() => {
    region.produce(draft => {
      draft.children = draft.children.filter(c => c.id !== part.id);
    });
  });
}