<PixiComponent onFocusedNodeChange={updaters.playerUI.selectedPointNode.getUpdater()} />

        <PixiComponent originalSetGameState={setGameState}/>

  console.log("in nodedetail, ", selectedPointNode);

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

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

import { PointNodeRef } from "../data/GameState";

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

import { UseGameStateContext } from "../contexts";
import { GameStateFactory } from "../dataFactory/GameStateFactory";

export function PixiComponent(props: {
  onFocusedNodeChange: (selection: PointNodeRef) => void;
}) {

export function PixiComponent(props: { originalSetGameState: Function }) {
  const [gameState, gameStateUpdaters, fireBatchedSetGameState]  = useContext(UseGameStateContext);

      <button onClick={() => {}}>draw circle</button>

      <button onClick={() => {
        gameStateUpdaters.update((old) => {
          let newGameState = new GameStateFactory({}).create(old.worldGen.seed);
          old.playerSave = newGameState.playerSave;
          old.playerUI = newGameState.playerUI;
          old.worldGen = newGameState.worldGen;
          return old
        });
      }}>Reset game state</button>
      <button onClick={() => {
        application.pause();
        application.destroy();
        setApplication(new BaseApplication({
          originalWindowWidth: window.innerWidth,
          originalWindowHeight: window.innerHeight,
        }, {}, true));
        let newGameState = new GameStateFactory({}).create(+new Date());
        props.originalSetGameState((old: GameState) => {
          old.playerSave = newGameState.playerSave;
          old.playerUI = newGameState.playerUI;
          old.worldGen = newGameState.worldGen;
          return old
        });
      }}>Get a fresh seed, reset, and rerender</button>

          application.pause();
          application.destroy();

          }))

          }, {}, true));

        [DEBUG] reset and rerender

        Rerender pixi application

    // const oldLength = container.current!.childNodes.length;

    // if (oldLength != 0) {
    //   return;
    // }

  }, [application.app.view]);

  }, [application]);

import { GameState } from "../data/GameState";

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

import { Vector2 } from "../lib/util/geometry/vector2";

