Run the "Oracle Billiards" shortcut.


Controls:

SPACEBAR to shoot the cue ball.

W, S control the power of the shot (see the meter to the right of the play field).
A, D rotate the play field (you always shoot the cue ball straight up).

Z, C rotate the play field more slowly so that you can see the ball interactions better.

1, 2, 3 restart the game with different rack setups.

There's no way to win (or even sink balls into pockets, or anything like that).


Questions to Jonathan Blow, jon _at_ number-none.com.

Much of Oracle Billiards is written in the programming language Lerp (http://lerp.org).  
Though this is a pretty old version of Lerp (from 2004) so if you want to know what
the language is like, this isn't the greatest example.




Here's an explanation of what this is all about (excerpted from an interview Arthouse Games
and not particularly edited):




The idea for Oracle Billiards came about one day when I saw the film Matrix Reloaded.  The
film was terrible, for sure, but there were some very specific things about it that 
triggered me.  One of the things I liked about the first Matrix movie was the character 
of the Oracle; the first movie seemed to have set up some interesting questions about 
her, but Reloaded dropped the ball completely, and I was really pissed off.

It seemed to me that the ability to see the future was fundamentally way, way more 
interesting than those guys were making it out to be.  So I thought about how to explore 
that in a game, and pretty quickly I came up with the design behind Oracle Billiards.  
It's a standard pool game -- you knock the cue ball and it hits some other balls, and 
they roll for a while and stop.  In all games like that there is a physics simulator 
that controls what the balls do -- how they slow down, how they bounce off walls and 
each other.  All that stuff is modelable by some basic math that you learn in high 
school or college.

The interesting thing, though, is that this math is deterministic -- given a certain 
starting state of the balls (positions, velocities, sizes, coefficients of friction, 
and what have you), there is exactly one answer for any future point in time about 
where the balls will be, unless you decide to explicitly introduce a random element.  
Some pool games do add such a random element, but I decided to keep it out of the 
design here.

So for a particular shot direction and force, there's exactly one future about how 
the balls will come to rest.  The premise behind Oracle Billiards is that you can 
see that future before you make the shot.  (Nobody had really done this before, 
not only because it's a different idea but because it requires a lot of CPU power.  
In order to show you where the balls end up, every frame the game has to crank through 
all of the physics computations for the 30 seconds or so that it would take the balls 
to come to rest... in 1/60 of a second or so.  But computers are fast now, so I figured, 
why not?)

This ability to see the results of the shot before you shoot, fundamentally changes the 
nature of the game.  It changes things from an aiming game into a strategy game; the 
aiming isn't a problem, you just need to decide strategically where you want the balls 
to end up, so that you sink a lot of yours, few of your opponents, and give him a poor 
position to make his own shot.  I'm not an expert billiards player, but it seems that 
this is a lot more like the way the game is for expert players -- they are pretty good 
at making the shots, so they are really planning ahead and making choices about which 
shots to take.  So in addition to the basic mind-expanding nature of the game, it also 
gives you something like a glimpse into what the game is like for a small percentage of 
elite players, and that is interesting.

This was a little prototype and never reached a stage of serious development.  I never 
got to the point of even adding pockets so that you can sink balls and win.  The reason 
is that, whereas the game accomplished what I set out to do, the way it felt to play was 
not what I envisioned.  I had hoped it could be an interesting strategy game, but it's 
not, really.  The reason is that the physical interactions of the balls are far too 
chaotic for the visualization to help you make a plan.  Small differences in angle are 
magnified hugely with each collision, so that slight changes in your aiming direction 
result in very fast changes to where the balls end up, so that it's very difficult to 
inspect the space and really make any kind of informed decision from the available choices.

My first attempt to deal with this problem was to add in the keys so that you can turn 
your shot very slowly and precisely.  But it didn't help enough, so I decided that the 
billiard-balls-physics phenomenon was inherently too chaotic for this kind of game.  
(And this chaos also illustrates that the game in't that close to what it's like for 
an expert to play, either -- trying to capture that, to discover how those players 
really see the play field and separate some possibilities from all the others, would 
be a really interesting exploration in cognitive science). 



[Despite the fact that the strategy part didn't work out, there were some interesting 
side-effects from the game that I wouldn't expect.  For example: watching balls rolling, 
you see two of them heading toward each other; normally you wouldn't be sure yet whether 
they are going to collide, but you see that the endpoints for the balls are off to the 
sides, not directly in their paths -- so they must collide, and you can visualize the 
collision in your head, but what you envision doesn't necessarily put the balls where 
it says they will go.  But then the collision happens, and they go right there.  It 
feels pretty surreal.]