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

package/dist/index.d.ts

@@ -1 +1,4 @@
+import "@vnejs/contracts.common.grid";
+import "@vnejs/contracts.common.turn";
+import "@vnejs/contracts.game.checkers";
 import "@vnejs/contracts.views.screens.checkers";

package/dist/index.js

@@ -1,15 +1,28 @@
+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 { 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";
-regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
-    CheckersController,
-    CheckersControllerGrid,
-    CheckersControllerAccept,
-    Checkers,
-    CheckersView,
+import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.screens.checkers";
+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, { events: SUBSCRIBE_EVENTS, params: PARAMS }, [
+    CheckersViewBridge,
+    CheckersViewController,
+    CheckersViewControllerGrid,
+    CheckersViewControllerAccept,
+    CheckersViewPlayerInteract,
+    CheckersViewPlayerSelect,
+    CheckersViewClick,
+    CheckersViewBoard,
+    CheckersViewStatus,
+    CheckersViewView,
 ]);

package/dist/modules/board.d.ts

@@ -0,0 +1,10 @@
+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 { type CheckersViewState } from "../utils/checkers.js";
+export declare class CheckersViewBoard extends ModuleCore<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
+    name: string;
+    subscribe: () => void;
+    onGridChanged: (payload?: GridChangedPayload) => Promise<void>;
+    onGridUnset: ({ id }?: GridUnsetPayload) => Promise<void>;
+}

package/dist/modules/board.js

@@ -0,0 +1,32 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { buildGridItems, emptyBoard, fromGridChanged } from "../utils/checkers.js";
+export class CheckersViewBoard extends ModuleCore {
+    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 = {}) => {
+        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 });
+        await this.emit(this.EVENTS.CHECKERS_VIEW.UPDATE_FAST);
+    };
+    onGridUnset = async ({ id } = {}) => {
+        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,
+        });
+        await this.emit(this.EVENTS.CHECKERS_VIEW.UPDATE_FAST);
+    };
+}

package/dist/modules/bridge.d.ts

@@ -0,0 +1,8 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+export declare class CheckersViewBridge extends ModuleCore<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams> {
+    name: string;
+    subscribe: () => void;
+    onCheckersShow: () => Promise<unknown[]> | undefined;
+    onCheckersHide: () => Promise<unknown[]> | undefined;
+}

package/dist/modules/bridge.js

@@ -0,0 +1,10 @@
+import { ModuleCore } from "@vnejs/module.core";
+export class CheckersViewBridge extends ModuleCore {
+    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/dist/modules/click.d.ts

@@ -0,0 +1,8 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import type { CheckersClickPayload, CheckersViewState } from "../utils/checkers.js";
+export declare class CheckersViewClick extends ModuleCore<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
+    name: string;
+    subscribe: () => void;
+    onClick: ({ row, column }?: CheckersClickPayload) => Promise<void>;
+}

package/dist/modules/click.js

@@ -0,0 +1,14 @@
+import { ModuleCore } from "@vnejs/module.core";
+export class CheckersViewClick extends ModuleCore {
+    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 } = {}) => {
+        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 });
+    };
+}

package/dist/modules/controller.accept.d.ts

@@ -1,30 +1,12 @@
 import { ModuleControllerAccept } from "@vnejs/module.controller.accept";
