1. void s() {
2.   if (keys[0] && keys[1]) { // same as if(key[0] == true && key[1] == true)
3.     p.z+= (-0.1+0.1);
4.   }
5.   else if (keys[0] && !keys[1]) {
6.     p.z+= (-0.1+0);
7.   }
8.   else if (!keys[0] && keys[1]) {
9.     p.z+= (0.0+0.1);
10.   }
11.   else {
12.     p.z+=(0+0);//well... not really needed...
13.   }
14.   if (keys[2]) {
15.     v+=0.1;
16.   }// not making the unneeded here v+=0;
17.   p.x=(p.x+width+v*cos(p.z))%width;
18.   p.y=(p.y+height+v*sin(p.z))%height;
19.   v*=.99;
20. } 

someVar = condition?  ifTrue:ifFalse;

or

1. x = x>2?  x+1:x-1;

if x bigger than 2 sum one otherwise subtract one

It was intentionally written to be confusing so that you would have trouble understanding it, and thus would have to understand and decode it before you could submit it.

But anyway, first thing's first: Let's get you a version of the code that is actually spaced out properly.

You could have done this yourself by using the Ctrl-t shortcut, which automatically formats your code:

Now let's examine the three global variable declarations that this program uses.

They're the first three lines of this program.

First, we have a PVector, p, which is shorthand for an array of three floats, p.x, p.y, and p.z.

p.x and p.y are used to remember the position of the car.

p.z is used to remember the angle at which the car is pointing.

This puts the car in the middle of the screen, pointing to the right as that is how the car is drawn when it is not rotated at all.

Next we have one more float variable, v.

v initially is set to 0.

v is used to remember the speed that the car is currently moving.

And finally we have a boolean array, keys, used to record which of the three keys we care about are currently being pressed.

No initial value is set for these booleans, so they default to being false.

This is fine, because we don't expect any keys to be pressed when the program starts.

Next we encounter the setup() function.

This function only runs once, at the start of the program.
This function sets the sketch widow's size with a call to size(), and sets the width and height of the sketch.

setup() also calls smooth(), to make the drawing of the triangle later look smooth.

You can try commenting out smooth() to see what sort of a difference it makes.

Next we see the draw() function.

This function runs about 60 times a second, to draw whatever it is the sketch needs to display.

Our draw function does three things:
1) Draws a solid black background with a call to background(). The 0 means "black".

2) Calls function s().

3) Calls function r().
That's all!
So what makes the car appear and move?
Well, we'll get to that in a bit.
Here's a hint: The functions s() and r() do things too!

Next up we have the keyPressed() and keyReleased() functions.
The only thing that these functions do is call another function, b(), with either a value of true or false as a parameter.

What does this mysterious function b() do?!?
We'll get to that in a bit too.

Like right now, because here's the function b()!

This function takes a single boolean as a parameter.

So what does b() actually do?
First, it checks to see if key is CODED.

If it is, it then checks if keyCode is LEFT, RIGHT, or SHIFT.

Those are the three keys we care about being pressed, remember?
The variable key records what the last key pressed or released was.
If it's a special key, however, then the variable key is assigned the value of CODED and the actual key that was pressed is stored in keyCode.
If b() detects that one of the special keys we care about was the last on pressed, it updates the appropriate one of the three boolean variables in the global variable keys[] with if that key was pressed or released, which is the value of d.

In this way, the value of keys[0] tells us, at all times, if the left arrow is being held down, and the value of keys[1] tells us, at all times, if the right arrow is being held down, and the value of keys[3] tells us, at all times, if the shift key is being held down.

Still with me?

Next, we see the functions s() and r().

Remember that s() and r() are called by draw, and are called about 60 times a second.

The "s" in function s() is short for "simulate".

The "r" in function r() is short for "render".

We'll skip over what s() is doing for right now and look at r().

What does r() do?

It translates the origin of our spacial reference frame to the point (p.x, p.y).
Remember what p.x and p.y are? They're the variables used to remember where our car is.
Then it rotates the spacial reference frame around the origin by some amount p.z.
Remember what p.z is? It's how much our car is rotated.
Next we draw a square and a triangle.
When I wrote it, it was a green square and a clear triangle, but I see now that you've changed it to be a white triangle and a black square.
Since the background is already black, you might as well get rid of the square all together.

Anyway, the function r() is the render function.
It draws a triangle at some position (p.x, p.y) on the screen, and rotates it by some amount p.z.

Now all we need to do is figure out how to determine what p.x, p.y, p.z, and v should be, based on which keys are pressed.

We also need to figure out what the function s() does!
Can you guess that they're the same thing?

So, what does s() do?
Find out.... IN MY NEXT POST!

1. void s() {
2.   p.z+=(keys[0]?-.1:0)+(keys[1]?.1:0);
3.   v+=(keys[2]?.1:0);
4.   p.x=(p.x+width+v*cos(p.z))%width;
5.   p.y=(p.y+height+v*sin(p.z))%height;
6.   v*=.99;
7. }

First, let's break some of those accumulated additions apart:

And now let's expand the shorthands for += and *=.

This is starting to make a lot of sense!
All that's left is to decode lines 11 and 12.
These are the two lines that update the car's position based on it's speed and the direction it is currently pointing.
Let's just look at line 11, which updates the X position, p.x.

p.x=(p.x+width+v*cos(p.z))%width;

In words, this says, "The new position for the car (p.x) is (=) the old position for the car (p.x), plus the width of the window (+width), plus (+) the car's speed (v) in the x direction (*cos(p.z)), mod the width of the window (%width)."

1. final int total_cars = 100;
2. ArrayList<Car> cars = new ArrayList();
3. 
   
4. void setup() {
5.   size(600,400);
6.   smooth();
7.   for( int i=0; i < total_cars; i++ ) cars.add( new Car() );
8. }
9. 
   
10. void draw() {
11.   background(0);
12.   for( int i=0; i < cars.size(); i++ ) cars.get(i).go();
13. }
14. 
    
15. class Car {
16.   float x, y, z, v;
17.   color k;
18.   boolean a, b, c;
19.   Car() {
20.     x=width/2;
21.     y=height/2;
22.     z=random(TWO_PI);
23.     v=random(10);
24.     k=color(random(255), random(255), random(255));
25.     a=b=c=false;
26.   }
27.   void go() {
28.     if ( random(1) > .95 ) a= !a;
29.     if ( random(1) > .95 ) b= !b;
30.     if ( random(1) > .95 ) c= !c;
31.     z+=(a?-.1:0)+(b?.1:0);
32.     v+=(c?.1:0);
33.     x=(x+width+v*cos(z))%width;
34.     y=(y+height+v*sin(z))%height;
35.     v*=.99;
36.     pushMatrix();
37.     translate(x, y);
38.     rotate(z);
39.     noStroke();
40.     fill(k); 
41.     rect(-10, -10, 20, 20);
42.     stroke(0);
43.     noFill();
44.     triangle(-8, -8, 7, 0, -8, 8);
45.     popMatrix();
46.   }
47. }