elevator.js

{
    init: function(elevators, floors) {
        let i = 0;
        for(let elevator of elevators){
            elevator.num = i;
            i++;
            elevator.on('idle', ()=>{
                if(elevator.num % 2 == 1){
                    elevator.goToFloor(0);
                } else {
                    elevator.goToFloor(floors.length - 1);
                }
            });

            elevator.on('floor_button_pressed', floor => {
                try_insert_floor(elevator, floor, 1) ||
                try_insert_floor(elevator, floor, -1) ||
                    elevator.goToFloor(floor);
            })

            elevator.on('passing_floor', (floorNum, direction) => {
            });

            elevator.on('stopped_at_floor', (floorNum) => {
                if(floorNum > elevator.destinationQueue[0]){
                    elevator.goingDownIndicator(true);
                    elevator.goingUpIndicator(false);
                }
                else if(floorNum < elevator.destinationQueue[0]){
                    elevator.goingDownIndicator(false);
                    elevator.goingUpIndicator(true);
                }
                else {
                    elevator.goingDownIndicator(true);
                    elevator.goingUpIndicator(true);
                }

            });
        }

        let try_insert_floor = (elevator, floor, direction) => {
            let queue = elevator.destinationQueue;
            for(let j = -1; j < queue.length - 1; j++){
                let queueFloor = queue[j];
                let nextQueueFloor = queue[j+1];
                let d = direction || 1;
                if(j<0){
                    queueFloor = elevator.currentFloor();
                }
                if(queueFloor*d <= floor*d && floor*d <= nextQueueFloor*d){
                    if(queueFloor == floor || nextQueueFloor == floor){
                        // already queued, nothing to do
                        return true;
                    }
                    // insert floor stop inbetween stops
                    queue.splice(j+1, 0, floor);
                    elevator.checkDestinationQueue();
                    return true;
                }
            }
            return false;
        }

        let call = (direction, floor) => {
            for(let elevator of elevators){
                if(elevator.loadFactor() > 0.66){
                    // elevator too full
                    continue;
                }
                let success = try_insert_floor(elevator, floor, direction);
                if(success){
                    return;
                }
            }
            // if we get here, we couldn't find a convenient place to insert the stop
            // we find which elevator will take the least amount of time to get there at the end of its queue
            let i = 0;
            let minCost = +Infinity;
            let minCostIdx = 0;
            for(let i = 0; i < elevators.length; i++){
                let elevator = elevators[i];
                let cost = 0;
                let lastFloor = elevator.currentFloor();
                for(let queueFloor of elevator.destinationQueue){
                    cost += Math.abs(lastFloor - queueFloor);
                    cost += .1; // for stopping and starting
                    lastFloor = queueFloor;
                }
                cost += Math.abs(lastFloor - floor);
                if(cost < minCost){
                    minCost = cost;
                    minCostIdx = i;
                }
            }
            elevators[minCostIdx].goToFloor(floor);
        }

        for(let floor of floors){
            floor.on('up_button_pressed', () => call(1, floor.floorNum()));
            floor.on('down_button_pressed', () => call(-1, floor.floorNum()));
        }
    },
    update: function(dt, elevators, floors) {
    }
}