For starters, speed up/down? You're setting it to the same value for up and down. You need to be adding/subtracting it (for modifying velocity while you hold the key), OR, at least set them to .1 and 0, or .1 and -1 (two specific velocities).

So you want (in old A4 code):

if(key[KEY_UP])object.speed += 0.1; // some acceleration value
if(key[KEY_DOWN])object.speed -= 0.1;

Your object should have the following values:

struct object{
float x;
float y;
float angle; //the angle of the vector (where the car is pointing)
float speed; //where speed is actually the LENGTH of the vector (how fast it moves in a given time)
}; //NOT x_vel and y_vel!

(GET RID OF X_VEL and Y_VEL, more on that at the bottom.)*

Every logic frame (cycle of your main loop) represents a point in time. Those frames represent equally long periods of time. So if your time was 1 second, and your car moved 10 feet, that means your car is moving at 10 feet/sec.

So every logic frame you do:

 x = x + cos(angle) * speed;
 y = y + sin(angle) * speed;

We take the original x and y, add a vector that represents that movement. If it was ten feet per second, and your logic is a second (normally much smaller than that), then speed = 10. If your car is moving to the right, the angle is 0 degrees. So angle = 0. That's it. Keep adding the x/y every frame and the car keeps moving 10 feet per frame.

Now let's say you turn your car to the left. All you have to do is turn the angle value to point to the left [TYPO: not RIGHT]! Positive angles are COUNTER-clockwise, so we add a positive value to the angle, and boom, we're now moving to the left of where we were (but still probably right on the screen). To turn right, decrease the angle by adding a negative number to it. You don't even have to loop the angle at 0 and 360 degrees, sin and cos work just fine with 300, 600, 52000 degrees (or Radians).

if(key[KEY_LEFT])angle -= 0.1; //turn left
if(key[KEY_RIGHT])angle += 0.1; //turn right

That's it!

[edit]

*x_vel and y_vel are something similiar. (x_vel, y_vel) and (angle, distance) are actually the exact same thing. They're just in a different format. If you wanted say, gravity to be down, you could either do:

y += y_gravity_vel; 
//OR 
y += sin(gravity_angle)*gravity_velocity;

As long as the angle points down, it's the same thing. You just use whatever format is more convenient. But a car has a direction, and a velocity, so it's much easier to keep the object in that angle, distance format. It's not wrong, or broken, but more convenient and natural to think of a car that way. Whereas for a ball falling, I tend to use y_vel.

Glad to hear it! If there's any areas that need clarification or elaboration, please let me know.

2 * PI radians = a full circle

4.713 / 2*pi = 0.75 = 75% rotated all the way around the circle.

Now, in normal math +x is right, +y is up. BUT, for a computer screen, 0,0 is the top-left. So that means that +y is DOWN. The y-axis is flipped.

So where as 0 degrees (0 radians) is to the right (+x), when you rotate positive 90 degrees (1.57... radians) it looks like you're rotating clockwise! But we know from that normal math says positive 90 should be counter-clockwise. That's because you've flipped the y-axis 180 degrees (because we're using positive Y values DOWNWARD from the screen).

So you can do one of two things:

1 - Use opposite angles.
2 - Flip the y coordinate back!
3 - Flip the angles.

1) Angles are angles, whether you assume 0 is up, right, left, or down, or somewhere inbetween is entirely up to you. But you will have to convert your coordinates accordingly. So if you leave things exactly as they are, you can just use negative or (360 - angle) to be your angle.

2) Flip the y-coordinate back:

Instead of using draw_thing(x, y), you do draw_thing(x, y - SCREEN_HEIGHT). Boom, that's it. 0 on the y axis is now at the bottom, and positive y values move upward.

3) Flip the angles.

I don't really recommend it because it can get confusing, but you can use variations of sin/cos to do a coordinate transformation to fix the angle issue.

 x = sin(angle)*distance;// normally cos!
 y = cos(angle)*distance;// normally sin!

or some combination of:

 x = -cos(angle)*distance;
 y = -sin(angle)*distance;

or

 x = cos(-angle)*distance;
 y = sin(-angle)*distance;

or

 x = cos(2*PI - angle)*distance;
 y = sin(2*PI - angle)*distance;

You don't necessarily change both lines of sin/cos. I don't recall the trig off the top of my head, so tread carefully. I don't recommend this route, I just want you to see that it's possible to move coordinates many different ways, whether it's internally in the objects x/y, or converting at the very end by changing the rendering direction.

This is all great stuff to be learning and exactly what I wanted to be doing when I started this project, to learn while 'doing'

I think for now I'll leave the angles how it is, now that I understand that +y is downwards and where the figure 4.713 comes from.

Thanks guys!

I will have more questions later