@jjlmoya/utils-science 1.37.0 → 1.39.0

package/src/tool/conway-life-rule-lab/i18n/ru.ts

@@ -0,0 +1,50 @@
+import { content as enContent } from './en';
+import type { ToolLocaleContent } from '../../../types';
+
+export const content: ToolLocaleContent = {
+  ...enContent,
+  slug: 'laboratoriya-pravil-igra-zhizn-konveya',
+  title: 'Лаборатория правил игры Жизнь Конвея',
+  description: 'Запускайте, редактируйте и сравнивайте клеточные автоматы типа Конвея с правилами B/S, начальными паттернами, живыми метриками и адаптивным полем.',
+  ui: {
+    boardLabel: 'Поле клеточного автомата типа Life',
+    play: 'Пуск',
+    pause: 'Пауза',
+    step: 'Шаг',
+    clear: 'Пустое поле',
+    randomize: 'Случайно',
+    ruleLabel: 'Нотация правила',
+    ruleHelp: 'Рождение / выживание',
+    speedLabel: 'Темп',
+    densityLabel: 'Начальная плотность',
+    patternLabel: 'Паттерн',
+    placePattern: 'Разместить паттерн',
+    generation: 'Поколение',
+    population: 'Популяция',
+    density: 'Плотность',
+    stability: 'Стабильность',
+    births: 'Рождения',
+    deaths: 'Смерти',
+    achievementsLabel: 'Журнал лаборатории',
+    achievementPulsar: 'Пульсар',
+    achievementPulsarDescription: 'Обнаружена осцилляция периода 2',
+    achievementImmortal: 'Бессмертный',
+    achievementImmortalDescription: 'Поколение 500 достигнуто при полной стабильности',
+    achievementBigBang: 'Большой взрыв',
+    achievementBigBangDescription: 'Редкое случайное зерно превысило 1 000 живых клеток',
+    presetClassic: 'Классика Конвея',
+    presetHighlife: 'HighLife',
+    presetSeeds: 'Seeds',
+    presetDayNight: 'День и ночь',
+    patternGlider: 'Глайдер',
+    patternGosper: 'Ружьё Госпера',
+    patternPulsar: 'Пульсар',
+    patternRPentomino: 'R-пентамино',
+    colonyStatus: 'Сигнал колонии',
+    statusFrozen: 'стабильно',
+    statusGrowing: 'растёт',
+    statusFading: 'угасает',
+    statusChaotic: 'нестабильно',
+    invalidRule: 'Используйте нотацию B/S, например B3/S23.',
+  },
+};

package/src/tool/conway-life-rule-lab/i18n/sv.ts

@@ -0,0 +1,50 @@
+import { content as enContent } from './en';
+import type { ToolLocaleContent } from '../../../types';
+
+export const content: ToolLocaleContent = {
+  ...enContent,
+  slug: 'conways-game-of-life-regellabb',
+  title: 'Conways Game of Life Regellabb',
+  description: 'Spela, redigera och jämför Conway-liknande cellulära automater med B/S-regler, mönsterfrön, livevärden och responsiv simuleringsyta.',
+  ui: {
+    boardLabel: 'Bräde för Life-liknande cellulära automater',
+    play: 'Spela',
+    pause: 'Pausa',
+    step: 'Steg',
+    clear: 'Tom duk',
+    randomize: 'Slumpa',
+    ruleLabel: 'Regelnotation',
+    ruleHelp: 'Födelse / överlevnad',
+    speedLabel: 'Tempo',
+    densityLabel: 'Startdensitet',
+    patternLabel: 'Mönster',
+    placePattern: 'Placera mönster',
+    generation: 'Generation',
+    population: 'Population',
+    density: 'Densitet',
+    stability: 'Stabilitet',
+    births: 'Födslar',
+    deaths: 'Dödsfall',
+    achievementsLabel: 'Laboratorielogg',
+    achievementPulsar: 'Pulsar',
+    achievementPulsarDescription: 'Period 2 oscillation upptäckt',
+    achievementImmortal: 'Odödlig',
+    achievementImmortalDescription: 'Generation 500 nådd med full stabilitet',
+    achievementBigBang: 'Big Bang',
+    achievementBigBangDescription: 'Ett glest slumpfrö passerade 1 000 levande celler',
+    presetClassic: 'Klassisk Conway',
+    presetHighlife: 'HighLife',
+    presetSeeds: 'Seeds',
+    presetDayNight: 'Dag och natt',
+    patternGlider: 'Glidare',
+    patternGosper: 'Gosper-kanon',
+    patternPulsar: 'Pulsar',
+    patternRPentomino: 'R-pentomino',
+    colonyStatus: 'Kolonisignal',
+    statusFrozen: 'stabil',
+    statusGrowing: 'växer',
+    statusFading: 'avtar',
+    statusChaotic: 'volatil',
+    invalidRule: 'Använd B/S-notation som B3/S23.',
+  },
+};

