ambersz/procgen-skill-tree - Change SJGRJWVRMIYRCSQUR4LMS2APZNSJ64JAW7647NYTB52REONXVD2QC

neighbors

Created by Bowei Liu on December 24, 2020

SJGRJWVRMIYRCSQUR4LMS2APZNSJ64JAW7647NYTB52REONXVD2QC

Dependencies

In channels

main

Change contents

Insertion in frontend/src/App.tsx at line 17 [5.24939]
[3.65]
[4.664]
```
import { JsxElement } from "typescript";
```

Replacement in frontend/src/App.tsx at line 53 [5.24939]

B:BD[6.907] → [6.907:955]

B:BD[6.955] → [7.218:297]

B:BD[7.297] → [8.0:125]

∅:D[8.125] → [6.1060:1067]

B:BD[6.1060] → [6.1060:1067]

B:BD[6.1067] → [8.126:231]

  const tabViews = useMemo(() => {
    return [
      <NodeDetail selectedPointNode={gameState.playerUI.selectedPointNode} />,
      <QuestProgress remainingPoints={batchContents} allocatedPoints={gameState.playerSave.allocatedPointNodeSet.size()} />,
    ];
  }, [gameState.playerUI.selectedPointNode, gameState.playerSave.allocatedPointNodeSet, batchContents]);

[6.907]

[6.1088]

  let tabViews: JSX.Element[] = []
  tabViews[0] = useMemo(() => {
    return (
      <NodeDetail
        selectedPointNode={gameState.playerUI.selectedPointNode}
        allocatedPointNodeSet={gameState.playerSave.allocatedPointNodeSet}
        worldGen={gameState.worldGen}
      />);
  }, [gameState.playerUI.selectedPointNode, gameState.playerSave.allocatedPointNodeSet, gameState.worldGen, batchContents]);
  tabViews[1] = useMemo(() => {
    return (
      <QuestProgress
        remainingPoints={batchContents}
        allocatedPoints={gameState.playerSave.allocatedPointNodeSet.size()}
      />);
  }, [gameState.playerSave.allocatedPointNodeSet.hash(), batchContents]);

Insertion in frontend/src/App.tsx at line 70 [5.24939]
[6.1089]
[5.25036]

Replacement in frontend/src/components/NodeDetail.tsx at line 2 [11.704]

B:BD[9.52] → [10.815:865]

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

[9.52]

[11.803]

import { PointNodeRef, WorldGenState } from "../data/GameState";
import { HashSet } from "../lib/util/data_structures/hash";
import { canAllocate } from "../pixi/components/PointNodeComponent";
type Props = {
  selectedPointNode?: PointNodeRef
  allocatedPointNodeSet: HashSet<PointNodeRef>,
  worldGen: WorldGenState,
}

Replacement in frontend/src/components/NodeDetail.tsx at line 14 [11.704]
∅:D[10.887] → [12.903:908]
B:BD[12.903] → [12.903:908]
B:BD[12.908] → [10.888:923]
∅:D[10.923] → [12.951:956]
B:BD[12.951] → [12.951:956]
```
}: {
  selectedPointNode?: PointNodeRef
}) {
```
[10.887]
[13.0]
```
  allocatedPointNodeSet,
  worldGen
}: Props) {
```

Insertion in frontend/src/components/NodeDetail.tsx at line 22 [11.704]

[13.207]

[11.900]


  if (!selectedPointNode) {
    return (<> </>)
  }
  const isAllocated = (allocatedPointNodeSet.contains(selectedPointNode));
  const canBeAllocated = canAllocate(selectedPointNode, worldGen, allocatedPointNodeSet)

Replacement in frontend/src/components/NodeDetail.tsx at line 30 [11.704]

B:BD[11.918] → [10.1226:1256]

∅:D[10.1256] → [6.1625:1678]

B:BD[6.1625] → [6.1625:1678]

B:BD[6.1678] → [10.1257:1342]

∅:D[10.1342] → [6.1759:1775]

B:BD[6.1759] → [6.1759:1775]

B:BD[6.1775] → [10.1343:1461]

∅:D[10.1461] → [6.1861:1889]

B:BD[6.1861] → [6.1861:1889]

B:BD[6.1889] → [13.208:227]

∅:D[10.1488] → [6.1908:1934]

∅:D[13.227] → [6.1908:1934]

B:BD[6.1908] → [6.1908:1934]

B:BD[6.1934] → [13.228:282]

