jschaufuss/DiceCloud
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Tested and fixed branches and notes

Browse Source 
in new action interrupt system
This commit is contained in:
ThaumRystra
2023-11-16 22:21:48 +02:00
parent 375a84226d
commit 581f99d467
3 changed files with 339 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
app/imports/api/engine/actions/Actions.ts
View File

@@ -1,8 +1,10 @@
import SimpleSchema from 'simpl-schema';
import { forEach, isEmpty } from 'lodash';
import { forEach, isEmpty, pick } from 'lodash';
import LogContentSchema from '/imports/api/creature/log/LogContentSchema';
import { getPropertyChildren, getSingleProperty } from '/imports/api/engine/loadCreatures';
import { getPropertyChildren, getSingleProperty, getVariables } from '/imports/api/engine/loadCreatures';
import recalculateInlineCalculations from '/imports/api/engine/actions/applyPropertyByType/shared/recalculateInlineCalculations';
import recalculateCalculation from '/imports/api/engine/actions/applyPropertyByType/shared/recalculateCalculation';
import rollDice from '/imports/parser/rollDice';
const Actions = new Mongo.Collection<ActionWithId>('actions');
@@ -10,7 +12,7 @@ interface Action {
creatureId: string;
rootPropId: string;
targetIds?: string[];
userInputNeeded?: boolean;
userInputNeeded?: any;
stepThrough?: boolean;
taskQueue: Task[];
results: TaskResult[];
@@ -32,9 +34,24 @@ type TaskResult = {
mutations: Mutation[];
}
type PartialTaskResult = {
class PartialTaskResult {
scope: any;
mutations: Mutation[];
constructor() {
this.scope = {};
this.mutations = [];
}
// Appends the log content to the latest mutation
appendLog(content: LogContent, targetIds: string[]) {
if (!this.mutations.length) {
this.mutations.push({ targetIds, contents: [] });
}
const latestMutation = this.mutations[this.mutations.length - 1]
if (!latestMutation.contents) {
latestMutation.contents = [];
}
latestMutation.contents.push(content);
}
}
type Mutation = {
@@ -74,8 +91,9 @@ const ActionSchema = new SimpleSchema({
regEx: SimpleSchema.RegEx.Id,
},
userInputNeeded: {
type: Boolean,
defaultValue: false,
type: Object,
optional: true,
blackbox: true,
},
stepThrough: {
type: Boolean,
@@ -115,7 +133,8 @@ const ActionSchema = new SimpleSchema({
// Pushing these to the top of the stack and deleting the results from this point onwards
// Should re-run the action identically from this point
'results.$.propId': {
type: Object,
type: String,
regEx: SimpleSchema.RegEx.Id,
},
'results.$.targetIds': {
type: Array,
@@ -139,16 +158,34 @@ const ActionSchema = new SimpleSchema({
'results.$.mutations.$': {
type: Object,
},
'results.$.mutations.$.propId': {
'results.$.mutations.$.targetIds': {
type: Array,
},
'results.$.mutations.$.targetIds.$': {
type: String,
regEx: SimpleSchema.RegEx.Id,
},
'results.$.mutations.$.set': {
'results.$.mutations.$.updates': {
type: Array,
optional: true,
},
'results.$.mutations.$.updates.$': {
type: Object,
},
'results.$.mutations.$.updates.$.propId': {
type: String,
regEx: SimpleSchema.RegEx.Id,
},
'results.$.mutations.$.updates.$.set': {
type: Object,
optional: true,
blackbox: true,
},
'results.$.mutations.$.logContent': {
'results.$.mutations.$.contents': {
type: Array,
optional: true,
},
'results.$.mutations.$.contents.$': {
type: LogContentSchema,
},
});
@@ -173,22 +210,52 @@ export function createAction(prop) {
}
// Run an already created action
export async function runAction(actionId: string, userInput) {
export async function runAction(actionId: string, userInput?) {
const action = await Actions.findOneAsync(actionId);
if (!action) throw new Meteor.Error('Not found', 'The action does not exist');
const originalAction = EJSON.clone(action);
let count = 0;
do {
// Get the next task
const task = action.taskQueue.shift();
// If there isn't one, stop
if (!task) break;
// Apply the prop
await applyProperty(task, action, userInput);
} while (!action.userInputNeeded || !action.stepThrough)
// If there isn't a next task, stop
if (!action.taskQueue.length) break;
await applyNextTask(action, userInput);
count += 1;
if (count > 100) {
break;
}
} while (!action.userInputNeeded && !action.stepThrough)
// Persist changes to the action
return writeChangedAction(originalAction, action);
const writePromise = writeChangedAction(originalAction, action);
if (count > 100) {
throw new Meteor.Error('Too many properties', 'Only 100 properties may fire at a time');
}
return writePromise;
}
async function applyNextTask(action, userInput?) {
// Get the next task
const task = action.taskQueue[0];
// Ensure the prop exists
const prop = await getSingleProperty(action.creatureId, task.propId);
if (!prop) throw new Meteor.Error('Not found', 'Property could not be found');
if (prop.deactivatedByToggle) return;
// Apply the property
const result: TaskResult | undefined = await applyPropertyByType[prop.type]?.(prop, task, action, userInput);
if (result) {
// There was a result, we can remove this task from the queue
action.taskQueue.shift();
// store the task's details and save the result
result.scope[`#${prop.type}`] = prop;
result.propId = task.propId;
result.targetIds = task.targetIds;
action.results.push(result);
} else if (!action.userInputNeeded) {
// Prevent accidental infinite loops if we don't remove the task, but also don't break for input
throw 'The only time result can be undefined is if we are waiting for user input';
}
}
function writeChangedAction(original: ActionWithId, changed: ActionWithId) {
@@ -203,21 +270,6 @@ function writeChangedAction(original: ActionWithId, changed: ActionWithId) {
}
}
async function applyProperty(task, action, userInput) {
// Ensure the prop exists
const prop = await getSingleProperty(action.creatureId, task.propId);
if (!prop) throw new Meteor.Error('Not found', 'Property could not be found');
if (prop.deactivatedByToggle) return;
// Apply the property
const { result }: { result: TaskResult } = await applyPropertyByType[prop.type]?.(prop, task, action, userInput);
// store the task's details and save the result
result.propId = task.propId;
result.targetIds = task.targetIds;
action.results.push(result);
}
/**
* Push a prop and its before/after triggers to the task stack
* Triggers will share the same targetIds as the prop task
@@ -241,43 +293,45 @@ function pushPropAndTriggers(action: Action, prop, targetIds?) {
}
/**
* Push all the children of a prop and all related triggers to the task stack
* Triggers will share the same targetIds as the prop task
* Push all the children of a prop and all trigger of those children to the task queue
* @param action The action to add the task to
* @param prop The property to make a task of
* @param targetIds The targetIds the prop and triggers will apply to
*/
async function pushChildrenAndTriggers(action: Action, prop, targetIds) {
async function pushChildren(action: Action, prop, targetIds) {
const children = await getPropertyChildren(action.creatureId, prop._id);
// Push the child tasks and related triggers to the stack
forEach(children, childProp => {
pushPropAndTriggers(action, childProp, targetIds)
pushPropAndTriggers(action, childProp, targetIds);
});
}
// After the children run, it must run 'afterChildren' triggers
// Make sure they're on the bottom of the stack
function pushAfterChildrenTriggers(action: Action, prop, targetIds) {
forEach(prop.triggerIds?.afterChildren, triggerId => {
action.taskQueue.push({ propId: triggerId, targetIds });
});
}
function createResult(prop): PartialTaskResult {
function createResult(): PartialTaskResult {
// Add the property to the action's local scope
return {
scope: {
[`#${prop.type}`]: { _propId: prop._id }
},
mutations: [],
};
return new PartialTaskResult();
}
// Combine all the action results into the scope at present
export function getEffectiveActionScope(action) {
const scope = getVariables(action.creatureId);
for (const result of action.results) {
Object.assign(scope, result.scope);
}
return scope;
}
// Return result object
// No side effects except pushing to taskQueue
const applyPropertyByType = {
async note(prop, task: Task, action) {
const result = createResult(prop);
async note(prop, task: Task, action: Action) {
const result = createResult();
let contents: LogContent[] | undefined = undefined;
const logContent = { name: prop.name, value: undefined };
@@ -302,9 +356,134 @@ const applyPropertyByType = {
});
}
await pushChildrenAndTriggers(action, prop, task.targetIds);
await pushChildren(action, prop, task.targetIds);
await pushAfterChildrenTriggers(action, prop, task.targetIds);
return result;
}
},
async branch(prop, task: Task, action: Action, userInput) {
// const scope = getEffectiveActionScope(action);
const result = createResult();
const targets = task.targetIds;
switch (prop.branchType) {
case 'if': {
recalculateCalculation(prop.condition, action, 'reduce');
if (prop.condition?.value) {
await pushChildren(action, prop, targets);
}
pushAfterChildrenTriggers(action, prop, targets);
break;
}
case 'index': {
const children = await getPropertyChildren(action.creatureId, prop._id);
if (children.length) {
recalculateCalculation(prop.condition, action, 'reduce');
if (!isFinite(prop.condition?.value)) {
result.appendLog({
name: 'Branch Error',
value: 'Index did not resolve into a valid number'
}, targets);
break;
}
let index = Math.floor(prop.condition?.value);
if (index < 1) index = 1;
if (index > children.length) index = children.length;
pushPropAndTriggers(action, children[index - 1], targets);
}
pushAfterChildrenTriggers(action, prop, targets);
break;
}
case 'hit': {
const scope = getEffectiveActionScope(action);
if (scope['~attackHit']?.value) {
if (!targets.length && !prop.silent) {
result.appendLog({
value: '**On hit**'
}, targets);
}
await pushChildren(action, prop, targets);
}
pushAfterChildrenTriggers(action, prop, targets);
break;
}
case 'miss': {
const scope = getEffectiveActionScope(action);
if (scope['~attackMiss']?.value) {
if (!targets.length && !prop.silent) {
result.appendLog({
value: '**On miss**'
}, targets);
}
await pushChildren(action, prop, targets);
}
pushAfterChildrenTriggers(action, prop, targets);
break;
}
case 'failedSave': {
const scope = getEffectiveActionScope(action);
if (scope['~saveFailed']?.value) {
if (!targets.length && !prop.silent) {
result.appendLog({
value: '**On failed save**'
}, targets);
}
await pushChildren(action, prop, targets);
}
pushAfterChildrenTriggers(action, prop, targets);
break;
}
case 'successfulSave': {
const scope = getEffectiveActionScope(action);
if (scope['~saveSucceeded']?.value) {
if (!targets.length && !prop.silent) {
result.appendLog({
value: '**On save**'
}, targets);
}
await pushChildren(action, prop, targets);
}
pushAfterChildrenTriggers(action, prop, targets);
break;
}
case 'random': {
const children = await getPropertyChildren(action.creatureId, prop._id);
if (children.length) {
const index = rollDice(1, children.length)[0] - 1;
pushPropAndTriggers(action, children[index], targets);
}
pushAfterChildrenTriggers(action, prop, targets);
break;
}
case 'eachTarget':
if (targets.length) {
for (const targetId in targets) {
await pushChildren(action, prop, [targetId]);
pushAfterChildrenTriggers(action, prop, [targetId]);
}
} else {
await pushChildren(action, prop, targets);
pushAfterChildrenTriggers(action, prop, targets);
}
break;
case 'choice': {
// If there is no input to consume, return no result, but mark the action as requiring input
if (!userInput) {
action.userInputNeeded = pick(prop, ['_id', 'type', 'branchType']);
return;
}
const children = await getPropertyChildren(action.creatureId, prop._id);
let index = userInput.choice;
if (!isFinite(index) || index < 0) index = 0;
if (index > children.length - 1) index = children.length - 1;
pushPropAndTriggers(action, children[index], targets);
pushAfterChildrenTriggers(action, prop, targets);
break;
}
}
return result;
},
}