Let's see some action! Who doesn't love action movies with fast noisy cars, especially those with a lot of crashes? Who doesn't love action shots in ascii art?
The scene is:
Two cars are starting at opposite sides of a straight road (with 60 spaces between). They start driving towards each other at constant speeds. The car to the left drives at 1 space per second, and the one to the right drives at 2 spaces per second.
Obviously, the cars can't pass through each other, so for n ≥ 20, the scene will be two crashed cars with bonnets up at the position where the crash occurred.
As a movie lover, I want to pause the scene now and then, just to enjoy the beauty of it.
Given an integer n (function argument or STDIN), representing the number of seconds from the start of the scene, show the scene at that moment.
This is the starting scene, with 60 spaces between the front wheels:
  __                                                                __
_/  \_                                                            _/  \_
o    o                                                            o    o

this is the scene after 11 seconds:
             __                               __
           _/  \_                           _/  \_
           o    o                           o    o

and this is what it looks like after the crash (note that the bonnets are up after the crash):
                      __    __
                    _/  \/\/  \_
                    o    oo    o

I'm only interested in watching two cars crashing, so spaces, newlines, ++ doesn't matter.
This is code golf, so the shortest code in bytes wins. Answers added later can still win if they are shorter than the current accepted answer.
Labyrinth, 394 386 bytes

I proudly introduce...

&lt;}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111
?                        @
:" }}_47}_95    3""""""""(
 _ :       }    _   }    {=}
 2 23_}29_ _    ;   :      \
 0       ; 3  +_( 3_"  60{ .{.{.
"-_95:}}"" 2  0 ) 2 "  _ _ {
""       _ :  2 _ ."(; } 3 .{
 ;_92}_47} :  _ 0    = : *  ;
           : "" 2 {.{{ . -""(
}}:59_}}:::: "";_ .    {  _ "
}             "   {.{.{.  32.
}}}_95:}}}}_20-


...my new two-dimensional esolang Labyrinth! The code above isn't incredibly well golfed (there are 161 spaces and 25 NOPs, so a better layout could shorten this a lot), but at least I managed to show that the language is usable for non-trivial tasks. :)

How it works

First, a quick overview of the language:


Labyrinth operates on two stacks, main and auxiliary, which can hold arbitrary signed integers. At the bottom of both stacks there is an infinite amount of zeroes.
Commands are individual characters on a 2D grid and they form a maze (that is unknown characters, particularly spaces, are walls). " is a NOP which is not a wall and can be helpful for padding certain paths in the code. As opposed to many other 2D languages, the edges do not wrap around.
The instruction pointer (IP) starts at the first non-wall character (in reading order) moving to the right. @ terminates the program.
If possible, the IP follows corridors (also around bends). If the IP has multiple cells to move to, it will generally turn left if the top of the main stack is negative, move straight ahead if it's zero, or turn right if it's positive. When the IP hits a wall it reverses direction. (There are a few more subtleties, but they shouldn't matter for this code.) This is the only way to implement control flow.
Apart from arithmetic and stack manipulation commands, the source code can be modified at runtime with the four commands &gt;v&lt;^ which will shift a row or column of the source code cyclically by one cell. Which row or column is affected depends on the top of the stack. If the IP's own row or column is shifted, it will move with the shift. This makes it possible to jump from one edge of the source code to the other.


Now for this particular challenge, here is the general idea of the algorithm:


Push the ends of the cars up to the bonnets (i.e. /  \_o    oo    o) onto the auxiliary stack.
Read the input and determine whether to push __ or /\ next.
Push the remainder of the cars (i.e. __    __  _/  \ and two leading spaces) onto the auxiliary stack.
Clamp the input to a maximum value of 20, let's call this N.
Now do the following 3 times:


Print N spaces.
Print 6 stored characters.
Print 60 - 3*N spaces.
Print 6 stored characters.
Print a newline.



Finally, let's look at some parts of the code. The IP starts in the top left corner, on a grid shifting command. The top of the main stack is 0 (which is used as a relative index), so the first row is shifted to the left, which also moves the IP to the right end of the grid. Now the first row is simply executed from right to left, which pushes the first set of fixed characters onto the auxiliary stack:

}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111&lt;


This row shifting is useful for golfing when you want to start with a large amount of linear code.

Next we read the input and push the correct bonnets:

?  
:" 
 _ 
 2 
 0       ;
"-_95:}}""
""       _
 ;_92}_47}


The bit on the left with the three NOPs sends negative results along the top branch and non-negative results along the bottom branch. At the right they are joined back together.

Now follows another large linear section (which could probably be golfed a lot with another row-shifting trick):

   }}_47}_95 
   :       } 
   23_}29_ _ 
           3 
           2 
           : 
           : 
           : 
}}:59_}}:::: 
}
}}}_95:}}}}


This pushes the remainder of the cars onto the auxiliary stack.

Next, we compute min(20, input), which is similar to first branch:

                ;
              +_(
              0 )
              2 _
              _ 0
             "" 2
             "";_
              "  
           _20-


Finally, we have the loop which runs three times to print the lines. Each iteration of the loop contains two small (3x3) loops to print the spaces, as well as two sections to print 6 characters from the auxiliary stack:

                         @
                3""""""""(
                _   }    {=}
                    :      \
                  3_"  60{ .{.{.
                  2 "  _ _ {
                  ."(; } 3 .{
                     = : *  ;
                  {.{{ . -""(
                  .    {  _ "
                  {.{.{.  32.


One nifty trick I'd like to draw attention to is the .{.{. at the right edge. This is a dead end, so apart from the . at the end the code is executed twice, once forward and once backward. This gives a neat way to shorten palindromic code (the catch is that you need to make sure the IP takes the correct turn when exiting the dead end again).