∅:D[13.282] → [6.1977:2030]

B:BD[6.1977] → [6.1977:2030]

B:BD[6.2030] → [13.283:453]

∅:D[13.453] → [6.2136:2191]

B:BD[6.2136] → [6.2136:2191]

B:BD[6.2191] → [13.454:476]

∅:D[10.1514] → [6.2215:2236]

∅:D[13.476] → [6.2215:2236]

B:BD[6.2215] → [6.2215:2236]

      {selectedPointNode && (
        <>
          <h1>Current</h1>
          <h3>
            Chunk: {selectedPointNode.chunkCoord.x},{selectedPointNode.chunkCoord.y}
          </h3>
          <h3>X: {selectedPointNode.pointNodeCoord.x}</h3>
          <h3>Y: {selectedPointNode.pointNodeCoord.y}</h3>
          <h2>Previous</h2>
          {history
            .slice(0, -1)
            .map((pointNodeRef: PointNodeRef, i) => {
              return (
                <div key={i}>
                  Chunk ({pointNodeRef.chunkCoord.x},{pointNodeRef.chunkCoord.y}) at ({pointNodeRef.pointNodeCoord.x},
                  {pointNodeRef.pointNodeCoord.y})
                </div>
              );
            })
          .reverse()}
        </>
      )}

[11.918]

[11.1064]

      <h1>Current</h1>
      <h3>
        Chunk: {selectedPointNode.chunkCoord.x},{selectedPointNode.chunkCoord.y}
      </h3>
      <h3>X: {selectedPointNode.pointNodeCoord.x}</h3>
      <h3>Y: {selectedPointNode.pointNodeCoord.y}</h3>
      <div>Allocated? {isAllocated ? "yes" : "no"} </div>
      <div>Can be allocated? {canBeAllocated ? (<>yes</>) : (<b>no</b>)} </div>
      <h2>Previous</h2>
      {history
        .slice(0, -1)
        .map((pointNodeRef: PointNodeRef, i) => {
          return (
            <div key={i}>
              Chunk ({pointNodeRef.chunkCoord.x},{pointNodeRef.chunkCoord.y}) at ({pointNodeRef.pointNodeCoord.x},
              {pointNodeRef.pointNodeCoord.y})
            </div>
          );
        })
        .reverse()}

Replacement in frontend/src/pixi/components/PointNodeComponent.ts at line 4 [14.9408]

B:BD[14.9574] → [14.9574:9638]

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

[14.9574]

[14.9638]

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

Insertion in frontend/src/pixi/components/PointNodeComponent.ts at line 7 [14.9408]

[14.9752]

[14.9753]

import { GameStateFactory } from "../../dataFactory/GameStateFactory";
import { HashSet } from "../../lib/util/data_structures/hash";

Replacement in frontend/src/pixi/components/PointNodeComponent.ts at line 84 [14.9408]

B:BD[2.1100] → [2.1100:1190]

          !prevGameState.playerSave.allocatedPointNodeSet.contains(args.selfPointNodeRef)

[2.1100]

[2.1190]

          canAllocate(args.selfPointNodeRef, prevGameState.worldGen, prevGameState.playerSave.allocatedPointNodeSet)

Insertion in frontend/src/pixi/components/PointNodeComponent.ts at line 111 [14.9408]

[14.12874]