-import type { CheckersAiType } from "@vnejs/contracts.views.screens.checkers";
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-import { type CheckersPos } from "../utils/board.js";
-import { type CheckersCellClickPayload, type CheckersPluginState } from "../utils/checkers.js";
-export declare class CheckersControllerAccept extends ModuleControllerAccept<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams, CheckersPluginState> {
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import type { CheckersViewState } from "../utils/checkers.js";
+export declare class CheckersViewControllerAccept extends ModuleControllerAccept<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
     name: string;
-    EVENT_SHOW: "vne:checkers:show";
-    EVENT_HIDE: "vne:checkers:hide";
-    EVENT_ACCEPT: "vne:checkers:accept";
-    EVENT_STATE_UPDATE: "vne:checkers:state_update";
+    EVENT_SHOW: "vne:checkers_view:show";
+    EVENT_HIDE: "vne:checkers_view:hide";
+    EVENT_ACCEPT: "vne:checkers_view:accept";
+    EVENT_STATE_UPDATE: "vne:checkers_view:state_update";
     CONTROLS_ZINDEX: number;
-    subscribe: () => void;
-    onShow: () => undefined;
-    onShowAndMaybeAi: () => Promise<void>;
-    onHide: () => Promise<unknown[]> | undefined;
-    controllerFor: (turn: NonNullable<CheckersPluginState["turn"]>) => CheckersAiType;
-    isHumanTurn: () => boolean;
-    onCellClick: ({ row, column }?: CheckersCellClickPayload) => Promise<void>;
     onAccept: () => Promise<void>;
-    onAiTurn: () => Promise<void>;
-    playMove: (from: CheckersPos, to: CheckersPos, { scheduleAi }?: {
-        scheduleAi?: boolean;
-    }) => Promise<boolean>;
-    emitBoardState: (patch: Partial<CheckersPluginState> & {
-        board?: CheckersPluginState["board"];
-        selected?: CheckersPluginState["selected"];
-        legalMoves?: CheckersPluginState["legalMoves"];
-    }) => Promise<void>;
 }

package/dist/modules/controller.accept.js

@@ -1,165 +1,18 @@
 import { ModuleControllerAccept } from "@vnejs/module.controller.accept";
-import { applyMove, findMove, getAllMoves, getWinner, oppositeColor, samePos } from "../utils/board.js";
-import { pickMove } from "../utils/ai.js";
-import { buildGridItems, statusForTurn } from "../utils/checkers.js";
-export class CheckersControllerAccept extends ModuleControllerAccept {
-    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,
-        });
-        // 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();
-        return this.emit(this.EVENTS.CONTROLS.POP, { key: this.name });
-    };
-    controllerFor = (turn) => (this.state.ai?.[turn] ?? this.shared.checkersAi?.[turn] ?? this.CONST.CHECKERS.AI_TYPES.PLAYER);
-    isHumanTurn = () => {
-        const turn = this.state.turn;
-        if (!turn)
-            return false;
-        return this.controllerFor(turn) === this.CONST.CHECKERS.AI_TYPES.PLAYER;
-    };
-    onCellClick = async ({ row, column } = {}) => {
-        if (this.shared.checkersAiBusy || !this.isHumanTurn())
-            return;
-        if (row == null || column == null)
-            return;
-        await this.emit(this.EVENTS.CHECKERS.STATE_UPDATE, {
-            gridRow: row,
-            gridColumn: column,
-        });
-        await this.emit(this.EVENTS.CHECKERS.UPDATE_FAST);
-        await this.onAccept();
-    };
+export class CheckersViewControllerAccept extends ModuleControllerAccept {
+    name = "checkers_view.controller.accept";
+    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;
+    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())
+        if (this.shared.checkersInteractDisableSources.isNotEmpty())
             return;
-        const { gridRow, gridColumn, board, turn, selected } = this.state;
-        if (gridRow == null || gridColumn == null || !board || !turn)
-            return;
-        const focus = { 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, to, { scheduleAi = true } = {}) => {
-        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;
-    };
-    emitBoardState = async (patch) => {
-        const board = patch.board ?? this.state.board;
-        if (!board)
+        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.STATE_UPDATE, {
-            ...patch,
-            gridItems,
-        });
-        await this.emit(this.EVENTS.CHECKERS.UPDATE_FAST);
+        await this.emit(this.EVENTS.CHECKERS_VIEW.GRID_CLEAR);
+        this.emit(this.EVENTS.CHECKERS_VIEW.PLAYER_INTERACT, { row: gridRow, column: gridColumn });
     };
 }

package/dist/modules/controller.d.ts

