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

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

  const pointNodeGen = worldGen.zLevels[selectedPointNode.z]!.chunks.get(selectedPointNode.chunkCoord)!.pointNodes.get(selectedPointNode.pointNodeCoord)!

  let nodeDescription: string = "Nothing (empty node)";
  if (pointNodeGen.resourceType !== ResourceType.Nothing) {
    nodeDescription = `${pointNodeGen.resourceAmount} ${pointNodeGen.resourceModifier} ${pointNodeGen.resourceType}`
  }

      <h3>
        Chunk: {selectedPointNode.chunkCoord.x},{selectedPointNode.chunkCoord.y}
      </h3>
      <h3>X: {selectedPointNode.pointNodeCoord.x}</h3>
      <h3>Y: {selectedPointNode.pointNodeCoord.y}</h3>

      <div>
        Z: {selectedPointNode.z} . Chunk: {selectedPointNode.chunkCoord.x}, {selectedPointNode.chunkCoord.y} . Node: {selectedPointNode.pointNodeCoord.x}, {selectedPointNode.pointNodeCoord.y} .
      </div>
      <br></br>

      <br></br>
      <div> Stats: </div>
      <div> {nodeDescription} </div>

  id: number

  id: number;

  resourceType: ResourceType | null;
  resourceModifier: ResourceModifier;
  resourceAmount: number;
}
export enum ResourceType {
  Mana0 = "Mana0",
  Mana1 = "Mana1",
  Mana2 = "Mana2",
  Nothing = "Nothing"
}
export enum ResourceModifier {
  Flat = "Flat",
  Increased0 = "% increased",
  AfterIncreased0 = "added after % increased",
  Increased1 = "% increased multiplier",
  AfterIncreased1 = "added after % increased multiplier"

import { WorldGenState, ChunkGen, PointNodeGen, ChunkGenConstants, ZLevelGen } from "../data/GameState";

import { rm } from "fs";
import { WorldGenState, ChunkGen, PointNodeGen, ChunkGenConstants, ZLevelGen, ResourceType, ResourceModifier } from "../data/GameState";

  public pointNodeGenFactory: PointNodeGenFactory

    this.pointNodeGenFactory = new PointNodeGenFactory({});

          pointNodes.put(loc, { id: squirrel3(id + i * ChunkGenConstants.CHUNK_DIM + j)});

          pointNodes.put(loc, this.pointNodeGenFactory.create({ seed: id, location: loc }));

  }
}
type PointNodeGenConfig = {};
export class PointNodeGenFactory {
  public config: PointNodeGenConfig;
  constructor(config: PointNodeGenConfig) {
    this.config = config;
  }
  public create(args: { seed: number, location: Vector2 }): PointNodeGen {
    const id = squirrel3(args.seed + squirrel3(args.seed + args.location.x) + args.location.y);
    let randomFloat = squirrel3(id + 1) / INTMAX32;
    let resourceType: ResourceType;
    if (randomFloat < 0.0) {
      resourceType = ResourceType.Nothing;
    } else if (randomFloat < 0.20) {
      resourceType = ResourceType.Mana0;
    } else if (randomFloat < 0.35) {
      resourceType = ResourceType.Mana1;
    } else if (randomFloat < 0.60) {
      resourceType = ResourceType.Mana2;
    } else {
      resourceType = ResourceType.Nothing;
    }
    randomFloat = squirrel3(id + 2) / INTMAX32;
    let resourceModifier: ResourceModifier;
    if (randomFloat < 0.70) {
      resourceModifier = ResourceModifier.Flat;
    } else if (randomFloat < 0.73) {
      resourceModifier = ResourceModifier.AfterIncreased0;
    } else if (randomFloat < 0.75) {
      resourceModifier = ResourceModifier.AfterIncreased1;
    } else if (randomFloat < 0.95) {
      resourceModifier = ResourceModifier.Increased0;
    } else {
      resourceModifier = ResourceModifier.Increased1;
    }
    let resourceAmount = 0;
    if (resourceModifier === ResourceModifier.Flat ||
      resourceModifier === ResourceModifier.AfterIncreased0 ||
      resourceModifier === ResourceModifier.AfterIncreased1) {
      randomFloat = Math.floor(squirrel3(id + 3) / INTMAX32 * 4); // base is 20 ish?
      randomFloat += Math.floor(squirrel3(id + 4) / INTMAX32 * 4); // base is 20 ish?
      randomFloat += Math.floor(squirrel3(id + 5) / INTMAX32 * 4); // base is 20 ish?
      resourceAmount = randomFloat * 20 + 60;
    } else {
      randomFloat = Math.floor(squirrel3(id + 3) / INTMAX32 * 2); // base is 20 ish?
      randomFloat += Math.floor(squirrel3(id + 4) / INTMAX32 * 2); // base is 20 ish?
      randomFloat += Math.floor(squirrel3(id + 5) / INTMAX32 * 2); // base is 20 ish?
      randomFloat += Math.floor(squirrel3(id + 6) / INTMAX32 * 3); // base is 20 ish?
      resourceAmount = randomFloat + 3;
    }
    return {
      id,
      resourceAmount,
      resourceModifier,
      resourceType
    };

}
export function multiplyColor(color1: number, color2: number): number {
  let reds = [color1 & 0xFF0000, color2 & 0xFF0000];
  let blues = [color1 & 0x0000FF, color2 & 0x0000FF];
  let greens = [color1 & 0x00FF00, color2 & 0x00FF00];
  let out = Math.round(reds[0] / (0x010000) * reds[1] / (0xFFFFFF)) * 0x010000;
  out += Math.round(greens[0] / 0x000100 * greens[1] / 0x00FF00) * 0x000100;
  out += Math.round(blues[0] * blues[1] / 0x0000FF);
  return out;

        pointNodeGen,

        pointNodeGen,

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

import { ChunkGenConstants, GameState, PointNodeGen, PointNodeRef, ResourceType, WorldGenState } from "../../data/GameState";

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

  pointNodeGen: PointNodeGen,

type State = {
}

  state!: {};

  state!: State;
  public sprite!: Pixi.Sprite

    let tint: number;

      this.container.tint = 0x000000;

      tint = 0x444444;

        this.container.tint = 0xBBBBBB;

        tint = 0xBBBBBB;

        this.container.tint = 0xFFFFFF;

        tint = 0xFFFFFF;

    let baseColor: number = 0;
    switch (props.pointNodeGen.resourceType) {
      case ResourceType.Nothing:
        baseColor = 0x99bbff; // blue that mixes in with bg
        break;
      case ResourceType.Mana0:
        baseColor = 0xeeaaaa; // red
        break;
      case ResourceType.Mana1:
        baseColor = 0xbb7733; // brown?
        break;
      case ResourceType.Mana2:
        baseColor = 0x44aa44; // green
        break;
    }
    this.container.tint = multiplyColor(baseColor, tint);

    g.beginFill(0xff8080);

    g.beginFill(0xffffff);