StepChain

Author: MathisSinet

src/Data/data.json

@@ -801,14 +801,15 @@
     }
   },
   "stratCategories": ["Best Overall", "Best Active", "Best Semi-Idle", "Best Idle"],
-  "modes": ["All", "Single sim", "Chain", "Steps", "Amount", "Time", "Time diff."],
-  "modeInputDescriptions": ["", "", "", "Step length: ", "Amount of pubs (Chain): ", "Total Time: "],
+  "modes": ["All", "Single sim", "Chain", "Steps", "StepChain", "Amount", "Time", "Time diff."],
+  "modeInputDescriptions": ["", "", "", "Step length: ", "Step length: ", "Amount of pubs (Chain): ", "Total Time: "],
   "modeInputPlaceholder": [
     "<sigma> <t1>* [t2]* ... [wsp]* ... [bap]* \n\n*[r/t/m] = rho/tau/total multiplier | default tau\n\nOr: input your save here and click \"Load save\"",
     "",
     "",
     "",
     "<Number>",
+    "<Number>",
     "<Hours>",
     "<t1> [t1], ... , <t8> [t8] or <wsp> [wsp], ... , <bap> [bap]",
     "<t1> [t1], ... , <t8> [t8] or <wsp> [wsp], ... , <bap> [bap]",

src/Sim/parse.ts

@@ -136,6 +136,23 @@ function parseStepSim(): StepSimQuery {
     }
 }
 
+function parseStepChainSim(): StepChainQuery {
+    const theory = theorySelector.value as theoryType;
+    const sigma = parseSigma(isMainTheory(theory));
+
+    return {
+        queryType: "step_chain",
+        theory: theory,
+        strat: stratSelector.value,
+        sigma: sigma,
+        rho: parseCurrency(currencyInput.value, theory, sigma),
+        cap: parseCurrency(capInput.value, theory, sigma),
+        step: parseExponentialValue(modeInput.value),
+        hardCap: hardCap.checked,
+        settings: parseSettings()
+    }
+}
+
 function parseSimAll(): SimAllQuery {
     const settings = parseSettings();
     const str = simAllInputArea.value;
@@ -179,6 +196,7 @@ export function parseQuery(): SimQuery {
         case "Single sim": return parseSingleSim();
         case "Chain": return parseChainSim();
         case "Steps": return parseStepSim();
+        case "StepChain": return parseStepChainSim();
         default: throw "This mode is not supported.";
     }
 }

src/Sim/simulate.ts

@@ -74,7 +74,7 @@ async function singleSim(query: SingleSimQuery): Promise<SingleSimResponse> {
     }
 }
 
-async function chainSim(query: ChainSimQuery): Promise<ChainSimResponse> {
+async function chainSim(query: ChainSimQuery, doLog = true): Promise<ChainSimResponse> {
     let rho = query.rho;
     let time = 0;
     let lastStrat = "";
@@ -84,7 +84,7 @@ async function chainSim(query: ChainSimQuery): Promise<ChainSimResponse> {
 
     while (rho < query.cap) {
         const ts = performance.now();
-        if (ts - lastLog > 250) {
+        if (ts - lastLog > 250 && doLog) {
             lastLog = ts;
             output.textContent = `Simulating ${logToExp(rho, 0)}/${stopStr}`;
             await sleep();
@@ -207,11 +207,71 @@ async function simAll(query: SimAllQuery): Promise<SimAllResponse> {
     }
 }
 
+async function stepChainSim(query: StepChainQuery): Promise<StepSimResponse> {
+    let rho = query.rho;
+    const results: simResult[] = [];
+    const stopStr = logToExp(query.cap);
+    let lastLog = 0;
+
+    while (rho < query.cap - query.step + 0.000001) {
+        const ts = performance.now();
+        if (ts - lastLog > 250) {
+            lastLog = ts;
+            output.textContent = `Simulating ${logToExp(rho, 0)}/${stopStr}`;
+            await sleep();
+        }
+
+        const chain_res = await chainSim({
+            queryType: "chain",
+            settings: query.settings,
+            sigma: query.sigma,
+            rho,
+            theory: query.theory,
+            strat: query.strat,
+            cap: query.cap,
+            hardCap: query.hardCap
+        }, false);
+        if (!global.simulating) break;
+
+        let tau_acc = 0;
+        let time_acc = 0;
+        let pub_count = 0;
+        let bestRes = defaultResult();
+        for (let result of chain_res.results) {
+            tau_acc += result.deltaTau;
+            time_acc += result.time;
+            pub_count++;
+            const tauH = tau_acc / (time_acc / 3600);
+            let cur_res: simResult = {
+                theory: query.theory,
+                sigma: query.sigma,
+                lastPub: rho,
+                pubRho: result.pubRho,
+                deltaTau: tau_acc,
+                pubMulti: 1,
+                strat: pub_count + " pub" + (pub_count > 1 ? "s": ""),
+                tauH: tauH,
+                time: time_acc,
+                boughtVars: []
+            }
+            bestRes = getBestResult(bestRes, cur_res);
+        }
+        results.push(bestRes);
+        rho += query.step;
+    }
+
+    return {
+        responseType: "step",
+        results: results
+    }
+}
+
 export async function simulate(query: SimQuery): Promise<SimResponse> {
     switch (query.queryType) {
         case "single": return await singleSim(query);
         case "chain": return await chainSim(query);
         case "step": return await stepSim(query);
         case "all": return await simAll(query);
+        case "step_chain": return await stepChainSim(query);
     }
 }

src/UI/render.ts

@@ -104,9 +104,9 @@ function modeUpdate(): void {
   // Displays the single-theory inputs
   if (newMode !== "All" && newMode !== "Time diff.") singleInput.style.display = "grid";
   // Displays the cap input for chain/steps mode
-  if (newMode === "Chain" || newMode === "Steps") capInputWrapper.style.display = "inline";
+  if (newMode === "Chain" || newMode === "Steps" || newMode === "StepChain") capInputWrapper.style.display = "inline";
   // Displays the hard cap input
-  if (newMode === "Chain") hardCapWrapper.style.display = "block";
+  if (newMode === "Chain" || newMode == "StepChain") hardCapWrapper.style.display = "block";
 
   // Extra Inputs
   if (newMode !== "Single sim" && newMode !== "Time diff." && newMode !== "Chain") extraInputs.style.display = "flex";

src/Utils/global.types.ts

@@ -62,7 +62,17 @@ declare global {
     stratType: SettingsSimAllStratsMode;
   }
 
-  type SimQuery = SingleSimQuery | ChainSimQuery | StepSimQuery | SimAllQuery;
+  type StepChainQuery = BaseSimQuery & {
+    queryType: "step_chain"
+    theory: theoryType
+    strat: string
+    rho: number
+    cap: number
+    step: number
+    hardCap: boolean
+  }
+
+  type SimQuery = SingleSimQuery | ChainSimQuery | StepSimQuery | SimAllQuery | StepChainQuery;
 
   type SingleSimResponse = {
     responseType: "single";