Elevator Saga – An elevator programming game

mind: blown

Never even knew all those years playing SimTower... I knew other tricks, but never this.

The people in that game were a lot smarter though; if the only path to a floor required switching elevators, they would do it.

Damn I miss this game

What I would've loved to have seen in some of the later levels is a very clear "you now need to use this new API call to accomplish the goal. Here's how that call works."

For example: in level 2, what if people only ever came to the second floor trying to go to the third floor, so you had to look at where buttons were being pushed and where they wanted to go?

hi, why leaving the elevator at a floor doesn't pick up additional passengers? i.e.

http://pastebin.com/xA4NJbas @ http://play.elevatorsaga.com/#challenge=2

(yes that's only a stub, but has logging as I was trying to understand the event order)

at least elevator.goToFloor(elevator.currentFloor());

doesn't count as a move and unlocks the passenger to onboarding

btw, when you start you get 2 moves per elevator in the moves count

Likewise.

http://www.quora.com/Is-there-any-public-elevator-scheduling...

Sure does

Another nitpick: it's 1360 px wide.

came to the comments to say this

v1. Not the same version as that HN article.

I'm not a developer of the game but:

DestinationQueue handling: It is not redundant, those are different options. Just to give an valid example: Add something to the queue, sort the queue, make the elevator run the updated and sorted queue.

Having both goingUpIndicator and goingDownIndicator is probabaly necessary to get this abritrary third state (both enabled / both disabled) which essentially indicates that the elevator will go in both directions.

> I got to Challenge #5 by just having the elevators go to every floor like in the first example.

Strange, that strategy doesn't allow me to get past challenge 2 (just going to every floor one after the other).

It isn't quite programming, but your assembly line comment reminded me of http://pleasingfungus.com/Manufactoria/ which is a game about making state automata.

Yeah! Something I think about occasionally is traffic-light optimization problems, optimizing for throughput, wait-time, safety etc. I think it could work well in a packaging similar to Elevator Saga.

oh man, both clever and evil. love it!

The error messages are bad because eval()...but rest assured there is a problem in your code.

ahead of time optimization!

They have that at work and it takes far longer to get an elevator. It's always annoying going to those buildings and using those elevators.

I'd love to see a version of the game that does this, for comparison.

Try looking in the dev tools? I've been able to debug a few runtime errors this way.

I don't think you need an argument. Within the callback function you still hold a reference to floor, and you know the up button has been pressed. There doesn't seem to be any more information. Note that there is also down_button_pressed

You're probably hitting an issue with the way that closures work in javascript (and many other languages).

    for(var i = 0; i < elevators.length; ++i) {
        elevator[i].on("floor_button_pressed",
             function(floorNum){ elevator[i].goToFloor(floornum)});
    }

Doesn't do what one might expect. When the anonymous function is invoked, it looks up the value of the 'i' identifier, which will have changed it's value to elevators.length by the end of the loop. To get the behavior you want, I've seen people do

    for(var i = 0; i < elevators.length; ++i) {
        (function(i){
            elevator[i].on("floor_button_pressed",
                function(floorNum){ elevator[i].goToFloor(floornum)});
        })(i);
    }

This creates a new scope, which ensures that 'i' has the value that was passed in. I'm afraid I'm a little too tired to look up the parts of the spec that make the semantics clear.

Dev here. :)

They spawn at a fixed rate, but at random floors, with 50% spawning at the bottom floor.

I agree it would be more interesting if there were patterns, distributions, more popular floors etc. Haven't gotten around to implementing it. There's a small unused bit of code here intended for this: https://github.com/magwo/elevatorsaga/blob/master/challenges...

Okay, didn't read or look (currentFloor is already defined) and this won't work in this context.