package/src/tool/conway-life-rule-lab/i18n/tr.ts

@@ -0,0 +1,50 @@
+import { content as enContent } from './en';
+import type { ToolLocaleContent } from '../../../types';
+
+export const content: ToolLocaleContent = {
+  ...enContent,
+  slug: 'conway-hayat-oyunu-kural-laboratuvari',
+  title: 'Conway Hayat Oyunu Kural Laboratuvarı',
+  description: 'B/S kuralları, desen tohumları, canlı metrikler ve duyarlı simülasyon tahtasıyla Conway tarzı hücresel otomatları oynayın, düzenleyin ve karşılaştırın.',
+  ui: {
+    boardLabel: 'Life benzeri hücresel otomat tahtası',
+    play: 'Oynat',
+    pause: 'Duraklat',
+    step: 'Adım',
+    clear: 'Boş tuval',
+    randomize: 'Rastgele',
+    ruleLabel: 'Kural gösterimi',
+    ruleHelp: 'Doğum / hayatta kalma',
+    speedLabel: 'Tempo',
+    densityLabel: 'Başlangıç yoğunluğu',
+    patternLabel: 'Desen',
+    placePattern: 'Deseni yerleştir',
+    generation: 'Nesil',
+    population: 'Popülasyon',
+    density: 'Yoğunluk',
+    stability: 'Kararlılık',
+    births: 'Doğumlar',
+    deaths: 'Ölümler',
+    achievementsLabel: 'Laboratuvar kaydı',
+    achievementPulsar: 'Pulsar',
+    achievementPulsarDescription: 'Periyot 2 salınım algılandı',
+    achievementImmortal: 'Ölümsüz',
+    achievementImmortalDescription: 'Tam kararlılıkla 500. nesle ulaşıldı',
+    achievementBigBang: 'Big Bang',
+    achievementBigBangDescription: 'Seyrek rastgele tohum 1.000 canlı hücreyi aştı',
+    presetClassic: 'Klasik Conway',
+    presetHighlife: 'HighLife',
+    presetSeeds: 'Seeds',
+    presetDayNight: 'Gündüz ve gece',
+    patternGlider: 'Planör',
+    patternGosper: 'Gosper topu',
+    patternPulsar: 'Pulsar',
+    patternRPentomino: 'R-pentomino',
+    colonyStatus: 'Koloni sinyali',
+    statusFrozen: 'kararlı',
+    statusGrowing: 'genişliyor',
+    statusFading: 'azalıyor',
+    statusChaotic: 'oynak',
+    invalidRule: 'B3/S23 gibi B/S gösterimi kullanın.',
+  },
+};

package/src/tool/conway-life-rule-lab/i18n/zh.ts

