@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/car-racing/CarRacingService.d.ts

@@ -1,44 +0,0 @@
-import type { SharedValue } from 'react-native-reanimated';
-export interface ObstacleSharedValues {
-    x: SharedValue<number>;
-    y: SharedValue<number>;
-}
-export declare function registerObstacleSharedValues(id: string, sv: ObstacleSharedValues): void;
-export declare function unregisterObstacleSharedValues(id: string): void;
-export declare function registerPlayerSharedValue(sv: SharedValue<number>): void;
-export declare function unregisterPlayerSharedValue(): void;
-export declare function registerRoadOffsetSharedValue(sv: SharedValue<number>): void;
-export declare function unregisterRoadOffsetSharedValue(): void;
-export declare class CarRacingService {
-    private obstacleSpawnTimer;
-    private animationFrameId;
-    private obstacleIdCounter;
-    private roadSpeed;
-    private obstacleSpawnInterval;
-    private collisionCooldown;
-    private onCollision?;
-    private onPass?;
-    private lastFrameTime;
-    private readonly TARGET_FRAME_TIME;
-    private obstaclePhysics;
-    private playerX;
-    private playerY;
-    private playerW;
-    private playerH;
-    private roadOffset;
-    constructor(roadSpeed?: number, obstacleSpawnInterval?: number);
-    setCallbacks(onCollision?: () => void, onPass?: () => void): void;
-    startGame(): void;
-    private gameLoop;
-    stopGame(): void;
-    private updateGameState;
-    private willCollide;
-    private handleCollision;
-    private startObstacleSpawning;
-    private spawnObstacle;
-    private fastRandom;
-    movePlayerToLane(lane: number): void;
-    setPlayerY(y: number): void;
-    cleanup(): void;
-    destroy(): void;
-}

package/lib/typescript/src/games/car-racing/CarRacingStore.d.ts