@@ -1,13 +1,11 @@
 import { ModuleController } from "@vnejs/module.components";
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-import { type CheckersPluginState } from "../utils/checkers.js";
-export declare 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 declare class CheckersViewController extends ModuleController<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
     name: string;
-    EVENT_UPDATE_VIEW: "vne:checkers:update";
+    EVENT_UPDATE_VIEW: "vne:checkers_view:update";
     CONTROLS: {};
     CONTROLS_INDEX: number;
     subscribe: () => void;
-    beforeShow: () => Promise<void>;
     afterHide: () => void;
-    onFinish: () => Promise<void>;
 }

package/dist/modules/controller.grid.d.ts

@@ -1,16 +1,16 @@
 import { ModuleControllerArrowsGrid } from "@vnejs/module.controller.arrows.grid";
-import type { CheckersPluginConstants, CheckersPluginEvents, CheckersPluginParams, CheckersPluginSettings } from "../types.js";
-import { type CheckersPluginState } from "../utils/checkers.js";
-export declare class CheckersControllerGrid extends ModuleControllerArrowsGrid<CheckersPluginEvents, CheckersPluginConstants, CheckersPluginSettings, CheckersPluginParams, CheckersPluginState> {
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import { type CheckersViewState } from "../utils/checkers.js";
+export declare class CheckersViewControllerGrid extends ModuleControllerArrowsGrid<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
     name: string;
-    EVENT_SHOW: "vne:checkers:show";
-    EVENT_HIDE: "vne:checkers:hide";
-    EVENT_STATE_UPDATE: "vne:checkers:state_update";
-    EVENT_UPDATE_FAST: "vne:checkers:update_fast";
-    EVENT_GRID_NEXT: "vne:checkers:grid_next";
-    EVENT_GRID_PREV: "vne:checkers:grid_prev";
-    EVENT_GRID_CLEAR: "vne:checkers:grid_clear";
-    EVENT_GRID_UPDATE_ITEMS: "vne:checkers:grid_update_items";
+    EVENT_SHOW: "vne:checkers_view:show";
+    EVENT_HIDE: "vne:checkers_view:hide";
+    EVENT_STATE_UPDATE: "vne:checkers_view:state_update";
+    EVENT_UPDATE_FAST: "vne:checkers_view:update_fast";
+    EVENT_GRID_NEXT: "vne:checkers_view:grid_next";
+    EVENT_GRID_PREV: "vne:checkers_view:grid_prev";
+    EVENT_GRID_CLEAR: "vne:checkers_view:grid_clear";
+    EVENT_GRID_UPDATE_ITEMS: "vne:checkers_view:grid_update_items";
     CONTROLS_ZINDEX: number;
     isDisableGridChangeHorizontal: boolean;
     isDisableGridChangeVertical: boolean;

package/dist/modules/controller.grid.js

@@ -1,29 +1,25 @@
 import { ModuleControllerArrowsGrid } from "@vnejs/module.controller.arrows.grid";
-import { buildGridItems } from "../utils/checkers.js";
-import { createInitialBoard } from "../utils/board.js";
-export class CheckersControllerGrid extends ModuleControllerArrowsGrid {
-    name = "checkers.controller.grid";
-    EVENT_SHOW = this.EVENTS.CHECKERS.SHOW;
-    EVENT_HIDE = this.EVENTS.CHECKERS.HIDE;
-    EVENT_STATE_UPDATE = this.EVENTS.CHECKERS.STATE_UPDATE;
-    EVENT_UPDATE_FAST = this.EVENTS.CHECKERS.UPDATE_FAST;
-    EVENT_GRID_NEXT = this.EVENTS.CHECKERS.GRID_NEXT;
-    EVENT_GRID_PREV = this.EVENTS.CHECKERS.GRID_PREV;
-    EVENT_GRID_CLEAR = this.EVENTS.CHECKERS.GRID_CLEAR;
-    EVENT_GRID_UPDATE_ITEMS = this.EVENTS.CHECKERS.GRID_UPDATE_ITEMS;
-    CONTROLS_ZINDEX = this.PARAMS.CHECKERS.ZINDEX;
+import { buildGridItems, emptyBoard } from "../utils/checkers.js";
+export class CheckersViewControllerGrid extends ModuleControllerArrowsGrid {
+    name = "checkers_view.controller.grid";
+    EVENT_SHOW = this.EVENTS.CHECKERS_VIEW.SHOW;
+    EVENT_HIDE = this.EVENTS.CHECKERS_VIEW.HIDE;
+    EVENT_STATE_UPDATE = this.EVENTS.CHECKERS_VIEW.STATE_UPDATE;
+    EVENT_UPDATE_FAST = this.EVENTS.CHECKERS_VIEW.UPDATE_FAST;
+    EVENT_GRID_NEXT = this.EVENTS.CHECKERS_VIEW.GRID_NEXT;
+    EVENT_GRID_PREV = this.EVENTS.CHECKERS_VIEW.GRID_PREV;
+    EVENT_GRID_CLEAR = this.EVENTS.CHECKERS_VIEW.GRID_CLEAR;
+    EVENT_GRID_UPDATE_ITEMS = this.EVENTS.CHECKERS_VIEW.GRID_UPDATE_ITEMS;
+    CONTROLS_ZINDEX = this.PARAMS.CHECKERS_VIEW.ZINDEX;
     isDisableGridChangeHorizontal = true;
     isDisableGridChangeVertical = true;
-    getMaxRows = () => this.PARAMS.CHECKERS.ROWS;
-    getMaxColumns = () => this.PARAMS.CHECKERS.COLUMNS;
-    getGridItems = async () => {
-        const board = this.state.board ?? createInitialBoard();
-        return buildGridItems({
-            board,
-            selected: this.state.selected ?? null,
-            legalMoves: this.state.legalMoves ?? [],
-            gridRow: this.state.gridRow ?? null,
-            gridColumn: this.state.gridColumn ?? null,
-        });
-    };
+    getMaxRows = () => this.PARAMS.CHECKERS_VIEW.ROWS;
+    getMaxColumns = () => this.PARAMS.CHECKERS_VIEW.COLUMNS;
+    getGridItems = async () => buildGridItems({
+        board: this.state.board ?? emptyBoard(),
+        selected: this.state.selected ?? null,
+        legalMoves: this.state.legalMoves ?? [],
+        gridRow: this.state.gridRow ?? null,
+        gridColumn: this.state.gridColumn ?? null,
+    });
 }

package/dist/modules/controller.js

@@ -1,34 +1,16 @@
 import { ModuleController } from "@vnejs/module.components";
-import { createInitialCheckersState } from "../utils/checkers.js";
-export class CheckersController extends ModuleController {
-    name = "checkers.controller";
-    EVENT_UPDATE_VIEW = this.EVENTS.CHECKERS.UPDATE;
+export class CheckersViewController extends ModuleController {
+    name = "checkers_view.controller";
+    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 });
-        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/dist/modules/player.interact.d.ts

@@ -0,0 +1,9 @@
+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 CheckersViewState } from "../utils/checkers.js";
+export declare class CheckersViewPlayerInteract extends ModuleCore<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
+    name: string;
+    subscribe: () => void;
+    onPlayerInteract: ({ row, column }?: CheckersPlayerInteractPayload) => Promise<undefined>;
+}