@@ -0,0 +1,50 @@
+import { content as enContent } from './en';
+import type { ToolLocaleContent } from '../../../types';
+
+export const content: ToolLocaleContent = {
+  ...enContent,
+  slug: 'conway-life-rule-lab',
+  title: '康威生命游戏规则实验室',
+  description: '使用 B/S 规则、图案种子、实时指标和响应式模拟棋盘，运行、编辑并比较康威式细胞自动机。',
+  ui: {
+    boardLabel: '类生命游戏细胞自动机棋盘',
+    play: '播放',
+    pause: '暂停',
+    step: '单步',
+    clear: '空白画布',
+    randomize: '随机',
+    ruleLabel: '规则记法',
+    ruleHelp: '诞生 / 存活计数',
+    speedLabel: '节奏',
+    densityLabel: '初始密度',
+    patternLabel: '图案',
+    placePattern: '放置图案',
+    generation: '世代',
+    population: '数量',
+    density: '密度',
+    stability: '稳定性',
+    births: '诞生',
+    deaths: '死亡',
+    achievementsLabel: '实验日志',
+    achievementPulsar: '脉冲星',
+    achievementPulsarDescription: '检测到周期 2 振荡',
+    achievementImmortal: '不朽',
+    achievementImmortalDescription: '在完全稳定下达到第 500 代',
+    achievementBigBang: '大爆炸',
+    achievementBigBangDescription: '低密度随机种子超过 1,000 个活细胞',
+    presetClassic: '经典康威',
+    presetHighlife: 'HighLife',
+    presetSeeds: 'Seeds',
+    presetDayNight: '昼夜',
+    patternGlider: '滑翔机',
+    patternGosper: 'Gosper 枪',
+    patternPulsar: '脉冲星',
+    patternRPentomino: 'R-五连块',
+    colonyStatus: '群落信号',
+    statusFrozen: '稳定',
+    statusGrowing: '扩张中',
+    statusFading: '衰退中',
+    statusChaotic: '波动',
+    invalidRule: '请使用 B3/S23 这样的 B/S 记法。',
+  },
+};

package/src/tool/conway-life-rule-lab/index.ts

@@ -0,0 +1,11 @@
+import { conwayLifeRuleLab } from './entry';
+import type { ToolDefinition } from '../../types';
+
+export * from './entry';
+
+export const CONWAY_LIFE_RULE_LAB_TOOL: ToolDefinition = {
+  entry: conwayLifeRuleLab,
+  Component: () => import('./component.astro'),
+  SEOComponent: () => import('./seo.astro'),
+  BibliographyComponent: () => import('./bibliography.astro'),
+};

package/src/tool/conway-life-rule-lab/logic/LifeAchievements.ts

@@ -0,0 +1,85 @@
+import type { LifeSnapshot } from './LifeUniverse';
+
+interface AchievementOutputs {
+  pulsar: HTMLElement | null;
+  immortal: HTMLElement | null;
+  bigBang: HTMLElement | null;
+}
+
+export class LifeAchievements {
+  private readonly active = { pulsar: false, immortal: false, bigBang: false };
+  private readonly history: Uint8Array[] = [];
+  private readonly storageKey = 'conway-life-rule-lab-achievements';
+
+  public constructor(private readonly outputs: AchievementOutputs) {
+    this.load();
+  }
+
+  public resetHistory(cells: Uint8Array): void {
+    this.history.length = 0;
+    this.record(cells);
+  }
+
+  public evaluate(snapshot: LifeSnapshot, cells: Uint8Array, randomSeedDensity: number): void {
+    const previous = this.history.length >= 1 ? this.history[this.history.length - 1] : null;
+    const twoBack = this.history.length >= 2 ? this.history[this.history.length - 2] : null;
+    this.evaluatePulsar(cells, previous, twoBack);
+    this.evaluateImmortal(snapshot);
+    this.evaluateBigBang(snapshot, randomSeedDensity);
+    this.record(cells);
+  }
+
+  private evaluatePulsar(cells: Uint8Array, previous: Uint8Array | null, twoBack: Uint8Array | null): void {
+    if (this.active.pulsar || !previous || !twoBack) return;
+    if (!this.arraysEqual(cells, twoBack) || this.arraysEqual(cells, previous)) return;
+    this.active.pulsar = true;
+    this.activate('pulsar');
+  }
+
+  private evaluateImmortal(snapshot: LifeSnapshot): void {
+    if (this.active.immortal || snapshot.stats.generation < 500 || snapshot.stats.stability !== 1) return;
+    this.activate('immortal');
+  }
+
+  private evaluateBigBang(snapshot: LifeSnapshot, randomSeedDensity: number): void {
+    if (this.active.bigBang || randomSeedDensity > 0.12 || snapshot.stats.population <= 1000) return;
+    this.activate('bigBang');
+  }
+
+  private activate(key: keyof typeof this.active): void {
+    this.active[key] = true;
+    this.outputs[key]?.classList.add('life-lab-achievement-active');
+    this.save();
+  }
+
+  private load(): void {
+    try {
+      const saved = window.localStorage.getItem(this.storageKey);
+      if (!saved) return;
+      const parsed = JSON.parse(saved) as Partial<Record<keyof typeof this.active, boolean>>;
+      Object.keys(this.active).forEach((key) => {
+        const achievement = key as keyof typeof this.active;
+        if (parsed[achievement]) this.activate(achievement);
+      });
+    } catch {
+      window.localStorage.removeItem(this.storageKey);
+    }
+  }
+
+  private save(): void {
+    window.localStorage.setItem(this.storageKey, JSON.stringify(this.active));
+  }
+
+  private record(cells: Uint8Array): void {
+    this.history.push(new Uint8Array(cells));
+    if (this.history.length > 3) this.history.shift();
+  }
+
+  private arraysEqual(a: Uint8Array, b: Uint8Array): boolean {
+    if (a.length !== b.length) return false;
+    for (let index = 0; index < a.length; index += 1) {
+      if (a[index] !== b[index]) return false;
+    }
+    return true;
+  }
+}

