Add directions

This commit adds indicators to the elevator. Passes challenges 1-5.

elevator.js

-{
+eval({
 	init: function(elevators, floors) {
-		console.clear();
-
 		// Get elevator/building info
 		let elevatorCount = elevators.length;
 		let floorCount    = floors.length;
 		let topFloor      = floorCount - 1;
 		let bottomFloor   = 0;
 
+		console.clear();
 		console.log("Starting (" + floorCount + " floors; " + elevatorCount + " elevator" + ((floorCount == 1) ? "s" : "") +")...");
 
 		// Direction constants
 		const DOWN = 1;
 		const IDLE = 2;
 
-		// Create a data structure for floor requests
+		// Data structure for floor requests
 		let requests = [new Set(), new Set()];
 
 		// ----
 		// Functions
 		// ----
 
-		function getClosestFloor(currentFloor, floorList, ignoredFloors = new Set(), direction = IDLE){
+		// getNextFloor chooses the best destination for an elevator
+		// when given the index of the elevator, along with all
+		// destinations, requests, and rest floors.
+		function getNextFloor(elevators, elevatorIndex, destinations, requests, restFloors) {
+			let elevator = elevators[elevatorIndex];
+			let floorNum = restFloors[1];
+
+			if (requests[UP].size == 0 && requests[DOWN].size == 0 && destinations.size == 0) {
+				// No people; send to rest floor
+			} else if (destinations.size == 0) {
+				// No destinations; send to pick up passengers
+				try {
+					floorNum = getClosestFloor(elevator.currentFloor(), new Set([...requests[UP], ...requests[DOWN]]));
+				} catch (e) {
+					console.log("ERROR: Requests set was empty");
+				}
+			} else {
+				// Prioritize dropping off current passengers
+				try {
+					floorNum = getClosestFloor(elevator.currentFloor(), destinations);
+				} catch (e) {
+					console.log("ERROR: Destinations set was empty");
+				}
+			}
+			return floorNum;
+		}
+
+		// getClosestFloor takes a floor, a list of floors, an optional
+		// list of ignored floors, and an optional direction. It
+		// returns the closest floor from that list in the given
+		// direction that is not part of the ignored floors list.
+		function getClosestFloor(currentFloor, floorList, ignoredFloors = new Set(), direction = IDLE) {
 			let closestFloor = currentFloor;
 			let distance     = floorCount;
 			let newDistance  = distance;
 				switch (direction) {
 					case UP:
 						newDistance = floorNum - currentFloor;
+						break;
 					case DOWN:
 						newDistance = currentFloor - floorNum;
+						break;
 					case IDLE:
 						newDistance = Math.abs(floorNum - currentFloor);
 				}
 					closestFloor = floorNum;
 					distance = newDistance;
 				}
-			})
+			});
 
 			if (closestFloor != currentFloor) {
 				return closestFloor;
 			}
 		}
 
-		function sendToNext(elevators, elevatorIndex, destinations, requests, restFloors) {
-			elevator = elevators[elevatorIndex]
-			if (elevator.loadFactor() < 0.8) {
-				if (requests[UP].size > 0 || requests[DOWN].size > 0 || destinations.size > 0) {
-					let allStops = new Set([...destinations, ...requests[UP], ...requests[DOWN]]);
-					try {
-						floorNum = getClosestFloor(elevator.currentFloor(), allStops)
-						//console.log("> Sending elevator[" + elevatorIndex + "] to floor[" + floorNum + "]");
-						elevator.goToFloor(floorNum);
-					} catch (e) {
-						//console.log("> No closest floor. Sending elevator[" + elevatorIndex + "] to rest floor[" + restFloors[1] + "]");
-						elevator.goToFloor(restFloors[1]);
-					}
-				} else {
-					//console.log("> Sending elevator[" + elevatorIndex + "] to rest floor[" + restFloors[1] + "]");
-					elevator.goToFloor(restFloors[1]);
-				}
-			} else {
-				try {
-					floorNum = getClosestFloor(elevator.currentFloor(), destinations)
-					console.log("> Sending elevator[" + elevatorIndex + "] to destination floor[" + floorNum + "]");
-					elevator.goToFloor(floorNum);
-				} catch (e) {
-					//console.log("> No closest floor. Sending elevator[" + elevatorIndex + "] to rest floor[" + restFloors[1] + "]");
-					elevator.goToFloor(restFloors[1]);
-				}
-			}
-		}
-
+		// getClosestElevator takes a floor number and returns the
+		// index of the closest elevator.
 		function getClosestElevator(floorNum) {
 			let closestElevator = 0;
 			let distance        = floorCount;
 			return closestElevator;
 		}
 