package/dist/modules/player.interact.js

@@ -0,0 +1,33 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { samePos } from "../utils/checkers.js";
+export class CheckersViewPlayerInteract extends ModuleCore {
+    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 } = {}) => {
+        const { board, turn, selected } = this.state;
+        if (row == null || column == null || !board || !turn)
+            return;
+        const focus = { 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 });
+        if (piece && piece.color === turn) {
+            const result = (await this.emitOne(this.EVENTS.CHECKERS.MOVES_GET, { board, turn }));
+            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 : [],
+            });
+        }
+        if (selected)
+            return void this.emit(this.EVENTS.CHECKERS_VIEW.PLAYER_SELECT, { selected: null, legalMoves: [] });
+    };
+}

package/dist/modules/player.select.d.ts

@@ -0,0 +1,9 @@
+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 { type CheckersViewState } from "../utils/checkers.js";
+export declare class CheckersViewPlayerSelect extends ModuleCore<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
+    name: string;
+    subscribe: () => void;
+    onPlayerSelect: ({ selected, legalMoves }?: CheckersPlayerSelectPayload) => Promise<void>;
+}

package/dist/modules/player.select.js

@@ -0,0 +1,29 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { buildGridItems } from "../utils/checkers.js";
+export class CheckersViewPlayerSelect extends ModuleCore {
+    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 = [] } = {}) => {
+        const board = this.state.board;
+        if (!board)
+            return;
+        const nextSelected = selected;
+        const nextLegalMoves = legalMoves;
+        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,
+        });
+        await this.emit(this.EVENTS.CHECKERS_VIEW.UPDATE_FAST);
+    };
+}

