import React, { useMemo, useState } from "react";

import React, { useCallback, useMemo, useState } from "react";

import { createQuest } from "./game/CreateQuest";

  let createQuestCb = useCallback(() => createQuest(updaters), [updaters]);

        allocatedPoints={gameState.playerSave.allocatedPointNodeSet.size()}

        createQuestCb={createQuestCb}
        activeQuest={gameState.playerSave.activeQuest}
        numBatches={gameState.playerSave.batchesSinceQuestStart}

  }, [gameState.playerSave.allocatedPointNodeSet, gameState.playerSave.availableSp]);

  }, [gameState.playerSave.availableSp, gameState.playerSave.activeQuest, createQuestCb, gameState.playerSave.batchesSinceQuestStart]);

import React, { useState } from "react";

import React from "react";
import { Quest } from "../data/GameState";

  allocatedPoints: number

  createQuestCb: () => void,
  activeQuest: Quest | undefined,
  numBatches: number,

  activeQuest,

  allocatedPoints

  createQuestCb,
  numBatches,

  let [activeQuest, setActiveQuest] = useState<string | null>(null);

      {activeQuest === null ? (<>

      {activeQuest === undefined ? (<>

          setActiveQuest("1000 Mana0");

          createQuestCb();

          <div>{activeQuest}</div>

          <div>{activeQuest.description}</div>

          <div>{3}</div>

          <div>{numBatches}</div>

  justAllocated: PointNodeRef | undefined,

        justAllocated: undefined,

): "yes" | "already allocated" | "not enough sp" | "no" {

): "yes" | "already allocated" | "not enough sp" | "not connected" {

  return "no";

  return "not connected";

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

import { GameState } from "../data/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;

  updaters.playerSave.enqueueUpdate((prev, prevGameState) => {
    let justAllocated = prevGameState.playerSave.justAllocated; // we are assuming that someone verified that this is good2go
    if (!justAllocated) { return prev; }
    let prevSet = prev.allocatedPointNodeSet;
    if (!prevSet.contains(justAllocated)) { // if it's new, add it to history, set, and decrement sp
      const nextSet = prev.allocatedPointNodeSet.clone();
      nextSet.put(justAllocated);
      const nextHistory = [...prev.allocatedPointNodeHistory];
      nextHistory.push(justAllocated);
      let availableSp = prev.availableSp - 1;
      return {
        ...prev,
        allocatedPointNodeHistory: nextHistory,
        allocatedPointNodeSet: nextSet,
        availableSp
      };

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

import { HashSet } from "../../lib/util/data_structures/hash";

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

      updaters.playerSave.justAllocated.enqueueUpdate((prev: PointNodeRef | undefined, prevGameState) : PointNodeRef | undefined => {

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

            return args.selfPointNodeRef;

      })

      });

      // whether or not we successfully allocated, run this just in case