Fixing UI for 2.1 data changes

app/imports/api/engine/computation/buildCreatureComputation.ts

@@ -0,0 +1,114 @@
+import { applyNestedSetProperties } from '/imports/api/parenting/parentingFunctions';
+import { CreatureProperty, DenormalisedOnlyCreaturePropertySchema as denormSchema }
+  from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { getProperties, getCreature, getVariables } from '/imports/api/engine/loadCreatures';
+import computedOnlySchemas from '/imports/api/properties/computedOnlyPropertySchemasIndex';
+import computedSchemas from '/imports/api/properties/computedPropertySchemasIndex';
+import linkInventory from './buildComputation/linkInventory';
+import walkDown from './utility/walkdown';
+import parseCalculationFields from './buildComputation/parseCalculationFields';
+import computeInactiveStatus from './buildComputation/computeInactiveStatus';
+import computeToggleDependencies from './buildComputation/computeToggleDependencies';
+import linkCalculationDependencies from './buildComputation/linkCalculationDependencies';
+import linkTypeDependencies from './buildComputation/linkTypeDependencies';
+import computeSlotQuantityFilled from './buildComputation/computeSlotQuantityFilled';
+import CreatureComputation from './CreatureComputation';
+import removeSchemaFields from './buildComputation/removeSchemaFields';
+
+/**
+ * Store index of properties
+ * recompute static tree-based enabled/disabled status
+ * Build a dependency graph
+ * id -> id dependencies for docs that rely on other docs directly
+ * id -> variable deps for docs that rely on a variable's value
+ * variable -> id deps for variables that are impacted by docs
+ */
+
+/**
+ * Forseen issues: Anything that computes during the build step will not obey
+ * computed toggles
+ */
+
+export default function buildCreatureComputation(creatureId: string) {
+  const creature = getCreature(creatureId);
+  const variables = getVariables(creatureId);
+  const properties = getProperties(creatureId);
+  const computation = buildComputationFromProps(properties, creature, variables);
+  return computation;
+}
+
+export function buildComputationFromProps(
+  properties: CreatureProperty[], creature, variables
+) {
+
+  const computation = new CreatureComputation(properties, creature, variables);
+  // Dependency graph where edge(a, b) means a depends on b
+  // The graph includes all dependencies even of inactive properties
+  // such that any properties changing without changing their dependencies
+  // can limit the recompute to connected parts of the graph
+  // Each node's data represents a prop or a virtual prop like a variable
+  // Each link's data is a string representing the link type
+  const dependencyGraph = computation.dependencyGraph;
+
+  // Link the denormalizedStats from the creature
+  if (creature && creature.denormalizedStats) {
+    if (creature.denormalizedStats.xp) {
+      dependencyGraph.addNode('xp', {
+        baseValue: creature.denormalizedStats.xp,
+        type: '_variable'
+      });
+    }
+    if (creature.denormalizedStats.milestoneLevels) {
+      dependencyGraph.addNode('milestoneLevels', {
+        baseValue: creature.denormalizedStats.milestoneLevels,
+        type: '_variable'
+      });
+    }
+  }
+
+  // Process the properties one by one
+  properties.forEach(prop => {
+    // The prop has been processed, it's no longer dirty
+    delete prop.dirty;
+
+    const computedSchema = computedOnlySchemas[prop.type];
+    removeSchemaFields([computedSchema, denormSchema], prop);
+
+    // Add a place to store all the computation details
+    prop._computationDetails = {
+      calculations: [],
+      emptyCalculations: [],
+      inlineCalculations: [],
+      toggleAncestors: [],
+    };
+
+    // Parse all the calculations
+    parseCalculationFields(prop, computedSchemas);
+
+  });
+
+  // Get all the properties as a forest, with their nested set properties set
+  const forest = applyNestedSetProperties(properties);
+
+  // Walk the property trees computing things that need to be inherited
+  walkDown(forest.trees, node => {
+    computeInactiveStatus(node);
+  });
+  // Inactive status must be complete for the whole tree before toggle deps
+  // are calculated
+  walkDown(forest.trees, node => {
+    computeToggleDependencies(node, computation, forest);
+    computeSlotQuantityFilled(node, dependencyGraph);
+  });
+
+  // Link the inventory dependencies
+  linkInventory(forest, dependencyGraph);
+
+  // Link functions that require the above to be complete
+  properties.forEach(prop => {
+    linkTypeDependencies(dependencyGraph, prop, computation);
+    linkCalculationDependencies(dependencyGraph, prop, computation);
+  });
+
+  return computation;
+}