Merge branch 'main' into feat/printformula

src/features/trees/tree.ts

@@ -338,34 +338,21 @@ export const branchedResetPropagation = function (
     tree: GenericTree,
     resettingNode: GenericTreeNode
 ): void {
-    const visitedNodes = [resettingNode];
-    let currentNodes = [resettingNode];
-    if (tree.branches != null) {
-        const branches = unref(tree.branches);
-        while (currentNodes.length > 0) {
-            const nextNodes: GenericTreeNode[] = [];
-            currentNodes.forEach(node => {
-                branches
-                    .filter(branch => branch.startNode === node || branch.endNode === node)
-                    .map(branch => {
-                        if (branch.startNode === node) {
-                            return branch.endNode;
-                        }
-                        return branch.startNode;
-                    })
-                    .filter(node => !visitedNodes.includes(node))
-                    .forEach(node => {
-                        // Check here instead of in the filter because this check's results may
-                        // change as we go through each node
-                        if (!nextNodes.includes(node)) {
-                            nextNodes.push(node);
-                            node.reset?.reset();
-                        }
-                    });
-            });
-            currentNodes = nextNodes;
-            visitedNodes.push(...currentNodes);
-        }
+    const links = unref(tree.branches);
+    if (links == null) return;
+    const reset: GenericTreeNode[] = [];
+    let current = [resettingNode];
+    while (current.length != 0) {
+        const next: GenericTreeNode[] = [];
+        for (const node of current) {
+            for (const link of links.filter(link => link.startNode === node)) {
+                if ([...reset, ...current].includes(link.endNode)) continue
+                next.push(link.endNode);
+                link.endNode.reset?.reset();
+            }
+        };
+        reset.push(...current);
+        current = next;
     }
 };
 

src/game/modifiers.tsx

@@ -4,7 +4,7 @@ import { jsx } from "features/feature";
 import settings from "game/settings";
 import type { DecimalSource } from "util/bignum";
 import Decimal, { formatSmall } from "util/bignum";
-import type { WithRequired } from "util/common";
+import type { RequiredKeys, WithRequired } from "util/common";
 import type { Computable, ProcessedComputable } from "util/computed";
 import { convertComputable } from "util/computed";
 import { createLazyProxy } from "util/proxies";
@@ -38,16 +38,11 @@ export interface Modifier {
     description?: ProcessedComputable<CoercableComponent>;
 }
 
-/**
- * Utility type used to narrow down a modifier type that will have a description and/or enabled property based on optional parameters, T and S (respectively).
- */
-export type ModifierFromOptionalParams<T, S> = undefined extends T
-    ? undefined extends S
-        ? Omit<WithRequired<Modifier, "invert" | "getFormula">, "description" | "enabled">
-        : Omit<WithRequired<Modifier, "invert" | "enabled" | "getFormula">, "description">
-    : undefined extends S
-    ? Omit<WithRequired<Modifier, "invert" | "description" | "getFormula">, "enabled">
-    : WithRequired<Modifier, "invert" | "enabled" | "description" | "getFormula">;
+/** Utility type that represents the output of all modifiers that represent a single operation. */
+export type OperationModifier<T> = WithRequired<
+    Modifier,
+    "invert" | "getFormula" | Extract<RequiredKeys<T>, keyof Modifier>
+>;
 
 /** An object that configures an additive modifier via {@link createAdditiveModifier}. */
 export interface AdditiveModifierOptions {
@@ -65,9 +60,9 @@ export interface AdditiveModifierOptions {
  * Create a modifier that adds some value to the input value.
  * @param optionsFunc Additive modifier options.
  */
-export function createAdditiveModifier<T extends AdditiveModifierOptions>(
+export function createAdditiveModifier<T extends AdditiveModifierOptions, S = OperationModifier<T>>(
     optionsFunc: OptionsFunc<T>
-): ModifierFromOptionalParams<T["description"], T["enabled"]> {
+) {
     return createLazyProxy(feature => {
         const { addend, description, enabled, smallerIsBetter } = optionsFunc.call(
             feature,
@@ -111,7 +106,7 @@ export function createAdditiveModifier<T extends AdditiveModifierOptions>(
                           </div>
                       ))
         };
-    }) as unknown as ModifierFromOptionalParams<T["description"], T["enabled"]>;
+    }) as S;
 }
 
 /** An object that configures an multiplicative modifier via {@link createMultiplicativeModifier}. */
@@ -130,9 +125,10 @@ export interface MultiplicativeModifierOptions {
  * Create a modifier that multiplies the input value by some value.
  * @param optionsFunc Multiplicative modifier options.
  */
-export function createMultiplicativeModifier<T extends MultiplicativeModifierOptions>(
-    optionsFunc: OptionsFunc<T>
-): ModifierFromOptionalParams<T["description"], T["enabled"]> {
+export function createMultiplicativeModifier<
+    T extends MultiplicativeModifierOptions,
+    S = OperationModifier<T>
+>(optionsFunc: OptionsFunc<T>) {
     return createLazyProxy(feature => {
         const { multiplier, description, enabled, smallerIsBetter } = optionsFunc.call(
             feature,
@@ -175,7 +171,7 @@ export function createMultiplicativeModifier<T extends MultiplicativeModifierOpt
                           </div>
                       ))
         };
-    }) as unknown as ModifierFromOptionalParams<T["description"], T["enabled"]>;
+    }) as S;
 }
 
 /** An object that configures an exponential modifier via {@link createExponentialModifier}. */