@@ -1,68 +0,0 @@
-export interface Obstacle {
-    id: string;
-    x: number;
-    y: number;
-    lane: number;
-    width: number;
-    height: number;
-    color: string;
-    passed: boolean;
-}
-export interface PlayerCar {
-    x: number;
-    y: number;
-    lane: number;
-    width: number;
-    height: number;
-}
-export interface ParticleEffect {
-    id: string;
-    x: number;
-    y: number;
-}
-export interface GameState {
-    score: number;
-    timeLeft: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    lives: number;
-}
-export interface CarRacingStore extends GameState {
-    obstacles: Obstacle[];
-    playerCar: PlayerCar;
-    roadOffset: number;
-    particleEffects: ParticleEffect[];
-    offset: number;
-    gameDuration: number;
-    startGame: (gameDuration?: number, offset?: number) => void;
-    setOffset: (offset: number) => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    updateScore: (points: number) => void;
-    decrementTime: () => void;
-    addObstacle: (obstacle: Obstacle) => void;
-    removeObstacle: (obstacleId: string) => void;
-    movePlayerCar: (lane: number) => void;
-    loseLife: () => void;
-    clearObstacles: () => void;
-    addParticleEffect: (x: number, y: number) => void;
-    removeParticleEffect: (effectId: string) => void;
-    batchScoreAndRemove: (obstaclesToPass: string[], obstaclesToRemove: string[]) => void;
-}
-export declare const useCarRacingStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<CarRacingStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: CarRacingStore, previousSelectedState: CarRacingStore) => void): () => void;
-        <U>(selector: (state: CarRacingStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useScore: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useLives: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useObstacles: () => Obstacle[];
-export declare const usePlayerCar: () => PlayerCar;
-export declare const useParticleEffects: () => ParticleEffect[];

package/lib/typescript/src/games/car-racing/components/CarComponent.d.ts

@@ -1,12 +0,0 @@
-import React from 'react';
-interface CarComponentProps {
-    id: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    color: string;
-    isPlayer?: boolean;
-}
-export declare const CarComponent: React.MemoExoticComponent<({ id, x, y, width, height, color, isPlayer }: CarComponentProps) => React.JSX.Element>;
-export {};

package/lib/typescript/src/games/car-racing/components/GameBackground.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-interface GameBackgroundProps {
-    width: number;
-    height: number;
-}
-export declare const GameBackground: React.MemoExoticComponent<({ width, height }: GameBackgroundProps) => React.JSX.Element>;
-export {};

package/lib/typescript/src/games/car-racing/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.MemoExoticComponent<({ offset }: ScoreBoardProps) => React.JSX.Element>;
-export {};

package/lib/typescript/src/games/chameleon-run/ChameleonRunService.d.ts

@@ -1,76 +0,0 @@
-import type { SharedValue } from 'react-native-reanimated';
-export interface ChameleonSharedValues {
-    y: SharedValue<number>;
-    scaleX: SharedValue<number>;
-    scaleY: SharedValue<number>;
-    rotation: SharedValue<number>;
-    opacity: SharedValue<number>;
-}
-export interface CameraSharedValues {
-    x: SharedValue<number>;
-}
-type Phase = 'idle' | 'running' | 'dead';
-export declare class ChameleonRunService {
-    private destroyed;
-    private animationRef;
-    private pendingTimeouts;
-    private lastFrameTime;
-    private platforms;
-    private platformSeq;
-    private phase;
-    private lastSyncTime;
-    private pendingSync;
-    private worldX;
-    private y;
-    private vy;
-    private onGround;
-    private jumpsUsed;
-    private currentPlatformId;
-    private distanceAccum;
-    private timeLeftMs;
-    private lastSyncedSeconds;
-    private cachedIsPlaying;
-    private cachedScore;
-    private chameleonSV;
-    private cameraSV;
-    private onJump?;
-    private onStar?;
-    private onLand?;
-    private onGameOver?;
-    private onTimeUp?;
-    private onStarBurst?;
-    setPlaying(value: boolean): void;
-    registerChameleonSharedValues(sv: ChameleonSharedValues): void;
-    registerCameraSharedValues(sv: CameraSharedValues): void;
-    registerStarBurstHandler(fn: (worldX: number, screenY: number) => void): void;
-    unregisterStarBurstHandler(): void;
-    setCallbacks(onJump?: () => void, onStar?: () => void, onLand?: () => void, onGameOver?: () => void, onTimeUp?: () => void): void;
-    private safeTimeout;
-    private makePlatform;
-    private jumpReach;
-    private nextTopY;
-    private randWidth;
-    private nextGap;
-    private appendPlatform;
-    private ensurePlatformsAhead;
-    private prunePlatforms;
-    private syncPlatforms;
-    private platformUnder;
-    private landingUnder;
-    initialize(): void;
-    startGame(): void;
-    jump(): void;
-    private startLoop;
-    stopLoop(): void;
-    private currentSpeed;
-    private update;
-    private handleEnterPlatform;
-    private handleLanded;
-    private checkStar;
-    private handleTimeUp;
-    private handleGameOver;
-    getPhase(): Phase;
-    resetGame(): void;
-    cleanup(): void;
-}
-export {};

package/lib/typescript/src/games/chameleon-run/ChameleonRunStore.d.ts

@@ -1,48 +0,0 @@
-export interface Platform {
-    id: string;
-    worldXStart: number;
-    worldXEnd: number;
-    topY: number;
-    starId: string | null;
-    starWorldX: number;
-    starCollected: boolean;
-}
-export interface ChameleonRunState {
-    score: number;
-    best: number;
-    stars: number;
-    timeLeft: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-    platforms: Platform[];
-    platformsVersion: number;
-}
-export interface ChameleonRunStore extends ChameleonRunState {
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    setScore: (score: number) => void;
-    collectStar: (starPoints: number, platforms: Platform[]) => void;
-    setTimeLeft: (seconds: number) => void;
-    setGameOver: () => void;
-    setGameWon: () => void;
-    setPlatforms: (platforms: Platform[]) => void;
-}
-export declare const useChameleonRunStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ChameleonRunStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: ChameleonRunStore, previousSelectedState: ChameleonRunStore) => void): () => void;
-        <U>(selector: (state: ChameleonRunStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useScore: () => number;
-export declare const useBest: () => number;
-export declare const useStars: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useGameWon: () => boolean;
-export declare const useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const usePlatformsVersion: () => number;

package/lib/typescript/src/games/chameleon-run/components/GameArea.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { ChameleonRunService } from '../ChameleonRunService';
-interface GameAreaProps {
-    gameService: ChameleonRunService;
-    offset?: number;
-}
-export declare const GameArea: React.NamedExoticComponent<GameAreaProps>;
-export {};

package/lib/typescript/src/games/chameleon-run/components/GameBackground.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-interface GameBackgroundProps {
-    children: React.ReactNode;
-    offset?: number;
-}
-export declare const GameBackground: React.NamedExoticComponent<GameBackgroundProps>;
-export {};

package/lib/typescript/src/games/chameleon-run/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.MemoExoticComponent<({ offset }: ScoreBoardProps) => React.JSX.Element>;
-export {};

package/lib/typescript/src/games/checkers/CheckersService.d.ts

@@ -1,6 +0,0 @@
-export declare class CheckersService {
-    private gameTimer;
-    startTimer(onTick: () => void): void;
-    stopTimer(): void;
-    cleanup(): void;
-}

package/lib/typescript/src/games/checkers/CheckersStore.d.ts

@@ -1,48 +0,0 @@
-import { type GameSettings } from '../../services/UtilsService';
-import { type CheckerPlayer, type CheckersBoard } from './CheckersConstants';
-export declare const createInitialBoard: () => CheckersBoard;
-export interface CheckersState {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isTimedOut: boolean;
-    board: CheckersBoard;
-    boardVersion: number;
-    selectionVersion: number;
-    currentPlayer: CheckerPlayer;
-    selectedIndex: number;
-    validTargets: number[];
-    captureTargets: number[];
-    mustContinueFrom: number;
-    winner: CheckerPlayer | null;
-    redCaptured: number;
-    blackCaptured: number;
-    score: number;
-    moves: number;
-    timeLeft: number;
-    initializeGame: () => void;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    handleSelect: (index: number, settings: GameSettings) => void;
-    runAIMove: (settings: GameSettings) => void;
-    updateTime: () => void;
-}
-export declare const useCheckersStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<CheckersState>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: CheckersState, previousSelectedState: CheckersState) => void): () => void;
-        <U>(selector: (state: CheckersState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useBoardVersion: () => number;
-export declare const useSelectionVersion: () => number;
-export declare const useCurrentPlayer: () => CheckerPlayer;
-export declare const useWinner: () => CheckerPlayer | null;
-export declare const useScore: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useRedCaptured: () => number;
-export declare const useBlackCaptured: () => number;

package/lib/typescript/src/games/checkers/components/GameBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface GameBoardProps {
-    onCellPress: (index: number) => void;
-}
-export declare const GameBoard: React.NamedExoticComponent<GameBoardProps>;
-export {};

package/lib/typescript/src/games/checkers/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/color-switch/ColorSwitchService.d.ts

@@ -1,63 +0,0 @@
-import type { SharedValue } from 'react-native-reanimated';
-import { type Obstacle, type ColorStar } from './ColorSwitchStore';
-export interface ColorSwitchSharedValues {
-    ballY: SharedValue<number>;
-    cameraY: SharedValue<number>;
-    ballColorIndex: SharedValue<number>;
-}
-export interface ObstacleRotationSV {
-    rotation: SharedValue<number>;
-}
-export declare function registerObstacleRotationSV(id: string, sv: ObstacleRotationSV): void;
-export declare function unregisterObstacleRotationSV(id: string): void;
-export declare class ColorSwitchService {
-    private destroyed;
-    private animationRef;
-    private isPlaying;
-    private isGameOver;
-    private ballY;
-    private ballVelocity;
-    private ballColorIndex;
-    private cameraY;
-    private obstacles;
-    private stars;
-    private obstacleRotations;
-    private ballInsideRing;
-    private collectedStars;
-    private currentRotationSpeed;
-    private obstaclesPassed;
-    private highestObstacleY;
-    private sharedValues;
-    private onListChange;
-    private onBallColorChange;
-    private onJump?;
-    private onPass?;
-    private onColorChange?;
-    private onGameOver?;
-    constructor();
-    registerSharedValues(sv: ColorSwitchSharedValues): void;
-    unregisterSharedValues(): void;
-    setOnListChange(cb: () => void): void;
-    setOnBallColorChange(cb: (colorIndex: number) => void): void;
-    setCallbacks(onJump?: () => void, onPass?: () => void, onColorChange?: () => void, onGameOver?: () => void): void;
-    setPlaying(playing: boolean): void;
-    setGameOver(over: boolean): void;
-    initializePreview(): void;
-    initializeGame(): void;
-    private spawnObstacle;
-    private spawnStar;
-    getObstacles(): Obstacle[];
-    getStars(): ColorStar[];
-    isStarCollected(id: string): boolean;
-    getObstacleRotation(id: string): number;
-    getBallColorIndex(): number;
-    getBallY(): number;
-    getCameraY(): number;
-    jump(): void;
-    private getColorAtAngle;
-    private isColorSafeAtAngle;
-    startPhysicsLoop(): void;
-    stopPhysicsLoop(): void;
-    resetGame(): void;
-    cleanup(): void;
-}

package/lib/typescript/src/games/color-switch/ColorSwitchStore.d.ts

@@ -1,43 +0,0 @@
-import { type GameIntervalHandle } from '../../helpers/GameTimer';
-export interface Obstacle {
-    id: string;
-    y: number;
-    rotationSpeed: number;
-    passed: boolean;
-}
-export interface ColorStar {
-    id: string;
-    y: number;
-    colorIndex: number;
-    collected: boolean;
-}
-export interface ColorSwitchState {
-    score: number;
-    time: number;
-    timerInterval: GameIntervalHandle | null;
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-}
-export interface ColorSwitchStore extends ColorSwitchState {
-    startGame: () => void;
-    resetGame: () => void;
-    updateScore: (points: number) => void;
-    decrementTime: () => void;
-    setGameOver: () => void;
-    setGameWon: () => void;
-}
-export declare const useColorSwitchStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ColorSwitchStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: ColorSwitchStore, previousSelectedState: ColorSwitchStore) => void): () => void;
-        <U>(selector: (state: ColorSwitchStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useScore: () => number;
-export declare const useTime: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useGameWon: () => boolean;

package/lib/typescript/src/games/color-switch/components/GameArea.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { ColorSwitchService } from '../ColorSwitchService';
-interface GameAreaProps {
-    gameService: ColorSwitchService;
-    offset?: number;
-}
-export declare const GameArea: React.NamedExoticComponent<GameAreaProps>;
-export {};

package/lib/typescript/src/games/color-switch/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.MemoExoticComponent<({ offset }: ScoreBoardProps) => React.JSX.Element>;
-export {};

package/lib/typescript/src/games/colors-sort/ColorsSortService.d.ts

@@ -1,61 +0,0 @@
-/**
- * ColorSort Game Service
- * Handles all utility functions, game logic, and background generation
- */
-export interface FloatingBlock {
-    key: string;
-    type: 'square' | 'rect' | 'wide' | 'circle';
-    x: number;
-    y: number;
-    size: number;
-    color: string;
-}
-export interface DecorativeBlock {
-    key: string;
-    x: number;
-    y: number;
-    size: number;
-    color: string;
-    r: number;
-}
-export interface DecorativeCircle {
-    key: string;
-    cx: number;
-    cy: number;
-    r: number;
-    color: string;
-}
-export declare const SORT_COLORS: readonly ["#FF6B35", "#FF4444", "#FF8C42", "#FFD700", "#32CD32", "#4169E1", "#FF1493", "#9370DB", "#00BCD4", "#FFA366", "#CDDC39", "#E91E63"];
-/**
- * Get grid layout style (fixed medium)
- */
-export declare const getGridLayout: () => {
-    maxWidth: number;
-};
-/**
- * Get piece height (fixed medium)
- */
-export declare const getPieceHeight: (baseSize: number) => number;
-/**
- * Generate floating color blocks for background
- */
-export declare const generateFloatingBlocks: () => FloatingBlock[];
-/**
- * Get decorative blocks positioned around the screen
- */
-export declare const getDecorativeBlocks: () => DecorativeBlock[];
-/**
- * Get decorative circles for variety
- */
-export declare const getDecorativeCircles: () => DecorativeCircle[];
-/**
- * Get gradient colors for background layers
- */
-export declare const getGradientColors: () => {
-    main: string[];
-    overlay: string[];
-    diagonal: string[];
-};
-export declare class ColorSortService {
-    cleanup(): void;
-}

package/lib/typescript/src/games/colors-sort/ColorsSortStore.d.ts

@@ -1,56 +0,0 @@
-import type { GameSettings } from '../../services/UtilsService';
-export interface Piece {
-    id: string;
-    color: string;
-}
-export interface Container {
-    id: string;
-    pieces: Piece[];
-    maxCapacity: number;
-    x: number;
-    y: number;
-}
-export interface ColorsSortState {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isTimedOut: boolean;
-    isPaused: boolean;
-    containers: Container[];
-    containersVersion: number;
-    selectedContainerId: string | null;
-    time: number;
-    timeLeft: number;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    pauseGame: () => void;
-    resumeGame: () => void;
-    initializeGame: () => void;
-    selectContainer: (containerId: string, settings: GameSettings) => void;
-    canMovePiece: (fromContainerId: string, toContainerId: string) => boolean;
-    movePiece: (fromContainerId: string, toContainerId: string, settings: GameSettings) => void;
-    checkWinCondition: () => boolean;
-    updateTime: () => void;
-}
-export declare const useColorsSortStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ColorsSortState>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: ColorsSortState, previousSelectedState: ColorsSortState) => void): () => void;
-        <U>(selector: (state: ColorsSortState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useIsTimedOut: () => boolean;
-export declare const useIsPaused: () => boolean;
-export declare const useTime: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useContainers: () => Container[];
-export declare const useSelectedContainerId: () => string | null;
-export declare const useContainerCount: () => number;
-export declare const useContainersVersion: () => number;
-export declare const useContainerPieces: (index: number) => Piece[];
-export declare const useContainerId: (index: number) => string;
-export declare const useIsContainerSelected: (containerId: string) => boolean;

package/lib/typescript/src/games/colors-sort/components/ColorContainer.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-interface ColorContainerProps {
-    containerIndex: number;
-    onPress: (containerId: string) => void;
-}
-export declare const ColorContainer: React.NamedExoticComponent<ColorContainerProps>;
-export {};

package/lib/typescript/src/games/colors-sort/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.NamedExoticComponent<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/connect-em-all/ConnectEmAllService.d.ts

@@ -1,20 +0,0 @@
-export interface Dot {
-    id: string;
-    row: number;
-    col: number;
-    colorIndex: number;
-    color: string;
-    fromRow: number;
-}
-export declare const formatScore: (score: number) => string;
-export declare const generateDots: (gridSize: number, initialFall?: boolean) => Dot[][];
-export declare const areAdjacent: (dot1: Dot, dot2: Dot) => boolean;
-export declare const canConnect: (dot1: Dot, dot2: Dot) => boolean;
-export declare const isValidConnection: (connectedDots: Dot[], newDot: Dot, connectedDotIds?: Set<string>) => boolean;
-export declare const calculateScore: (dotsConnected: number) => number;
-export declare const isSquare: (connectedDots: Dot[]) => boolean;
-export declare const refillDots: (dots: Dot[][], removedPositions: {
-    row: number;
-    col: number;
-}[]) => Dot[][];
-export declare const findAllDotsOfColor: (dots: Dot[][], colorIndex: number) => Dot[];