let updaters = updaterGenerator(gameState, setGameState);

  let updaters = useMemo(() => updaterGenerator(gameState, setGameState), [setGameState]);

import { GameState } from "../data/GameState";
import { DeepReadonly } from "../lib/util/misc";

  const [gameState]  = useContext(UseGameStateContext);

  const [gameState, gameStateUpdaters]  = useContext(UseGameStateContext);

  const prevRef = useRef<DeepReadonly<GameState>>();
  useEffect(() => {
    prevRef.current = gameState;
  });
  const prevGameState = prevRef.current;

    pixiComponentState,

    pixiComponentState

    prevGameState,
    gameStateUpdaters,

 * 4. data about the window display - should never be persisted to disk.

  playerSave: PlayerSaveState
  playerUI: PlayerUIState

  playerSave: PlayerSaveState,
  playerUI: PlayerUIState,

}
/**
 * current window settings -- allows for dynamic resizing and also rotation on mobile web
 */
export type WindowState = {
  orientation: "original" | "rotated", // rotated === we are forcing landscape-in-portrait
  innerWidth: number,
  innerHeight: number,

    [k: string]: any,

import { KeyboardState } from "../lib/pixi/keyboard";
import { FpsTracker } from "../lib/util/fpsTracker";
import { registerDraggable } from "../lib/pixi/DraggableHelper";
import createBunnyExample from "./BunnyExample";
import { Chunk, RenderedChunk } from "./Chunk";

import { ZLevel } from "./ZLevel";
import { RenderedZLevel } from "./RenderedZLevel";
import { HashMap } from "../lib/util/data_structures/hash";
import { GameState, PointNodeRef } from "../data/GameState";
import { generatePointNodeTexture } from "./textures/PointNodeTexture";
import { Reticle } from "./Reticle";
import { ZLevelGenFactory } from "../dataFactory/WorldGenStateFactory";
import { assertOnlyCalledOnce, DeepReadonly, Lazy } from "../lib/util/misc";
import { PixiComponentState } from "../components/PixiComponent";
import { render } from "@testing-library/react";

import { GameState, WindowState } from "../data/GameState";
import { assertOnlyCalledOnce, DeepReadonly, updaterGenerator, UpdaterGeneratorType } from "../lib/util/misc";
import { GameStateFactory } from "../dataFactory/GameStateFactory";

  onFocusedNodeChange: (selection: PointNodeRef) => void;

  onFocusedNodeChange: () => { }

export type BaseApplicationProps = DeepReadonly<{

export type BaseApplicationProps = DeepReadonly<MutableProps>
type MutableProps = {

  windowSize: Vector2,
}>

  pixiComponentState: WindowState, // shim
}
export type BaseApplicationUpdaters = {
  gameState: UpdaterGeneratorType<GameState>,
};

  originalAppWidth: number;
  originalAppHeight: number;

  public globalEventQueue: ((...args: any[]) => void)[] = [];

  updaters!: BaseApplicationUpdaters;

  originalAppWidth: number;
  originalAppHeight: number;

  gameState!: GameState;
  props!: MutableProps;
  // nextProps!: MutableProps | undefined;

    this.state.appSize = BaseApplication.appSizeFromWindowSize(props.windowSize);

    this.state.appSize = BaseApplication.appSizeFromWindowSize(new Vector2(props.pixiComponentState.innerWidth, props.pixiComponentState.innerHeight));

    this.state.appSize = BaseApplication.appSizeFromWindowSize(props.windowSize);

    this.state.appSize = BaseApplication.appSizeFromWindowSize(new Vector2(props.pixiComponentState.innerWidth, props.pixiComponentState.innerHeight));
  }
  // shim, called from react, possibly many times , possibly at any time, including during the baseGameLoop below
  rerender(props: {
    gameStateUpdaters: UpdaterGeneratorType<GameState>,
    pixiComponentState: DeepReadonly<WindowState>,
    // needed to avoid double-updates
    prevGameState: DeepReadonly<GameState>,
    gameState: DeepReadonly<GameState>,
  }) {
    this.globalEventQueue.push(() => {
      this.props.pixiComponentState = props.pixiComponentState;
      this.updaters.gameState = props.gameStateUpdaters; // optional
    })

  blockedReactUpdate: { old: GameState, new: GameState } | undefined;

    // now: read the value of this.gameState
    let startGameState = this.gameState
    // generates a new object by shallow copying
    let setStartGameState = (arg: GameState | ((old: GameState) => GameState)) => {
      if (typeof arg === 'function') {
        startGameState = { ...arg(startGameState) };
      } else {
        startGameState = { ...arg }
      }
    }

    // apply changes to gameState - this should be synchronous, or at least locked
    let updater = updaterGenerator<GameState>(startGameState, setStartGameState);
    for (let eventAction of this.globalEventQueue) {
      eventAction(updater); // includes actions sent down from react
    }
    // pass the new game state back up
    this.gameState = startGameState;
    // note that react will view this as a state change and trigger this.rerender immediately, so we need to block that
    this.updaters.gameState.update((old: GameState): GameState => {
      this.blockedReactUpdate = { old, new: this.gameState };
      return this.gameState;
    });