@vnejs/plugins.views.screens.checkers 0.2.2 → 0.2.3

package/src/modules/controller.ts

@@ -1,50 +1,30 @@
 import { ModuleController } from "@vnejs/module.components";
 
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-import { createInitialCheckersState, type CheckersPluginState } from "../utils/checkers.js";
-
-export class CheckersController extends ModuleController<
-  CheckersPluginEvents,
-  CheckersPluginConstants,
-  CheckersPluginSettings,
-  CheckersPluginParams,
-  CheckersPluginState
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import type { CheckersViewState } from "../utils/checkers.js";
+
+export class CheckersViewController extends ModuleController<
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams,
+  CheckersViewState
 > {
-  name = "checkers.controller";
+  name = "checkers_view.controller";
 
-  EVENT_UPDATE_VIEW = this.EVENTS.CHECKERS.UPDATE;
+  EVENT_UPDATE_VIEW = this.EVENTS.CHECKERS_VIEW.UPDATE;
 
   CONTROLS = {};
-  CONTROLS_INDEX = this.PARAMS.CHECKERS.ZINDEX;
+  CONTROLS_INDEX = this.PARAMS.CHECKERS_VIEW.ZINDEX;
 
   subscribe = () => {
-    this.on(this.EVENTS.CHECKERS.SHOW, this.onShow);
-    this.on(this.EVENTS.CHECKERS.HIDE, this.onHide);
-    this.on(this.EVENTS.CHECKERS.STATE_UPDATE, this.updateState);
-    this.on(this.EVENTS.CHECKERS.UPDATE_FAST, this.updateViewFast);
-    this.on(this.EVENTS.CHECKERS.FINISH, this.onFinish);
-  };
-
-  beforeShow = async () => {
-    this.shared.checkersAiBusy = false;
-    const initial = createInitialCheckersState();
-    const ai = {
-      white: this.shared.checkersAi?.white ?? this.CONST.CHECKERS.AI_TYPES.PLAYER,
-      black: this.shared.checkersAi?.black ?? this.CONST.CHECKERS.AI_TYPES.PLAYER,
-    };
-
-    await this.emit(this.EVENTS.CHECKERS.STATE_UPDATE, { ...initial, ai } satisfies Partial<CheckersPluginState>);
-    await this.emit(this.EVENTS.CHECKERS.GRID_UPDATE_ITEMS);
+    this.on(this.EVENTS.CHECKERS_VIEW.SHOW, this.onShow);
+    this.on(this.EVENTS.CHECKERS_VIEW.HIDE, this.onHide);
+    this.on(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, this.updateState);
+    this.on(this.EVENTS.CHECKERS_VIEW.UPDATE_FAST, this.updateViewFast);
   };
 
   afterHide = () => {
-    this.shared.checkersAiBusy = false;
     this.setDefaultState();
   };
-
-  onFinish = async () => {
-    this.shared.checkersAiBusy = false;
-    await this.emit(this.EVENTS.CHECKERS.HIDE);
-    this.emitNext();
-  };
 }

package/src/modules/player.interact.ts