Here is another approach that brought me through till challenge #7:

    {   
        init: function(elevators, floors)  // hook up events
        {
            // these are the global wish lists that idle elevators choose from (key are floor numbers, values are number of people): 
            var wishListUp = {}, wishListDown = {}; 

            for (var i = 0, l = elevators.length; i < l; i++)
            {
                var elevator = elevators[i];
                // API: goToFloor(n) [enqueues], stop() [clears queue], currentFloor(), 
                //      goingUpIndicator([set]), goingDownIndicator([set]), loadFactor() [0..1], 
                //      destinationQueue[], checkDestinationQueue() [after manual update]

                elevator.on("idle", function()  // elevator destination queue finished
                {
                    processWishList();
                }); 

                elevator.on("floor_button_pressed", function(floorNum)  // passenger indicates where to go
                {
                    if (this.destinationQueue.filter(function (d) { return d == floorNum; }).length == 0)  // if not already enqueued
                        this.goToFloor(floorNum);  // enqueue
                    // note: passengers coming first need to be delivered first (or at least at all)
                    //       however, the elevator will check by passing, whether one destination
                    //       can be approached before the others since it comes on the way. 
                }); 

                elevator.on("passing_floor", function(floorNum, direction/*"up"/"down"*/)  // if not in destination queue
                {
                    updateIndicators(this);  // indicate next destination from here
                    // we stop here if the queue contains this destination, 
                    // or if a passenger on the global wish list want to go in our direction. 
                    // we can only hope that people check where the elevator is going. 
                    if (this.destinationQueue.filter(function(d) { return d == floorNum; }).length > 0)
                    {
                        this.destinationQueue = this.destinationQueue.filter(function(d) { return d != floorNum; });  // remove from later
                        this.destinationQueue.unshift(floorNum);  // add as immediate next destination
                        this.checkDestinationQueue();  // announce modification
                    }
                    else if (this.loadFactor() < 1.0)  // if there is some space left
                    {
                        switch (getDirection(this))
                        {
                            case 1:  // going up
                                if (wishListUp[floorNum])  // are people waiting to go up from here?
                                {
                                    //if ((1.0 - this.loadFactor()) * 10.0 - wishListUp[floorNum] > 0)  // assume capacity for 10 people with regular weight
                                    //    delete wishListUp[floorNum];  // mark as visited
                                    this.destinationQueue.unshift(floorNum);  // add as immediate next destination
                                    this.checkDestinationQueue();  // announce modification
                                }
                                break;
                            case -1: // going down
                                if (wishListDown[floorNum])  // are people waiting to go down from here?
                                {
                                    //if ((1.0 - this.loadFactor()) * 10.0 - wishListDown[floorNum] > 0)  // assume capacity for 10 people with regular weight
                                    //    delete wishListDown[floorNum];  // mark as visited
                                    this.destinationQueue.unshift(floorNum);  // add as immediate next destination
                                    this.checkDestinationQueue();  // announce modification
                                }
                                break;
                            case 0:  // final destination
                            default: 
                                break; 
                        }
                    }
                }); 

                elevator.on("stopped_at_floor", function(floorNum)  // one destination reached
                {
                    processWishList(); 
                    updateIndicators(this);  // next direction
                });
            }

            for (var i = 0, l = floors.length; i < l; i++)
            {
                var floor = floors[i];
                // API: floorNum()

                floor.on("up_button_pressed", function()  // somebody wants to go up from a certain floor
                {
                    // elevators are choosing their next best destination, 
                    // we just enqueue this into the global wish list queue: 
                    var f = this.floorNum(); 
                    if (wishListUp[f])
                        wishListUp[f]++; 
                    else
                        wishListUp[f] = 1;
                    processWishList(); 
                }); 

                floor.on("down_button_pressed", function()  // somebody wants to go down from a certain floor
                {
                    // elevators are choosing their next best destination, 
                    // we just enqueue this into the global wish list queue: 
                    var f = this.floorNum();
                    if (wishListDown[f])
                        wishListDown[f]++;
                    else
                        wishListDown[f] = 1;
                    processWishList();
                });
            }


            function processWishList()  // give idle elevators a new destination
            {
                for (var i = 0, l = elevators.length; i < l; i++)  // idle
                {
                    var elevator = elevators[i]; 
                    if (elevator.destinationQueue.length == 0)
                    {
                        var next = chooseFloor(elevator.currentFloor(), true);  // find closest wish
                        if (elevator.currentFloor() != next)
                            elevator.goToFloor(next); 
                    }
                }
            }

            function getDirection(elevator)
            {
                if (elevator.destinationQueue.length == 0)
                    return 0;  // nowhere
                else if (elevator.currentFloor() < elevator.destinationQueue[0])
                    return 1;  // up
                else
                    return -1;  // down
            }

            function chooseFloor(currentFloor, dequeue)
            {
                // choose next destination from the global wish lists for up and down, 
                // depending on a) closest distance and b) number of waiting passengers: 
                var wishList = {};  // joined up and down lists with passenger counts
                var floors = [];  // array of distinct floor numbers
                for (var i in wishListUp)
                {
                    wishList[i] = wishListUp[i]; 
                    floors.push(i); 
                }
                for (var i in wishListDown)
                    if (wishList[i])
                        wishList[i] += wishListDown[i];
                    else
                    {
                        wishList[i] = wishListDown[i];
                        floors.push(i); 
                    }
                floors.sort(function(a, b)
                    { 
                        var res = Math.abs(currentFloor - a) - Math.abs(currentFloor - b);  // by closeness asc
                        if (res == 0)
                            res = wishList[b] - wishList[a];  // by passengers waiting desc
                        return res; 
                    }); 
                if (floors.length == 0)
                    return 0;  // nothing to do, go back to base
                var next = floors[0];
                if (dequeue)
                {
                    if (wishListUp[next])
                        delete wishListUp[next]; 
                    if (wishListDown[next])
                        delete wishListDown[next];
                }
                return next; 
            }

            function updateIndicators(elevator)
            {
    return;  // there seems to be a bug if announcing, people do not react ..
                switch (getDirection(elevator))
                {
                    case 1:  // up
                        if (!elevator.goingUpIndicator())
                            elevator.goingUpIndicator(true);
                        if (elevator.goingDownIndicator())
                            elevator.goingDownIndicator(false);
                        break; 

                    case -1:  // down
                        if (elevator.goingUpIndicator())
                            elevator.goingUpIndicator(false);
                        if (!elevator.goingDownIndicator())
                            elevator.goingDownIndicator(true);
                        break; 

                    case 0:  // nowhere
                    default: 
                        if (elevator.goingUpIndicator())
                            elevator.goingUpIndicator(false);
                        if (elevator.goingDownIndicator())
                            elevator.goingDownIndicator(false);
                        break; 
                }
            }
        },

        update: function(time, elevators, floors)  // loop during operation, called each frame
        {
        }, 

        vendor: 'frevd'
    }

Good find!

Clearing cookies/localstorage should fix that for you, at least until the devs figure out a fix :)

Why do you have conditionals written like this: if (elevator.goingUpIndicator() == true)? Why not just: if (elevator.goingUpIndicator())?

here mine: https://gist.github.com/eridal/7ce55190837801811067

side note: why are you using underscore? I wanted to try your code, but doesn't work out-of-the-box.

lol

Non-programmer here playing. It gamifies coding for sure. Intended purpose unknown.

If the makers read this, firstly this is brilliant. Second my feature request would be to have some record of history to watch how I improve (or not) each simulation.

Arguably https://www.bloc.io/ruby-warrior (warning: sound autoplays) - although there's something direct and storyless about the elevator one that I prefer.

http://www.pythonchallenge.com/ - Gamified way to learn Python, but is a puzzle in addition to being a game. Is not exclusive to Python, but many things are intended to be solved with things that are idiomatic in Python.

www.checkio.org - Looks more like a game, but the programming environment feels more "in-your-face" than elevator saga to me.

This one was on HN a few months ago: https://alexnisnevich.github.io/untrusted/

It's JavaScript, everything is a global! (so long as you don't declare it with var)