export function canAllocate(selfPointNodeRef: PointNodeRef, worldGen: WorldGenState, allocatedPointNodeSet: HashSet<PointNodeRef>): boolean {
  if (allocatedPointNodeSet.contains(selfPointNodeRef)) {
    return false;
  }
  // check if any of our neighbors are allocated
  let neighbors: { left?: PointNodeRef, right?: PointNodeRef, up?: PointNodeRef, down?: PointNodeRef } = {};
  
  let zLevel = worldGen.zLevels[selfPointNodeRef.z]
  let myChunk = zLevel.chunks.get(selfPointNodeRef.chunkCoord)!;
  // first, the right neighbor:
  if (selfPointNodeRef.pointNodeCoord.x === ChunkGenConstants.CHUNK_HALF_DIM) {
    let chunkCoord = selfPointNodeRef.chunkCoord.addX(1)
    let chunk = zLevel.chunks.get(chunkCoord);
    if (chunk) {
      let pointNodeCoord = selfPointNodeRef.pointNodeCoord.withX(-ChunkGenConstants.CHUNK_HALF_DIM)
      let nbor = chunk.pointNodes.get(pointNodeCoord);
      if (nbor) {
        neighbors.right = new PointNodeRef({
          z: selfPointNodeRef.z,
          chunkCoord,
          pointNodeCoord,
          pointNodeId: nbor.id
        })
      }
    }
  } else {
    let pointNodeCoord = selfPointNodeRef.pointNodeCoord.addX(1);
    let nbor = myChunk.pointNodes.get(pointNodeCoord);
    if (nbor) {
      neighbors.right = new PointNodeRef({
        z: selfPointNodeRef.z,
        chunkCoord: selfPointNodeRef.chunkCoord,
        pointNodeCoord,
        pointNodeId: nbor.id
      })
    }
  }
  // left neighbor
  if (selfPointNodeRef.pointNodeCoord.x === -ChunkGenConstants.CHUNK_HALF_DIM) {
    let chunkCoord = selfPointNodeRef.chunkCoord.addX(-1)
    let chunk = zLevel.chunks.get(chunkCoord);
    if (chunk) {
      let pointNodeCoord = selfPointNodeRef.pointNodeCoord.withX(ChunkGenConstants.CHUNK_HALF_DIM)
      let nbor = chunk.pointNodes.get(pointNodeCoord);
      if (nbor) {
        neighbors.left = new PointNodeRef({
          z: selfPointNodeRef.z,
          chunkCoord,
          pointNodeCoord,
          pointNodeId: nbor.id
        })
      }
    }
  } else {
    let pointNodeCoord = selfPointNodeRef.pointNodeCoord.addX(-1);
    let nbor = myChunk.pointNodes.get(pointNodeCoord);
    if (nbor) {
      neighbors.left = new PointNodeRef({
        z: selfPointNodeRef.z,
        chunkCoord: selfPointNodeRef.chunkCoord,
        pointNodeCoord,
        pointNodeId: nbor.id
      })
    }
  }
  // +y is down
  if (selfPointNodeRef.pointNodeCoord.y === ChunkGenConstants.CHUNK_HALF_DIM) {
    let chunkCoord = selfPointNodeRef.chunkCoord.addY(1)
    let chunk = zLevel.chunks.get(chunkCoord);
    if (chunk) {
      let pointNodeCoord = selfPointNodeRef.pointNodeCoord.withY(-ChunkGenConstants.CHUNK_HALF_DIM)
      let nbor = chunk.pointNodes.get(pointNodeCoord);
      if (nbor) {
        neighbors.down = new PointNodeRef({
          z: selfPointNodeRef.z,
          chunkCoord,
          pointNodeCoord,
          pointNodeId: nbor.id
        })
      }
    }
  } else {
    let pointNodeCoord = selfPointNodeRef.pointNodeCoord.addY(1);
    let nbor = myChunk.pointNodes.get(pointNodeCoord);
    if (nbor) {
      neighbors.down = new PointNodeRef({
        z: selfPointNodeRef.z,
        chunkCoord: selfPointNodeRef.chunkCoord,
        pointNodeCoord,
        pointNodeId: nbor.id
      })
    }
  }
  // -y is up
  if (selfPointNodeRef.pointNodeCoord.y === -ChunkGenConstants.CHUNK_HALF_DIM) {
    let chunkCoord = selfPointNodeRef.chunkCoord.addY(-1)
    let chunk = zLevel.chunks.get(chunkCoord);
    if (chunk) {
      let pointNodeCoord = selfPointNodeRef.pointNodeCoord.withY(ChunkGenConstants.CHUNK_HALF_DIM)
      let nbor = chunk.pointNodes.get(pointNodeCoord);
      if (nbor) {
        neighbors.up = new PointNodeRef({
          z: selfPointNodeRef.z,
          chunkCoord,
          pointNodeCoord,
          pointNodeId: nbor.id
        })
      }
    }
  } else {
    let pointNodeCoord = selfPointNodeRef.pointNodeCoord.addY(-1);
    let nbor = myChunk.pointNodes.get(pointNodeCoord);
    if (nbor) {
      neighbors.up = new PointNodeRef({
        z: selfPointNodeRef.z,
        chunkCoord: selfPointNodeRef.chunkCoord,
        pointNodeCoord,
        pointNodeId: nbor.id
      })
    }
  }
  for (let nbor of Object.values(neighbors)) {
    if (nbor && allocatedPointNodeSet.contains(nbor)) {
      return true;
    }
  }
  return false;
}