@@ -196,9 +192,10 @@ export interface ExponentialModifierOptions {
  * Create a modifier that raises the input value to the power of some value.
  * @param optionsFunc Exponential modifier options.
  */
-export function createExponentialModifier<T extends ExponentialModifierOptions>(
-    optionsFunc: OptionsFunc<T>
-): ModifierFromOptionalParams<T["description"], T["enabled"]> {
+export function createExponentialModifier<
+    T extends ExponentialModifierOptions,
+    S = OperationModifier<T>
+>(optionsFunc: OptionsFunc<T>) {
     return createLazyProxy(feature => {
         const { exponent, description, enabled, supportLowNumbers, smallerIsBetter } =
             optionsFunc.call(feature, feature);
@@ -263,7 +260,7 @@ export function createExponentialModifier<T extends ExponentialModifierOptions>(
                           </div>
                       ))
         };
-    }) as unknown as ModifierFromOptionalParams<T["description"], T["enabled"]>;
+    }) as S;
 }
 
 /**
@@ -274,11 +271,9 @@ export function createExponentialModifier<T extends ExponentialModifierOptions>(
  * @see {@link createModifierSection}.
  */
 export function createSequentialModifier<
-    T extends Modifier[],
-    S = T extends WithRequired<Modifier, "invert">[]
-        ? WithRequired<Modifier, "description" | "invert">
-        : Omit<WithRequired<Modifier, "description">, "invert">
->(modifiersFunc: () => T): S {
+    T extends Modifier,
+    S = WithRequired<Modifier, Extract<RequiredKeys<T>, keyof Modifier>>
+>(modifiersFunc: () => T[]) {
     return createLazyProxy(() => {
         const modifiers = modifiersFunc();
 
@@ -296,10 +291,14 @@ export function createSequentialModifier<
                 : undefined,
             getFormula: modifiers.every(m => m.getFormula != null)
                 ? (gain: FormulaSource) =>
-                      modifiers
+                      modifiers.reduce((acc, curr) => {
+                          if (curr.enabled == null || curr.enabled === true) {
+                              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                              return curr.getFormula!(acc);
+                          }
                           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                          .reduce((acc, curr) => Formula.if(acc, curr.enabled ?? true,
-                            acc => curr.getFormula!(acc), acc => acc), gain)
+                          return Formula.if(acc, curr.enabled, acc => curr.getFormula!(acc));
+                      }, gain)
                 : undefined,
             enabled: modifiers.some(m => m.enabled != null)
                 ? computed(() => modifiers.filter(m => unref(m.enabled) !== false).length > 0)
@@ -317,7 +316,7 @@ export function createSequentialModifier<
                   ))
                 : undefined
         };
-    }) as unknown as S;
+    }) as S;
 }
 
 /** An object that configures a modifier section via {@link createModifierSection}. */

src/util/common.ts

@@ -1,3 +1,11 @@
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: NonNullable<unknown> extends Pick<T, K> ? never : K;
+}[keyof T];
+export type OptionalKeys<T> = {
+    [K in keyof T]-?: NonNullable<unknown> extends Pick<T, K> ? K : never;
+}[keyof T];
+
+export type OmitOptional<T> = Pick<T, RequiredKeys<T>>;
 export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
 
 export type ArrayElements<T extends ReadonlyArray<unknown>> = T extends ReadonlyArray<infer S>

tests/game/modifiers.test.ts

@@ -133,14 +133,14 @@ describe("Exponential Modifiers", () =>
     testModifiers(createExponentialModifier, "exponent", Decimal.pow));
 
 describe("Sequential Modifiers", () => {
-    function createModifier(
+    function createModifier<T extends Partial<ModifierConstructorOptions>>(
         value: Computable<DecimalSource>,
-        options: Partial<ModifierConstructorOptions> = {}
-    ): WithRequired<Modifier, "invert" | "getFormula"> {
+        options?: T
+    ) {
         return createSequentialModifier(() => [
-            createAdditiveModifier(() => ({ ...options, addend: value })),
-            createMultiplicativeModifier(() => ({ ...options, multiplier: value })),
-            createExponentialModifier(() => ({ ...options, exponent: value }))
+            createAdditiveModifier(() => ({ ...(options ?? {}), addend: value })),
+            createMultiplicativeModifier(() => ({ ...(options ?? {}), multiplier: value })),
+            createExponentialModifier(() => ({ ...(options ?? {}), exponent: value }))
         ]);
     }
 
@@ -199,6 +199,17 @@ describe("Sequential Modifiers", () => {
             // So long as one is true or undefined, enable should be true
             expect(unref(modifier.enabled)).toBe(true);
         });
+        test("respects enabled", () => {
+            const value = ref(10);
+            const enabled = ref(false);
+            const modifier = createSequentialModifier(() => [
+                createMultiplicativeModifier(() => ({ multiplier: 5, enabled }))
+            ]);
+            const formula = modifier.getFormula(Formula.variable(value));
+            expect(formula.evaluate()).compare_tolerance(value.value);
+            enabled.value = true;
+            expect(formula.evaluate()).not.compare_tolerance(value.value);
+        });
     });
 
     describe("applies smallerIsBetter correctly", () => {