@@ -0,0 +1,48 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { CheckersMovePayload, CheckersMovePlayPayload, CheckersMovesGetResult } from "@vnejs/contracts.game.checkers";
+import type { CheckersPlayerInteractPayload, CheckersPlayerSelectPayload } from "@vnejs/contracts.views.screens.checkers";
+
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import { samePos, type CheckersPos, type CheckersViewState } from "../utils/checkers.js";
+
+export class CheckersViewPlayerInteract extends ModuleCore<
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams,
+  CheckersViewState
+> {
+  name = "checkers_view.player.interact";
+
+  subscribe = () => {
+    this.on(this.EVENTS.CHECKERS_VIEW.PLAYER_INTERACT, this.onPlayerInteract);
+    this.on(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, this.updateState);
+  };
+
+  onPlayerInteract = async ({ row, column }: CheckersPlayerInteractPayload = {}) => {
+    const { board, turn, selected } = this.state;
+    if (row == null || column == null || !board || !turn) return;
+
+    const focus: CheckersPos = { row, column };
+    const piece = board[focus.row]?.[focus.column] ?? null;
+    const legalFromState = this.state.legalMoves ?? [];
+    const move = selected && legalFromState.find((m) => samePos(m.from, selected) && samePos(m.to, focus));
+
+    if (move) return void this.emitOne(this.EVENTS.CHECKERS.MOVE_PLAY, { move, controllerType: this.CONST.AI.PLAYER_TYPE } satisfies CheckersMovePlayPayload);
+
+    if (piece && piece.color === turn) {
+      const result = (await this.emitOne(this.EVENTS.CHECKERS.MOVES_GET, { board, turn })) as CheckersMovesGetResult<CheckersMovePayload> | null;
+      const legalMoves = (result?.moves ?? []).filter((m) => samePos(m.from, focus));
+      if (legalMoves.length === 0) return;
+
+      const nextSelected = selected && samePos(selected, focus) ? null : focus;
+
+      return void this.emit(this.EVENTS.CHECKERS_VIEW.PLAYER_SELECT, {
+        selected: nextSelected,
+        legalMoves: nextSelected ? legalMoves : [],
+      } satisfies CheckersPlayerSelectPayload);
+    }
+
+    if (selected) return void this.emit(this.EVENTS.CHECKERS_VIEW.PLAYER_SELECT, { selected: null, legalMoves: [] } satisfies CheckersPlayerSelectPayload);
+  };
+}

package/src/modules/player.select.ts

@@ -0,0 +1,42 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { CheckersPlayerSelectPayload } from "@vnejs/contracts.views.screens.checkers";
+
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import { buildGridItems, type CheckersMove, type CheckersPos, type CheckersViewState } from "../utils/checkers.js";
+
+export class CheckersViewPlayerSelect extends ModuleCore<
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams,
+  CheckersViewState
+> {
+  name = "checkers_view.player.select";
+
+  subscribe = () => {
+    this.on(this.EVENTS.CHECKERS_VIEW.PLAYER_SELECT, this.onPlayerSelect);
+    this.on(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, this.updateState);
+  };
+
+  onPlayerSelect = async ({ selected = null, legalMoves = [] }: CheckersPlayerSelectPayload = {}) => {
+    const board = this.state.board;
+    if (!board) return;
+
+    const nextSelected = selected as CheckersPos | null;
+    const nextLegalMoves = legalMoves as CheckersMove[];
+    const gridItems = buildGridItems({
+      board,
+      selected: nextSelected,
+      legalMoves: nextLegalMoves,
+      gridRow: this.state.gridRow ?? null,
+      gridColumn: this.state.gridColumn ?? null,
+    });
+
+    await this.emit(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, {
+      selected: nextSelected,
+      legalMoves: nextLegalMoves,
+      gridItems,
+    } satisfies Partial<CheckersViewState>);
+    await this.emit(this.EVENTS.CHECKERS_VIEW.UPDATE_FAST);
+  };
+}

package/src/modules/view.ts

@@ -1,17 +1,23 @@
 import { ModuleView } from "@vnejs/module.components";
 
 import { render } from "../view/index.js";
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-import type { CheckersPluginState } from "../utils/checkers.js";
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import type { CheckersViewState } from "../utils/checkers.js";
 
