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

package/dist/modules/view.d.ts

@@ -1,10 +1,10 @@
 import { ModuleView } from "@vnejs/module.components";
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-import type { CheckersPluginState } from "../utils/checkers.js";
-export declare class CheckersView extends ModuleView<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams, CheckersPluginState> {
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import type { CheckersViewState } from "../utils/checkers.js";
+export declare class CheckersViewView extends ModuleView<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
     name: string;
-    EVENT_UPDATE_VIEW: "vne:checkers:update";
+    EVENT_UPDATE_VIEW: "vne:checkers_view:update";
     LOC_LABEL: null;
     TRANSITION: number;
-    renderFunc: import("@vnejs/module.components").ViewRenderFunc<CheckersPluginState>;
+    renderFunc: import("@vnejs/module.components").ViewRenderFunc<CheckersViewState>;
 }

package/dist/modules/view.js

@@ -1,9 +1,9 @@
 import { ModuleView } from "@vnejs/module.components";
 import { render } from "../view/index.js";
-export class CheckersView extends ModuleView {
-    name = "checkers.view";
-    EVENT_UPDATE_VIEW = this.EVENTS.CHECKERS.UPDATE;
+export class CheckersViewView extends ModuleView {
+    name = "checkers_view.view";
+    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/dist/types.d.ts

@@ -1,9 +1,13 @@
 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, PluginName as ScenarioPluginName, 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";
-export type CheckersPluginEvents = ModuleComponentsEvents & Record<PluginName, SubscribeEvents> & Record<ScenarioPluginName, ScenarioSubscribeEvents> & Record<LogsPluginName, LogsSubscribeEvents>;
-export type CheckersPluginConstants = ModuleComponentsConstants & Record<PluginName, Constants> & Record<ControlsPluginName, ControlsConstants> & Record<ScenarioPluginName, ScenarioConstants>;
-export type CheckersPluginSettings = ModuleComponentsSettings;
-export type CheckersPluginParams = ModuleComponentsParams & Record<PluginName, Params>;
+import type { PluginName as GridPluginName, SubscribeEvents as GridSubscribeEvents } from "@vnejs/contracts.common.grid";
+import type { PluginName as TurnsPluginName, SubscribeEvents as TurnsSubscribeEvents } from "@vnejs/contracts.common.turn";
+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 CheckersViewPluginEvents = ModuleComponentsEvents & Record<PluginName, SubscribeEvents> & Record<CheckersPluginName, CheckersSubscribeEvents> & Record<GridPluginName, GridSubscribeEvents> & Record<TurnsPluginName, TurnsSubscribeEvents> & Record<AiPluginName, AiSubscribeEvents> & Record<ScenarioPluginName, ScenarioSubscribeEvents> & Record<LogsPluginName, LogsSubscribeEvents>;
+export type CheckersViewPluginConstants = ModuleComponentsConstants & Record<CheckersPluginName, CheckersConstants> & Record<AiPluginName, AiConstants> & Record<ControlsPluginName, ControlsConstants> & Record<ScenarioPluginName, ScenarioConstants>;
+export type CheckersViewPluginSettings = ModuleComponentsSettings;
+export type CheckersViewPluginParams = ModuleComponentsParams & Record<PluginName, Params> & Record<CheckersPluginName, CheckersParams> & Record<AiPluginName, AiParams>;

package/dist/utils/checkers.d.ts

@@ -1,4 +1,15 @@
-import type { CheckersBoard, CheckersColor, CheckersMove, CheckersPiece, CheckersPos } from "./board.js";
+import type { GridChangedPayload } from "@vnejs/contracts.common.grid";
+import type { CheckersMovePayload, CheckersPosPayload } from "@vnejs/contracts.game.checkers";
+export declare 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;
     column: number;
@@ -8,7 +19,7 @@ export type CheckersGridItem = {
     isLegalTarget?: boolean;
     isFocus?: boolean;
 };
-export type CheckersPluginState = {
+export type CheckersViewState = {
     isShow: boolean;
     isForce: boolean;
     board?: CheckersBoard;
@@ -22,16 +33,13 @@ 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 declare const statusForTurn: (turn: CheckersColor, winner?: CheckersColor | null) => "Black to move" | "Black wins" | "White to move" | "White wins";
+export declare const isDarkSquare: (row: number, column: number) => boolean;
+export declare const samePos: (a: CheckersPos, b: CheckersPos) => boolean;
 export declare const buildGridItems: ({ board, selected, legalMoves, gridRow, gridColumn, }: {
     board: CheckersBoard;
     selected?: CheckersPos | null;
@@ -39,4 +47,7 @@ export declare const buildGridItems: ({ board, selected, legalMoves, gridRow, gr
     gridRow?: number | null;
     gridColumn?: number | null;
 }) => CheckersGridItem[];
-export declare const createInitialCheckersState: () => Pick<CheckersPluginState, "board" | "turn" | "selected" | "legalMoves" | "winner" | "statusText" | "gridItems" | "gridIndex" | "gridsCount">;
+export declare const listBoardPieces: (board: CheckersBoard) => (CheckersPiece & CheckersPosPayload)[];
+export declare const emptyBoard: () => CheckersBoard;
+export declare const statusForTurn: (turn?: CheckersColor, winner?: CheckersColor | null) => "" | "Black to move" | "Black wins" | "White to move" | "White wins";
+export declare const fromGridChanged: (payload?: GridChangedPayload) => Partial<CheckersViewState>;

package/dist/utils/checkers.js

@@ -1,9 +1,6 @@
-import { BOARD_SIZE, createInitialBoard, getAllMoves, isDarkSquare } from "./board.js";
-export const statusForTurn = (turn, winner = null) => {
-    if (winner)
-        return winner === "white" ? "White wins" : "Black wins";
-    return turn === "white" ? "White to move" : "Black to move";
-};
+export const BOARD_SIZE = 8;
+export const isDarkSquare = (row, column) => (row + column) % 2 === 1;
+export const samePos = (a, b) => a.row === b.row && a.column === b.column;
 export const buildGridItems = ({ board, selected = null, legalMoves = [], gridRow = null, gridColumn = null, }) => {
     const legalKeys = new Set(legalMoves.map((move) => `${move.to.row}:${move.to.column}`));
     const items = [];
@@ -22,19 +19,29 @@ export const buildGridItems = ({ board, selected = null, legalMoves = [], gridRo
     }
     return items;
 };
-export const createInitialCheckersState = () => {
-    const board = createInitialBoard();
-    const turn = "white";
-    const legalMoves = getAllMoves(board, turn);
-    return {
-        board,
-        turn,
-        selected: null,
-        legalMoves: [],
-        winner: null,
-        statusText: statusForTurn(turn),
-        gridItems: buildGridItems({ board, legalMoves: [] }),
-        gridIndex: 0,
-        gridsCount: 1,
-    };
+export const listBoardPieces = (board) => {
+    const pieces = [];
+    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 = () => Array.from({ length: BOARD_SIZE }, () => Array.from({ length: BOARD_SIZE }, () => null));
+export const statusForTurn = (turn, winner = null) => {
+    if (winner)
+        return winner === "white" ? "White wins" : "Black wins";
+    if (!turn)
+        return "";
+    return turn === "white" ? "White to move" : "Black to move";
 };
+export const fromGridChanged = (payload = {}) => ({
+    board: payload.cells,
+    // selection is view-only — reset on every game model change
+    selected: null,
+    legalMoves: [],
+});

package/dist/view/index.d.ts

@@ -1,3 +1,3 @@
 import type { ViewRenderFunc } from "@vnejs/module.components";
-import type { CheckersPluginState } from "../utils/checkers.js";
-export declare const render: ViewRenderFunc<CheckersPluginState>;
+import type { CheckersViewState } from "../utils/checkers.js";
+export declare const render: ViewRenderFunc<CheckersViewState>;

package/dist/view/index.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Flex, PositionBox, Screen, Text, createRenderFunc, useCallback, useEffect, useMemo, useState, useStoreState } from "@vnejs/uis.react";
 import { getVneLength } from "@vnejs/uis.utils";
-import { listBoardPieces } from "../utils/board.js";
+import { listBoardPieces } from "../utils/checkers.js";
 const SELECTED_OPACITY = 0.7;
 const GRAVEYARD_STACK = 0.55;
 const cellBackground = (item) => {
@@ -37,13 +37,13 @@ const kingMarkLook = () => ({
 });
 const CheckersScreen = ({ store, onMount, PARAMS, emit, EVENTS }) => {
     const { isShow = false, isForce = false, board, gridItems = [], gridRow = null, gridColumn = null, selected = null, statusText = "", } = useStoreState(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;
+    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;
     const boardPieces = useMemo(() => (board ? listBoardPieces(board) : []), [board]);
@@ -169,12 +169,12 @@ const CheckersScreen = ({ store, onMount, PARAMS, emit, EVENTS }) => {
         }
         return `translate(calc(${boardOffsetX} + ${piece.column} * ${stepLen}), calc(${piece.row} * ${stepLen}))`;
     }, [blackGraveyardX, boardOffsetX, cellLen, stepLen]);
-    const onCellClick = useCallback((row, column) => {
-        void emit(EVENTS.CHECKERS.CELL_CLICK, { row, column });
-    }, [emit, EVENTS.CHECKERS.CELL_CLICK]);
+    const onClick = useCallback((row, column) => {
+        void emit(EVENTS.CHECKERS_VIEW.CLICK, { row, column });
+    }, [emit, EVENTS.CHECKERS_VIEW.CLICK]);
     return (_jsx(Screen, { ...propsScreen, children: _jsx(PositionBox, { ...propsByView.position, children: _jsxs(Flex, { ...propsByView.flex, children: [_jsx(Text, { ...propsStatus }), _jsxs("div", { style: playfieldStyle, children: [_jsx("div", { style: graveyardStyle("left") }), _jsx("div", { style: graveyardStyle("right") }), _jsx("div", { style: boardStyle, children: gridItems.map((item) => {
                                     const isFocus = gridRow === item.row && gridColumn === item.column;
-                                    return (_jsx("div", { onClick: () => onCellClick(item.row, item.column), "vne-cursor-type": "pointer", style: {
+                                    return (_jsx("div", { onClick: () => onClick(item.row, item.column), "vne-cursor-type": "pointer", style: {
                                             ...cellBaseStyle,
                                             background: cellBackground({ ...item, isFocus }),
                                         } }, `${item.row}-${item.column}`));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vnejs/plugins.views.screens.checkers",
-  "version": "0.2.2",
-  "description": "",
+  "version": "0.2.4",
+  "description": "Checkers screen view (CHECKERS_VIEW)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -30,6 +30,10 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@vnejs/contracts.ai": "~0.2.0",
+    "@vnejs/contracts.common.grid": "~0.2.0",
+    "@vnejs/contracts.common.turn": "~0.2.0",
+    "@vnejs/contracts.game.checkers": "~0.2.0",
     "@vnejs/contracts.views.screens.checkers": "~0.2.0"
   },
   "peerDependencies": {
@@ -40,13 +44,18 @@
     "@vnejs/module.controller.arrows.grid": "~0.2.0",
     "@vnejs/contracts.controls": "~0.2.0",
     "@vnejs/shared": "~0.2.0",
+    "@vnejs/sources-set": "~0.2.0",
     "@vnejs/uis.react": "~0.2.0"
   },
   "devDependencies": {
     "@vnejs/configs.ts-common": "~0.2.0",
     "@vnejs/configs.vitest": "~0.2.0",
     "@vnejs/test-utils": "~0.2.0",
+    "@vnejs/contracts.ai": "~0.2.0",
+    "@vnejs/contracts.common.grid": "~0.2.0",
+    "@vnejs/contracts.common.turn": "~0.2.0",
     "@vnejs/contracts.controls": "~0.2.0",
+    "@vnejs/contracts.game.checkers": "~0.2.0",
     "@vnejs/contracts.views.screens.checkers": "~0.2.0",
     "@vnejs/helpers": "~0.2.0",
     "@vnejs/module.core": "~0.2.0",
@@ -54,6 +63,7 @@
     "@vnejs/module.controller.accept": "~0.2.0",
     "@vnejs/module.controller.arrows.grid": "~0.2.0",
     "@vnejs/shared": "~0.2.0",
+    "@vnejs/sources-set": "~0.2.0",
     "@vnejs/uis.react": "~0.2.0"
   }
 }

package/src/index.ts

@@ -1,18 +1,31 @@
+import "@vnejs/contracts.common.grid";
+import "@vnejs/contracts.common.turn";
+import "@vnejs/contracts.game.checkers";
 import "@vnejs/contracts.views.screens.checkers";
 
 import { regPlugin } from "@vnejs/shared";
-import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.screens.checkers";
+import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.screens.checkers";
 
-import { CheckersController } from "./modules/controller.js";
-import { CheckersControllerAccept } from "./modules/controller.accept.js";
-import { CheckersControllerGrid } from "./modules/controller.grid.js";
-import { Checkers } from "./modules/checkers.js";
-import { CheckersView } from "./modules/view.js";
+import { CheckersViewBoard } from "./modules/board.js";
+import { CheckersViewBridge } from "./modules/bridge.js";
+import { CheckersViewClick } from "./modules/click.js";
+import { CheckersViewController } from "./modules/controller.js";
+import { CheckersViewControllerAccept } from "./modules/controller.accept.js";
+import { CheckersViewControllerGrid } from "./modules/controller.grid.js";
+import { CheckersViewPlayerInteract } from "./modules/player.interact.js";
+import { CheckersViewPlayerSelect } from "./modules/player.select.js";
+import { CheckersViewStatus } from "./modules/status.js";
+import { CheckersViewView } from "./modules/view.js";
 
-regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
-  CheckersController,
-  CheckersControllerGrid,
-  CheckersControllerAccept,
-  Checkers,
-  CheckersView,
+regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS }, [
+  CheckersViewBridge,
+  CheckersViewController,
+  CheckersViewControllerGrid,
+  CheckersViewControllerAccept,
+  CheckersViewPlayerInteract,
+  CheckersViewPlayerSelect,
+  CheckersViewClick,
+  CheckersViewBoard,
+  CheckersViewStatus,
+  CheckersViewView,
 ]);

package/src/modules/board.ts

@@ -0,0 +1,47 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { GridChangedPayload, GridUnsetPayload } from "@vnejs/contracts.common.grid";
+
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import { buildGridItems, emptyBoard, fromGridChanged, type CheckersViewState } from "../utils/checkers.js";
+
+export class CheckersViewBoard extends ModuleCore<
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams,
+  CheckersViewState
+> {
+  name = "checkers_view.board";
+
+  subscribe = () => {
+    this.on(this.EVENTS.GRID.CHANGED, this.onGridChanged);
+    this.on(this.EVENTS.GRID.UNSET, this.onGridUnset);
+    this.on(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, this.updateState);
+  };
+
+  onGridChanged = async (payload: GridChangedPayload = {}) => {
+    if (payload.id !== this.CONST.CHECKERS.GRID_ID) return;
+
+    const mirror = fromGridChanged(payload);
+    const board = mirror.board ?? this.state.board ?? emptyBoard();
+    const gridItems = buildGridItems({ board, gridRow: this.state.gridRow ?? null, gridColumn: this.state.gridColumn ?? null });
+
+    await this.emit(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, { ...mirror, board, gridItems } satisfies Partial<CheckersViewState>);
+    await this.emit(this.EVENTS.CHECKERS_VIEW.UPDATE_FAST);
+  };
+
+  onGridUnset = async ({ id }: GridUnsetPayload = {}) => {
+    if (id !== this.CONST.CHECKERS.GRID_ID) return;
+
+    const board = emptyBoard();
+    const gridItems = buildGridItems({ board, gridRow: this.state.gridRow ?? null, gridColumn: this.state.gridColumn ?? null });
+
+    await this.emit(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, {
+      board,
+      selected: null,
+      legalMoves: [],
+      gridItems,
+    } satisfies Partial<CheckersViewState>);
+    await this.emit(this.EVENTS.CHECKERS_VIEW.UPDATE_FAST);
+  };
+}

package/src/modules/bridge.ts

@@ -0,0 +1,20 @@
+import { ModuleCore } from "@vnejs/module.core";
+
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+
+export class CheckersViewBridge extends ModuleCore<
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams
+> {
+  name = "checkers_view.bridge";
+
+  subscribe = () => {
+    this.on(this.EVENTS.CHECKERS.SHOW, this.onCheckersShow);
+    this.on(this.EVENTS.CHECKERS.HIDE, this.onCheckersHide);
+  };
+
+  onCheckersShow = () => this.emit(this.EVENTS.CHECKERS_VIEW.SHOW);
+  onCheckersHide = () => this.emit(this.EVENTS.CHECKERS_VIEW.HIDE);
+}

package/src/modules/click.ts

@@ -0,0 +1,28 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { CheckersPlayerInteractPayload } from "@vnejs/contracts.views.screens.checkers";
+
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import type { CheckersClickPayload, CheckersViewState } from "../utils/checkers.js";
+
+export class CheckersViewClick extends ModuleCore<
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams,
+  CheckersViewState
+> {
+  name = "checkers_view.click";
+
+  subscribe = () => {
+    this.on(this.EVENTS.CHECKERS_VIEW.CLICK, this.onClick);
+    this.on(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, this.updateState);
+  };
+
+  onClick = async ({ row, column }: CheckersClickPayload = {}) => {
+    if (this.shared.checkersInteractDisableSources.isNotEmpty() || row == null || column == null) return;
+
+    await this.emit(this.EVENTS.CHECKERS_VIEW.GRID_CLEAR);
+
+    this.emit(this.EVENTS.CHECKERS_VIEW.PLAYER_INTERACT, { row, column } satisfies CheckersPlayerInteractPayload);
+  };
+}

package/src/modules/controller.accept.ts

@@ -1,202 +1,33 @@
 import { ModuleControllerAccept } from "@vnejs/module.controller.accept";
-import type { ControlsPopPayload, ControlsPushPayload } from "@vnejs/contracts.controls";
+import type { CheckersPlayerInteractPayload } from "@vnejs/contracts.views.screens.checkers";
 
-import type { CheckersAiType } from "@vnejs/contracts.views.screens.checkers";
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import type { CheckersViewState } from "../utils/checkers.js";
 
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-import { applyMove, findMove, getAllMoves, getWinner, oppositeColor, samePos, type CheckersPos } from "../utils/board.js";
-import { pickMove } from "../utils/ai.js";
-import { buildGridItems, statusForTurn, type CheckersCellClickPayload, type CheckersPluginState } from "../utils/checkers.js";
-
-export class CheckersControllerAccept extends ModuleControllerAccept<
-  CheckersPluginEvents,
-  CheckersPluginConstants,
-  CheckersPluginSettings,
-  CheckersPluginParams,
-  CheckersPluginState
+export class CheckersViewControllerAccept extends ModuleControllerAccept<
+  CheckersViewPluginEvents,
+  CheckersViewPluginConstants,
+  CheckersViewPluginSettings,
+  CheckersViewPluginParams,
+  CheckersViewState
 > {
-  name = "checkers.controller.accept";
-
-  EVENT_SHOW = this.EVENTS.CHECKERS.SHOW;
-  EVENT_HIDE = this.EVENTS.CHECKERS.HIDE;
-  EVENT_ACCEPT = this.EVENTS.CHECKERS.ACCEPT;
-  EVENT_STATE_UPDATE = this.EVENTS.CHECKERS.STATE_UPDATE;
-
-  CONTROLS_ZINDEX = this.PARAMS.CHECKERS.ZINDEX;
-
-  subscribe = () => {
-    this.on(this.EVENT_SHOW, this.onShow);
-    this.on(this.EVENT_HIDE, this.onHide);
-    this.on(this.EVENT_ACCEPT, this.onAccept);
-    if (this.EVENT_STATE_UPDATE) this.on(this.EVENT_STATE_UPDATE, this.updateState);
-    this.on(this.EVENTS.CHECKERS.CELL_CLICK, this.onCellClick);
-    this.on(this.EVENTS.CHECKERS.AI_TURN, this.onAiTurn);
-  };
-
-  onShow = () => void this.onShowAndMaybeAi();
-
-  onShowAndMaybeAi = async () => {
-    await this.emit(this.EVENTS.CONTROLS.PUSH, {
-      key: this.name,
-      controls: this.CONTROLS,
-      index: this.CONTROLS_ZINDEX + 1,
-      checkNext: true,
-    } satisfies ControlsPushPayload);
-
-    // SHOW handlers run in parallel with controller.beforeShow — wait for board.
-    await this.waitCheck(() => Boolean(this.state.board && this.state.turn));
-    await this.onAiTurn();
-  };
-
-  onHide = () => {
-    this.shared.checkersAiBusy = false;
-    this.setDefaultState();
+  name = "checkers_view.controller.accept";
 
-    return this.emit(this.EVENTS.CONTROLS.POP, { key: this.name } satisfies ControlsPopPayload);
-  };
-
-  controllerFor = (turn: NonNullable<CheckersPluginState["turn"]>) =>
-    (this.state.ai?.[turn] ?? this.shared.checkersAi?.[turn] ?? this.CONST.CHECKERS.AI_TYPES.PLAYER) as CheckersAiType;
-
-  isHumanTurn = () => {
-    const turn = this.state.turn;
-    if (!turn) return false;
-    return this.controllerFor(turn) === this.CONST.CHECKERS.AI_TYPES.PLAYER;
-  };
-
-  onCellClick = async ({ row, column }: CheckersCellClickPayload = {}) => {
-    if (this.shared.checkersAiBusy || !this.isHumanTurn()) return;
-    if (row == null || column == null) return;
+  EVENT_SHOW = this.EVENTS.CHECKERS_VIEW.SHOW;
+  EVENT_HIDE = this.EVENTS.CHECKERS_VIEW.HIDE;
+  EVENT_ACCEPT = this.EVENTS.CHECKERS_VIEW.ACCEPT;
+  EVENT_STATE_UPDATE = this.EVENTS.CHECKERS_VIEW.STATE_UPDATE;
 
-    await this.emit(this.EVENTS.CHECKERS.STATE_UPDATE, {
-      gridRow: row,
-      gridColumn: column,
-    } satisfies Partial<CheckersPluginState>);
-    await this.emit(this.EVENTS.CHECKERS.UPDATE_FAST);
-    await this.onAccept();
-  };
+  CONTROLS_ZINDEX = this.PARAMS.CHECKERS_VIEW.ZINDEX;
 
   onAccept = async () => {
-    if (this.shared.checkersAiBusy) return;
-
-    if (this.state.winner) {
-      await this.emit(this.EVENTS.CHECKERS.FINISH);
-      return;
-    }
-
-    if (!this.isHumanTurn()) return;
-
-    const { gridRow, gridColumn, board, turn, selected } = this.state;
-    if (gridRow == null || gridColumn == null || !board || !turn) return;
-
-    const focus: CheckersPos = { row: gridRow, column: gridColumn };
-    const piece = board[focus.row]?.[focus.column] ?? null;
-
-    if (selected && findMove(this.state.legalMoves ?? [], selected, focus)) {
-      await this.playMove(selected, focus);
-      return;
-    }
-
-    if (piece && piece.color === turn) {
-      const all = getAllMoves(board, turn);
-      const legalMoves = all.filter((move) => samePos(move.from, focus));
-      if (legalMoves.length === 0) return;
-
-      const nextSelected = selected && samePos(selected, focus) ? null : focus;
-      const nextLegal = nextSelected ? legalMoves : [];
-
-      await this.emitBoardState({
-        selected: nextSelected,
-        legalMoves: nextLegal,
-      });
-      return;
-    }
-
-    if (selected) {
-      await this.emitBoardState({ selected: null, legalMoves: [] });
-    }
-  };
-
-  onAiTurn = async () => {
-    if (this.state.winner || !this.state.board || !this.state.turn) return;
-    if (this.isHumanTurn()) return;
-    if (this.shared.checkersAiBusy) return;
-
-    this.shared.checkersAiBusy = true;
-
-    try {
-      while (!this.state.winner && this.state.board && this.state.turn && !this.isHumanTurn()) {
-        await this.waitTimeout(this.PARAMS.CHECKERS.AI_DELAY);
-
-        const { board, turn } = this.state;
-        if (!board || !turn || this.state.winner) break;
-
-        const move = pickMove(board, turn, this.controllerFor(turn));
-        if (!move) break;
-
-        const played = await this.playMove(move.from, move.to, { scheduleAi: false });
-        if (!played) break;
-      }
-    } finally {
-      this.shared.checkersAiBusy = false;
-    }
-  };
-
-  playMove = async (from: CheckersPos, to: CheckersPos, { scheduleAi = true }: { scheduleAi?: boolean } = {}) => {
-    const { board, turn } = this.state;
-    if (!board || !turn) return false;
-
-    // Always resolve against current legal moves — `legalMoves: []` after a move is truthy and must not win over getAllMoves.
-    const move = findMove(getAllMoves(board, turn), from, to);
-    if (!move) return false;
-
-    const nextBoard = applyMove(board, move);
-    const nextTurn = oppositeColor(turn);
-    const winner = getWinner(nextBoard, nextTurn);
-
-    await this.emitBoardState({
-      board: nextBoard,
-      turn: nextTurn,
-      selected: null,
-      legalMoves: [],
-      winner,
-      statusText: statusForTurn(nextTurn, winner),
-    });
-
-    if (winner) {
-      await this.waitTimeout(this.PARAMS.CHECKERS.TRANSITION);
-      await this.emit(this.EVENTS.CHECKERS.FINISH);
-      return true;
-    }
-
-    if (scheduleAi) await this.onAiTurn();
-    return true;
-  };
+    if (this.shared.checkersInteractDisableSources.isNotEmpty()) return;
 
-  emitBoardState = async (
-    patch: Partial<CheckersPluginState> & {
-      board?: CheckersPluginState["board"];
-      selected?: CheckersPluginState["selected"];
-      legalMoves?: CheckersPluginState["legalMoves"];
-    },
-  ) => {
-    const board = patch.board ?? this.state.board;
-    if (!board) return;
+    const { gridRow, gridColumn } = this.state;
+    if (gridRow == null || gridColumn == null) return;
 
-    const selected = patch.selected !== undefined ? patch.selected : this.state.selected;
-    const legalMoves = patch.legalMoves !== undefined ? patch.legalMoves : this.state.legalMoves;
-    const gridItems = buildGridItems({
-      board,
-      selected: selected ?? null,
-      legalMoves: legalMoves ?? [],
-      gridRow: this.state.gridRow ?? null,
-      gridColumn: this.state.gridColumn ?? null,
-    });
+    await this.emit(this.EVENTS.CHECKERS_VIEW.GRID_CLEAR);
 
-    await this.emit(this.EVENTS.CHECKERS.STATE_UPDATE, {
-      ...patch,
-      gridItems,
-    } satisfies Partial<CheckersPluginState>);
-    await this.emit(this.EVENTS.CHECKERS.UPDATE_FAST);
+    this.emit(this.EVENTS.CHECKERS_VIEW.PLAYER_INTERACT, { row: gridRow, column: gridColumn } satisfies CheckersPlayerInteractPayload);
   };
 }