I made a brick breaker game that works pretty well besides a few problems with the ball and brick collisions. I have it set up so if the ball touches a brick just its y-speed will change, but I need it to be able to detect the sides of bricks also. I'm not quite sure how to do this though. I think booleans could work well, but I don't know how to set it up so just the sides or just the top and bottom are detected. 

Here is my overall code: 

2. 
   
3. void setup() {
4.   size(800, 600);
5.   smooth();
6.   variables();
7. 
   
8.   bricklist = new ArrayList();
9.   for (int tx = 0; tx <= 9; tx++) {
10.     for (int ty = 0; ty <= layers-1; ty++) {
11.       bricklist.add(new Brick(tx*w+w/2, ty*h+h/2, ceil(random(4))));
12.     }
13.   }
14. }
15. 
    
16. void draw() {
17.   background(0);
18.   gamestarter();
19.   win_loss();
20.   next_level();
21.   complete_victory();
22.   paddle();
23.   ball();
24.   screen_ballConstraints();
25.   ball_paddleConstraints();
26. 
    
27.   for (int i = bricklist.size()-1; i >= 0; i--) {
28.     Brick onebrick = (Brick) bricklist.get(i);
29.     onebrick.display();
30.     if (onebrick.collision(bx, by, bsize)) {
31.       bspeedy *= -1;
32.       bricklist.remove(i);
33.     }
34.   }
35. }
36. 
    
37. 
    
38. float px, py, bx, by, bspeedx, bspeedy, direction;
39. int pwidth, pheight, pspeed, bsize, w, h, layers;
40. boolean left, right, started;
41. ArrayList bricklist;
42. 
    
43. void variables() {
44.   px = width/2;
45.   py = height-20;
46.   pwidth = 100;
47.   pheight = 15;
48.   pspeed = 3;
49.   left = false;
50.   right = false;
51.   bx = width/2;
52.   by = height/2;
53.   bsize = 20;
54.   bspeedx = 0;
55.   bspeedy = 0;
56.   started = false;
57.   w = width/10;
58.   h = 20;
59.   layers = 4;
60.   direction = 0;
61. }
62. 
    
63. void keyPressed() {
64.   if (key == CODED) {
65.     if (keyCode == LEFT) {
66.       left = true;
67.     }
68.   }
69.   if (key == CODED) {
70.     if (keyCode == RIGHT) {
71.       right = true;
72.     }
73.   }
74. }
75. 
    
76. void keyReleased() {
77.   if (key == CODED) {
78.     if (keyCode == LEFT) {
79.       left = false;
80.     }
81.   }
82.   if (key == CODED) {
83.     if (keyCode == RIGHT) {
84.       right = false;
85.     }
86.   }
87. }
88. 
    
89. 
    
90. void paddle() {
91.   if (left == true) {
92.     pspeed = 4;
93.     px -= pspeed;
94.   } 
95.   else {
96.     if (left == false) {
97.       pspeed = 0;
98.     }
99.   }
100. 
     
101.   if (right == true) {
102.     pspeed = 4;
103.     px += pspeed;
104.   } 
105.   else {
106.     if (right == false) {
107.       pspeed = 0;
108.     }
109.   }
110. 
     
111.   fill(255);
112.   rectMode(CENTER);
113.   rect(px, py, pwidth, pheight);
114. }
115. 
     
116. void ball() {
117.   bx += bspeedx;
118.   by += bspeedy;
119. 
     
120.   fill(255);
121.   ellipse(bx, by, bsize, bsize);
122. }
123. 
     
124. void ball_paddleConstraints() {
125.   if (bx > px-pwidth/2 && bx < px+pwidth/2 && by+bsize/3 > py-pheight) {
126.     bspeedy *= -1;
127. 
     
128.     if (bx > px) {
129.       direction = (dist(bx, by+bsize/2, px, py-pheight/2))*-1;
130.     }
131.     if (bx < px) {
132.       direction = dist(bx, by+bsize/2, px, py-pheight/2);
133.     }
134. 
     
135.     bspeedx = direction/10;
136.   }
137. }
138. 
     
