Break closest floor ties by floor index

This commit adjusts the way ties are calculated when deciding the
closest floor. Even floors default to going up, and odd floors default
to going down. This changed reduced waiting time a bit, which allows
this code to pass challenges 1-12.

elevator.js

 eval({
 	init: function(elevators, floors) {
 		// Get elevator/building info
-		let elevatorCount = elevators.length;
-		let floorCount    = floors.length;
-		let topFloor      = floorCount - 1;
-		let bottomFloor   = 0;
+		const elevatorCount = elevators.length,
+		      floorCount    = floors.length,
+		      bottomFloor   = 0,
+		      topFloor      = floorCount - 1;
 
 		console.clear();
-		console.log("Starting (" + floorCount + " floors; " + elevatorCount + " elevator" + ((floorCount == 1) ? "s" : "") +")...");
+		("Starting (" + floorCount + " floors; " + elevatorCount + " elevator" + (floorCount == 1) ? "s" : "" + ")...");
 
 		// Direction constants
-		const UP   = 0;
-		const DOWN = 1;
-		const IDLE = 2;
+		const UP   = 0,
+		      DOWN = 1,
+		      IDLE = 2;
+
+		// Rest floor constants
+		const LOW  = 0,
+		      MED  = 1,
+		      HIGH = 2;
 
 		// Data structure for floor requests
-		let requests = [new Set(), new Set()];
+		const requests = [new Set(), new Set()];
 
 		// ----
 		// Functions
 		// ----
 
+		// 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. Ties
+		// are broken by even/oddness of the current floor.
+		function getClosestFloor(currentFloor, floorList, ignoredFloors = new Set(), direction = IDLE) {
+			const isEven = (currentFloor % 2 == 0);
+
+			let closestFloor = currentFloor,
+			    distance     = floorCount,
+			    newDistance  = distance;
+
+			floorList.forEach(function(floorNum) {
+				const direction = getDirection(currentFloor, floorNum);
+				newDistance = Math.abs(currentFloor - floorNum);
+
+				if (newDistance < distance && newDistance > 0 && !(ignoredFloors.has(floorNum))) {
+					closestFloor = floorNum;
+					distance = newDistance;
+				} else if (newDistance == distance && !(ignoredFloors.has(floorNum))) {
+					if (isEven && direction == UP) {
+						closestFloor = floorNum;
+					} else if (!isEven && direction == DOWN) {
+						closestFloor = floorNum;
+					}
+				}
+			});
+
+			if (closestFloor != currentFloor) {
+				return closestFloor;
+			} else {
+				throw new Error("No floor in selected direction");
+			}
+		}
+
 		// 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];
+			let elevator = elevators[elevatorIndex],
+			    floorNum = restFloors[MED];
 
 			if (requests[UP].size == 0 && requests[DOWN].size == 0 && destinations.size == 0) {
 				// No people; send to rest floor
 					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;
-
-			floorList.forEach(function(floorNum) {
-				switch (direction) {
-					case UP:
-						newDistance = floorNum - currentFloor;
-						break;
-					case DOWN:
-						newDistance = currentFloor - floorNum;
-						break;
-					case IDLE:
-						newDistance = Math.abs(floorNum - currentFloor);
-				}
-				if (newDistance < distance && newDistance > 0 && !(ignoredFloors.has(floorNum))) {
-					closestFloor = floorNum;
-					distance = newDistance;
-				}
-			});
 
-			if (closestFloor != currentFloor) {
-				return closestFloor;
-			} else {
-				throw new Error("No floor in selected direction");
-			}
+			return floorNum;
 		}
 
 		// getClosestElevator takes a floor number and returns the
 		// index of the closest elevator.
 		function getClosestElevator(floorNum) {
-			let closestElevator = 0;
-			let distance        = floorCount;
-			let newDistance     = distance;
+			let closestElevator = 0,
+			    distance        = floorCount,
+			    newDistance     = distance;
 
-			elevators.forEach(function (elevator, elevatorIndex) {
+			elevators.forEach(function(elevator, elevatorIndex) {
 				newDistance = Math.abs(elevator.currentFloor() - floorNum);
 				if (newDistance < distance) {
 					distance = newDistance;
 		// 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;
+			const distance = currentFloor - floorNum;
+			let direction = IDLE;
+
 			if (distance > 0 || currentFloor == topFloor) {
-				return DOWN;
-			} else if (distance < 0 || currentFloor == 0) {
-				return UP;
-			} else {
-				return IDLE;
+				direction = DOWN;
+			} else if (distance < 0 || currentFloor == bottomFloor) {
+				direction = UP;
 			}
+
+			return direction;
 		}
 
 		// 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;
-				case DOWN:
-					elevator.goingUpIndicator(false);
-					elevator.goingDownIndicator(true);
-					break;
-				default:
-					elevator.goingUpIndicator(true);
-					elevator.goingDownIndicator(true);
+			case UP:
+				elevator.goingUpIndicator(true);
+				elevator.goingDownIndicator(false);
+				break;
+			case DOWN:
+				elevator.goingUpIndicator(false);
+				elevator.goingDownIndicator(true);
+				break;
+			default:
+				elevator.goingUpIndicator(true);
+				elevator.goingDownIndicator(true);
 			}
 		}
 
 		// Floors
 		// ----
 
-		floors.forEach(function (floor) {
+		floors.forEach(function(floor) {
 			floor.on("up_button_pressed", function() {
 				//console.log("> Up request on floor[" + floor.level + "]");
 				requests[UP].add(floor.level);
 		// Elevators
 		// ----
 
-		elevators.forEach(function (elevator, elevatorIndex) {
+		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];
+			let destinations = new Set(),
+			    nextFloor = restFloors[LOW];
 
 			// Start
 			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] + ".");
+			console.log("> Elevator[" + elevatorIndex + "] rest floors are " + restFloors[LOW] + ", " + restFloors[MED] + ", and " + restFloors[HIGH] + ". Starting at " + restFloors[LOW] + ".");
 			elevator.goToFloor(nextFloor); // Nearest rest floor
 
 			// Idle
 
 			// Passing
 			elevator.on("passing_floor", function(floorNum, direction) {
-				if (destinations.has(floorNum)
-				  || (elevator.loadFactor() < 1 && elevator.destinationDirection() == "up" && requests[UP].has(floorNum))
-				  || (elevator.loadFactor() < 1 && elevator.destinationDirection() == "down" && requests[DOWN].has(floorNum))) {
+				if (destinations.has(floorNum) ||
+				   (elevator.loadFactor() < 1 &&
+				   (elevator.destinationDirection() == "up" && requests[UP].has(floorNum)) ||
+				   (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));
+				let isNext = (elevator.currentFloor() == nextFloor);
+
 				destinations.delete(floorNum);
+
+				if (isNext) {
+					nextFloor = getNextFloor(elevators, elevatorIndex, destinations, requests, restFloors);
+					setDirection(elevator, getDirection(elevator.currentFloor(), nextFloor));
+				}
+
 				if (elevator.goingUpIndicator() == true) {
 					requests[UP].delete(floorNum);
 				}
+
 				if (elevator.goingDownIndicator() == true) {
 					requests[DOWN].delete(floorNum);
 				}
+
+				if (isNext) {
+					elevator.goToFloor(nextFloor);
+				}
 			});
 		});
 	},