91 lines
3.4 KiB
TypeScript
91 lines
3.4 KiB
TypeScript
import { Store } from 'vuex';
|
|
import { insertAction } from '/imports/api/engine/action/methods/insertAction';
|
|
import Task from '/imports/api/engine/action/tasks/Task';
|
|
import EngineActions, { EngineAction } from '/imports/api/engine/action/EngineActions';
|
|
import InputProvider from '/imports/api/engine/action/functions/userInput/InputProvider';
|
|
import applyAction from '/imports/api/engine/action/functions/applyAction';
|
|
import { runAction } from '/imports/api/engine/action/methods/runAction';
|
|
import getDeterministicDiceRoller from '/imports/api/engine/action/functions/userInput/getDeterministicDiceRoller';
|
|
|
|
/**
|
|
* Apply an action on the client that first creates the action on both the client and server, then
|
|
* simulates the action, opening the action dialog if necessary to get input from the user, saving
|
|
* the decisions the user makes, then applying the action as a method call to the server with the
|
|
* saved decisions, which will persist the action results.
|
|
*
|
|
* @param prop The property initializing the action, if no task is applied the property will be
|
|
* applied as the starting point of the action
|
|
* @param $store The Vuex store instance that has the dialog stack
|
|
* @param elementId The element to animate the dialog from if a dialog needs to open
|
|
* @param task The task to apply instead of applying the property itself
|
|
*/
|
|
export default async function doAction(
|
|
prop: { _id: string, root: { id: string } },
|
|
$store: Store<any>,
|
|
elementId: string,
|
|
task?: Task,
|
|
) {
|
|
// Create the action
|
|
const actionId = insertAction.call({
|
|
action: {
|
|
creatureId: prop.root.id,
|
|
rootPropId: prop._id,
|
|
results: [],
|
|
taskCount: 0,
|
|
}
|
|
});
|
|
|
|
// Get the inserted and cleaned action instance
|
|
const action = EngineActions.findOne(actionId);
|
|
|
|
if (!action) throw new Meteor.Error('not-found', 'The action could not be found');
|
|
|
|
// Applying the action is deterministic, so we apply it, if it asks for user input, we escape and
|
|
// create a dialog that will re-apply the action, but with the ability to actually get input
|
|
// Either way, call the action method afterwards
|
|
try {
|
|
const finishedAction = await applyAction(
|
|
action, getErrorOnInputRequestProvider(action._id), { simulate: true, task }
|
|
);
|
|
return callActionMethod(finishedAction, task);
|
|
} catch (e) {
|
|
if (e !== 'input-requested') throw e;
|
|
return new Promise(resolve => {
|
|
$store.commit('pushDialogStack', {
|
|
component: 'action-dialog',
|
|
elementId,
|
|
data: {
|
|
actionId,
|
|
task,
|
|
},
|
|
callback(action: EngineAction) {
|
|
resolve(callActionMethod(action, task));
|
|
return elementId;
|
|
},
|
|
});
|
|
})
|
|
}
|
|
}
|
|
|
|
const callActionMethod = (action: EngineAction, task?: Task) => {
|
|
if (!action._id) throw new Meteor.Error('type-error', 'Action must have and _id');
|
|
//@ts-expect-error callAsync not defined in types
|
|
return runAction.callAsync({ actionId: action._id, decisions: action._decisions, task });
|
|
}
|
|
|
|
const throwInputRequestedError = () => {
|
|
throw 'input-requested';
|
|
}
|
|
|
|
function getErrorOnInputRequestProvider(actionId) {
|
|
const errorOnInputRequest: InputProvider = {
|
|
targetIds: throwInputRequestedError,
|
|
nextStep: throwInputRequestedError,
|
|
rollDice: getDeterministicDiceRoller(actionId),
|
|
choose: throwInputRequestedError,
|
|
advantage: throwInputRequestedError,
|
|
check: throwInputRequestedError,
|
|
}
|
|
return errorOnInputRequest;
|
|
}
|