package/src/tool/conway-life-rule-lab/logic/LifeCanvasRenderer.ts

@@ -0,0 +1,104 @@
+import type { LifeUniverse } from './LifeUniverse';
+
+interface RenderMetrics {
+  dpr: number;
+  cell: number;
+  boardWidth: number;
+  boardHeight: number;
+  offsetX: number;
+  offsetY: number;
+}
+
+interface GridSize {
+  width: number;
+  height: number;
+}
+
+export class LifeCanvasRenderer {
+  public constructor(
+    private readonly root: HTMLElement,
+    private readonly canvas: HTMLCanvasElement,
+    private readonly universe: LifeUniverse,
+    private readonly grid: GridSize,
+  ) {}
+
+  public render(latestPopulation: number): void {
+    this.resizeCanvas();
+    const context = this.canvas.getContext('2d');
+    if (!context) return;
+    this.paintBoard(context, this.getRenderMetrics(), latestPopulation);
+  }
+
+  public canvasToCell(event: PointerEvent): { x: number; y: number } | null {
+    const rect = this.canvas.getBoundingClientRect();
+    const inset = this.boardInset();
+    const size = Math.min((rect.width - inset * 2) / this.grid.width, (rect.height - inset * 2) / this.grid.height);
+    const x = Math.floor((event.clientX - rect.left - (rect.width - size * this.grid.width) / 2) / size);
+    const y = Math.floor((event.clientY - rect.top - (rect.height - size * this.grid.height) / 2) / size);
+    if (x < 0 || y < 0 || x >= this.grid.width || y >= this.grid.height) return null;
+    return { x, y };
+  }
+
+  private resizeCanvas(): void {
+    const rect = this.canvas.getBoundingClientRect();
+    const dpr = Math.min(window.devicePixelRatio || 1, 2);
+    this.canvas.width = Math.floor(rect.width * dpr);
+    this.canvas.height = Math.floor(rect.height * dpr);
+  }
+
+  private getRenderMetrics(): RenderMetrics {
+    const dpr = this.canvas.width / this.canvas.clientWidth;
+    const inset = this.boardInset() * dpr;
+    const cell = Math.min((this.canvas.width - inset * 2) / this.grid.width, (this.canvas.height - inset * 2) / this.grid.height);
+    return {
+      dpr,
+      cell,
+      boardWidth: cell * this.grid.width,
+      boardHeight: cell * this.grid.height,
+      offsetX: (this.canvas.width - cell * this.grid.width) / 2,
+      offsetY: (this.canvas.height - cell * this.grid.height) / 2,
+    };
+  }
+
+  private paintBoard(context: CanvasRenderingContext2D, metrics: RenderMetrics, latestPopulation: number): void {
+    const styles = getComputedStyle(this.root);
+    context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    context.fillStyle = styles.getPropertyValue('--life-board-canvas').trim();
+    context.fillRect(0, 0, this.canvas.width, this.canvas.height);
+    this.paintGrid(context, metrics, styles.getPropertyValue('--life-grid-canvas').trim());
+    this.paintCells(context, metrics, styles, latestPopulation);
+  }
+
+  private paintGrid(context: CanvasRenderingContext2D, metrics: RenderMetrics, color: string): void {
+    context.strokeStyle = color;
+    context.lineWidth = Math.max(1, metrics.dpr);
+    for (let x = 0; x <= this.grid.width; x += 1) this.strokeGridLine(context, metrics, x, true);
+    for (let y = 0; y <= this.grid.height; y += 1) this.strokeGridLine(context, metrics, y, false);
+  }
+
+  private strokeGridLine(context: CanvasRenderingContext2D, metrics: RenderMetrics, index: number, vertical: boolean): void {
+    const position = vertical ? metrics.offsetX + index * metrics.cell : metrics.offsetY + index * metrics.cell;
+    context.beginPath();
+    context.moveTo(vertical ? position : metrics.offsetX, vertical ? metrics.offsetY : position);
+    context.lineTo(vertical ? position : metrics.offsetX + metrics.boardWidth, vertical ? metrics.offsetY + metrics.boardHeight : position);
+    context.stroke();
+  }
+
+  private paintCells(context: CanvasRenderingContext2D, metrics: RenderMetrics, styles: CSSStyleDeclaration, latestPopulation: number): void {
+    const cells = this.universe.getCells();
+    context.fillStyle = latestPopulation > this.grid.width * this.grid.height * 0.238 ? styles.getPropertyValue('--life-cell-high').trim() : styles.getPropertyValue('--life-cell-low').trim();
+    for (let y = 0; y < this.grid.height; y += 1) {
+      for (let x = 0; x < this.grid.width; x += 1) this.paintCell({ context, metrics, cells, x, y });
+    }
+  }
+
+  private paintCell(cell: { context: CanvasRenderingContext2D; metrics: RenderMetrics; cells: Uint8Array; x: number; y: number }): void {
+    const { context, metrics, cells, x, y } = cell;
+    if (!cells[y * this.grid.width + x]) return;
+    context.fillRect(metrics.offsetX + x * metrics.cell + metrics.dpr, metrics.offsetY + y * metrics.cell + metrics.dpr, Math.max(1, metrics.cell - metrics.dpr * 2), Math.max(1, metrics.cell - metrics.dpr * 2));
+  }
+
+  private boardInset(): number {
+    return parseFloat(getComputedStyle(this.root).getPropertyValue('--life-board-inset')) || 0;
+  }
+}

