ambersz/procgen-skill-tree - Change T46XFRUL5T6SFCNY34NJFKJXDO3UTN6RZFLBVTAQZ4XFUEFBHRLQC

deps

Created by Bowei Liu on October 12, 2020

T46XFRUL5T6SFCNY34NJFKJXDO3UTN6RZFLBVTAQZ4XFUEFBHRLQC

Dependencies

In channels

main

Change contents

Replacement in procgen-skill-tree/src/johnfn_library/base_game.ts at line 2 [3.125]

B:BD[3.182] → [2.0:474]

// import { Entity } from "./entity";
// import { Debug } from "./debug";
// import { HashSet } from "./data_structures/hash";
// import { TypesafeLoader, AllResourcesType } from "./typesafe_loader";
// import { CreateGame as ReactMountGame } from "./react/react_root";
// import { Camera } from "./camera";
// import { DebugFlagsType } from "./react/debug_flag_buttons";
// import { CollisionHandler } from "./collision_handler";
// import { Rect } from "./geometry/rect";

[3.182]

[2.474]

import { Entity } from "./entity";
import { Debug } from "./debug";
import { HashSet } from "./data_structures/hash";
import { TypesafeLoader, AllResourcesType } from "./typesafe_loader";
import { CreateGame as ReactMountGame } from "./react/react_root";
import { Camera } from "./camera";
import { DebugFlagsType } from "./react/debug_flag_buttons";
import { CollisionHandler } from "./collision_handler";
import { Rect } from "./geometry/rect";

Replacement in procgen-skill-tree/src/johnfn_library/base_game.ts at line 12 [3.125]

B:BD[2.533] → [2.533:6259]

// import { IGameState } from 'Library';
// import { BaseGameState } from "./base_state";
// 
// export let GameReference: BaseGame<any>;
// 
// export type GameArgs = {
//   scale: number;
//   canvasWidth: number;
//   canvasHeight: number;
//   tileHeight: number;
//   tileWidth: number;
//   debugFlags: DebugFlagsType;
//   state: Omit<IGameState, keyof BaseGameState>;
//   assets: TypesafeLoader<any>;
// };
// 
// export const StageName = "Stage";
// export const FixedStageName = "FixedStage";
// export const ParallaxStageName = "ParallaxStage";
// 
// export class BaseGame<TResources extends AllResourcesType = {}> {
//   app: PIXI.Application;
// 
//   state: IGameState;
// 
//   /** 
//    * The root of the display hierarchy for the game. Everything that exists in
//    * the game that isn't fixed as the camera moves should be under this.
//    */
//   stage: Entity;
// 
//   parallaxStage: Entity;
// 
//   /**
//    * A stage for things in the game that don't move when the camera move and are
//    * instead fixed to the screen. For example, the HUD.
//    */
//   fixedCameraStage: Entity;
// 
//   private assets: TypesafeLoader<TResources>;
// 
//   renderer: Renderer;
// 
//   camera: Camera;
// 
//   collisionHandler: CollisionHandler;
// 
//   coroutineManager: CoroutineManager;
// 
//   constructor(props: GameArgs) {
//     GameReference = this;
// 
//     this.coroutineManager = new CoroutineManager(this);
//     this.state = {
//       ...(new BaseGameState()),
//       ...props.state,
//     }
// 
//     const view = document.getElementById('canvas');
// 
//     if (!view) {
//       throw new Error("I couldn't find an element named #canvas on initialization. Giving up!")
//     }
// 
//     this.collisionHandler = new CollisionHandler({
//       canvasWidth: props.canvasWidth / props.scale,
//       canvasHeight: props.canvasHeight / props.scale,
//       tileHeight: props.tileHeight,
//       tileWidth: props.tileWidth,
//     });
// 
//     this.app = new Application({
//       width: props.canvasWidth,
//       height: props.canvasHeight,
//       powerPreference: "low-power",
//       antialias: false,
//       transparent: false,
//       resolution: window.devicePixelRatio,
//       autoDensity: true,
//       backgroundColor: 0x4e5759,
//       view: view as HTMLCanvasElement,
//     });
// 
//     this.app.stage.scale = new Point(props.scale, props.scale);
// 
//     this.parallaxStage = new Entity({ name: ParallaxStageName });
//     this.stage = new Entity({ name: StageName });
//     this.fixedCameraStage = new Entity({ name: FixedStageName });
// 
//     this.state.stage = this.stage;
// 
//     this.app.stage.addChild(this.parallaxStage.sprite);
//     this.app.stage.addChild(this.stage.sprite);
//     this.app.stage.addChild(this.fixedCameraStage.sprite);
// 
//     this.state.renderer = this.app.renderer;
//     this.state.stage = this.stage;
// 
//     this.assets = props.assets;
//     this.assets.onLoadComplete(() => this.startGameLoop());
//     this.assets.onLoadComplete(() => this.initialize());
// 
//     this.renderer = this.app.renderer;
// 
//     this.camera = new Camera({
//       stage: this.stage,
//       state: this.state,
//       canvasWidth: props.canvasWidth,
//       canvasHeight: props.canvasHeight,
//       scale: props.scale,
//       bounds: new Rect({ x: -5000, y: -5000, width: 10000, height: 10000 }),
//     });
// 
//     this.state.camera = this.camera;
// 
//     ReactMountGame(this, props.debugFlags);
// 
//     this.stage.sprite.sortableChildren = true;
//     this.fixedCameraStage.sprite.sortableChildren = true;
//   }
// 
//   /**
//    * Called after resources are finished loading.
//    */
//   initialize() {
// 
//   }
// 
//   startGameLoop = () => {
//     this.app.ticker.add(() => this.gameLoop());
//   };
// 
//   gameLoop() {
//     Debug.Clear();
// 
//     const { entities } = this.state;
// 
//     if (!this.state.lastCollisionGrid) {
//       const grid = this.collisionHandler.buildCollisionGrid({
//         bounds: new Rect({ x: 0, y: 0, width: 5000, height: 5000 }),
//         entities: this.state.entities,
//       });
// 
//       this.state.lastCollisionGrid = grid;
//     }
// 
//     this.state.tick++;
// 
//     this.state.keys.update();
// 
//     for (const entity of entities.values()) {
//       entity.baseUpdate(this.state);
//     }
// 
//     this.state.entities = new HashSet(entities.values().filter(ent => !this.state.toBeDestroyed.includes(ent)));
// 
//     for (const entity of this.state.toBeDestroyed) {
//       if (entity.sprite.parent) {
//         entity.sprite.parent.removeChild(entity.sprite);
//       }
// 
//       this.coroutineManager.stopCoroutinesOwnedBy(entity);
//     }
// 
//     this.state.toBeDestroyed = [];
// 
//     const activeEntities = new HashSet(this.state.entities.values().filter(e => e.activeModes.includes(this.state.mode)));
// 
//     const grid = this.collisionHandler.buildCollisionGrid({
//       bounds: this.camera.getBounds(),
//       entities: activeEntities,
//     });
// 
//     this.state.lastCollisionGrid = grid;
// 
//     this.collisionHandler.resolveCollisions({
//       entities: activeEntities,
//       grid: grid,
//     });
// 
//     this.camera.update(this.state);
// 
//     this.coroutineManager.updateCoroutines(this.state);
// 
//     // let foo = Debug.GetDrawnObjects();
// 
//     // for (const f of Debug.GetDrawnObjects()) {
//     //   if (f instanceof AugmentedSprite) {
//     //     if (f.width > 1024) { 
//     //       f.visible = false; 
//     //     }
//     //   }
//     // }
// 
//     // let foo = Debug.GetDrawn();
// 
//     Debug.ResetDrawCount();
//   };
// }

