feat(game): add disableUndo flag to game config (#742)

Co-authored-by: Chris Swithinbank <[email protected]>

Author: shashikanthgadgay

docs/documentation/api/Game.md

@@ -102,5 +102,8 @@
   // Called at the end of the game.
   // `ctx.gameover` is available at this point.
   onEnd: (G, ctx) => G,
+  
+  // Disable undo feature for all the moves in the game
+  disableUndo: true,
 }
 ```

docs/documentation/undo.md

@@ -5,7 +5,8 @@ moves in the current turn. This is a common pattern in
 games that allow a player to make multiple moves per turn,
 and can be a useful feature to allow the player to experiment
 with different move combinations (and seeing what they do)
-before committing to one.
+before committing to one. You can disable this feature by 
+setting `disableUndo` to true in the game config. 
 
 ### Usage
 

src/core/flow.test.js

@@ -201,16 +201,32 @@ describe('phases', () => {
 });
 
 describe('turn', () => {
-  test('onBegin', () => {
+  test('onBegin with undoable feature', () => {
     const onBegin = jest.fn(G => G);
     const flow = Flow({
       turn: { onBegin },
+      disableUndo: false,
     });
     const state = { ctx: flow.ctx(2) };
 
     expect(onBegin).not.toHaveBeenCalled();
-    flow.init(state);
+    const updatedState = flow.init(state);
+    expect(onBegin).toHaveBeenCalled();
+    expect(updatedState._undo).toHaveLength(1);
+  });
+
+  test('onBegin without undoable feature', () => {
+    const onBegin = jest.fn(G => G);
+    const flow = Flow({
+      turn: { onBegin },
+      disableUndo: true,
+    });
+    const state = { ctx: flow.ctx(2) };
+
+    expect(onBegin).not.toHaveBeenCalled();
+    const updatedState = flow.init(state);
     expect(onBegin).toHaveBeenCalled();
+    expect(updatedState._undo).toHaveLength(0);
   });
 
   test('onEnd', () => {

src/core/flow.ts

@@ -43,6 +43,7 @@ export function Flow({
   turn,
   events,
   plugins,
+  disableUndo,
 }: Game) {
   // Attach defaults.
   if (moves === undefined) {
@@ -296,7 +297,7 @@ export function Flow({
 
     G = conf.turn.wrapped.onBegin({ ...state, G, ctx });
 
-    const _undo = [{ G, ctx }];
+    const _undo = disableUndo ? [] : [{ G, ctx }];
 
     return { ...state, G, ctx, _undo, _redo: [] };
   }

src/core/game.test.js

@@ -265,3 +265,21 @@ describe('config errors', () => {
     );
   });
 });
+
+describe('disableUndo', () => {
+  test('set disableUndo to false by default', () => {
+    const game = ProcessGameConfig({
+      moves: {},
+    });
+    expect(game.disableUndo).toBeFalsy();
+  });
+
+  test('set disableUndo to true', () => {
+    const game = ProcessGameConfig({
+      moves: {},
+      disableUndo: true,
+    });
+
+    expect(game.disableUndo).toBeTruthy();
+  });
+});

src/core/game.ts

@@ -48,6 +48,7 @@ export function ProcessGameConfig(game: Game | ProcessedGame): ProcessedGame {
   }
 
   if (game.name === undefined) game.name = 'default';
+  if (game.disableUndo === undefined) game.disableUndo = false;
   if (game.setup === undefined) game.setup = () => ({});
   if (game.moves === undefined) game.moves = {};
   if (game.playerView === undefined) game.playerView = G => G;

src/core/reducer.test.ts

@@ -364,6 +364,45 @@ test('undo / redo', () => {
   expect(state.G).toMatchObject({ roll: 4 });
 });
 
+test('disable undo / redo', () => {
+  const game: Game = {
+    seed: 0,
+    disableUndo: true,
+    moves: {
+      move: (G, ctx, arg) => ({ ...G, [arg]: true }),
+    },
+  };
+
+  const reducer = CreateGameReducer({ game });
+
+  let state = InitializeGame({ game });
+
+  state = reducer(state, makeMove('move', 'A'));
+  expect(state.G).toMatchObject({ A: true });
+  expect(state._undo).toEqual([]);
+  expect(state._redo).toEqual([]);
+
+  state = reducer(state, makeMove('move', 'B'));
+  expect(state.G).toMatchObject({ A: true, B: true });
+  expect(state._undo).toEqual([]);
+  expect(state._redo).toEqual([]);
+
+  state = reducer(state, undo());
+  expect(state.G).toMatchObject({ A: true, B: true });
+  expect(state._undo).toEqual([]);
+  expect(state._redo).toEqual([]);
+
+  state = reducer(state, undo());
+  expect(state.G).toMatchObject({ A: true, B: true });
+  expect(state._undo).toEqual([]);
+  expect(state._redo).toEqual([]);
+
+  state = reducer(state, redo());
+  expect(state.G).toMatchObject({ A: true, B: true });
+  expect(state._undo).toEqual([]);
+  expect(state._redo).toEqual([]);
+});
+
 describe('undo stack', () => {
   const game: Game = {
     moves: {

src/core/reducer.ts

@@ -213,7 +213,7 @@ export function CreateGameReducer({
 
         // Update undo / redo state.
         // Only update undo stack if the turn has not been ended
-        if (state.ctx.turn === prevTurnCount) {
+        if (state.ctx.turn === prevTurnCount && !game.disableUndo) {
           state._undo = state._undo.concat({
             G: state.G,
             ctx: state.ctx,
@@ -233,6 +233,11 @@ export function CreateGameReducer({
       }
 
       case Actions.UNDO: {
+        if (game.disableUndo) {
+          error("Undo is not enabled");
+          return state;
+        }
+
         const { _undo, _redo } = state;
 
         if (_undo.length < 2) {
@@ -264,6 +269,11 @@ export function CreateGameReducer({
       case Actions.REDO: {
         const { _undo, _redo } = state;
 
+        if (game.disableUndo) {
+          error("Redo is not enabled");
+          return state;
+        }
+
         if (_redo.length == 0) {
           return state;
         }

src/types.ts

@@ -229,6 +229,7 @@ interface PhaseMap<G extends any = any, CtxWithPlugins extends Ctx = Ctx> {
 
 export interface Game<G extends any = any, CtxWithPlugins extends Ctx = Ctx> {
   name?: string;
+  disableUndo?: boolean;
   seed?: string | number;
   setup?: (ctx: CtxWithPlugins, setupData?: any) => any;
   moves?: MoveMap<G, CtxWithPlugins>;