// activeQuest: any | undefined,
  // batchesSinceQuestStart: number,

  activeQuest: Quest | undefined,
  batchesSinceQuestStart: number,

}
export type Quest = {
  description: string

import { GameState, Quest } from "../data/GameState";
import { UpdaterGeneratorType2 } from "../lib/util/updaterGenerator";
export function createQuest(updaters: UpdaterGeneratorType2<GameState>) {
  updaters.playerSave.activeQuest.enqueueUpdate((prev) => {
    return new QuestFactory({}).create();
  });
  updaters.playerSave.batchesSinceQuestStart.enqueueUpdate((prev) => {
    return 1;
  });
  updaters.playerSave.availableSp.enqueueUpdate((prev) =>  {
    return 5;
  });
}
type QuestFactoryConfig = { }
export class QuestFactory {
  public config: QuestFactoryConfig
  constructor(config: QuestFactoryConfig) {
    this.config = config;
  }
  public create(): Quest {
    return {
      description: "placeholder"
    };
  }
}

        activeQuest: undefined,
        batchesSinceQuestStart: 0,

import { GameState, PointNodeRef } from "../data/GameState";
import { HashSet } from "../lib/util/data_structures/hash";
import { UpdaterGeneratorType2 } from "../lib/util/updaterGenerator";

// Things that should happen after allocation history is appended to , in order to maintain the game state in a good state
export function afterAppendAllocationHistory(updaters: UpdaterGeneratorType2<GameState>) {
  updaters.playerSave.allocatedPointNodeSet.enqueueUpdate((prev: HashSet<PointNodeRef>, prevGameState) => {
    let history = prevGameState.playerSave.allocatedPointNodeHistory
    let mostRecent = history[history.length - 1]
    console.log({ history, actualHistory: [...history] });
    // if we were already selected, try to allocate us
    if (!prev.contains(mostRecent)) {
      const next = prev.clone();
      next.put(mostRecent);
      console.log({ prev, next, prevSize: prev.size(), nextSize: next.size(), isEqual: prev === next })
      return next;
    }
    return prev;
  });

export function afterAppendAllocationHistory() {}

  updaters.playerSave.availableSp.enqueueUpdate(prev => prev - 1);
}

import { afterAppendAllocationHistory } from "../../game/OnAllocation";

      updaters.playerSave.allocatedPointNodeHistory.update((prev, prevGameState) => {

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

        if (prevGameState.playerUI.selectedPointNode?.pointNodeId === args.selfPointNodeRef.pointNodeId && 
          canAllocate(

        if (prevGameState.playerUI.selectedPointNode?.pointNodeId === args.selfPointNodeRef.pointNodeId) {
          if (canAllocate(

          ) === 'yes'
        ) {
          prev.push(args.selfPointNodeRef);
          console.log({ prev, actualPrev : [...prev]});
          return [...prev];

          ) === 'yes') {
            prev.push(args.selfPointNodeRef);
            console.log({ prev, actualPrev: [...prev] });
            return [...prev];
          } else {
            // happens +1 tick afterwards due to nested enqueue, but NBD
            updaters.playerUI.activeTab.enqueueUpdate((prev) => {
              return 1;
            })
          }

      updaters.playerSave.allocatedPointNodeSet.update((prev: HashSet<PointNodeRef>, prevGameState) => {
        let history = prevGameState.playerSave.allocatedPointNodeHistory
        let mostRecent = history[history.length - 1]
          console.log({ history, actualHistory: [...history] });
        // if we were already selected, try to allocate us
        if (!prev.contains(mostRecent)) {
          const next = prev.clone();
          next.put(mostRecent);
          console.log({ prev, next, prevSize: prev.size(), nextSize: next.size(), isEqual: prev === next })
          return next;
        }
        return prev;
      })

      afterAppendAllocationHistory(updaters);

      updaters.playerUI.selectedPointNode.update((prev, gameState) => {

      // update selected to ourselves
      updaters.playerUI.selectedPointNode.enqueueUpdate((prev, gameState) => {