package/src/tool/conway-life-rule-lab/logic/LifeLabDom.ts

@@ -0,0 +1,55 @@
+import { LIFE_PATTERNS } from './LifePatterns';
+
+export interface RuntimeLabels {
+  play: string;
+  pause: string;
+  frozen: string;
+  growing: string;
+  fading: string;
+  chaotic: string;
+  invalidRule: string;
+}
+
+export function getOutputs(byId: (id: string) => HTMLElement): Record<string, HTMLElement | null> {
+  return {
+    generation: byId('life-lab-generation'),
+    population: byId('life-lab-population'),
+    density: byId('life-lab-density'),
+    stability: byId('life-lab-stability'),
+    births: byId('life-lab-births'),
+    deaths: byId('life-lab-deaths'),
+    status: byId('life-lab-status'),
+    pulsar: byId('life-lab-achievement-pulsar'),
+    immortal: byId('life-lab-achievement-immortal'),
+    bigBang: byId('life-lab-achievement-big-bang'),
+  };
+}
+
+export function getLabels(root: HTMLElement, playButton: HTMLButtonElement): RuntimeLabels {
+  const data = root.dataset;
+  return {
+    play: playButton.getAttribute('aria-label') || '',
+    pause: data.pause || '',
+    frozen: data.statusFrozen || '',
+    growing: data.statusGrowing || '',
+    fading: data.statusFading || '',
+    chaotic: data.statusChaotic || '',
+    invalidRule: data.invalidRule || '',
+  };
+}
+
+export function fillPatternSelect(root: HTMLElement, patternSelect: HTMLSelectElement): void {
+  const data = root.dataset;
+  const names: Record<string, string> = {
+    glider: data.patternGlider || '',
+    gosper: data.patternGosper || '',
+    pulsar: data.patternPulsar || '',
+    'r-pentomino': data.patternRPentomino || '',
+  };
+  LIFE_PATTERNS.forEach((pattern) => {
+    const option = document.createElement('option');
+    option.value = pattern.id;
+    option.textContent = names[pattern.id] || pattern.id;
+    patternSelect.append(option);
+  });
+}