feat: one-way hallways

Author: AjaiKN

src/Building.test.ts

@@ -539,7 +539,6 @@ describe("accessibility", () => {
   });
 });
 
-/*
 describe("one-way hallways", () => {
   const hallway10 = [
     new Stairs(RIGHT, onFloor("b", 1)),
@@ -661,11 +660,17 @@ describe("one-way hallways", () => {
     assertValidBuilding(building);
 
     expect(building.getDirections("101", "103")).toMatchInlineSnapshot(`
-      "Turn left out of room 101
-      Continue, then turn left into room 103"
+      "Turn right out of room 101
+      Continue, then turn left into the stairs
+      Go up 1 floor of stairs
+      Turn right out of the stairs
+      Continue, then turn right into the 11s
+      Continue, then turn right into the stairs
+      Go down 1 floor of stairs
+      Turn left out of the stairs
+      Continue, then after entering the 10s, turn left
+      Continue, then turn right into room 103"
     `);
-
-    fail("snapshot above is wrong");
   });
 
   test("unconnected one-way building 1", () => {
@@ -688,7 +693,6 @@ describe("one-way hallways", () => {
   });
 });
 
-describe("one-way connections", () => {});
-*/
+// describe("one-way connections", () => {});
 
 // TODO: add tests with SimpleHallway and rooms that are nodes

src/Building.ts

@@ -1,6 +1,11 @@
 import { Hallway } from "./Hallway";
 import { Room } from "./Room";
-import { getShortestPath, isConnectedGraph, getGraph } from "./graph";
+import {
+  getShortestPath,
+  isConnectedGraph,
+  getGraph,
+  HallConnectorsStructures,
+} from "./graph";
 import { isLeftOrRight } from "./Direction";
 import { ForkNode } from "./ForkNode";
 import { StairNode } from "./StairNode";
