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

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

const initialGameState: Lazy<GameState> = new Lazy(() => new GameStateFactory({}).create());

  const [gameState, setGameState] = useState<GameState>(
    new GameStateFactory({}).create()
  );

  // const x_initialGameState = useMemo(() => new GameStateFactory({}).create(), []);
  // const [gameState, setGameState] = useState<GameState>(x_initialGameState);
  const [gameState, setGameState] = useState<GameState>(initialGameState.get());
  // const [gameState, setGameState] = useState<GameState>(() => new GameStateFactory({}).create());
  // useEffect(() => {
  //   setGameState(new GameStateFactory({}).create());
  // }, []);
  // if (!gameState) {
  //   setGameState(new GameStateFactory({}).create());
  // }
  // if (gameState === undefined) {
  //   throw new Error();
  // }

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

const initialApplication = new Lazy(() => new Application({
  originalWindowWidth: window.innerWidth,
  originalWindowHeight: window.innerHeight,
}));

  const [application, setApplication] = useState<Application>(
    new Application({
      originalWindowWidth: window.innerWidth,
      originalWindowHeight: window.innerHeight,
    })
  );

  const [application, setApplication] = useState<Application>(initialApplication.get());

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

    console.log("BOWEI CREATING GAME STATE, should only run once!!")

    assertOnlyCalledOnce("GameStateFactory.create");

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

}
const assertOnlyCalledOnceData: { [k: string]: string } = {};
export function assertOnlyCalledOnce(id: string | number) {
  let k = id.toString();
  if (assertOnlyCalledOnceData[k] !== undefined) {
    throw new Error("Error, called twice with same id: " + k + " , callback the first time was : " + assertOnlyCalledOnceData[k]);
  } else {
    const stacktrace = new Error().stack!
    assertOnlyCalledOnceData[k] = stacktrace;
  }
}
export class Lazy<T> {
  private _wasConstructed: boolean = false;
  private _value: T | undefined = undefined;
  private _factory: () => T
  constructor(factory: () => T) {
    this._factory = factory;
  }
  public get(): T {
    // T might have undefined as a valid value
    if (this._value !== undefined || this._wasConstructed === true) {
      return this._value!;
    } else {
      this._value = this._factory();
      this._wasConstructed = true;
      return this._value;
    }
  }

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

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

    assertOnlyCalledOnce("Application constructor");

    assertOnlyCalledOnce("Application.drawStart");