-		function setDirection(elevator, direction){
+		// getDirection get the direction (up or down) that an elevator
+		// will need to travel to get to a specified floor
+		function getDirection(currentFloor, floorNum) {
+			let distance = currentFloor - floorNum;
+			if (distance > 0 || currentFloor == topFloor) {
+				return DOWN;
+			} else if (distance < 0 || currentFloor == 0) {
+				return UP;
+			} else {
+				return IDLE;
+			}
+		}
+
+		// setDirection changes the indicator lights on a specified
+		// elevator to match the given direction.
+		function setDirection(elevator, direction) {
 			switch (direction) {
 				case UP:
 					elevator.goingUpIndicator(true);
 					elevator.goingDownIndicator(false);
-					break
+					break;
 				case DOWN:
 					elevator.goingUpIndicator(false);
 					elevator.goingDownIndicator(true);
-					break
+					break;
 				default:
 					elevator.goingUpIndicator(true);
 					elevator.goingDownIndicator(true);
 		// ----
 
 		elevators.forEach(function (elevator, elevatorIndex) {
-
 			// Elevator info and variables
 			let destinations = new Set();
+
 			const restFloors = [
 				elevatorIndex * Math.floor(floorCount / (elevatorCount + 1)),
 				(elevatorIndex + 1) * Math.floor(floorCount / (elevatorCount + 1)),
 				(elevatorIndex + 2) * Math.floor(floorCount / (elevatorCount + 1))
-			]
+			];
+
+			// Next primary stop
+			let nextFloor = restFloors[0];
 
 			// Start
-			setDirection(elevator, UP); // Starts on the ground floor
-			console.log("> Elevator[" + elevatorIndex + "] rest floors are " + restFloors[0] + ", " + restFloors[1] + ", and " + restFloors[2] + ". Starting at " + restFloors[0] + ".")
-			elevator.goToFloor(restFloors[0]); // Nearest rest floor
+			setDirection(elevator, UP); // Starts on the ground floor, must be going up
+			console.log("> Elevator[" + elevatorIndex + "] rest floors are " + restFloors[0] + ", " + restFloors[1] + ", and " + restFloors[2] + ". Starting at " + restFloors[0] + ".");
+			elevator.goToFloor(nextFloor); // Nearest rest floor
 
 			// Idle
 			elevator.on("idle", function() {
 				//console.log("> Elevator[" + elevatorIndex + "] is idle")
-				setDirection(elevator, IDLE);
-				if (requests[UP].size == 0 && requests[DOWN].size == 0 && destinations.size == 0) {
-					elevator.goToFloor(restFloors[1]);
-				} else {
-					sendToNext(elevators, elevatorIndex, destinations, requests, restFloors);
-				}
+				nextFloor = getNextFloor(elevators, elevatorIndex, destinations, requests, restFloors);
+				elevator.goToFloor(nextFloor);
 			});
 
 			// Passing
 			elevator.on("passing_floor", function(floorNum, direction) {
-				if (elevator.loadFactor() < 1 && (requests[UP].has(floorNum) || requests[DOWN].has(floorNum))) {
+				if (destinations.has(floorNum)
+				  || (elevator.loadFactor() < 1 && elevator.destinationDirection() == "up" && requests[UP].has(floorNum))
+				  || (elevator.loadFactor() < 1 && elevator.destinationDirection() == "down" && requests[DOWN].has(floorNum))) {
 					elevator.goToFloor(floorNum, true);
 				}
 			});
 			// Stopped
 			elevator.on("stopped_at_floor", function(floorNum) {
 				//console.log("> elevator[" + elevatorIndex + "] stopped at floor[" + floorNum + "]");
+				setDirection(elevator, getDirection(elevator.currentFloor(), nextFloor));
 				destinations.delete(floorNum);
-				requests[UP].delete(floorNum);
-				requests[DOWN].delete(floorNum);
+				if (elevator.goingUpIndicator() == true) {
+					requests[UP].delete(floorNum);
+				}
+				if (elevator.goingDownIndicator() == true) {
+					requests[DOWN].delete(floorNum);
+				}
 			});
 		});
 	},
 
 	update: function(dt, elevators, floors) {}
-}
+});