cardcore/dist/game-action-middleware.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = createGameActionMiddleware;
/**
 * So we have lots of actions that come to us from the nextActions queue in the reducer. Some of
 * them can be dispatched as-is, but many of them require us to run an action creator function to
 * e.g. decrypt or encrypt something as is appropriate. This middleware detects such actions and
 * sees if we have a cooresponding action based on a simple naming convention.
 *
 * actions.SEED_RNG_DECRYPT => actions.seedRngDecryptAction
 */

function createGameActionMiddleware(actions) {
  var actionMap = {};
  Object.keys(actions).forEach(function (key) {
    var value = actions[key];
    if (typeof value !== "string" || key !== value) {
      return;
    }
    var camelCase = value.split("_").map(function (word) {
      return word[0].toUpperCase() + word.slice(1).toLowerCase();
    }).join("");
    var actionCreator = camelCase[0].toLowerCase() + camelCase.slice(1);
    if (actions[actionCreator]) {
      actionMap[value] = actions[actionCreator];
    }
  });

  /**
   * two kinds of actions are allowed - you can either be a human that did an action on your turn or you can be a computer handling the most recent action in nextactions
   */
  function checkActionAllowed(state, action) {
    // non-game actions are always allowed
    if (!actions[action.type]) {
      return;
    }
    // also if we don't have a turn order yet, nbd
    if (!state.game || !state.game.turn) {
      return;
    }
    var sender = action.agent || state.client.keys.id;
    if (state.game.nextActions.length > 0) {
      var queueUser = state.game.nextActions[0].playerId;
      if (sender !== queueUser) {
        throw new Error("queue wants user " + queueUser + " but user " + sender + " acted");
      }
    }
    // no queue, check if it's an allowed action
    else if (state.game.allowedActions[action.type] !== true) {
        throw new Error(sender + " attempted to do non-allowed action " + action.type);
      } else if (state.game.turn !== sender) {
        throw new Error(sender + " acted out of turn; it's " + state.game.turn + "'s turn");
      }
  }

  return function gameActionMiddleware(store) {
    return function (next) {
      return function (action) {
        var state = store.getState();
        var dispatch = store.dispatch,
            getState = store.getState;

        checkActionAllowed(state, action);
        if (!state.client.loadingState && actionMap[action.type] && action._fromQueue && !action._dispatchedFromQueue) {
          action = actionMap[action.type](action);
          dispatch = function dispatch(action) {
            return store.dispatch(Object.assign({}, action, {
              _fromQueue: true,
              _dispatchedFromQueue: true
            }));
          };
        }
        // implement thunk
        if (typeof action === "function") {
          return action(dispatch, getState);
        }
        return next(action);
      };
    };
  };
}
//# sourceMappingURL=game-action-middleware.js.map