markForceUpdate: () => { },

        markForceUpdate: () => { },

    markForceUpdate: (childInstance: any) => void,

  
  public _children: {childClass :any, instance: any, propsFactory: Function}[] = []
  public forceUpdates: {childClass :any, instance: any, propsFactory: Function}[] = []

    for (let [pointNodeCoord, pointNodeGen] of props.chunkGen.pointNodes.entries()) {
      const pointNodeRef = new PointNodeRef({
        z: props.selfChunkRef.z,
        chunkCoord: props.selfChunkRef.chunkCoord,
        pointNodeCoord: pointNodeCoord,
        pointNodeId: pointNodeGen.id
      })
      let childProps = {
        delta: props.delta,
        args: {
          pointNodeTexture: props.args.pointNodeTexture,
        },
        selfPointNodeRef: pointNodeRef,
        updaters: props.updaters,
        pointNodeGen,
        position: pointNodeRef.pointNodeCoord.multiply(RenderedChunkConstants.SPACING_PX),
        isSelected: props.selectedPointNode?.pointNodeId === pointNodeRef.pointNodeId,
        isAllocated: props.allocatedPointNodeSubset.contains(pointNodeRef),
      };
      let childComponent = new PointNodeComponent(childProps);
      this.children.put(pointNodeRef, childComponent);
      this.container.addChild(childComponent.container);
    }

    this.upsertChildren(props);

  /** callback passed to child - since child is not a pure component, it needs to inform us of updates if otherwise we wouldnt update */
  markForceUpdate = (childInstance: any) => {
    this.staleProps.args.markForceUpdate(this); // mark us for update in OUR parent
    if ((this._children as any[]).indexOf(childInstance) === -1) {
      throw new Error(`Error, child ${childInstance} not found in ${this}`);
    } else {
      this.forceUpdates.push(this._children[(this._children as any[]).indexOf(childInstance)])
    }
  }

  public update(props: Props) {
    // let staleState = { ...this.state };
    this.updateSelf(props)
    if (!this.shouldUpdate(this.staleProps, props)) { return; }

  upsertChildren(props: Props) {
    let childrenToDelete = this.children.clone(); // track which children need to be destroyed according to new props

          markForceUpdate: this.markForceUpdate,

      const childKey = pointNodeRef;

      let childComponent = this.children.get(pointNodeRef);

      let childComponent = this.children.get(childKey);

        childrenToDelete.remove(childKey);

      }
      for (let [childKey, childComponent] of childrenToDelete.entries()) {
        childComponent.willUnmount();
        this.children.remove(childKey);
        this.container.removeChild(childComponent.container);

  }
  public update(props: Props) {
    // let staleState = { ...this.state };
    this.updateSelf(props)
    if (!this.shouldUpdate(this.staleProps, props)) { return; }
    this.upsertChildren(props);

import { TooltippableAreaComponent, TooltippableAreaComponentType } from "./TooltippableAreaComponent";

import { TooltippableAreaComponent, TooltippableAreaComponentProps, TooltippableAreaComponentType } from "./TooltippableAreaComponent";

    markForceUpdate: (childInstance: any) => void,

  public hitArea: Pixi.IHitArea;

  public tooltippableAreaPropsFactory: (p: Props, s: State) => TooltippableAreaComponentProps
  public _children: {childClass :any, instance: any, propsFactory: Function}[] = []
  public forceUpdates: {childClass :any, instance: any, propsFactory: Function}[] = []

    const hitArea: Pixi.Rectangle = new Pixi.Rectangle(

    this.hitArea = new Pixi.Rectangle(

    this.tooltippableArea = new TooltippableAreaComponent({
      hitArea
    });

    this.tooltippableAreaPropsFactory = (p: Props, s: State) => {
      return {
        hitArea: this.hitArea
      }
    }
    this.tooltippableArea = new TooltippableAreaComponent(this.tooltippableAreaPropsFactory(props, this.state));

  /** callback passed to child - since child is not a pure component, it needs to inform us of updates if otherwise we wouldnt update */
  markForceUpdate = (childInstance: any) => {
    this.staleProps.args.markForceUpdate(this); // mark us for update in OUR parent
    if ((this._children as any[]).indexOf(childInstance) === -1) {
      throw new Error(`Error, child ${childInstance} not found in ${this}`);
    } else {
      this.forceUpdates.push(this._children[(this._children as any[]).indexOf(childInstance)])
    }
  }

    if (!this.shouldUpdate(this.staleProps, props)) { return; }

    if (!this.shouldUpdate(this.staleProps, props)) {
      // update the chidlren that asked us to forcefully update them even though props didnt change
      let forceUpdates = [...this.forceUpdates];
      this.forceUpdates = [];
      for (let { instance, propsFactory } of forceUpdates) {
        instance._update(propsFactory(props, this.state)); // why are we even calling props factory here?? theres no point... we should just tell the child to use their own stale props, like this:
        // instance._forceUpdate();
      }
      // no need to do anything else -- stale props has not changed
      return;
    }

    this.tooltippableArea._update({
      hitArea: this.container.hitArea
    });

    this.tooltippableArea._update(this.tooltippableAreaPropsFactory(props, this.state));

import { ZLevelComponent } from "./ZLevelComponent";

import { ZLevelComponent, ZLevelComponentProps } from "./ZLevelComponent";

    markForceUpdate: (childInstance: any) => void,

  public zLevelPropsFactory: (p: Props, s: State) => ZLevelComponentProps;

  public _children: {childClass :any, instance: any, propsFactory: Function}[] = []
  public forceUpdates: {childClass :any, instance: any, propsFactory: Function}[] = []

    const childProps = {
      delta: 0,
      args: {
        pointNodeTexture: this.state.pointNodeTexture.get(),
      },
      z: this.state.playerCurrentZ,
      updaters: props.updaters,
      position: props.appSize.multiply(0.5),
      zLevelGen: props.gameState.worldGen.zLevels[this.state.playerCurrentZ],
      selectedPointNode: props.gameState.playerUI.selectedPointNode,
      allocatedPointNodeSubset: props.gameState.playerSave.allocatedPointNodeSet,
    };

    this.zLevelPropsFactory = (p: Props, s: State) => {
      return {
        delta: p.delta,
        args: {
          pointNodeTexture: this.state.pointNodeTexture.get(),
          markForceUpdate: this.markForceUpdate,
        },
        z: this.state.playerCurrentZ,
        updaters: props.updaters,
        position: props.appSize.multiply(0.5),
        zLevelGen: props.gameState.worldGen.zLevels[this.state.playerCurrentZ],
        selectedPointNode: props.gameState.playerUI.selectedPointNode,
        allocatedPointNodeSubset: props.gameState.playerSave.allocatedPointNodeSet,
      };
    }

      this.zLevel = new ZLevelComponent(childProps);

      this.zLevel = new ZLevelComponent(this.zLevelPropsFactory(props, this.state));

      this.zLevel.update(childProps);

      this.zLevel.update(this.zLevelPropsFactory(props, this.state));

  }
  /** callback passed to child - since child is not a pure component, it needs to inform us of updates if otherwise we wouldnt update */
  markForceUpdate = (childInstance: any) => {
    this.staleProps.args.markForceUpdate(this); // mark us for update in OUR parent
    if ((this._children as any[]).indexOf(childInstance) === -1) {
      throw new Error(`Error, child ${childInstance} not found in ${this}`);
    } else {
      this.forceUpdates.push(this._children[(this._children as any[]).indexOf(childInstance)])
    }

    const childProps = {
      delta: 0,
      args: {
        pointNodeTexture: this.state.pointNodeTexture.get(),
      },
      z: this.state.playerCurrentZ,
      updaters: props.updaters,
      position: props.appSize.multiply(0.5),
      zLevelGen: props.gameState.worldGen.zLevels[this.state.playerCurrentZ],
      selectedPointNode: props.gameState.playerUI.selectedPointNode,
      allocatedPointNodeSubset: props.gameState.playerSave.allocatedPointNodeSet,
    };

      this.zLevel = new ZLevelComponent(childProps);

      this.zLevel = new ZLevelComponent(this.zLevelPropsFactory(props, this.state));

      this.zLevel.update(childProps);

      this.zLevel.update(this.zLevelPropsFactory(props, this.state));

export type { exportedType as TooltippableAreaComponentType };

export type { exportedType as TooltippableAreaComponentType };
export type { Props as TooltippableAreaComponentProps };

    markForceUpdate: (childInstance: any) => void,

  public _children: {childClass :any, instance: any, propsFactory: Function}[] = []
  public forceUpdates: {childClass :any, instance: any, propsFactory: Function}[] = []

    this.updateChildren(props);

    this.upsertChildren(props);

  }
  /** callback passed to child - since child is not a pure component, it needs to inform us of updates if otherwise we wouldnt update */
  markForceUpdate = (childInstance: any) => {
    this.staleProps.args.markForceUpdate(this); // mark us for update in OUR parent
    if ((this._children as any[]).indexOf(childInstance) === -1) {
      throw new Error(`Error, child ${childInstance} not found in ${this}`);
    } else {
      this.forceUpdates.push(this._children[(this._children as any[]).indexOf(childInstance)])
    }

        markForceUpdate: this.markForceUpdate

  updateChildren(props: Props) {

  upsertChildren(props: Props) {

    console.log(`i have ${this.children.size()} children`)

    // console.log(`i have ${this.children.size()} children`)

    for (let [ref, childComponent] of childrenToDelete.entries()) {

    for (let [childKey, childComponent] of childrenToDelete.entries()) {

      this.children.remove(ref);

      this.children.remove(childKey);

    this.updateChildren(props);

    this.upsertChildren(props);

export type { Props as ZLevelComponentProps };