Solution by DeSjoerd

This solution solves levels 1 to 11. With some levels the variable nOfElevators must be tweaked to 1.

{
    init: function(elevators, floors) {
        var nOfElevators = elevators.length;

        var waitQueue = [];
        var getClosestQueued = function(currentFloorNum) {

            var lowestScore = 100000;
            var closest = -1;
            var closestIndex = -1;
            for(var i = 0; i < waitQueue.length; i++) {
                var value = waitQueue[i];
                var score = Math.max(currentFloorNum, value) - Math.min(currentFloorNum, value);
                if(score < lowestScore) {
                    lowestScore = score;
                    closest = value;
                    closestIndex = i;
                }
            }

            if(closestIndex != -1) {
                waitQueue.splice(closestIndex -1, 1);
            }

            return closest;
        };

        var Elevator = function(elevator, baseFloor) {
            baseFloor = baseFloor || 0;

            var self = this;
            self.elevator = elevator;

            self.goingUp = true;
            self.prevFloor = 0;
            self.isGoingTo = function(floorNum) {
                return self.elevator.destinationQueue.indexOf(floorNum) != -1;
            };

            self.isFull = function() {
                return self.elevator.loadFactor() > 0.3;
            }

            self.goToFloorScore = function(goToFloorNum, goToUp) {
                var multiplier = 4 * self.elevator.loadFactor() + 3;

                if(self.isGoingTo(goToFloorNum) || self.elevator.destinationQueue.length == 0) {
                    return 0;
                }
                
                if((self.goingUp && goToUp) || (!self.goingUp && !goToUp)) {
                    multiplier =  4 * self.elevator.loadFactor();
                }

                var value = 0;
                if(self.goingUp && goToFloorNum > self.prevFloor) {
                    value += (goToFloorNum * multiplier) - (self.prevFloor * multiplier);
                } else if(!self.goingUp && goToFloorNum < self.prevFloor) {
                    value += (self.prevFloor * multiplier) - (goToFloorNum * multiplier);
                } else {
                    value += floors.length * multiplier * 2;
                }

                return value;
            };

            self.floor_button_pressed = function(floorNum) {
                if(self.elevator.destinationQueue.indexOf(floorNum) == -1) {
                    self.elevator.destinationQueue.push(floorNum);

                    var lower = [];
                    var higher = [];

                    for(var i = 0; i < self.elevator.destinationQueue.length; i++) {
                        var destinationFloorNum = self.elevator.destinationQueue[i];
                        if(destinationFloorNum <= self.prevFloor) {
                            lower.push(destinationFloorNum);
                        } else {
                            higher.push(destinationFloorNum);
                        }
                    }

                    higher = higher.sort();
                    lower = lower.sort().reverse();
                    
                    if(self.goingUp) {
                        self.elevator.destinationQueue = higher.concat(lower);
                    } else {
                        self.elevator.destinationQueue = lower.concat(higher);
                    }

                    if(!self.goingUp) {
                        //self.elevator.destinationQueue = self.elevator.destinationQueue.reverse();
                    }

                    elevator.checkDestinationQueue();
                }
            };

            self.elevator.on("floor_button_pressed", self.floor_button_pressed);
            self.elevator.on("stopped_at_floor", function(floorNum) {
                if(floorNum > self.prevFloor || floorNum == 0) {
                    self.goingUp = true;
                } else if(floorNum < self.prevFloor || floorNum == floors.length -1) {
                    self.goingUp = false;
                }
                prevFloor = floorNum;
            });
            self.elevator.on("idle", function() {
                var next = getClosestQueued(self.prevFloor);
                if(next != -1) {
                    self.elevator.goToFloor(next);
                } else {
                    self.elevator.goToFloor(self.prevFloor);
                }
            });
        };

        var elevatorObjects = [];
        for(var i = 0; i < nOfElevators; i++) {
            var elevatorObject = new Elevator(elevators[i], i);
            
            elevatorObjects.push(elevatorObject);

            elevatorObject.elevator.goToFloor(0);
            elevatorObject.elevator.checkDestinationQueue();
        }

        var requestElvator = function(floorNum, up) {
            var lowestScore = elevatorObjects[0].goToFloorScore(floorNum, up);
            var lowestIndex = 0;
            for(var i = 1; i < elevatorObjects.length; i++) {
                if(!elevatorObjects[i].isFull()) {
                    var score = elevatorObjects[i].goToFloorScore(floorNum, up);
                    if(score < lowestScore) {
                        lowestIndex = i;
                        lowestScore = score;
                    }
                }
            }
            if(!elevatorObjects[lowestIndex].isFull()) {
                elevatorObjects[lowestIndex].floor_button_pressed(floorNum);
            } else {
                if(waitQueue.indexOf(floorNum) == -1) {
                    waitQueue.push(floorNum);
                }
            }
        };

        var Floor = function(floor) {
            var self = this;
            self.floorNum = floor.floorNum();


            floor.on("up_button_pressed", function() {
                requestElvator(self.floorNum, true);
            });
            floor.on("down_button_pressed", function() {
                requestElvator(self.floorNum, false);
            });
        };

        var floorObjects = [];
        for(var i = 0; i < floors.length; i++) {
            floorObjects.push(new Floor(floors[i]));
        }
        
        
    },
    update: function(dt, elevators, floors) {
        // We normally don't need to do anything here
    }
}