[2.533]

import { IGameState } from 'Library';
import { BaseGameState } from "./base_state";
export let GameReference: BaseGame<any>;
export type GameArgs = {
  scale: number;
  canvasWidth: number;
  canvasHeight: number;
  tileHeight: number;
  tileWidth: number;
  debugFlags: DebugFlagsType;
  state: Omit<IGameState, keyof BaseGameState>;
  assets: TypesafeLoader<any>;
};
export const StageName = "Stage";
export const FixedStageName = "FixedStage";
export const ParallaxStageName = "ParallaxStage";
export class BaseGame<TResources extends AllResourcesType = {}> {
  app: PIXI.Application;
  state: IGameState;
  /** 
   * The root of the display hierarchy for the game. Everything that exists in
   * the game that isn't fixed as the camera moves should be under this.
   */
  stage: Entity;
  parallaxStage: Entity;
  /**
   * A stage for things in the game that don't move when the camera move and are
   * instead fixed to the screen. For example, the HUD.
   */
  fixedCameraStage: Entity;
  private assets: TypesafeLoader<TResources>;
  renderer: Renderer;
  camera: Camera;
  collisionHandler: CollisionHandler;
  // coroutineManager: CoroutineManager;
  constructor(props: GameArgs) {
    GameReference = this;
    // this.coroutineManager = new CoroutineManager(this);
    this.state = {
      ...(new BaseGameState()),
      ...props.state,
    }
    const view = document.getElementById('canvas');
    if (!view) {
      throw new Error("I couldn't find an element named #canvas on initialization. Giving up!")
    }
    this.collisionHandler = new CollisionHandler({
      canvasWidth: props.canvasWidth / props.scale,
      canvasHeight: props.canvasHeight / props.scale,
      tileHeight: props.tileHeight,
      tileWidth: props.tileWidth,
    });
    this.app = new Application({
      width: props.canvasWidth,
      height: props.canvasHeight,
      powerPreference: "low-power",
      antialias: false,
      transparent: false,
      resolution: window.devicePixelRatio,
      autoDensity: true,
      backgroundColor: 0x4e5759,
      view: view as HTMLCanvasElement,
    });
    this.app.stage.scale = new Point(props.scale, props.scale);
    this.parallaxStage = new Entity({ name: ParallaxStageName });
    this.stage = new Entity({ name: StageName });
    this.fixedCameraStage = new Entity({ name: FixedStageName });
    this.state.stage = this.stage;
    this.app.stage.addChild(this.parallaxStage.sprite);
    this.app.stage.addChild(this.stage.sprite);
    this.app.stage.addChild(this.fixedCameraStage.sprite);
    this.state.renderer = this.app.renderer;
    this.state.stage = this.stage;
    this.assets = props.assets;
    this.assets.onLoadComplete(() => this.startGameLoop());
    this.assets.onLoadComplete(() => this.initialize());
    this.renderer = this.app.renderer;
    this.camera = new Camera({
      stage: this.stage,
      state: this.state,
      canvasWidth: props.canvasWidth,
      canvasHeight: props.canvasHeight,
      scale: props.scale,
      bounds: new Rect({ x: -5000, y: -5000, width: 10000, height: 10000 }),
    });
    this.state.camera = this.camera;
    ReactMountGame(this, props.debugFlags);
    this.stage.sprite.sortableChildren = true;
    this.fixedCameraStage.sprite.sortableChildren = true;
  }
  /**
   * Called after resources are finished loading.
   */
  initialize() {
  }
  startGameLoop = () => {
    this.app.ticker.add(() => this.gameLoop());
  };
  gameLoop() {
    Debug.Clear();
    const { entities } = this.state;
    if (!this.state.lastCollisionGrid) {
      const grid = this.collisionHandler.buildCollisionGrid({
        bounds: new Rect({ x: 0, y: 0, width: 5000, height: 5000 }),
        entities: this.state.entities,
      });
      this.state.lastCollisionGrid = grid;
    }
    this.state.tick++;
    this.state.keys.update();
    for (const entity of entities.values()) {
      entity.baseUpdate(this.state);
    }
    this.state.entities = new HashSet(entities.values().filter(ent => !this.state.toBeDestroyed.includes(ent)));
    for (const entity of this.state.toBeDestroyed) {
      if (entity.sprite.parent) {
        entity.sprite.parent.removeChild(entity.sprite);
      }
      // this.coroutineManager.stopCoroutinesOwnedBy(entity);
    }
    this.state.toBeDestroyed = [];
    const activeEntities = new HashSet(this.state.entities.values().filter(e => e.activeModes.includes(this.state.mode)));
    const grid = this.collisionHandler.buildCollisionGrid({
      bounds: this.camera.getBounds(),
      entities: activeEntities,
    });
    this.state.lastCollisionGrid = grid;
    this.collisionHandler.resolveCollisions({
      entities: activeEntities,
      grid: grid,
    });
    this.camera.update(this.state);
    // this.coroutineManager.updateCoroutines(this.state);
    // let foo = Debug.GetDrawnObjects();
    // for (const f of Debug.GetDrawnObjects()) {
    //   if (f instanceof AugmentedSprite) {
    //     if (f.width > 1024) { 
    //       f.visible = false; 
    //     }
    //   }
    // }
    // let foo = Debug.GetDrawn();
    Debug.ResetDrawCount();
  };
}

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 35 [3.14628]