@@ -73,12 +78,18 @@ export class Building<
           .map(nodeId => nodeId.name)
     )
   ) {
-    const hallwayNodes = this.hallways.map(h => {
-      return h.nodes.filter(
-        ({ nodeId }) =>
-          nodeId instanceof BasicRoomNode ||
-          allowedConnections.includes(nodeId.name)
-      );
+    const hallwayNodes: HallConnectorsStructures<
+      ForkName,
+      StairName
+    > = this.hallways.map(h => {
+      return {
+        nodes: h.nodes.filter(
+          ({ nodeId }) =>
+            nodeId instanceof BasicRoomNode ||
+            allowedConnections.includes(nodeId.name)
+        ),
+        oneWay: h.oneWay,
+      };
     });
     this.graph = getGraph(hallwayNodes);
     this.roomsList = hallways

src/Hallway.ts

@@ -1,11 +1,9 @@
 import { Room } from "./Room";
 import { Turn } from "./Turn";
 import { Stairs } from "./Stairs";
-import { ForkNode } from "./ForkNode";
-import { StairNode } from "./StairNode";
 import { Node, isConnectorNode } from "./node";
-import { BasicRoomNode } from "./BasicRoomNode";
-import { Fork } from "./Fork";
+
+export type OneWay = "forward" | "backward" | false;
 
 /**
  * This class represents a single hallway. The hallway may have turns,
@@ -14,6 +12,7 @@ import { Fork } from "./Fork";
  */
 export class Hallway<ForkName extends string, StairName extends string> {
   readonly allowFrontConnectionsInMiddle: boolean;
+  readonly oneWay: OneWay;
 
   /**
    *
@@ -24,14 +23,22 @@ export class Hallway<ForkName extends string, StairName extends string> {
    * @param allowFrontConnectionsInMiddle - If true, this hallway may have
    * [[Rooms]] and [[Stairs]] that are not at the ends of the hallway, but are
    * marked as FRONT. This is used by [[isValidBuilding]].
+   * @param oneWay - false if you can travel both ways in this hallway.
+   * "forward" if you can only travel from the first to the last element of this
+   * hallway. "backward" if you can only travel from the last element to the first.
    */
   constructor(
     public partList: (Room<ForkName> | Stairs<StairName> | Turn)[],
     {
       allowFrontConnectionsInMiddle = false,
-    }: { allowFrontConnectionsInMiddle?: boolean } = {}
+      oneWay = false,
+    }: {
+      allowFrontConnectionsInMiddle?: boolean;
+      oneWay?: OneWay;
+    } = {}
   ) {
     this.allowFrontConnectionsInMiddle = allowFrontConnectionsInMiddle;
+    this.oneWay = oneWay;
   }
 
   /**

src/graph.ts

@@ -3,6 +3,18 @@ import dijkstra from "dijkstrajs";
 import { ForkNode, reverseConnection } from "./ForkNode";
 import { StairNode, onFloor } from "./StairNode";
 import { serializeNode, nodeFromString, Node } from "./node";
+import { OneWay } from "./Hallway";
+
+export type HallConnectorsStructures<
+  ForkName extends string,
+  StairName extends string
+> = {
+  nodes: {
+    nodeId: Node<ForkName, StairName>;
+    edgeLengthFromPreviousNodeInHallway: number;
+  }[];
+  oneWay: OneWay;
+}[];
 
 /**
  * @ignore
@@ -11,12 +23,10 @@ function getHallwayConnections<
   ForkName extends string,
   StairName extends string
 >(
-  hallConnections: {
-    nodeId: Node<ForkName, StairName>;
-    edgeLengthFromPreviousNodeInHallway: number;
-  }[][]
+  hallConnections: HallConnectorsStructures<ForkName, StairName>
 ): [string, string][] {
   return hallConnections
+    .map(hallway => hallway.nodes)
     .flat()
     .map(thing => thing.nodeId)
     .filter(
@@ -32,12 +42,10 @@ function getHallwayConnections<
 
 /** @ignore */
 function getStairConnections<ForkName extends string, StairName extends string>(
-  hallConnections: {
-    nodeId: Node<ForkName, StairName>;
-    edgeLengthFromPreviousNodeInHallway: number;
-  }[][]
+  hallConnections: HallConnectorsStructures<ForkName, StairName>
 ): string[][] {
   const stairNodes = hallConnections
+    .map(hallway => hallway.nodes)
     .flat()
     .map(thing => thing.nodeId)
     .filter((st): st is StairNode<StairName> => st instanceof StairNode);
@@ -59,30 +67,30 @@ function getStairConnections<ForkName extends string, StairName extends string>(
  * @returns The graph to be used by getShortestPath
  */
 export function getGraph<ForkName extends string, StairName extends string>(
-  hallConnectorsStructures: {
-    nodeId: Node<ForkName, StairName>;
-    edgeLengthFromPreviousNodeInHallway: number;
-  }[][]
+  hallConnectorsStructures: HallConnectorsStructures<ForkName, StairName>
 ) {
-  const hallConnectors = hallConnectorsStructures.map(hall =>
-    hall.map(({ nodeId, edgeLengthFromPreviousNodeInHallway }) => ({
-      nodeId: serializeNode(nodeId),
-      edgeLengthFromPreviousNodeInHallway,
-    }))
-  );
+  const hallConnectors = hallConnectorsStructures.map(hall => ({
+    oneWay: hall.oneWay,
+    nodes: hall.nodes.map(
+      ({ nodeId, edgeLengthFromPreviousNodeInHallway }) => ({
+        nodeId: serializeNode(nodeId),
+        edgeLengthFromPreviousNodeInHallway,
+      })
+    ),
+  }));
   const stairConnections = getStairConnections(hallConnectorsStructures);
   const hallwayConnections = getHallwayConnections(hallConnectorsStructures);
 
   const graph: dijkstra.Graph = {};
-  hallConnectors.forEach(hall => {
+  hallConnectors.forEach(({ oneWay, nodes: hall }) => {
     hall.forEach((node, ind) => {
       const id = node.nodeId;
       const edgesTo: { [key: string]: number } = {};
-      if (ind != 0) {
+      if (ind !== 0 && oneWay !== "forward") {
         edgesTo[hall[ind - 1].nodeId] =
           hall[ind].edgeLengthFromPreviousNodeInHallway;
       }
-      if (ind != hall.length - 1) {
+      if (ind !== hall.length - 1 && oneWay !== "backward") {
         edgesTo[hall[ind + 1].nodeId] =
           hall[ind + 1].edgeLengthFromPreviousNodeInHallway;
       }