139. void screen_ballConstraints() {
140.   if (bx+bsize/2 > width || bx-bsize/2 < 0) {
141.     bspeedx *= -1;
142.   }
143.   if (by-bsize/2 < 0) {
144.     bspeedy *= -1;
145.   }
146. }
147. 
     
148. 
     
149. class Brick {
150.   float x, y;
151.   int w, h;
152.   int c;
153. 
     
154.   Brick(float X, float Y, int C) {
155.     x = X;
156.     y = Y;
157.     c = C;
158. 
     
159.     w = width/10;
160.     h = 20;
161.   }
162. 
     
163.   void display() {
164.     if (c == 1) {
165.       fill(#FF0303);
166.     }
167.     if (c == 2) {
168.       fill(#FFF703);
169.     }
170.     if (c == 3) {
171.       fill(#03FF04);
172.     }
173.     if (c == 4) {
174.       fill(#0A03FF);
175.     }
176.     rect(x, y, w, h);
177.   }
178. 
     
179.   boolean collision(float Bx, float By, float Bsize) {
180.     if ((bx+bsize/2 > x-w/2) &&
181.       (bx-bsize/2 < x+w/2) &&
182.       (by-bsize/2 < y+h/2) &&
183.       (by+bsize/2 > y-h/2)) {
184.       return(true);
185.     } 
186.     else {
187.       return(false);
188.     }
189.   }
190. }
191. 
     
192. 
     
193. void gamestarter() {
194.   if (keyPressed && started == false) {
195.     if ( key == ENTER || key == RETURN) {
196.       bspeedy = 4;
197.       started = true;
198.     }
199.   }
200. }
201. 
     
202. void next_level() {
203.   if (bricklist.size() == 0 && started == true) {
204.     if (keyPressed) {
205.       if (key == ENTER || key == RETURN) {
206.         background(0);
207.         bx = width/2;
208.         by = height/2;
209.         px = width/2;
210.         py = height-20;
211.         bspeedx = 0;
212.         bspeedy = 0;
213.         layers += 1;
214. 
     
215.         for (int tx = 0; tx <= 9; tx++) {
216.           for (int ty = 0; ty <= layers-1; ty++) {
217.             bricklist.add(new Brick(tx*80+40, ty*20+10, ceil(random(4))));
218.           }
219.         }
220.         started = false;
221.       }
222.     }
223.   }
224.   if (by+bsize/2 > height) {
225.     if (keyPressed) {
226.       if (key == ENTER || key == RETURN) {
227.         background(0);
228.         bx = width/2;
229.         by = height/2;
230.         px = width/2;
231.         py = height-20;
232.         bspeedx = 0;
233.         bspeedy = 0;
234.         layers = 4;
235. 
     
236.         for (int tx = 0; tx <= 9; tx++) {
237.           for (int ty = 0; ty <= layers-1; ty++) {
238.             bricklist.add(new Brick(tx*80+40, ty*20+10, ceil(random(4))));
239.           }
240.         }
241.         started = false;
242.       }
243.     }
244.   }
245. }
246. 
     
247. void complete_victory() {
248.   if (bricklist.size() == 0 && layers == 8) {
249.     background(0);
250.     bspeedx = 0;
251.     bspeedy = 0;
252.     textAlign(CENTER);
253.     textSize(40);
254.     fill(255);
255.     text("You are a SUPER AWESOME and", width/2, height/2);
256.     text("have completed EVERY LEVEL!", width/2, height/2+40);
257.     noLoop();
258.   }
259. }
260. 
     
261. void win_loss() {
262.   if (bricklist.size() == 0) {
263.     bspeedx = 0;
264.     bspeedy = 0;
265.     textAlign(CENTER);
266.     textSize(40);
267.     fill(255);
268.     text("You are a WINNER!", width/2, height/2);
269.   }
270.   if (by+bsize/2 > height) {
271.     bspeedx = 0;
272.     bspeedy = 0;
273.     textAlign(CENTER);
274.     textSize(40);
275.     fill(255);
276.     text("You are a LOSER!", width/2, height/2);
277.   }
278. }