-export class CheckersView extends ModuleView<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams, CheckersPluginState> {
-  name = "checkers.view";
+export class CheckersViewView extends ModuleView<
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams,
+  CheckersViewState
+> {
+  name = "checkers_view.view";
 
-  EVENT_UPDATE_VIEW = this.EVENTS.CHECKERS.UPDATE;
+  EVENT_UPDATE_VIEW = this.EVENTS.CHECKERS_VIEW.UPDATE;
 
   LOC_LABEL = null;
 
-  TRANSITION = this.PARAMS.CHECKERS.TRANSITION;
+  TRANSITION = this.PARAMS.CHECKERS_VIEW.TRANSITION;
 
   renderFunc = render;
 }

package/src/tests/player.interact.test.ts

@@ -0,0 +1,56 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { SUBSCRIBE_EVENTS as CHECKERS_EVENTS } from "@vnejs/contracts.game.checkers";
+import { SUBSCRIBE_EVENTS as CHECKERS_VIEW_EVENTS } from "@vnejs/contracts.views.screens.checkers";
+import { stubEvent } from "@vnejs/test-utils";
+
+import { CheckersViewPlayerInteract } from "../modules/player.interact.js";
+import { BOARD_SIZE, type CheckersBoard, type CheckersPiece } from "../utils/checkers.js";
+import { createCheckersViewTestModule, registerCheckersViewPluginVne } from "./setup.js";
+
+const emptyBoard = (): CheckersBoard => Array.from({ length: BOARD_SIZE }, () => Array.from({ length: BOARD_SIZE }, () => null));
+
+const piece = (id: string, color: CheckersPiece["color"]): CheckersPiece => ({ id, color, king: false });
+
+/** White at (5,2): (4,1) hangs to black at (3,0); (4,3) is safe. */
+const hangingScenarioBoard = (): CheckersBoard => {
+  const board = emptyBoard();
+  board[5]![2] = piece("w1", "white");
+  board[3]![0] = piece("b1", "black");
+  return board;
+};
+
+describe("checkers_view player.interact", () => {
+  beforeEach(() => {
+    registerCheckersViewPluginVne();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("PLAYER_INTERACT selects piece and emits PLAYER_SELECT", async () => {
+    const board = hangingScenarioBoard();
+    const { module, observer } = createCheckersViewTestModule(CheckersViewPlayerInteract, { subscribe: false });
+    const interact = module as CheckersViewPlayerInteract;
+    interact.updateState({ board, turn: "white", selected: null, legalMoves: [] });
+
+    const playerSelect = vi.fn(() => null);
+    stubEvent(observer, CHECKERS_VIEW_EVENTS.PLAYER_SELECT, playerSelect);
+    stubEvent(observer, CHECKERS_EVENTS.MOVES_GET, () => ({
+      moves: [
+        { from: { row: 5, column: 2 }, to: { row: 4, column: 1 }, captures: [] },
+        { from: { row: 5, column: 2 }, to: { row: 4, column: 3 }, captures: [] },
+      ],
+      hanging: [],
+      safe: [],
+    }));
+
+    await interact.onPlayerInteract({ row: 5, column: 2 });
+
+    expect(playerSelect).toHaveBeenCalledOnce();
+    const args = playerSelect.mock.calls[0]?.[0] as { selected: { row: number; column: number }; legalMoves: unknown[] };
+    expect(args.selected).toEqual({ row: 5, column: 2 });
+    expect(args.legalMoves).toHaveLength(2);
+  });
+});

package/src/tests/setup.ts

@@ -1,23 +1,33 @@
+import { CONSTANTS as AI_CONST, PARAMS as AI_PARAMS, PLUGIN_NAME as AI, SUBSCRIBE_EVENTS as AI_EVENTS } from "@vnejs/contracts.ai";
 import { CONSTANTS as CONTROLS_CONST, PLUGIN_NAME as CONTROLS, SUBSCRIBE_EVENTS as CONTROLS_EVENTS } from "@vnejs/contracts.controls";
-import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.screens.checkers";
+import {
+  CONSTANTS as CHECKERS_CONST,
+  PARAMS as CHECKERS_PARAMS,
+  PLUGIN_NAME as CHECKERS,
+  SUBSCRIBE_EVENTS as CHECKERS_EVENTS,
+} from "@vnejs/contracts.game.checkers";
+import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.screens.checkers";
+import { SourcesSet } from "@vnejs/sources-set";
 import { createTestModule as baseCreateTestModule, registerCoreVne, registerVnePlugin, stubSilentEvent } from "@vnejs/test-utils";
 
-export const registerCheckersPluginVne = () => {
+export const registerCheckersViewPluginVne = () => {
   registerCoreVne();
   registerVnePlugin(CONTROLS, { constants: CONTROLS_CONST, events: CONTROLS_EVENTS });
-  registerVnePlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS });
+  registerVnePlugin(AI, { constants: AI_CONST, events: AI_EVENTS, params: AI_PARAMS });
+  registerVnePlugin(CHECKERS, { constants: CHECKERS_CONST, events: CHECKERS_EVENTS, params: CHECKERS_PARAMS });
+  registerVnePlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS });
 };
 
