import { batchify, batchifySetState, Lazy } from "./lib/util/misc";

import { batchifySetState, Lazy } from "./lib/util/misc";

  // eslint-disable-next-line

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

import { HashMap, HashSet, KeyedHashMap } from "../lib/util/data_structures/hash"

 * 5. data that is computed from other data - no need to persist to disk.

  computed: ComputedState

  resourceType: ResourceType | null;

  resourceType: ResourceType;

export enum ResourceType {

export enum ResourceNontrivialType {

  Nothing = "Nothing"

export type ResourceType = "Nothing" | ResourceNontrivialType;
// eslint-disable-next-line
export const ResourceType = { Nothing: "Nothing", ...ResourceNontrivialType };

  justAllocated: PointNodeRef | undefined,

  // justAllocated: PointNodeRef | undefined,

}
export type ComputedState = {
  playerResourceAmounts?: { [k in ResourceType]: number }
  playerResourceNodesAggregated?: HashMap<ResourceTypeAndModifier, number>
}
// export type ResourceTypeAndModifier = [ResourceType.Nothing] | ([ResourceType, ResourceModifier]);
export class ResourceTypeAndModifier {
  public type: ResourceNontrivialType;
  public modifier: ResourceModifier;
  constructor(args: { type: ResourceNontrivialType, modifier: ResourceModifier}) {
    this.type = args.type;
    this.modifier = args.modifier;
  }
  public hash(): string {
    return this.type.toString() + ',' + this.modifier.toString();
  }

import { GameState, ResourceModifier, ResourceType, ResourceTypeAndModifier } from "../data/GameState";
import { HashMap } from "../lib/util/data_structures/hash";
import { enumKeys } from "../lib/util/misc";
export function computePlayerResourceAmounts(gameState: GameState): ({ [k in ResourceType]: number }) {
  let amounts: { [k in ResourceType]?: number } = {};
  let playerResourceNodesAggregated = new HashMap<ResourceTypeAndModifier, number>();
  for (let pointNodeRef of gameState.playerSave.allocatedPointNodeHistory) {
    let pointNodeGen = gameState.worldGen.zLevels[pointNodeRef.z]!.chunks.get(pointNodeRef.chunkCoord)!.pointNodes.get(pointNodeRef.pointNodeCoord)!
    if (pointNodeGen.resourceType === "Nothing") {
      continue;
    }
    let resourceTypeAndModifier = new ResourceTypeAndModifier({
      type: pointNodeGen.resourceType, modifier: pointNodeGen.resourceModifier
    });
  }
  for (let key of enumKeys(ResourceType)) {
    if (key === ResourceType.Nothing) {
      amounts[key] = 0;
      continue;
    }
    // iterate throu
    amounts[key];
  }
  return amounts as { [k in ResourceType]: number }
}

        justAllocated: undefined,

        // justAllocated: undefined,

      }

      },
      computed: {}

    // TODO: need to find out if the quest is finished...

      resourceType = ResourceType.Nothing;

      resourceType = "Nothing";

      resourceType = ResourceType.Nothing;

      resourceType = "Nothing";

      resourceType = ResourceType.Nothing;

      resourceType = "Nothing";

import { canAllocate } from "../../game/Neighbors";

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

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

          return afterMaybeSpendingSp(prev, prevGameState);

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