Start new API for specifying nodes

Docs aren't updated yet

Author: AjaiKN

src/Building.test.ts

@@ -1,7 +1,14 @@
 import { Hallway } from "./Hallway";
-import { Room } from "./Room";
-import { getGraph, getShortestPath, isConnectedGraph } from "./graph";
+import { ForkableRoom } from "./ForkableRoom";
+import {
+  getShortestPath,
+  isConnectedGraph,
+  isConnectionStairs,
+  getGraph,
+} from "./graph";
 import { isLeftOrRight } from "./Direction";
+import { ForkNode } from "./ForkNode";
+import { StairNode } from "./StairNode";
 
 /**
  * @ignore
@@ -51,7 +58,10 @@ function format(str: string, { capitalize = true, periods = false }) {
  * Continue, then turn left into room C
  * ```
  */
-export class Building {
+export class Building<
+  ForkName extends string = string,
+  StairName extends string = string
+> {
   /**
    * The graph that is generated from the nodes in the [[hallways]] and the
    * [[hallwayConnections]] and [[stairConnections]] between them
@@ -72,18 +82,14 @@ export class Building {
    * in the building. Each connection is an array of node IDs that starts at the
    * bottom floor and goes to the top floor.
    */
-  constructor(
-    readonly hallways: Hallway[],
-    readonly hallwayConnections: [string, string][] = [],
-    readonly stairConnections: string[][] = []
-  ) {
+  constructor(readonly hallways: Hallway<ForkName, StairName>[]) {
     const hallwayNodes = this.hallways.map(h => {
       return h.nodes;
     });
-    this.graph = getGraph(hallwayNodes, stairConnections, hallwayConnections);
+    this.graph = getGraph(hallwayNodes);
     this.roomsList = hallways
       .flatMap(h => h.partList)
-      .filter((a): a is Room => "name" in a && a.name != null)
+      .filter((a): a is ForkableRoom<ForkName> => "name" in a && a.name != null)
       .flatMap(r => r.aliases.concat(r.name!))
       .sort();
   }
@@ -107,39 +113,25 @@ export class Building {
    * is the index of the hallway where the node is located, and
    * the second element is the index of the node in the hallway
    */
-  protected getHallwayIndexAndIndexFromNode(nodeId: string): [number, number] {
+  protected getHallwayIndexAndIndexFromNode(
+    nodeId: ForkNode<ForkName> | StairNode<StairName>
+  ): [number, number] {
     const inds = this.hallways.map(h =>
-      h.partList.findIndex(r => "nodeId" in r && r.nodeId === nodeId)
+      h.partList.findIndex(
+        r =>
+          "nodeId" in r && JSON.stringify(r.nodeId) === JSON.stringify(nodeId)
+      )
     );
     const hallwayInd = inds.findIndex(a => a !== -1);
     return [hallwayInd, inds[hallwayInd]];
   }
 
-  /**
-   * @param id1
-   * @param id2
-   * @return Is the connection between these two nodes
-   * a Stairs connection? (as opposed to a Fork)
-   */
-  protected isConnectionStairs(id1: string, id2: string): boolean {
-    return (
-      this.stairConnections.findIndex(
-        arr => arr.includes(id1) && arr.includes(id2)
-      ) != -1
-    );
-  }
-
   protected getStairConnectionInstruction(
-    id1: string,
-    id2: string,
+    id1: StairNode<StairName>,
+    id2: StairNode<StairName>,
     numFlights: number
   ): string {
-    const goingUp = this.stairConnections.find(
-      arr =>
-        arr.includes(id1) &&
-        arr.includes(id2) &&
-        arr.indexOf(id2) > arr.indexOf(id1)
-    );
+    const goingUp = id2.floor > id1.floor;
     const maybeS = numFlights > 1 ? "s" : "";
     return `go ${
       goingUp ? "up" : "down"
@@ -208,12 +200,7 @@ export class Building {
       const [prevHallwayInd, prevInd] = this.getHallwayIndexAndIndexFromNode(
         shortest[i - 1]
       );
-      if (
-        this.isConnectionStairs(
-          shortest[i - 1],
-          shortest[i]
-        ) /* going up or down stairs */
-      ) {
+      if (isConnectionStairs(shortest[i]) /* going up or down stairs */) {
         directions += this.hallways[currentHallwayInd].getDirectionsFromIndices(
           currentInd,
           prevInd,
@@ -223,12 +210,13 @@ export class Building {
             entranceWasStraight,
           }
         );
-        const numStairFlights = Math.ceil(
-          this.graph[shortest[i - 1]][shortest[i]]
+        const numStairFlights = Math.abs(
+          (shortest[i - 1] as StairNode<StairName>).floor -
+            (shortest[i] as StairNode<StairName>).floor
         );
         directions += this.getStairConnectionInstruction(
-          shortest[i - 1],
-          shortest[i],
+          shortest[i - 1] as StairNode<StairName>,
+          shortest[i] as StairNode<StairName>,
           numStairFlights
         );
         [currentHallwayInd, currentInd] = this.getHallwayIndexAndIndexFromNode(
@@ -246,7 +234,9 @@ export class Building {
           }
         );
         entranceWasStraight = !isLeftOrRight(
-          (<Room>this.hallways[currentHallwayInd].partList[prevInd]).side
+          (this.hallways[currentHallwayInd].partList[prevInd] as ForkableRoom<
+            ForkName
+          >).side
         );
         [currentHallwayInd, currentInd] = [hallwayInd, ind];
       }

src/Building.ts

@@ -1,13 +1,14 @@
 import { Direction } from "./Direction";
-import { Room } from "./Room";
+import { ForkableRoom } from "./ForkableRoom";
+import { ForkNode } from "./ForkNode";
 
 /**
  * A Fork represents a connection between 2 [[Hallway]]s on the same
  * floor. You can connect the [[Fork]]s of 2 hallways by
  * adding to the `hallwayConnections` argument of the [[Hallway]]
  * constructor.
  */
-export class Fork extends Room {
+export class Fork<ForkName extends string> extends ForkableRoom<ForkName> {
   /**
    *
    * @param side - The side of the [[Hallway]] that this [[Fork]] is on
@@ -21,7 +22,7 @@ export class Fork extends Room {
    */
   constructor(
     side: Direction,
-    nodeId: string,
+    nodeId: ForkNode<ForkName>,
     public destinationName: string,
     edgeLengthFromPreviousNodeInHallway: number | undefined = 1
   ) {

src/Fork.ts

@@ -0,0 +1,14 @@
+export interface ReversedConnection<ForkName extends string> {
+  readonly _type: "ReversedConnection";
+  readonly name: ForkName;
+}
+
+export function reverseConnection<ForkName extends string>(
+  name: ForkName
+): ForkNode<ForkName> {
+  return { _type: "ReversedConnection", name };
+}
+
+export type ForkNode<ForkName extends string> =
+  | ReversedConnection<ForkName>
+  | ForkName;

src/ForkNode.ts

@@ -0,0 +1,30 @@
+import { HallwayElement } from "./HallwayElement";
+import { Direction } from "./Direction";
+import { ForkNode } from "./ForkNode";
+
+export class ForkableRoom<ForkName extends string> extends HallwayElement {
+  readonly nodeId: ForkNode<ForkName> | undefined;
+
+  constructor(
+    name?: (string | null) | undefined,
+    side: Direction = Direction.LEFT,
+    {
+      edgeLengthFromPreviousNodeInHallway,
+      prefix = "room",
+      aliases = [],
+      nodeId,
+    }: {
+      prefix?: string;
+      aliases?: string[];
+      edgeLengthFromPreviousNodeInHallway?: number | null;
+      nodeId?: ForkNode<ForkName>;
+    } = {}
+  ) {
+    super(name, side, {
+      edgeLengthFromPreviousNodeInHallway,
+      prefix,
+      aliases,
+    });
+    this.nodeId = nodeId;
+  }
+}

src/ForkableRoom.ts

@@ -1,12 +1,15 @@
-import { Room } from "./Room";
+import { ForkableRoom } from "./ForkableRoom";
 import { Turn } from "./Turn";
+import { Stairs } from "./Stairs";
+import { ForkNode } from "./ForkNode";
+import { StairNode } from "./StairNode";
 
 /**
  * This class represents a single hallway. The hallway may have turns,
  * but if you need a fork, you need to add another [[Hallway]] to the list
  * and connect them with 2 [[Fork]]s.
  */
-export class Hallway {
+export class Hallway<ForkName extends string, StairName extends string> {
   /**
    *
    * @param partList - An array of every [[Room]] or [[Turn]] in the hallway.
@@ -15,7 +18,10 @@ export class Hallway {
    * consistent with the direction you choose as forward.
    * @param name - The name of this [[Hallway]].
    */
-  constructor(public partList: (Room | Turn)[], public name?: string | null) {}
+  constructor(
+    public partList: (ForkableRoom<ForkName> | Stairs<StairName> | Turn)[],
+    public name?: string | null
+  ) {}
 
   /**
    * @param - name The name of the room
@@ -36,33 +42,38 @@ export class Hallway {
    * @param roomInd - The index of the room in the hallway
    * @returns The id of the "closest" node to the room in the hallway
    */
-  idOfClosestNodeToIndex(roomInd: number): string {
+  idOfClosestNodeToIndex(
+    roomInd: number
+  ): ForkNode<ForkName> | StairNode<StairName> {
     let closestNodeInd: number;
     this.partList.forEach((r, currentInd) => {
       if (
         "nodeId" in r &&
-        r.nodeId &&
+        r.nodeId != null &&
         (closestNodeInd === undefined ||
           Math.abs(currentInd - roomInd) < Math.abs(closestNodeInd - roomInd))
       ) {
         closestNodeInd = currentInd;
       }
     });
 
-    const closest = this.partList[closestNodeInd!];
-    return (closest as Room).nodeId!;
+    const closest = this.partList[closestNodeInd!] as
+      | ForkableRoom<ForkName>
+      | Stairs<StairName>;
+    return closest.nodeId!;
   }
 
   get nodes(): {
-    nodeId: string;
+    nodeId: ForkNode<ForkName> | StairNode<StairName>;
     edgeLengthFromPreviousNodeInHallway: number;
   }[] {
     return this.partList
       .filter(
-        (r): r is Room & { nodeId: string } => "nodeId" in r && r.nodeId != null
+        (r): r is ForkableRoom<ForkName> | Stairs<StairName> =>
+          "nodeId" in r && r.nodeId != null
       )
       .map(({ nodeId, edgeLengthFromPreviousNodeInHallway }) => ({
-        nodeId,
+        nodeId: nodeId!,
         edgeLengthFromPreviousNodeInHallway:
           edgeLengthFromPreviousNodeInHallway == null
             ? 1
@@ -98,9 +109,13 @@ export class Hallway {
       entranceWasStraight: boolean;
     }
   ): string {
-    const fromRoom = this.partList[from] as Room;
+    const fromRoom = this.partList[from] as
+      | ForkableRoom<ForkName>
+      | Stairs<StairName>;
 
-    const toRoom = this.partList[to] as Room;
+    const toRoom = this.partList[to] as
+      | ForkableRoom<ForkName>
+      | Stairs<StairName>;
 
     if (from === to) {
       return `Bruh. You at ${fromRoom.fullName}\n`;
@@ -122,7 +137,10 @@ export class Hallway {
         prevInd >= 0 &&
         prevInd < this.partList.length &&
         this.partList[i - forwardOrBackward];
-      ret += current.onPass(forwardOrBackward, prevRoom as Room);
+      ret += current.onPass(
+        forwardOrBackward,
+        prevRoom as ForkableRoom<ForkName> | Stairs<StairName>
+      );
     }
 
     ret += toRoom.onArrive(forwardOrBackward, isEndOfDirections);