You probably should post your code.

You know where the car is.

I can't find where you deal w/ user input in your game!

That was a mistake of copy/paste. I do have that code in there.

Here is my best attempt so far to make this work.  Within the draw();

  for (int i = 0; i < 10; i++) {
    if (xposCar == xposGrape && yposCar == yposGrape) {
      newGrape.tele();
    }
  }

And here is the tele() function within the Grape Class.

void tele() {
    xpos = int(random(width));
    ypos = int(random(height));
    xposGrape = xpos;
    yposGrape = ypos;
   }
}

Nothing happens when the car goes over the grape. I have to stop now and go find some perspective.

Thanks for your suggestions GoToLoop. I was not able to understand any of the examples you posted. However, I had not known of that website previously, so thank you for the new resource. :)

Another way to do this is to use the dist( ) function. 
You know where the car is and where the grape is. 
You know how big the car is and how big the grape is.
if the car gets too close to the grape, they collide.

float d = dist( carX, carY, grapeX, grapeY );
if ( d <  some variable that is the minimum safe distance to avoid a collision)
   move the grape

One advantage of this approach is that you can make the game harder by altering the minimum distance variable every time they squash some number of grapes.

Hope this helps

Thank you for the the advice and resources, all. I have been trying to improve the functionality of this "car" by having it move diagonally. 

Hello,

here comes a working version........


one problem we had was that you didn't call the move-methods of the car. No surprise the car didn't move

Another problem was that you had global vars

1. float xposGrape;
2. float yposGrape;
3. float xposCar;
4. float yposCar;

that were part of the class.

I also made a better if-clause for collision.

On collision, the old grape gets over written with a new one (new color, new pos)

I also made the grape move for test purposes. Otherwise we don't have collisions.


your questions
1. see above
2. final means make a var a constant (then it is written in capitals, see 5)
3. when you know a var is const the code is better readable. You know the value stays put.
4. curly brackets are used to make a block of lines { } - all lines within that block belong to if. When there's only one line, the { } are not needed.
5. see 2


Good luck to you!


Greetings, Chrisir   

1. Car myCar;
2. Grape newGrape;
3. void setup() {
4.   size(500, 500);
5.   myCar = new Car();
6.   newGrape = new Grape();
7. }
8. void draw() {
9.   background(255);
10. 
    
11.   newGrape.ypos+=1.6;
12.   if (newGrape.ypos>height)
13.     newGrape.ypos=0;
14. 
    
15.   if (myCar.xpos >= newGrape.xpos-10 && myCar.ypos >= newGrape.ypos-10 &&
16.     myCar.xpos <= newGrape.xpos+10 && myCar.ypos <= newGrape.ypos+10 ) {
17.     println ("hit");
18.     newGrape = new Grape();
19.   }
20.   else {
21.     newGrape.display();
22.   }
23.   myCar.moveRight();
24.   myCar.moveUp();
25.   myCar.display();
26. }
27. // ===============================================
28. class Car {
29.   color c;
30.   float xpos;
31.   float ypos;
32.   float speed;
33.   int sizeW = 20;
34.   int sizeH = 10;
35.   float topBorder = ypos - sizeW/2;
36.   float bottomBorder = ypos + sizeW/2;
37.   float rightBorder = xpos + sizeH/2;
38.   float leftBorder = xpos - sizeH/2;
39.   Car() {
40.     c = color(175);
41.     xpos = width/2;
42.     ypos = width/2;
43.     speed = 5;
44.   }
45.   void display() {
46.     rectMode(CENTER);
47.     stroke(0);
48.     fill(c);
49.     rect(xpos, ypos, 20, 10);
50.   }
51.   void moveRight() {
52.     xpos = xpos + speed;
53.     if (xpos > width) {
54.       xpos = 0;
55.     }
56.   }
57.   void moveLeft() {
58.     xpos = xpos - speed;
59.     if (xpos < 0) {
60.       xpos = width;
61.     }
62.   }
63.   void moveUp() {
64.     ypos = ypos - speed;
65.     if (ypos < 0) {
66.       ypos = height;
67.     }
68.   }
69.   void moveDown() {
70.     ypos = ypos + speed;
71.     if (ypos > height) {
72.       ypos = 0;
73.     }
74.   }
75. }
76. 
    
77. // ===============================================
78. 
    
79. class Grape {
80.   color c;
81.   float xpos;
82.   float ypos;
83.   //  float speed;
84.   Grape() {
85.     c = color(random(216), 44, 208);
86.     xpos = int(random(width));
87.     ypos = int(random(height));
88.     //    speed = 5;
89.   }
90.   void display() {
91.     rectMode(CENTER);
92.     stroke(0);
93.     fill(c);
94.     rect(xpos, ypos, 10, 10);
95.   }
96. }
97. // ===============================================

Thanks for this response! A very interesting rendition of the 'game', but not what I am trying to accomplish. :)

I am very sorry, I overlooked your new version on openprocessing.org and was referring to the old version above

Hello,

In the version on openprocessing.org, your car moves.
But not diagonally.

Is your expectation that the car moves diagonally when hold cursor up and cursor right simultaneously?
Hm.... not sure that works at all
Maybe processing can only check one key at a time?


keyPressed inside a class
A problem could be that you have the function
Same goes for

1.     if (k == ENTER | k == RETURN)

should be
Should give you an error.

Greetings, Chrisir    

could you post your entire code please?

check out V.2 on openprocessing

here you go...

problems were:

• you had the var speed declared on a global level (before setup()) and also in the class; only on a global level it was set to 7, the var speed in the class over ruled that and this speed was 0. So you ended up adding 0 to the position of the car. Remeber to put all vars in the class that belong to it. Same goes for position and Borders.
• keyPressed and KeyReleased don't belong in the class. They are called automatically but can only be called automatically by processing when they are not in the class but top level in the program (like setup() and draw()).