package/dist/modules/status.d.ts

@@ -0,0 +1,18 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { TurnsChangedPayload, TurnsUnsetPayload } from "@vnejs/contracts.common.turn";
+import type { CheckersFinishPayload } from "@vnejs/contracts.game.checkers";
+import type { CheckersViewPluginConstants, CheckersViewPluginEvents, CheckersViewPluginParams, CheckersViewPluginSettings } from "../types.js";
+import { type CheckersColor, type CheckersViewState } from "../utils/checkers.js";
+export declare class CheckersViewStatus extends ModuleCore<CheckersViewPluginEvents, CheckersViewPluginConstants, CheckersViewPluginSettings, CheckersViewPluginParams, CheckersViewState> {
+    name: string;
+    subscribe: () => void;
+    applyStatus: ({ turn, winner, clearSelection }: {
+        turn?: CheckersColor;
+        winner: CheckersColor | null;
+        clearSelection?: boolean;
+    }) => Promise<void>;
+    onTurnsChanged: ({ id, owner }?: TurnsChangedPayload) => false | Promise<void>;
+    onTurnsUnset: ({ id }?: TurnsUnsetPayload) => false | Promise<void>;
+    onFinish: ({ winner }?: CheckersFinishPayload) => Promise<void>;
+    onShow: () => Promise<void>;
+}

package/dist/modules/status.js

@@ -0,0 +1,24 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { statusForTurn } from "../utils/checkers.js";
+export class CheckersViewStatus extends ModuleCore {
+    name = "checkers_view.status";
+    subscribe = () => {
+        this.on(this.EVENTS.TURNS.CHANGED, this.onTurnsChanged);
+        this.on(this.EVENTS.TURNS.UNSET, this.onTurnsUnset);
+        this.on(this.EVENTS.CHECKERS.FINISH, this.onFinish);
+        this.on(this.EVENTS.CHECKERS.SHOW, this.onShow);
+        this.on(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, this.updateState);
+    };
+    applyStatus = async ({ turn, winner, clearSelection = false }) => {
+        const next = { turn, winner, statusText: statusForTurn(turn, winner) };
+        if (clearSelection)
+            Object.assign(next, { selected: null, legalMoves: [] });
+        await this.emit(this.EVENTS.CHECKERS_VIEW.STATE_UPDATE, next);
+        await this.emit(this.EVENTS.CHECKERS_VIEW.UPDATE_FAST);
+    };
+    onTurnsChanged = ({ id, owner } = {}) => id === this.CONST.CHECKERS.TURN_ID &&
+        this.applyStatus({ turn: owner, winner: this.state.winner ?? null, clearSelection: true });
+    onTurnsUnset = ({ id } = {}) => id === this.CONST.CHECKERS.TURN_ID && this.applyStatus({ turn: undefined, winner: this.state.winner ?? null, clearSelection: true });
+    onFinish = ({ winner } = {}) => this.applyStatus({ turn: this.state.turn, winner: (winner ?? null) });
+    onShow = () => this.applyStatus({ turn: this.state.turn, winner: null });
+}