import { ZLevelGenFactory } from "./WorldGenStateFactory";

  public create(seed: number | undefined | null = undefined): GameState {
    if (seed === undefined) {
      assertOnlyCalledOnce("GameStateFactory.create");
    }
    const mySeed = seed || 0x19283;

  public create(): GameState {
    assertOnlyCalledOnce("GameStateFactory.create");

    const zLevel = new ZLevelGenFactory({}).create({ seed: mySeed, z: 0, startingChunks: 0 });
    const origin = new Vector2(0, 0);
    const firstId = zLevel.chunks.get(origin)?.pointNodes.get(origin)?.id!
    const pointNodeRef: PointNodeRef = new PointNodeRef({
      z: 0,
      chunkCoord: origin,
      pointNodeId: firstId,
      pointNodeCoord: origin
    });

        seed: 0xcafebabe,
        zLevels: []

        seed: mySeed,
        zLevels: { 0: zLevel },

        // selectedPointNodeHistory: [],
        allocatedPointNodeSet: new HashSet(),
        allocatedPointNodeHistory: []

        allocatedPointNodeSet: new HashSet([pointNodeRef]),
        allocatedPointNodeHistory: [pointNodeRef],

  public create(args: { seed: number, z: number }): ZLevelGen {

  public create(args: { seed: number, z: number, startingChunks?: number }): ZLevelGen {

    const max = args.startingChunks || 3;

    for (let i = -3; i <= 3; i++) {
      for (let j = -3; j <= 3; j++){

    for (let i = -max; i <= max; i++) {
      for (let j = -max; j <= max; j++){

    console.log(this);

  get(key: K): V {

  get(key: K): V | undefined {

  get(key: K): V {
    return this._kvalues[key.hash()][1];

  get(key: K): V | undefined {
    return this._kvalues[key.hash()]?.[1];

  onTick!: (d: number) => void;

  constructor(args: Partial<Config> = {}, props: Partial<BaseApplicationProps> = {}) {
    assertOnlyCalledOnce("Base application constructor"); // annoying with react hot reload, disable for now

  constructor(args: Partial<Config> = {}, props: Partial<BaseApplicationProps> = {}, isSecondTime = false) {
    // verify that we are not loading this twice when we expect to load it only once -- bad for performance!!
    if (!isSecondTime) {
      assertOnlyCalledOnce("Base application constructor"); // annoying with react hot reload, disable for now}
    }

  public pause() {
    this.app.ticker.remove(this.onTick);
  }
  public destroy() {
    this.app.destroy(true, { children: true, texture: true, baseTexture: true });
  }

    this.app.ticker.add((delta) => this.baseGameLoop(delta));

    this.onTick = (delta) => this.baseGameLoop(delta);
    this.onTick = this.onTick.bind(this);
    this.app.ticker.add(this.onTick);

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

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

import { UpdaterGeneratorType2 } from "../lib/util/updaterGenerator";

import { updaterGenerator2, UpdaterGeneratorType2, UpdaterFn } from "../lib/util/updaterGenerator";

  stateUpdaters: UpdaterGeneratorType2<State>;
  fireStateUpdaters: () => void;

    this.container = new Pixi.Container();
    this.container.sortableChildren = true;

    this.container = new Pixi.Container();
    this.container.sortableChildren = true;

    const setState: UpdaterFn<State> = ((valueOrCallback) => {
      if (typeof valueOrCallback === "function") {
        this.state = valueOrCallback(this.state);
      } else {
        this.state = valueOrCallback;
      }
    })
    let [batchedSetState, fireBatch] = batchify(setState);
    this.stateUpdaters = updaterGenerator2<State>(this.state, batchedSetState);
    this.fireStateUpdaters = fireBatch;

    const childProps = {
      delta: 0,
      args: {
        pointNodeTexture: this.state.pointNodeTexture.get(),
        z: 0,
      },
      updaters: props.updaters,
      position: props.appSize.multiply(0.5),
      zLevelGen: props.gameState.worldGen.zLevels[0],
      selectedPointNode: props.gameState.playerUI.selectedPointNode,
      allocatedPointNodeSubset: props.gameState.playerSave.allocatedPointNodeSet,
    };
    if (!this.zLevel) {
      this.zLevel = new ZLevelComponent(childProps);
      this.actionStage.addChild(this.zLevel.container);
    } else {
      this.zLevel.update(childProps);
    }

    if (props.gameState.worldGen.zLevels[0]) {
      const childProps = {
        delta: 0,
        args: {
          pointNodeTexture: this.state.pointNodeTexture.get(),
          z: 0,
        },
        updaters: props.updaters,
        position: props.appSize.multiply(0.5),
        zLevelGen: props.gameState.worldGen.zLevels[0],
        selectedPointNode: props.gameState.playerUI.selectedPointNode,
        allocatedPointNodeSubset: props.gameState.playerSave.allocatedPointNodeSet,
      };
      if (!this.zLevel) {
        this.zLevel = new ZLevelComponent(childProps);
        this.actionStage.addChild(this.zLevel.container);
      } else {
        this.zLevel.update(childProps);
      }

    const childProps = {
      delta: 0,
      args: {
        pointNodeTexture: this.state.pointNodeTexture.get(),
        z: 0,
      },
      updaters: props.updaters,
      position: props.appSize.multiply(0.5),
      zLevelGen: props.gameState.worldGen.zLevels[0],
      selectedPointNode: props.gameState.playerUI.selectedPointNode,
      allocatedPointNodeSubset: props.gameState.playerSave.allocatedPointNodeSet,
    };
    if (!this.zLevel) {
      this.zLevel = new ZLevelComponent(childProps);
      this.actionStage.addChild(this.zLevel.container);
    } else {
      this.zLevel.update(childProps);

    this.fireStateUpdaters();

    const { updaters } = this.staleProps;
    assertOnlyCalledOnce("root application did mount");
    updaters.worldGen.zLevels.update((prev, prevGameState) => {
      assertOnlyCalledOnce("root application callback");
      if (!prev[0]) {
        return { 0: new ZLevelGenFactory({}).create({ seed: prevGameState.worldGen.seed, z: 0 }) };
      }
      return prev;
    })

      childComponent.update(childProps);

      if (childComponent) {
        childComponent.update(childProps);
      } else {
        childComponent = new PointNodeComponent(childProps);
        this.children.put(pointNodeRef, childComponent);
        this.container.addChild(childComponent.container);
      }

import { ZLevelGenFactory } from "../../dataFactory/WorldGenStateFactory";

  zLevelGen: Const<ZLevelGen>,

  zLevelGen: Const<ZLevelGen> | undefined,

    for (let [chunkCoord, chunkGen] of props.zLevelGen.chunks.entries()) {

    for (let [chunkCoord, chunkGen] of props.zLevelGen?.chunks?.entries() || []) {

    this.didMount();

    for (let [chunkCoord, chunkGen] of props.zLevelGen.chunks.entries()) {

    for (let [chunkCoord, chunkGen] of props.zLevelGen?.chunks?.entries() || []) {

      this.children.get(chunkRef).update(childProps);

      let childComponent = this.children.get(chunkRef);
      if (childComponent) {
        childComponent.update(childProps);
      } else {
        childComponent = new ChunkComponent(childProps);
        this.children.put(chunkRef, childComponent);
        this.container.addChild(childComponent.container);
      }

    this.didUpdate(this.staleProps, props);

  }
  didUpdate(prevProps: Props, props: Props) {
  }
  didMount() {
    const { args, updaters } = this.staleProps;
    // if we mounted but our data is not generated, please generate ourselves
    updaters.worldGen.zLevels.update((prev, prevGameState) => {
      if (!prev[args.z]) {
        return { [args.z]: new ZLevelGenFactory({}).create({ seed: prevGameState.worldGen.seed, z: args.z }) };
      }
      return prev;
    })
    // updaters.playerSave.allocatedPointNodeSet.update((prev, prevGameState) => {
    //   if (prev.size() === 0) {
    //     let startNode = prevGameState.worldGen.zLevels[0].chunks.get(new Vector2(0, 0))?.pointNodes.get(new Vector2(0, 0));
    //     if (startNode) {
    //       prev.put(new PointNodeRef({
    //         z: 0,
    //         chunkCoord: new Vector2(0, 0),
    //         pointNodeCoord: new Vector2(0, 0),
    //         pointNodeId: startNode?.id
    //       }))
    //       return prev.clone();
    //     }
    //   }
    //   return prev;
    // })