1. //    Car Game v.3
2. //
3. Car myCar;
4. Grape newGrape;
5. //
6. // =========================================================
7. void setup() {
8.   size(500, 500);
9.   myCar = new Car();
10.   newGrape = new Grape();
11. }
12. void draw() {
13.   background(255);
14.   //
15.   newGrape.display();
16.   myCar.display();
17.   myCar.move();
18.   //
19.   if (rectangle_collision (myCar.xpos, myCar.ypos, myCar.sizeW, myCar.sizeH,
20.   newGrape.xpos, newGrape.ypos, newGrape.sizeW, newGrape.sizeH)) { 
21.     // println ("hit");
22.     newGrape = new Grape();
23.   }
24. }
25. //
26. boolean rectangle_collision(float x_1, float y_1, float width_1, float height_1,
27. float x_2, float y_2, float width_2, float height_2)
28. // from PhiLho
29. {
30.   return !(x_1 > x_2+width_2 || x_1+width_1 < x_2 || y_1 > y_2+height_2 || y_1+height_1 < y_2);
31. }
32. // =========================================================
33. void keyPressed() {
34.   int k = keyCode;
35.   if (k == ENTER | k == RETURN)
36.     myCar.speed = myCar.speed + 1;
37.   else if (k == ' ') 
38.     myCar.speed = myCar.speed - 1;
39.   else if (k == UP)     myCar.up    = true;
40.   else if (k == DOWN)   myCar.down  = true;
41.   else if (k == LEFT)   myCar.left  = true;
42.   else if (k == RIGHT)  myCar.right = true;
43. }
44. void keyReleased() {
45.   int k = keyCode;
46.   if      (k == UP)     myCar.up    = false;
47.   else if (k == DOWN)   myCar.down  = false;
48.   else if (k == LEFT)   myCar.left  = false;
49.   else if (k == RIGHT)  myCar.right = false;
50. }
51. // =========================================================
52. class Car {
53.   color c;
54.   float xpos;
55.   float ypos;
56.   float speed=7;
57.   int sizeW = 50;
58.   int sizeH = 50;
59.   boolean up, down, left, right;
60.   float topBorderC;
61.   float bottomBorderC;
62.   float rightBorderC;
63.   float leftBorderC;
64.   Car() {
65.     c = color(175);
66.     xpos = width/2;
67.     ypos = width/2;
68.     setBordersC() ;
69.   }
70.   void setBordersC() {
71.     topBorderC = ypos - sizeW/2;
72.     bottomBorderC = ypos + sizeW/2;
73.     rightBorderC = xpos + sizeH/2;
74.     leftBorderC = xpos - sizeH/2;
75.   }
76.   void display() {
77.     rectMode(CENTER);
78.     stroke(0);
79.     fill(c);
80.     rect(xpos, ypos, sizeW, sizeH);
81.   }
82.   void move() {
83.     if (up)    ypos -= speed;
84.     if (down)  ypos += speed;
85.     if (left)  xpos -= speed;
86.     if (right) xpos += speed;
87.   }
88. }
89. // =========================================================
90. class Grape {
91.   color c;
92.   float xpos;
93.   float ypos;
94.   int sizeW = 10;
95.   int sizeH = 10;
96.   float topBorderG;
97.   float bottomBorderG;
98.   float rightBorderG;
99.   float leftBorderG;
100.   //  float speed;
101.   Grape() {
102.     c = color(random(180, 255), 44, 208);
103.     xpos = int(random(width));
104.     ypos = int(random(height));
105.     setBordersG();
106.   }
107.   void setBordersG() {
108.     topBorderG = ypos - sizeW/2;
109.     bottomBorderG = ypos + sizeW/2;
110.     rightBorderG = xpos + sizeH/2;
111.     leftBorderG = xpos - sizeH/2;
112.   }
113.   void display() {
114.     rectMode(CENTER);
115.     stroke(0);
116.     fill(c);
117.     setBordersG();
118.     rect(xpos, ypos, sizeW, sizeH);
119.   }
120.   void tele() {
121.     xpos = int(random(width));
122.     ypos = int(random(height));
123.   }
124. }
125. // =========================================================

A little late, but here's my reply:

1. Sometimes I see only 'final' or only 'static' and other times both. What is the difference? How does one know when to use what combination?
2. If I am working with a variable that I know will not change is it best to use these terms de facto?

You can see both Java keywords @ Processing's reference:
http://processing.org/reference/final.html
http://processing.org/reference/static.html

The static keyword has a very limited use in Processing, so you don't need to worry about that too much. 
Just take notice that only field variables can be static. Local ones can't.
Its advantage is that we can access a field or a method from a class w/o instantiating it 1st if they are static!
Also, a static field variable is shared among all instantiated objects from a class. And thus avoids redundancy.

The final keyword is very handy for someone examining your source code for debugging.
For it's assured its stored value won't change later once set. So it's 1 less problem to worry about! 

And if it happens a field variable be of a primitive type as well, Java compiler replaces all occurrences of it
for its real literal constant value, thus boosting performance a tiny little! 

And if a primitive field variable is final, it also makes sense to declare it static.
Since it's a constant, there's no need to make redundant copies of it when its class is instantiated. 

And as you've noticed already, it's a Java's convention to make final field labels be in all caps.

And sorry for my example below:
http://studio.processingtogether.com/sp/pad/export/ro.9bY07S95k2C2a/latest
wasn't using 100% Java's naming convention yet.

It's an old code example and I was still in transition to be fully compliant for it! 
It's correct now. Check that out! 

Thanks again for taking time to look through my code. All of these suggestions and coaching has really been a help. 

Generally, keep them in the same thread, while reposting your current progress like you did!