@enigma-lake/tower-play-controller-sdk 2.0.13 → 2.0.15

package/README.md

@@ -1,358 +1,130 @@
 # TowerPlayController SDK
 
-The **TowerPlayController** SDK provides a fully-configurable wager & play-control interface for Tower-style games.  
-It supports **manual play**, **optional autoplay**, **optional risk selection**, **currency management**, **play amount input**, and **custom widgets**.
+`@enigma-lake/tower-play-controller-sdk` is a React SDK for Tower-style game controls.
 
-Configuration is driven by the `PlayControllerProps` type, which supports two modes:
+It includes:
+- Manual play
+- Optional autoplay
+- Optional risk selection
+- Play amount controls
+- Currency-aware UI
+- Optional Double Or Nothing button
+- Custom widget slots
 
-- **Full Mode (default)** — risk & autoplay enabled (flag omitted or `false`)  
-- **Simplified Mode** — risk & autoplay disabled when `withoutRiskAndAutoplay: true`
+`PlayControllerProps` supports two modes:
+- Full mode (default): risk + autoplay enabled
+- Simplified mode: set `withoutRiskAndAutoplay: true`
 
-This keeps backwards compatibility with existing games (they don't need to pass the flag), and lets new games opt into a simpler controller by setting the flag.
-
----
-
-## 🚀 Installation
+## Installation
 
 ```bash
 npm install @enigma-lake/tower-play-controller-sdk
 ```
 
-Import styles:
-
 ```tsx
 import "@enigma-lake/tower-play-controller-sdk/dist/style.css";
 ```
 
----
-
-## 🧠 AutoManualPlayProvider
-
-Wrap your game UI inside:
+## Quickstart
 
 ```tsx
-<AutoManualPlayProvider config={config}>
-  {({ autoPlay, manual, mode }) => (
-    // your UI
-  )}
-</AutoManualPlayProvider>
-```
-
-The provider manages all logic:
-
-| Feature                | Full Mode (default)                      | Simplified Mode (`withoutRiskAndAutoplay: true`) |
-|------------------------|------------------------------------------|--------------------------------------------------|
-| Autoplay               | ✅ Enabled (requires onAutoPlay)         | ❌ Disabled                                      |
-| Risk Difficulty        | ✅ Enabled (risks/currentRisk/onRiskChange) | ❌ Hidden                                        |
-| Dropdown Risk Colors   | ✅ Required                              | ❌ Not used                                      |
-| Manual Play            | ✅ Enabled                               | ✅ Enabled                                       |
-| Play Amount            | ✅ Enabled                               | ✅ Enabled                                       |
-
----
-
-## 🔧 Prop Structure
-
-Below is an overview of the configuration props.
-
----
-
-### 1. `currencyOptions`
-
-```ts
-{
-  current: Currency;
-  available: Currency[];
-}
-```
-
----
-
-### 2. Styling (Conditional)
-
-#### Panel
-
-```ts
-panel: {
-  bottom?: string;
-  bgColorHex: string;
-  bgColorOpacity?: number;
-}
-```
-
-#### Dropdown
-
-**Full Mode (default)**  
-`withoutRiskAndAutoplay` omitted or `false`:
-
-```ts
-dropdown: {
-  bgColorHex: string;
-  riskColorConfig: {
-    LOW: string;
-    MEDIUM: string;
-    HIGH: string;
-  };
-}
-```
-
-**Simplified Mode**  
-`withoutRiskAndAutoplay: true`:
-
-```ts
-dropdown: {
-  bgColorHex: string;
-}
-```
-
----
-
-### 3. Actions
-
-**Shared (both modes)**:
-
-```ts
-onPlay: () => void;
-onCashout: () => void;
-```
-
-**Only required in Full Mode (`withoutRiskAndAutoplay` omitted or `false`)**:
-
-```ts
-onAutoPlay: (selection: number[], next: () => void, stop: () => void) => void;
-onAutoPlayStop?: () => void;
-```
-
-In Simplified Mode, `onAutoPlay` and `onAutoPlayStop` are not required and are effectively ignored.
-
----
-
-### 4. Play Options (Conditional)
-
-#### Full Mode (default)
-
-```ts
-playOptions: {
-  isPlaying: boolean;
-  canCashout: boolean;
-  disabledController: boolean;
-  displayController: boolean;
-
-  // RISK SYSTEM
-  risks: RiskTypes[];
-  currentRisk: RiskTypes;
-  onRiskChange(risk: RiskTypes): void;
-
-  // AUTOPLAY SYSTEM
-  autoPlayDelay?: number;
-  showAutoPlayToast({ type, message }): void;
-
-  disabledMenu: boolean;
-
-  playHook(): {
-    playLimits?: PlayLimits;
-    playAmount: number;
-    setPlayAmount(value: number): void;
-  };
-
-  totalBalance: number;
-}
-```
-
-#### Simplified Mode  
-`withoutRiskAndAutoplay: true`:
-
-```ts
-playOptions: {
-  isPlaying: boolean;
-  canCashout: boolean;
-  disabledController: boolean;
-  displayController: boolean;
-
-  disabledMenu: boolean;
-
-  playHook(): {
-    playLimits?: PlayLimits;
-    playAmount: number;
-    setPlayAmount(value: number): void;
-  };
-
-  totalBalance: number;
-}
-```
-
-Risk/autoplay properties (`risks`, `currentRisk`, `onRiskChange`, `autoPlayDelay`, `showAutoPlayToast`) are not part of the simplified mode.
-
----
-
-### 5. Widgets
+import { AutoManualPlayProvider, type PlayControllerProps } from "@enigma-lake/tower-play-controller-sdk";
 
-```ts
-leftWidgets: Widget[];
-centerWidgets: Widget[];
-rightWidgets: Widget[];
-```
-
----
-
-## 🎮 Example Usage
-
-### Example 1 — Full Mode (default: risk + autoplay enabled)
-
-```tsx
-import {
-  AutoManualPlayProvider,
-} from "@enigma-lake/tower-play-controller-sdk";
-import { Currency } from "@enigma-lake/zoot-platform-sdk";
-
-const config = {
-  // withoutRiskAndAutoplay omitted or false => FULL mode
-  currencyOptions: {
-    current: Currency.SWEEPS,
-    available: [Currency.SWEEPS, Currency.GOLD],
+const config: PlayControllerProps = {
+  currencyOptions,
+  panel: { bgColorHex: "#01243A", bgColorOpacity: 0.5 },
+  dropdown: {
+    bgColorHex: "#01243A",
+    riskColorConfig: {
+      LOW: "#4CAF50",
+      MEDIUM: "#FF9800",
+      HIGH: "#F44336",
+    },
   },
-
-  onPlay: () => console.log("Play"),
+  leftWidgets: [],
+  centerWidgets: [],
+  rightWidgets: [],
+  onPlay: () => {},
+  onCashout: () => {},
   onAutoPlay: (selection, next, stop) => {
-    console.log("Autoplay selection:", selection);
-    next(); // continue to next round
+    // call next() when round succeeds, stop() to abort autoplay
+    next();
   },
-  onAutoPlayStop: () => console.log("Autoplay stopped"),
-  onCashout: () => console.log("Cashout"),
-
   playOptions: {
-    displayController: true,
     isPlaying: false,
     canCashout: false,
+    disabledCashout: false,
     disabledController: false,
-    disableInput: false,
-
-    // Risk controls
-    risks: [RiskTypes.LOW, RiskTypes.MEDIUM, RiskTypes.HIGH],
-    currentRisk: RiskTypes.LOW,
-    onRiskChange: (risk) => console.log("Risk:", risk),
-
-    // Autoplay
-    autoPlayDelay: 1000,
-    showAutoPlayToast: ({ type, message }) =>
-      console.log(`${type}: ${message}`),
-
     disabledMenu: false,
-
+    displayController: true,
+    disableInput: false,
+    risks: ["LOW", "MEDIUM", "HIGH"],
+    currentRisk: "LOW",
+    onRiskChange: () => {},
+    showAutoPlayToast: () => {},
+    totalBalance: 1000,
     playHook: () => ({
-      playLimits: { min: 1, max: 100 },
-      playAmount: 10,
-      setPlayAmount: (v) => console.log("Amount:", v),
+      playAmount: 1,
+      setPlayAmount: () => {},
+      playLimits: undefined,
     }),
-
-    totalBalance: 100,
-  },
-
-  panel: {
-    bottom: "60px",
-    bgColorHex: "#08643F",
-    bgColorOpacity: 0.8,
-  },
-
-  dropdown: {
-    bgColorHex: "#123456",
-    riskColorConfig: {
-      LOW: "#1AE380",
-      MEDIUM: "#FAEB78",
-      HIGH: "#FF5646",
-    },
+    autoPlayDelay: 1500,
   },
-
-  leftWidgets: [],
-  centerWidgets: [],
-  rightWidgets: [],
 };
 
-export const GameExampleFull = () => (
-  <AutoManualPlayProvider config={config}>
-    {({ mode }) => (
-      <div>Mode: {mode}</div>
-    )}
-  </AutoManualPlayProvider>
-);
+<AutoManualPlayProvider config={config}>
+  {() => null}
+</AutoManualPlayProvider>;
 ```
 
----
+## Cashout Behavior
 
-### Example 2 — Simplified Mode (`withoutRiskAndAutoplay: true`)
+`canCashout` and `disabledCashout` are independent:
 
-```tsx
-import {
-  AutoManualPlayProvider,
-} from "@enigma-lake/tower-play-controller-sdk";
-import { Currency } from "@enigma-lake/zoot-platform-sdk";
+- `canCashout: false`: cashout button state is not shown.
+- `canCashout: true` + `disabledCashout: false`: cashout is visible and clickable.
+- `canCashout: true` + `disabledCashout: true`: cashout is visible but disabled.
 
-const config = {
-  withoutRiskAndAutoplay: true, // simplified mode
+When `disabledCashout` is `true`, click handlers are blocked in:
+- Manual cashout button
+- Autoplay stop/cashout button
 
-  currencyOptions: {
-    current: Currency.SWEEPS,
-    available: [Currency.SWEEPS],
-  },
+## Full Mode vs Simplified Mode
 
-  onPlay: () => console.log("Play"),
-  onCashout: () => console.log("Cashout"),
+Full mode (default):
+- Requires `onAutoPlay`
+- Includes risk configuration in `playOptions`
+- `dropdown.riskColorConfig` is required
 
-  playOptions: {
-    displayController: true,
-    isPlaying: false,
-    canCashout: false,
-    disabledController: false,
-    disableInput: false,
-    disabledMenu: false,
+Simplified mode:
 
-    playHook: () => ({
-      playLimits: { min: 1, max: 20 },
-      playAmount: 5,
-      setPlayAmount: (value) => console.log("New amount:", value),
-    }),
-
-    totalBalance: 50,
-  },
+```ts
+withoutRiskAndAutoplay: true;
+```
 
-  panel: {
-    bgColorHex: "#0A3F2F",
-  },
+In simplified mode:
+- `onAutoPlay` and `onAutoPlayStop` are not required
+- Risk configuration is removed from `playOptions`
+- `dropdown.riskColorConfig` is not required
 
-  dropdown: {
-    bgColorHex: "#10243F", // no riskColorConfig here
-  },
+## Double Or Nothing (Optional)
 
-  leftWidgets: [],
-  centerWidgets: [],
-  rightWidgets: [],
+```ts
+doubleOrNothing?: {
+  disabled: boolean;
+  display: boolean;
+  onDoubleOrNothingOpen: () => void;
+  onDoubleOrNothingClose: () => void;
 };
-
-export const GameExampleSimplified = () => (
-  <AutoManualPlayProvider config={config}>
-    {({ mode }) => (
-      <div>Mode: {mode}</div>
-    )}
-  </AutoManualPlayProvider>
-);
 ```
 
----
-
-## ⭐ Features
-
-- **Optional Risk System** – enabled by default; disabled when `withoutRiskAndAutoplay: true`
-- **Optional Autoplay** – fully controlled via callbacks and delay (full mode only)
-- **Dynamic Currency Management** – multiple currencies supported
-- **Wager Controls** – validated against play limits
-- **UI Widgets** – customizable left/center/right areas
-- **Flexible Styling** – configurable colors, bottom positioning, and opacity
-- **Responsive Layout** – suitable for desktop and mobile
-
----
+Behavior:
+- Shown only when `display` is `true`
+- Sits beside Cashout (cashout width shrinks accordingly)
+- Fully optional and backwards compatible
 
-## 🛠 Development Notes
+## Notes
 
-- `onAutoPlay` / `onAutoPlayStop` are **only required** in full mode.
-- `dropdown.riskColorConfig` is **only allowed/required** in full mode.
-- Risk-related and autoplay-related fields in `playOptions` are removed in simplified mode.
-- Use `withoutRiskAndAutoplay: true` to explicitly opt into the simplified experience.
+- Import `PlayControllerProps` for strongly typed integration.
+- Keep `playOptions` values in sync with your game engine state.
+- `displayController: false` hides the SDK UI entirely.

package/dist/components/AutoManualPlayStateProvider/AutoManualPlayStateContext.d.ts

@@ -1,4 +1,4 @@
-import { GAME_MODE, AUTO_PLAY_STATE } from "../../types/gameMode";
+import { GAME_MODE, AUTO_PLAY_STATE, DOUBLE_OR_NOTHING_STATE } from "../../types/gameMode";
 import { PlayControllerProps } from "../../types/playController";
 export interface AutoManualPlayStateContextType {
     mode: GAME_MODE;
@@ -21,6 +21,14 @@ export interface AutoManualPlayStateContextType {
         setSelection: (values: number[]) => void;
         updateState: (newState: AUTO_PLAY_STATE.SELECTING | AUTO_PLAY_STATE.PLAYING) => void;
     };
+    /**
+     * ✅ Double Or Nothing state & controls
+     */
+    doubleOrNothing: {
+        state: DOUBLE_OR_NOTHING_STATE;
+        startDoubleOrNothing: () => void;
+        stopDoubleOrNothing: () => void;
+    };
     reset: () => void;
     toggleMode: () => void;
     playValues: {

package/dist/components/base/Button/buttonStyle.d.ts

@@ -0,0 +1,5 @@
+import { Currency } from "@enigma-lake/zoot-platform-sdk";
+type ButtonStyleClasses = Record<string, string>;
+export declare const getDefaultButtonClassName: (currencyCode: Currency, styles: ButtonStyleClasses) => string;
+export declare const getActiveButtonClassName: (currencyCode: Currency, styles: ButtonStyleClasses) => string;
+export {};

package/dist/components/base/Cashout/cashoutBehavior.d.ts

@@ -0,0 +1,27 @@
+import { AUTO_PLAY_STATE } from "../../../types";
+export declare const isManualCashoutDisabled: ({ disabledController, isPlaying, cashoutDisabled, }: {
+    disabledController: boolean;
+    isPlaying: boolean;
+    cashoutDisabled: boolean;
+}) => boolean;
+export declare const createManualCashoutClickHandler: ({ cashoutDisabled, onCashout, }: {
+    cashoutDisabled: boolean;
+    onCashout: () => void;
+}) => () => void;
+export declare const canAutoplaySpaceTrigger: ({ state, cashoutDisabled, isDisabled, }: {
+    state: AUTO_PLAY_STATE;
+    cashoutDisabled: boolean;
+    isDisabled: boolean;
+}) => boolean;
+export declare const isAutoplayButtonDisabled: ({ state, cashoutDisabled, isDisabled, isValidPlayAmount, }: {
+    state: AUTO_PLAY_STATE;
+    cashoutDisabled: boolean;
+    isDisabled: boolean;
+    isValidPlayAmount: boolean;
+}) => boolean;
+export declare const createAutoplayButtonAction: ({ state, cashoutDisabled, onStopPlay, onPlay, }: {
+    state: AUTO_PLAY_STATE;
+    cashoutDisabled: boolean;
+    onStopPlay: () => void;
+    onPlay: () => void;
+}) => () => void;

package/dist/components/hooks/playAmount.d.ts

@@ -0,0 +1,5 @@
+export declare const getNextPlayAmount: ({ currentAmount, defaultBetOptions, direction, }: {
+    currentAmount: number;
+    defaultBetOptions: number[];
+    direction: -1 | 1;
+}) => number;

package/dist/components/hooks/usePlayController.d.ts

@@ -15,12 +15,14 @@ export declare const usePlayController: () => {
         isDisabled: () => boolean;
         onPlay: () => void;
         canCashout: boolean;
+        cashoutDisabled: boolean;
     };
     autoPlay: {
         isDisabled: () => boolean;
         state: AUTO_PLAY_STATE;
         onPlay: () => void;
         onStopPlay: () => void;
+        cashoutDisabled: boolean;
     };
     playValues: {
         displayPlayAmountView: boolean;

package/dist/components/hooks/useSpacebarButtonTrigger.d.ts

@@ -0,0 +1,8 @@
+import { GAME_MODE } from "../../types";
+type UseSpacebarButtonTriggerParams = {
+    roleButton: GAME_MODE;
+    activeClassName: string;
+    canTrigger: () => boolean;
+};
+export declare const useSpacebarButtonTrigger: ({ roleButton, activeClassName, canTrigger, }: UseSpacebarButtonTriggerParams) => void;
+export {};

package/dist/components/index.d.ts

@@ -1,6 +1,6 @@
 import AutoManualPlayProvider from "./AutoManualPlayStateProvider";
-import { GAME_MODE, AUTO_PLAY_STATE } from "../types/gameMode";
+import { GAME_MODE, AUTO_PLAY_STATE, DOUBLE_OR_NOTHING_STATE } from "../types/gameMode";
 import { format } from "./utils";
 import { PlayControllerProps, PlayControllerWithoutRisk, PlayControllerWithRisk } from "../types";
-export { AutoManualPlayProvider, GAME_MODE, AUTO_PLAY_STATE, format };
+export { AutoManualPlayProvider, GAME_MODE, AUTO_PLAY_STATE, DOUBLE_OR_NOTHING_STATE, format, };
 export type { PlayControllerProps, PlayControllerWithoutRisk, PlayControllerWithRisk, };

package/dist/index.d.ts

@@ -10,6 +10,10 @@ declare enum AUTO_PLAY_STATE {
     SELECTING = "selecting",
     PLAYING = "playing"
 }
+declare enum DOUBLE_OR_NOTHING_STATE {
+    IDLE = "idle",
+    PROGRESS = "progress"
+}
 
 declare enum WIDGET {
     CENTER = "center",
@@ -80,6 +84,7 @@ type ActionsWithoutAutoplay = ActionsBase;
 type PlaySettingsProps = {
     isPlaying: boolean;
     canCashout: boolean;
+    disabledCashout?: boolean;
     disabledController: boolean;
     risks: RiskTypes[];
     currentRisk: RiskTypes;
@@ -118,6 +123,15 @@ type PlaySettingsWithRisk = PlaySettingsProps;
  * Risk/autoplay-specific fields are removed.
  */
 type PlaySettingsWithoutRisk = BasePlaySettings;
+/**
+ * Double Or Nothing feature props.
+ */
+type DoubleOrNothingProps = {
+    disabled: boolean;
+    display: boolean;
+    onDoubleOrNothingOpen: () => void;
+    onDoubleOrNothingClose: () => void;
+};
 /**
  * Common controller props that don't depend on the flag.
  */
@@ -126,6 +140,11 @@ type BaseControllerCommon = {
     leftWidgets: Widget[];
     rightWidgets: Widget[];
     centerWidgets: Widget[];
+    /**
+     * Optional so existing integrations don't break.
+     * If you want it required, remove the `?`.
+     */
+    doubleOrNothing?: DoubleOrNothingProps;
 };
 /**
  * Variant when risk & autoplay are enabled (FULL mode).
@@ -165,6 +184,33 @@ type PlayControllerProps = PlayControllerWithRisk | PlayControllerWithoutRisk;
 
 declare const format: (value: number | string, decimals: number) => string | number;
 
+declare const isManualCashoutDisabled: ({ disabledController, isPlaying, cashoutDisabled, }: {
+    disabledController: boolean;
+    isPlaying: boolean;
+    cashoutDisabled: boolean;
+}) => boolean;
+declare const createManualCashoutClickHandler: ({ cashoutDisabled, onCashout, }: {
+    cashoutDisabled: boolean;
+    onCashout: () => void;
+}) => () => void;
+declare const canAutoplaySpaceTrigger: ({ state, cashoutDisabled, isDisabled, }: {
+    state: AUTO_PLAY_STATE;
+    cashoutDisabled: boolean;
+    isDisabled: boolean;
+}) => boolean;
+declare const isAutoplayButtonDisabled: ({ state, cashoutDisabled, isDisabled, isValidPlayAmount, }: {
+    state: AUTO_PLAY_STATE;
+    cashoutDisabled: boolean;
+    isDisabled: boolean;
+    isValidPlayAmount: boolean;
+}) => boolean;
+declare const createAutoplayButtonAction: ({ state, cashoutDisabled, onStopPlay, onPlay, }: {
+    state: AUTO_PLAY_STATE;
+    cashoutDisabled: boolean;
+    onStopPlay: () => void;
+    onPlay: () => void;
+}) => () => void;
+
 interface AutoManualPlayStateContextType {
     mode: GAME_MODE;
     config: PlayControllerProps;
@@ -186,6 +232,14 @@ interface AutoManualPlayStateContextType {
         setSelection: (values: number[]) => void;
         updateState: (newState: AUTO_PLAY_STATE.SELECTING | AUTO_PLAY_STATE.PLAYING) => void;
     };
+    /**
+     * ✅ Double Or Nothing state & controls
+     */
+    doubleOrNothing: {
+        state: DOUBLE_OR_NOTHING_STATE;
+        startDoubleOrNothing: () => void;
+        stopDoubleOrNothing: () => void;
+    };
     reset: () => void;
     toggleMode: () => void;
     playValues: {
@@ -202,4 +256,4 @@ interface AutoManualPlayStateProviderProps {
 }
 declare const AutoManualPlayProvider: React.FC<AutoManualPlayStateProviderProps>;
 
-export { AUTO_PLAY_STATE, AutoManualPlayProvider, GAME_MODE, type PlayControllerProps, type PlayControllerWithRisk, type PlayControllerWithoutRisk, WIDGET, type Widget, format };
+export { AUTO_PLAY_STATE, AutoManualPlayProvider, DOUBLE_OR_NOTHING_STATE, GAME_MODE, type PlayControllerProps, type PlayControllerWithRisk, type PlayControllerWithoutRisk, WIDGET, type Widget, canAutoplaySpaceTrigger, createAutoplayButtonAction, createManualCashoutClickHandler, format, isAutoplayButtonDisabled, isManualCashoutDisabled };