import { computeQuestEfficiencyPercent, remapQuestEfficiencyToGrade } from "./game/EfficiencyCalculator";

      efficiencyGrade={remapQuestEfficiencyToGrade(computeQuestEfficiencyPercent(gameState.playerSave))}

      playerSave={gameState.playerSave}

import { ComputedState, PointNodeRef, ResourceType, WorldGenState } from "../data/GameState";

import { ComputedState, PlayerSaveState, PointNodeRef, ResourceType, WorldGenState } from "../data/GameState";

import { computeQuestEfficiencyPercent } from "../game/EfficiencyCalculator";

  playerSave: PlayerSaveState,

  allocatedPointNodeSet,

  playerSave,

  availableSp,

  const { allocatedPointNodeSet, availableSp } = playerSave;

      <h3>efficiency percent</h3>
      {
        computeQuestEfficiencyPercent(playerSave)
      }
      <h3>Quest progress history</h3>
      {
        playerSave.questProgressHistory.length === 0 ? (<> empty </>) : 
        playerSave.questProgressHistory.map((num, i) => {
          return (
            <div key={i}>
              i={i}, quest progress={num}
            </div>
          )
        })
      }

  efficiencyGrade: string;

  efficiencyGrade,

          <div>{"SS"}</div>

          <div>{efficiencyGrade}</div>

  questProgressHistory: number[];

import { PlayerSaveState } from "../data/GameState";
import { Const } from "../lib/util/misc";
export function computeQuestEfficiencyPercent(playerSave: Const<PlayerSaveState>): number {
  if (playerSave.questProgressHistory.length === 0) {
    return 100;
  }
  let noEffectNodeCount = 0;
  playerSave.questProgressHistory.forEach((num, i, arr) => {
    let prev = (i === 0) ? 0 : arr[i - 1];
    if (num === prev) {
      noEffectNodeCount += 1;
    }
  });
  // guaranteed to be between 0 and 100
  // let noEffectNodePercent = 100 * noEffectNodeCount / (playerSave.questProgressHistory.length); 
  // add a 2-node buffer so efficiency doesnt drop to 0 at the very beginning of a quest
  const noEffectNodeBufferCount = 0.5;
  let noEffectNodePercent = 100 * (noEffectNodeCount) / (playerSave.questProgressHistory.length + noEffectNodeBufferCount); 
  console.log({ noEffectNodeCount, noEffectNodePercent });
  // the baseline we expect effect node percent to be -- influenced by world gen
  // let hasEffectNodePercentBaseline = 100;
  // let hasEffectNodeEfficiencyRaw = Math.min((100 - noEffectNodePercent) / hasEffectNodePercentBaseline * 100, 100);
  return (100 - noEffectNodePercent);
}
export function remapQuestEfficiencyToDisplayable(percent: number): number {
  // remaps the 0-100 percent scale to something that looks better
  // let's try: 5-110, but also 50 -> 80
  let x = percent / 100;
  x = 1 - Math.pow((1 - x), 3);
  x = x * 1.05 + 0.05;
  x = Math.max(0, Math.min(x * 100, 100));
  return x;
}
export function remapQuestEfficiencyToGrade(percent: number): string {
  const displayable = remapQuestEfficiencyToDisplayable(percent);
  // 0 - 100, remap to grades D, C, B, A, S
  if (displayable <= 20) {
    return "D";
  } else if (displayable <= 40) {
    return "C";
  } else if (displayable <= 60) {
    return "B";
  } else if (displayable <= 80) {
    return "A";
  } else {
    return "S";
  }
}

        questProgressHistory: [],

  let next = prev;
  if (prev.spSpentThisQuest !== undefined) {
    next = {
      ...next,
      spSpentThisQuest: prev.spSpentThisQuest + 1
    };

  let next = { ...prev };
  if (next.spSpentThisQuest !== undefined) {
    next.spSpentThisQuest += 1;

  if (prev.availableSp === 0 && prev.activeQuest) {

  if (next.availableSp === 0 && next.activeQuest) {

    next = {
      ...next,
      availableSp: 1,
      batchesSinceQuestStart: prev.batchesSinceQuestStart + 1
    };

    next.availableSp = 1;
    next.batchesSinceQuestStart += 1;

  // update quest progress history?
  if (next.activeQuest) {
    let resourceType = next.activeQuest.resourceType;
    let amount = prevGameState.computed.playerResourceAmounts?.[resourceType] || 0;
    next.questProgressHistory.push(amount);
  }

      updaters.enqueueUpdate((prev, prevGameState) => {

      updaters.computed.enqueueUpdate((prev, prevGameState) => {
        if (this.state.justSpentSp) {
          // this.state.justSpentSp = false;
          // console.log("just spent SP!");
          return computePlayerResourceAmounts(prevGameState);
        }
        return prev;
      })
      updaters.playerSave.enqueueUpdate((prev, prevGameState) => {

          return {
            ...prev,
            playerSave: afterMaybeSpendingSp(prev.playerSave, prevGameState),
            computed: {
              ...computePlayerResourceAmounts(prevGameState)
            }
          };

          return afterMaybeSpendingSp(prev, prevGameState);

import { computeQuestEfficiencyPercent, remapQuestEfficiencyToDisplayable } from "../../game/EfficiencyCalculator";

        efficiencyPercent: 100

        efficiencyPercent: remapQuestEfficiencyToDisplayable(computeQuestEfficiencyPercent(props.gameState.playerSave)),