B:BD[3.15530] → [3.15530:15621]

  constructor(props: {
    width: number;
    height: number;
    cellSize: number;
  }) {

[3.15530]

[3.15621]

  constructor(props: { width: number; height: number; cellSize: number }) {

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 45 [3.14628]

B:BD[3.15867] → [3.15867:16007]

    this._cells = new DefaultGrid<Cell>((x, y) => new Cell(
      new Vector2({ x: x * cellSize, y: y * cellSize }),
      cellSize
    ));

[3.15867]

[3.16007]

    this._cells = new DefaultGrid<Cell>(
      (x, y) =>
        new Cell(new Vector2({ x: x * cellSize, y: y * cellSize }), cellSize)
    );

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 56 [3.14628]

B:BD[3.16118] → [3.16118:16323]

        Debug.DrawRect(new Rect({
          x: x * this._cellSize,
          y: y * this._cellSize,
          width: this._cellSize,
          height: this._cellSize,
        }), 0xff0000, true, "fixed");

[3.16118]

[3.16323]

        Debug.DrawRect(
          new Rect({
            x: x * this._cellSize,
            y: y * this._cellSize,
            width: this._cellSize,
            height: this._cellSize,
          }),
          0xff0000,
          true,
          "fixed"
        );

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 80 [3.14628]

B:BD[3.16556] → [3.16556:16631]

    return this._position.add({ x: this._width / 2, y: this._height / 2 })

[3.16556]

[3.16631]

    return this._position.add({ x: this._width / 2, y: this._height / 2 });

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 83 [3.14628]
B:BD[3.16636] → [3.16636:16643]
```
  /** 
```
[3.16636]
[3.16643]
```
  /**
```

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 88 [3.14628]

B:BD[3.16847] → [3.16847:16931]

  getRectCollisions = (rect: Rect, skipEntity?: Entity): CollisionResultRect[] => {

[3.16847]

[3.16931]

  getRectCollisions = (
    rect: Rect,
    skipEntity?: Entity
  ): CollisionResultRect[] => {

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 133 [3.14628]

B:BD[3.17932] → [3.17932:18023]

  getRectGroupCollisions = (group: RectGroup, entity?: Entity): CollisionResultRect[] => {

[3.17932]

[3.18023]

  getRectGroupCollisions = (
    group: RectGroup,
    entity?: Entity
  ): CollisionResultRect[] => {

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 140 [3.14628]

B:BD[3.18115] → [3.18115:18217]

      collisions = [
        ...collisions,
        ...this.getRectCollisions(rect, entity),
      ];

[3.18115]

[3.18217]

      collisions = [...collisions, ...this.getRectCollisions(rect, entity)];

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 144 [3.14628]
B:BD[3.18247] → [3.18247:18251]
```
  }
```
[3.18247]
[3.18251]
```
  };
```
Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 146 [3.14628]
B:BD[3.18252] → [3.18252:18259]
```
  /** 
```
[3.18252]
[3.18259]
```
  /**
```

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 151 [3.14628]

B:BD[3.18448] → [3.18448:18603]

    const cells = corners.map(corner => this._cells.get(
      Math.floor(corner.x / this._cellSize),
      Math.floor(corner.y / this._cellSize),
    ));

[3.18448]

[3.18603]

    const cells = corners.map((corner) =>
      this._cells.get(
        Math.floor(corner.x / this._cellSize),
        Math.floor(corner.y / this._cellSize)
      )
    );

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 183 [3.14628]

B:BD[3.19117] → [3.19117:19200]

  collidesPoint = (point: Vector2, takeFirst = false): CollisionResultPoint[] => {

[3.19117]

[3.19200]

  collidesPoint = (
    point: Vector2,
    takeFirst = false
  ): CollisionResultPoint[] => {

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 189 [3.14628]
B:BD[3.19278] → [3.19278:19322]
```
      Math.floor(point.y / this._cellSize),
```
[3.19278]
[3.19322]
```
      Math.floor(point.y / this._cellSize)
```

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 232 [3.14628]

B:BD[3.20263] → [3.20263:20349]

          const intersection = collider1.rect.getIntersection(collider2.rect, false);

[3.20263]

[3.20349]

          const intersection = collider1.rect.getIntersection(
            collider2.rect,
            false
          );

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 244 [3.14628]
B:BD[3.20629] → [3.20629:20644]
```
            })
```
[3.20629]
[3.20644]
```
            });
```
Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 251 [3.14628]
B:BD[3.20700] → [3.20700:20704]
```
  }
```
[3.20700]
[3.20704]
```
  };
```
Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 282 [3.14628]
B:BD[3.21595] → [3.21595:21599]
```
  }
```
[3.21595]
[3.21599]
```
  };
```
Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 313 [3.14628]
B:BD[3.22115] → [3.22115:22116]
```
}
```
[3.22115]
```
}
```

Replacement in procgen-skill-tree/src/johnfn_library/debug.ts at line 2 [3.35148]

B:BD[3.35205] → [2.9655:18979]

// import { Graphics, Sprite, Container } from "pixi.js";
// import { Line } from "./geometry/line";
// import { Entity } from "./entity";
// import { Rect } from "./geometry/rect";
// import { RectGroup } from "./geometry/rect_group";
// import { GameReference } from "./base_game";
// import { BaseGameState } from "./base_state";
// import { IS_DEBUG, IS_PRODUCTION } from "./environment";
// 
// const MAX_DEBUGGING_GRAPHICS_COUNT = 500;
// 
// export class Debug {
//   public static stageReference: Entity;
// 
//   public static DebugMode = false;
// 
//   public static DebugGraphicStack: Graphics[] = [];
// 
//   public static Clear(): void {
//     for (const debug of Debug.DebugGraphicStack) {
//       debug.parent.removeChild(debug);
//       debug.destroy();
//     }
// 
//     Debug.DebugGraphicStack = [];
//   }
// 
//   /** 
//    * Draw a point on the canvas.
//    * 
//    * We expect this function to be called every tick in an update() function.
//    * Debug graphics drawn in the previous tick are removed in the game loop. 
//    * If that's not what you want, pass persistent = true.
//    */
//   public static DrawPoint(point: IVector2, color = 0xff0000, persistent = false): Graphics {
//     if (IS_PRODUCTION) {
//       console.error("SHOULD NOT HAPPEN")
//     }
// 
//     const graphics = new Graphics();
// 
//     new Line({
//       x1: point.x - 40,
//       x2: point.x + 40,
// 
//       y1: point.y - 40,
//       y2: point.y + 40,
//     }).drawOnto(graphics, color);
// 
//     new Line({
//       x1: point.x + 40,
//       x2: point.x - 40,
// 
//       y1: point.y - 40,
//       y2: point.y + 40,
//     }).drawOnto(graphics, color);
// 
//     GameReference.stage.sprite.addChild(graphics);
// 
//     if (!persistent) {
//       this.DebugGraphicStack.push(graphics);
// 
//       if (this.DebugGraphicStack.length > MAX_DEBUGGING_GRAPHICS_COUNT) {
//         const toBeRemoved = this.DebugGraphicStack.shift()!;
// 
//         toBeRemoved.parent.removeChild(toBeRemoved);
//         toBeRemoved.destroy();
//       }
//     }
// 
//     return graphics;
//   }
// 
//   /** 
//    * Draw a line from start to end on the canvas, for debugging.
//    * 
//    * We expect this function to be called every tick in an update() function.
//    * Debug graphics drawn in the previous tick are removed in the game loop.
//    * 
//    * If that's not what you want, pass persistent = true.
//    */
//   public static DrawLineV2(start: Vector2, end: Vector2, color = 0xff0000, persistent = false): Graphics {
//     if (IS_PRODUCTION) {
//       console.error("SHOULD NOT HAPPEN")
//     }
// 
//     return Debug.DrawLine(new Line({ start, end }), color, persistent);
//   }
// 
//   /** 
//    * Draw a line on the canvas, for debugging.
//    * 
//    * We expect this function to be called every tick in an update() function.
//    * Debug graphics drawn in the previous tick are removed in the game loop.
//    * 
//    * If that's not what you want, pass persistent = true.
//    */
//   public static DrawLine(line: Line, color = 0xff0000, persistent = false, target: "stage" | "fixed" = "fixed"): Graphics {
//     if (IS_PRODUCTION) {
//       console.error("SHOULD NOT HAPPEN")
//     }
// 
//     const graphics = new Graphics();
// 
//     line.drawOnto(graphics, color);
// 
//     if (target === "fixed") {
//       GameReference.fixedCameraStage.sprite.addChild(graphics);
//     } else {
//       GameReference.stage.sprite.addChild(graphics);
//     }
// 
//     if (!persistent) {
//       this.DebugGraphicStack.push(graphics);
// 
//       if (this.DebugGraphicStack.length > MAX_DEBUGGING_GRAPHICS_COUNT) {
//         const toBeRemoved = this.DebugGraphicStack.shift()!;
// 
//         toBeRemoved.parent.removeChild(toBeRemoved);
//         toBeRemoved.destroy();
//       }
//     }
// 
//     return graphics;
//   }
// 
//   /** 
//    * Draw a rectangle from start to end on the canvas, for debugging.
//    * 
//    * We expect this function to be called every tick in an update() function.
//    * Debug graphics drawn in the previous tick are removed in the game loop.
//    * 
//    * If that's not what you want, pass persistent = true.
//    */
//   public static DrawRect(rect: Rect, color = 0xff0000, persistent = false, target: "stage" | "fixed" = "fixed"): Graphics[] {
//     if (IS_PRODUCTION) {
//       console.error("SHOULD NOT HAPPEN")
//     }
// 
//     const lines: Graphics[] = [];
// 
//     for (const line of rect.getLinesFromRect()) {
//       lines.push(Debug.DrawLine(line, color, persistent, target));
//     }
// 
//     return lines;
//   }
// 
//   /** 
//    * Draw the bounds of a game object on the canvas, for debugging.
//    * 
//    * We expect this function to be called every tick in an update() function.
//    * Debug graphics drawn in the previous tick are removed in the game loop.
//    * 
//    * If that's not what you want, pass persistent = true.
//    */
//   public static DrawBounds(
//     entity: Entity | Sprite | Graphics | RectGroup | Container | Rect, 
//     color = 0xff0000, 
//     persistent = false,
//     target: "stage" | "fixed" = "stage"
//   ): Graphics[] {
//     if (IS_PRODUCTION) {
//       console.error("SHOULD NOT HAPPEN")
//     }
// 
//     if (entity instanceof Entity) {
//       entity = entity.collisionBounds()
//         .add(entity.positionAbsolute())
//         ;
//     } 
//     
//     if (entity instanceof RectGroup) {
//       const results: Graphics[] = [];
// 
//       for (const rect of entity.getRects()) {
//         const lines = Debug.DrawRect(rect, color, persistent, target);
// 
//         for (const line of lines) {
//           results.push(line);
//         }
//       }
// 
//       return results;
//     } else {
//       return Debug.DrawRect(new Rect({
//         x     : entity.x,
//         y     : entity.y,
//         width : entity.width,
//         height: entity.height,
//       }), color, persistent, target);
//     }
//   }
// 
//   private static profiles: { [key: string]: number[] } = {};
// 
//   /**
//    * Performance test a block of code.
//    */
//   public static Profile(name: string, cb: () => void): void {
//     Debug.profiles[name] = Debug.profiles[name] || [];
// 
//     const start = window.performance.now();
// 
//     cb(); 
// 
//     const end = window.performance.now();
// 
//     Debug.profiles[name].push(end - start);
// 
//     if (Debug.profiles[name].length === 60) {
//       const average = Debug.profiles[name].reduce((a, b) => a + b) / 60;
//       const rounded = Math.floor(average * 100) / 100;
// 
//       Debug.profiles[name] = [];
// 
//       console.log(`${ name }: ${ rounded }ms`);
//     }
//   }
// 
//   static ResetDrawCount() {
//     (Sprite as any).drawCount = 0;
//     (Container as any).drawCount = 0;
//     drawn = [];
//   }
// 
//   static GetDrawnObjects() {
//     return drawn;
//   }
// 
//   static GetDrawCount() {
//     return (
//       (Sprite as any).drawCount + 
//       (Container as any).drawCount
//     );
//   }
// 
//   public static DebugStuff(state: BaseGameState) {
//     if (state.keys.justDown.Z) {
//       Debug.DebugMode = true;
// 
//       state.stage.x = 0;
//       state.stage.y = 0;
// 
//       if (state.stage.scale.x === 0.2) {
//         state.stage.scale = new Vector2({ x: 1, y: 1 });
//       } else {
//         state.stage.scale = new Vector2({ x: 0.2, y: 0.2 });
//       }
//     }
// 
//     if (Debug.DebugMode) {
//       if (state.keys.down.W) {
//         state.stage.y += 20;
//       }
// 
//       if (state.keys.down.S) {
//         state.stage.y -= 20;
//       }
// 
//       if (state.keys.down.D) {
//         state.stage.x -= 20;
//       }
// 
//       if (state.keys.down.A) {
//         state.stage.x += 20;
//       }
//     }
//   }
// 
//   public static DebugShowRect(state: BaseGameState, rect: Rect) {
//     state.stage.scale = new Vector2({ x: 0.2, y: 0.2 });
//     state.stage.x = -rect.x * 0.2;
//     state.stage.y = -rect.y * 0.2;
//   }
// }
// 
// let drawn: any[] = [];
// 
// if (IS_DEBUG) {
//   (Sprite as any).drawCount = 0;
// 
//   (Sprite.prototype as any).__render = (Sprite.prototype as any)._render;
//   (Sprite.prototype as any)._render = function (renderer: any) {
//     (Sprite as any).drawCount++;
//     this.__render(renderer);
//     drawn.push(this);
//   };
// 
// 
//   (Sprite.prototype as any).__renderCanvas = (Sprite.prototype as any)._renderCanvas;
//   (Sprite.prototype as any)._renderCanvas = function (renderer: any) {
//     (Sprite as any).drawCount++;
//     this.__renderCanvas(renderer);
//     drawn.push(this);
//   };
// 
// 
//   // PIXI.Container
// 
//   (Container as any).drawCount = 0;
// 
//   (Container.prototype as any).__render = (Container.prototype as any)._render;
//   (Container.prototype as any)._render = function (renderer: any) {
//     (Container as any).drawCount++;
//     this.__render(renderer);
//     drawn.push(this);
//   };
// 
// 
//   (Container.prototype as any).__renderCanvas = (Container.prototype as any)._renderCanvas;
//   (Container.prototype as any)._renderCanvas = function (renderer: any) {
//     (Container as any).drawCount++;
//     this.__renderCanvas(renderer);
//     drawn.push(this);
//   };
// }

[3.35205]

import { Graphics, Sprite, Container } from "pixi.js";
import { Line } from "./geometry/line";
import { Entity } from "./entity";
import { Rect } from "./geometry/rect";
import { RectGroup } from "./geometry/rect_group";
import { GameReference } from "./base_game";
import { BaseGameState } from "./base_state";
import { IS_DEBUG, IS_PRODUCTION } from "./environment";
const MAX_DEBUGGING_GRAPHICS_COUNT = 500;
export class Debug {
  public static stageReference: Entity;
  public static DebugMode = false;
  public static DebugGraphicStack: Graphics[] = [];
  public static Clear(): void {
    for (const debug of Debug.DebugGraphicStack) {
      debug.parent.removeChild(debug);
      debug.destroy();
    }
    Debug.DebugGraphicStack = [];
  }
  /** 
   * Draw a point on the canvas.
   * 
   * We expect this function to be called every tick in an update() function.
   * Debug graphics drawn in the previous tick are removed in the game loop. 
   * If that's not what you want, pass persistent = true.
   */
  public static DrawPoint(point: IVector2, color = 0xff0000, persistent = false): Graphics {
    if (IS_PRODUCTION) {
      console.error("SHOULD NOT HAPPEN")
    }
    const graphics = new Graphics();
    new Line({
      x1: point.x - 40,
      x2: point.x + 40,
      y1: point.y - 40,
      y2: point.y + 40,
    }).drawOnto(graphics, color);
    new Line({
      x1: point.x + 40,
      x2: point.x - 40,
      y1: point.y - 40,
      y2: point.y + 40,
    }).drawOnto(graphics, color);
    GameReference.stage.sprite.addChild(graphics);
    if (!persistent) {
      this.DebugGraphicStack.push(graphics);
      if (this.DebugGraphicStack.length > MAX_DEBUGGING_GRAPHICS_COUNT) {
        const toBeRemoved = this.DebugGraphicStack.shift()!;
        toBeRemoved.parent.removeChild(toBeRemoved);
        toBeRemoved.destroy();
      }
    }
    return graphics;
  }
  /** 
   * Draw a line from start to end on the canvas, for debugging.
   * 
   * We expect this function to be called every tick in an update() function.
   * Debug graphics drawn in the previous tick are removed in the game loop.
   * 
   * If that's not what you want, pass persistent = true.
   */
  public static DrawLineV2(start: Vector2, end: Vector2, color = 0xff0000, persistent = false): Graphics {
    if (IS_PRODUCTION) {
      console.error("SHOULD NOT HAPPEN")
    }
    return Debug.DrawLine(new Line({ start, end }), color, persistent);
  }
  /** 
   * Draw a line on the canvas, for debugging.
   * 
   * We expect this function to be called every tick in an update() function.
   * Debug graphics drawn in the previous tick are removed in the game loop.
   * 
   * If that's not what you want, pass persistent = true.
   */
  public static DrawLine(line: Line, color = 0xff0000, persistent = false, target: "stage" | "fixed" = "fixed"): Graphics {
    if (IS_PRODUCTION) {
      console.error("SHOULD NOT HAPPEN")
    }
    const graphics = new Graphics();
    line.drawOnto(graphics, color);
    if (target === "fixed") {
      GameReference.fixedCameraStage.sprite.addChild(graphics);
    } else {
      GameReference.stage.sprite.addChild(graphics);
    }
    if (!persistent) {
      this.DebugGraphicStack.push(graphics);
      if (this.DebugGraphicStack.length > MAX_DEBUGGING_GRAPHICS_COUNT) {
        const toBeRemoved = this.DebugGraphicStack.shift()!;
        toBeRemoved.parent.removeChild(toBeRemoved);
        toBeRemoved.destroy();
      }
    }
    return graphics;
  }
  /** 
   * Draw a rectangle from start to end on the canvas, for debugging.
   * 
   * We expect this function to be called every tick in an update() function.
   * Debug graphics drawn in the previous tick are removed in the game loop.
   * 
   * If that's not what you want, pass persistent = true.
   */
  public static DrawRect(rect: Rect, color = 0xff0000, persistent = false, target: "stage" | "fixed" = "fixed"): Graphics[] {
    if (IS_PRODUCTION) {
      console.error("SHOULD NOT HAPPEN")
    }
    const lines: Graphics[] = [];
    for (const line of rect.getLinesFromRect()) {
      lines.push(Debug.DrawLine(line, color, persistent, target));
    }
    return lines;
  }
  /** 
   * Draw the bounds of a game object on the canvas, for debugging.
   * 
   * We expect this function to be called every tick in an update() function.
   * Debug graphics drawn in the previous tick are removed in the game loop.
   * 
   * If that's not what you want, pass persistent = true.
   */
  public static DrawBounds(
    entity: Entity | Sprite | Graphics | RectGroup | Container | Rect, 
    color = 0xff0000, 
    persistent = false,
    target: "stage" | "fixed" = "stage"
  ): Graphics[] {
    if (IS_PRODUCTION) {
      console.error("SHOULD NOT HAPPEN")
    }
    if (entity instanceof Entity) {
      entity = entity.collisionBounds()
        .add(entity.positionAbsolute())
        ;
    } 
    
    if (entity instanceof RectGroup) {
      const results: Graphics[] = [];
      for (const rect of entity.getRects()) {
        const lines = Debug.DrawRect(rect, color, persistent, target);
        for (const line of lines) {
          results.push(line);
        }
      }
      return results;
    } else {
      return Debug.DrawRect(new Rect({
        x     : entity.x,
        y     : entity.y,
        width : entity.width,
        height: entity.height,
      }), color, persistent, target);
    }
  }
  private static profiles: { [key: string]: number[] } = {};
  /**
   * Performance test a block of code.
   */
  public static Profile(name: string, cb: () => void): void {
    Debug.profiles[name] = Debug.profiles[name] || [];
    const start = window.performance.now();
    cb(); 
    const end = window.performance.now();
    Debug.profiles[name].push(end - start);
    if (Debug.profiles[name].length === 60) {
      const average = Debug.profiles[name].reduce((a, b) => a + b) / 60;
      const rounded = Math.floor(average * 100) / 100;
      Debug.profiles[name] = [];
      console.log(`${ name }: ${ rounded }ms`);
    }
  }
  static ResetDrawCount() {
    (Sprite as any).drawCount = 0;
    (Container as any).drawCount = 0;
    drawn = [];
  }
  static GetDrawnObjects() {
    return drawn;
  }
  static GetDrawCount() {
    return (
      (Sprite as any).drawCount + 
      (Container as any).drawCount
    );
  }
  public static DebugStuff(state: BaseGameState) {
    if (state.keys.justDown.Z) {
      Debug.DebugMode = true;
      state.stage.x = 0;
      state.stage.y = 0;
      if (state.stage.scale.x === 0.2) {
        state.stage.scale = new Vector2({ x: 1, y: 1 });
      } else {
        state.stage.scale = new Vector2({ x: 0.2, y: 0.2 });
      }
    }
    if (Debug.DebugMode) {
      if (state.keys.down.W) {
        state.stage.y += 20;
      }
      if (state.keys.down.S) {
        state.stage.y -= 20;
      }
      if (state.keys.down.D) {
        state.stage.x -= 20;
      }
      if (state.keys.down.A) {
        state.stage.x += 20;
      }
    }
  }
  public static DebugShowRect(state: BaseGameState, rect: Rect) {
    state.stage.scale = new Vector2({ x: 0.2, y: 0.2 });
    state.stage.x = -rect.x * 0.2;
    state.stage.y = -rect.y * 0.2;
  }
}
let drawn: any[] = [];
if (IS_DEBUG) {
  (Sprite as any).drawCount = 0;
  (Sprite.prototype as any).__render = (Sprite.prototype as any)._render;
  (Sprite.prototype as any)._render = function (renderer: any) {
    (Sprite as any).drawCount++;
    this.__render(renderer);
    drawn.push(this);
  };
  (Sprite.prototype as any).__renderCanvas = (Sprite.prototype as any)._renderCanvas;
  (Sprite.prototype as any)._renderCanvas = function (renderer: any) {
    (Sprite as any).drawCount++;
    this.__renderCanvas(renderer);
    drawn.push(this);
  };
  // PIXI.Container
  (Container as any).drawCount = 0;
  (Container.prototype as any).__render = (Container.prototype as any)._render;
  (Container.prototype as any)._render = function (renderer: any) {
    (Container as any).drawCount++;
    this.__render(renderer);
    drawn.push(this);
  };
  (Container.prototype as any).__renderCanvas = (Container.prototype as any)._renderCanvas;
  (Container.prototype as any)._renderCanvas = function (renderer: any) {
    (Container as any).drawCount++;
    this.__renderCanvas(renderer);
    drawn.push(this);
  };
}

Replacement in procgen-skill-tree/src/johnfn_library/react/hierarchy.tsx at line 7 [3.181974]
B:BD[3.182158] → [3.182158:182205]
```
import { DebugFlags } from '../../game/debug';
```
[3.182158]
[3.182205]
```
// import { DebugFlags } from '../../game/debug';
```

deps

Dependencies

In channels

Change contents

Replacement in procgen-skill-tree/src/johnfn_library/base_game.ts at line 2 [3.125]

Replacement in procgen-skill-tree/src/johnfn_library/base_game.ts at line 12 [3.125]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 35 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 45 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 56 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 80 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 83 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 88 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 133 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 140 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 144 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 146 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 151 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 183 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 189 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 232 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 244 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 251 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 282 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/collision_grid.ts at line 313 [3.14628]

Replacement in procgen-skill-tree/src/johnfn_library/debug.ts at line 2 [3.35148]

Replacement in procgen-skill-tree/src/johnfn_library/react/hierarchy.tsx at line 7 [3.181974]