-export const createCheckersTestModule = <T extends Parameters<typeof baseCreateTestModule>[0]>(
+export const createCheckersViewTestModule = <T extends Parameters<typeof baseCreateTestModule>[0]>(
   ModuleClass: T,
   options: Parameters<typeof baseCreateTestModule>[1] = {},
 ) => {
   const result = baseCreateTestModule(ModuleClass, {
-    state: {
-      checkers: { isShow: false },
-      ...(options.state ?? {}),
-    },
     ...options,
+    shared: {
+      checkersInteractDisableSources: new SourcesSet(),
+      ...(options.shared ?? {}),
+    },
   });
 
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.SHOW);
@@ -26,9 +36,10 @@ export const createCheckersTestModule = <T extends Parameters<typeof baseCreateT
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.UPDATE_FAST);
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.STATE_UPDATE);
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.GRID_UPDATE_ITEMS);
-  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.FINISH);
+  stubSilentEvent(result.observer, CHECKERS_EVENTS.BOARD_CHANGE);
+  stubSilentEvent(result.observer, CHECKERS_EVENTS.FINISH);
 
   return result;
 };
 
-export { SUBSCRIBE_EVENTS, PARAMS, PLUGIN_NAME, CONTROLS_EVENTS };
+export { SUBSCRIBE_EVENTS, PARAMS, PLUGIN_NAME, CONTROLS_EVENTS, CHECKERS_EVENTS };

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { ModuleComponentsConstants, ModuleComponentsEvents, ModuleComponentsParams, ModuleComponentsSettings } from "@vnejs/module.components";
+import type { Constants as AiConstants, Params as AiParams, PluginName as AiPluginName, SubscribeEvents as AiSubscribeEvents } from "@vnejs/contracts.ai";
 import type { Constants as ControlsConstants, PluginName as ControlsPluginName } from "@vnejs/contracts.controls";
 import type {
   Constants as ScenarioConstants,
@@ -6,18 +7,30 @@ import type {
   SubscribeEvents as ScenarioSubscribeEvents,
 } from "@vnejs/contracts.core.scenario";
 import type { PluginName as LogsPluginName, SubscribeEvents as LogsSubscribeEvents } from "@vnejs/contracts.core.logs";
-import type { Constants, Params, PluginName, SubscribeEvents } from "@vnejs/contracts.views.screens.checkers";
+import type {
+  Constants as CheckersConstants,
+  Params as CheckersParams,
+  PluginName as CheckersPluginName,
+  SubscribeEvents as CheckersSubscribeEvents,
+} from "@vnejs/contracts.game.checkers";
+import type { Params, PluginName, SubscribeEvents } from "@vnejs/contracts.views.screens.checkers";
 
-export type CheckersPluginEvents = ModuleComponentsEvents &
+export type CheckersViewPluginEvents = ModuleComponentsEvents &
   Record<PluginName, SubscribeEvents> &
+  Record<CheckersPluginName, CheckersSubscribeEvents> &
+  Record<AiPluginName, AiSubscribeEvents> &
   Record<ScenarioPluginName, ScenarioSubscribeEvents> &
   Record<LogsPluginName, LogsSubscribeEvents>;
 
-export type CheckersPluginConstants = ModuleComponentsConstants &
-  Record<PluginName, Constants> &
+export type CheckersViewPluginConstants = ModuleComponentsConstants &
+  Record<CheckersPluginName, CheckersConstants> &
+  Record<AiPluginName, AiConstants> &
   Record<ControlsPluginName, ControlsConstants> &
   Record<ScenarioPluginName, ScenarioConstants>;
 
-export type CheckersPluginSettings = ModuleComponentsSettings;
+export type CheckersViewPluginSettings = ModuleComponentsSettings;
 
-export type CheckersPluginParams = ModuleComponentsParams & Record<PluginName, Params>;
+export type CheckersViewPluginParams = ModuleComponentsParams &
+  Record<PluginName, Params> &
+  Record<CheckersPluginName, CheckersParams> &
+  Record<AiPluginName, AiParams>;

package/src/utils/checkers.ts

@@ -1,5 +1,20 @@
-import type { CheckersBoard, CheckersColor, CheckersMove, CheckersPiece, CheckersPos } from "./board.js";
-import { BOARD_SIZE, createInitialBoard, getAllMoves, isDarkSquare } from "./board.js";
+import type { CheckersBoardChangedPayload, CheckersMovePayload, CheckersPosPayload } from "@vnejs/contracts.game.checkers";
+
+export const BOARD_SIZE = 8;
+
+export type CheckersColor = "white" | "black";
+
+export type CheckersPiece = {
+  id: string;
+  color: CheckersColor;
+  king: boolean;
+};
+
+export type CheckersPos = CheckersPosPayload;
+
+export type CheckersMove = CheckersMovePayload;
+
+export type CheckersBoard = (CheckersPiece | null)[][];
 
 export type CheckersGridItem = {
   row: number;
@@ -11,7 +26,7 @@ export type CheckersGridItem = {
   isFocus?: boolean;
 };
 
-export type CheckersPluginState = {
+export type CheckersViewState = {
   isShow: boolean;
   isForce: boolean;
   board?: CheckersBoard;
@@ -25,21 +40,16 @@ export type CheckersPluginState = {
   gridItems?: CheckersGridItem[];
   gridIndex?: number;
   gridsCount?: number;
-  ai?: {
-    white: string;
-    black: string;
-  };
 };
 
-export type CheckersCellClickPayload = {
+export type CheckersClickPayload = {
   row?: number;
   column?: number;
 };
 
-export const statusForTurn = (turn: CheckersColor, winner: CheckersColor | null = null) => {
-  if (winner) return winner === "white" ? "White wins" : "Black wins";
-  return turn === "white" ? "White to move" : "Black to move";
-};
+export const isDarkSquare = (row: number, column: number) => (row + column) % 2 === 1;
+
+export const samePos = (a: CheckersPos, b: CheckersPos) => a.row === b.row && a.column === b.column;
 
 export const buildGridItems = ({
   board,
@@ -74,23 +84,39 @@ export const buildGridItems = ({
   return items;
 };
 
-export const createInitialCheckersState = (): Pick<
-  CheckersPluginState,
-  "board" | "turn" | "selected" | "legalMoves" | "winner" | "statusText" | "gridItems" | "gridIndex" | "gridsCount"
-> => {
-  const board = createInitialBoard();
-  const turn: CheckersColor = "white";
-  const legalMoves = getAllMoves(board, turn);
+export const listBoardPieces = (board: CheckersBoard) => {
+  const pieces: Array<CheckersPiece & CheckersPos> = [];
+
+  for (let row = 0; row < BOARD_SIZE; row++) {
+    for (let column = 0; column < BOARD_SIZE; column++) {
+      const piece = board[row]?.[column];
+      if (!piece) continue;
+      pieces.push({ ...piece, row, column });
+    }
+  }
+
+  return pieces;
+};
+
+export const emptyBoard = (): CheckersBoard => Array.from({ length: BOARD_SIZE }, () => Array.from({ length: BOARD_SIZE }, () => null));
+
+export const statusForTurn = (turn?: CheckersColor, winner: CheckersColor | null = null) => {
+  if (winner) return winner === "white" ? "White wins" : "Black wins";
+  if (!turn) return "";
+  return turn === "white" ? "White to move" : "Black to move";
+};
+
+export const fromBoardChanged = (payload: CheckersBoardChangedPayload = {}): Partial<CheckersViewState> => {
+  const turn = payload.turn as CheckersColor | undefined;
+  const winner = (payload.winner ?? null) as CheckersColor | null;
 
   return {
-    board,
+    board: payload.board as CheckersBoard | undefined,
     turn,
+    winner,
+    statusText: statusForTurn(turn, winner),
+    // selection is view-only — reset on every game model change
     selected: null,
     legalMoves: [],
-    winner: null,
-    statusText: statusForTurn(turn),
-    gridItems: buildGridItems({ board, legalMoves: [] }),
-    gridIndex: 0,
-    gridsCount: 1,
   };
 };

package/src/view/index.tsx

@@ -4,17 +4,16 @@ import type { ReactComponentProps } from "@vnejs/uis.react";
 import { Flex, PositionBox, Screen, Text, createRenderFunc, useCallback, useEffect, useMemo, useState, useStoreState } from "@vnejs/uis.react";
 import { getVneLength } from "@vnejs/uis.utils";
 
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-import type { CheckersColor, CheckersPiece } from "../utils/board.js";
-import { listBoardPieces } from "../utils/board.js";
-import type { CheckersGridItem, CheckersPluginState } from "../utils/checkers.js";
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import type { CheckersColor, CheckersGridItem, CheckersPiece, CheckersViewState } from "../utils/checkers.js";
+import { listBoardPieces } from "../utils/checkers.js";
 
 type CheckersComponentProps = ReactComponentProps<
-  CheckersPluginEvents,
-  CheckersPluginConstants,
-  CheckersPluginSettings,
-  CheckersPluginParams,
-  CheckersPluginState
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams,
+  CheckersViewState
 >;
 
 type VisualPiece = {
@@ -72,15 +71,15 @@ const CheckersScreen = ({ store, onMount, PARAMS, emit, EVENTS }: CheckersCompon
     gridColumn = null,
     selected = null,
     statusText = "",
-  } = useStoreState<CheckersPluginState>(store, onMount);
-
-  const transition = PARAMS.CHECKERS.TRANSITION;
-  const propsByView = PARAMS.CHECKERS.VIEW_PROPS;
-  const rows = PARAMS.CHECKERS.ROWS;
-  const columns = PARAMS.CHECKERS.COLUMNS;
-  const cellSize = PARAMS.CHECKERS.CELL_SIZE;
-  const cellGap = PARAMS.CHECKERS.CELL_GAP;
-  const graveyardGap = PARAMS.CHECKERS.GRAVEYARD_GAP;
+  } = useStoreState<CheckersViewState>(store, onMount);
+
+  const transition = PARAMS.CHECKERS_VIEW.TRANSITION;
+  const propsByView = PARAMS.CHECKERS_VIEW.VIEW_PROPS;
+  const rows = PARAMS.CHECKERS_VIEW.ROWS;
+  const columns = PARAMS.CHECKERS_VIEW.COLUMNS;
+  const cellSize = PARAMS.CHECKERS_VIEW.CELL_SIZE;
+  const cellGap = PARAMS.CHECKERS_VIEW.CELL_GAP;
+  const graveyardGap = PARAMS.CHECKERS_VIEW.GRAVEYARD_GAP;
   const boardSize = columns * cellSize + (columns - 1) * cellGap;
   const playfieldWidth = cellSize + graveyardGap + boardSize + graveyardGap + cellSize;
 
@@ -244,11 +243,11 @@ const CheckersScreen = ({ store, onMount, PARAMS, emit, EVENTS }: CheckersCompon
     [blackGraveyardX, boardOffsetX, cellLen, stepLen],
   );
 
-  const onCellClick = useCallback(
+  const onClick = useCallback(
     (row: number, column: number) => {
-      void emit(EVENTS.CHECKERS.CELL_CLICK, { row, column });
+      void emit(EVENTS.CHECKERS_VIEW.CLICK, { row, column });
     },
-    [emit, EVENTS.CHECKERS.CELL_CLICK],
+    [emit, EVENTS.CHECKERS_VIEW.CLICK],
   );
 
   return (
@@ -266,7 +265,7 @@ const CheckersScreen = ({ store, onMount, PARAMS, emit, EVENTS }: CheckersCompon
                 return (
                   <div
                     key={`${item.row}-${item.column}`}
-                    onClick={() => onCellClick(item.row, item.column)}
+                    onClick={() => onClick(item.row, item.column)}
                     vne-cursor-type="pointer"
                     style={{
                       ...cellBaseStyle,
@@ -306,4 +305,4 @@ const CheckersScreen = ({ store, onMount, PARAMS, emit, EVENTS }: CheckersCompon
   );
 };
 
-export const render: ViewRenderFunc<CheckersPluginState> = createRenderFunc(CheckersScreen);
+export const render: ViewRenderFunc<CheckersViewState> = createRenderFunc(CheckersScreen);

package/dist/modules/checkers.d.ts

@@ -1,9 +0,0 @@
-import { ModuleCore } from "@vnejs/module.core";
-import type { LineExecHandlerArg } from "@vnejs/module.core";
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-export declare class Checkers extends ModuleCore<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams> {
-    name: string;
-    postinject: () => void;
-    init: () => Promise<unknown[]> | undefined;
-    onLineExec: ({ line }?: LineExecHandlerArg) => Promise<unknown[]> | undefined;
-}

package/dist/modules/checkers.js

@@ -1,37 +0,0 @@
-import { tokenizeExecLine } from "@vnejs/helpers";
-import { ModuleCore } from "@vnejs/module.core";
-const AI_COLOR_VALUES = new Set(["white", "black"]);
-const AI_TYPE_VALUES = new Set(["player", "sacrifice", "random", "strong"]);
-export class Checkers extends ModuleCore {
-    name = "checkers";
-    postinject = () => {
-        this.shared.checkersAi ??= {
-            white: this.CONST.CHECKERS.AI_TYPES.PLAYER,
-            black: this.CONST.CHECKERS.AI_TYPES.PLAYER,
-        };
-        this.shared.checkersAiBusy ??= false;
-    };
-    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: this.name, handler: this.onLineExec });
-    onLineExec = ({ line = "" } = {}) => {
-        const [action = "", colorRaw = "", typeRaw = ""] = tokenizeExecLine(line).map(String);
-        if (action === this.CONST.CHECKERS.EXEC_ACTIONS.SHOW) {
-            this.emitLog({ action });
-            return this.emit(this.EVENTS.CHECKERS.SHOW);
-        }
-        if (action !== this.CONST.CHECKERS.EXEC_ACTIONS.AI)
-            return;
-        if (!AI_COLOR_VALUES.has(colorRaw) || !AI_TYPE_VALUES.has(typeRaw)) {
-            this.emitLog({ action, color: colorRaw, type: typeRaw, error: "invalid_args" });
-            this.emitNext();
-            return;
-        }
-        const color = colorRaw;
-        const type = typeRaw;
-        this.shared.checkersAi = {
-            ...this.shared.checkersAi,
-            [color]: type,
-        };
-        this.emitLog({ action, color, type });
-        this.emitNext();
-    };
-}

package/dist/utils/ai.d.ts

@@ -1,4 +0,0 @@
-import { type CheckersBoard, type CheckersColor, type CheckersMove } from "./board.js";
-export type CheckersAiType = "player" | "sacrifice" | "random" | "strong";
-export declare const isHangingMove: (board: CheckersBoard, move: CheckersMove, color: CheckersColor) => boolean;
-export declare const pickMove: (board: CheckersBoard, color: CheckersColor, type: CheckersAiType) => CheckersMove | null;

package/dist/utils/ai.js

@@ -1,27 +0,0 @@
-import { applyMove, getAllMoves, oppositeColor } from "./board.js";
-export const isHangingMove = (board, move, color) => {
-    const nextBoard = applyMove(board, move);
-    const opponentMoves = getAllMoves(nextBoard, oppositeColor(color));
-    return opponentMoves.some((candidate) => candidate.captures.length > 0);
-};
-const pickRandom = (items) => {
-    if (items.length === 0)
-        return null;
-    return items[Math.floor(Math.random() * items.length)] ?? null;
-};
-export const pickMove = (board, color, type) => {
-    if (type === "player")
-        return null;
-    const moves = getAllMoves(board, color);
-    if (moves.length === 0)
-        return null;
-    if (type === "random")
-        return pickRandom(moves);
-    const hanging = moves.filter((move) => isHangingMove(board, move, color));
-    const safe = moves.filter((move) => !isHangingMove(board, move, color));
-    if (type === "sacrifice")
-        return pickRandom(hanging.length > 0 ? hanging : moves);
-    if (type === "strong")
-        return pickRandom(safe.length > 0 ? safe : hanging.length > 0 ? hanging : moves);
-    return pickRandom(moves);
-};

package/dist/utils/board.d.ts

@@ -1,32 +0,0 @@
-export type CheckersColor = "white" | "black";
-export type CheckersPiece = {
-    id: string;
-    color: CheckersColor;
-    king: boolean;
-};
-export type CheckersPos = {
-    row: number;
-    column: number;
-};
-export type CheckersMove = {
-    from: CheckersPos;
-    to: CheckersPos;
-    captures: CheckersPos[];
-};
-export type CheckersBoard = (CheckersPiece | null)[][];
-export declare const BOARD_SIZE = 8;
-export declare const oppositeColor: (color: CheckersColor) => CheckersColor;
-export declare const isDarkSquare: (row: number, column: number) => boolean;
-export declare const inBounds: (row: number, column: number) => boolean;
-export declare const cloneBoard: (board: CheckersBoard) => CheckersBoard;
-export declare const createInitialBoard: () => CheckersBoard;
-export declare const samePos: (a: CheckersPos, b: CheckersPos) => boolean;
-export declare const getMovesFrom: (board: CheckersBoard, from: CheckersPos) => CheckersMove[];
-export declare const getAllMoves: (board: CheckersBoard, color: CheckersColor, onlyFrom?: CheckersPos) => CheckersMove[];
-export declare const applyMove: (board: CheckersBoard, move: CheckersMove) => CheckersBoard;
-/** Apply one hop of a multi-capture chain (first capture only). */
-export declare const applyCaptureStep: (board: CheckersBoard, from: CheckersPos, to: CheckersPos, capture: CheckersPos) => CheckersBoard;
-export declare const listBoardPieces: (board: CheckersBoard) => (CheckersPiece & CheckersPos)[];
-export declare const countPieces: (board: CheckersBoard, color: CheckersColor) => number;
-export declare const getWinner: (board: CheckersBoard, colorToMove: CheckersColor) => CheckersColor | null;
-export declare const findMove: (moves: CheckersMove[], from: CheckersPos, to: CheckersPos) => CheckersMove | undefined;