1. //Symbolic constants
2. final String IMAGE_NAME = "Image_file";
3. final int TILES_HORZ = 2;
4. final int TILES_VERT = 2;
5. final int TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
6. final int BTN_HEIGHT = 50;
7. final String FONT_NAME = "Arial";
8. final int EMPTY_GRAY = color(204);
9. //Global variables
10. PImage fullImage;
11. int tileWidth=40;
12. int tileHeight=40;
13. Tile[] tiles = new Tile [TOTAL_TILES+1];
14. PFont font;
15. // image entering stuff
16. int openImages = 0; // counter
17. int lastImage = -1; // which was the last
18. int currentImage = -1;
19. // timer
20. int timer;
21. // game
22. boolean gameWon = false;
23. // ------------------------------------------------------------------
24. void setup()
25. {
26.   size(800, 800);
27.   fullImage = loadImage("Simpsons.jpg");
28.   fullImage.resize(width, height);
29.   tileWidth=width/TILES_HORZ-1 ;
30.   tileHeight=height/TILES_VERT-1 ;
31.   int i=0;
32.   for (int x=0; x<TILES_HORZ; x++) {
33.     for (int y=0; y<TILES_VERT; y++) {  
34.       tiles[i] = new Tile (new Position (tileWidth*x, tileHeight*y), i );
35.       i++;
36.     }
37.   }
38.   i=0;
39.   int imageCode=0;
40.   for (int x=0; x<TILES_HORZ; x++) {
41.     for (int y=0; y<TILES_VERT; y++) {
42.       if (!tiles[i].hasDuplicate) {
43.         int j = int(random (0, tiles.length-1));
44.         while (i==j || tiles[j].hasDuplicate) {
45.           j = int(random (0, tiles.length-1));
46.         }
47.         if (i!=j) {
48.           tiles[i].img  = tiles[j].img;
49.           tiles[i].hasDuplicate=true;
50.           tiles[j].hasDuplicate=true;
51.           tiles[i].theImageCode=imageCode;
52.           tiles[j].theImageCode=imageCode;
53.           imageCode++;
54.         }
55.         else
56.           println ("error");
57.       }
58.       i++;
59.     }
60.   }
61.   textSize(34);
62. }
63. void draw()
64. {
65.   // play
66.   background(0);
67.   // draw it
68.   for (int x=0; x<TOTAL_TILES; x++) {
69.     tiles[x].draw();
70.   }
71.   // if two images are shown we have to check them
72.   if (openImages == 2) {
73.     // vut only after a while
74.     if (timer + 1000 < millis()) {
75.       // two are shown (the user has made his move)
76.       openImages=0; // reset
77.       // check
78.       if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
79.       {
80.         //  correct
81.         println ("Good");
82.         tiles[currentImage].isSolved=true;
83.         tiles[lastImage].isSolved=true;
84.         checkIfSolved();
85.       }
86.       else
87.       {
88.         // not correct
89.         tiles[currentImage].isShown=false;
90.         tiles[lastImage].isShown=false;
91.       }
92.     }
93.   }
94.   if (gameWon) {
95.     fill(255, 1, 1);
96.     text ( "Hurraay!", 10, 60);
97.   }
98. }
99. void mousePressed() {
100.   if (openImages != 2) {
101.     // search  
102.     int x=-1;
103.     for (int x2=0; x2<TOTAL_TILES; x2++) {
104.       if (tiles[x2].mouseInside()) {
105.         //println (x2);
106.         x=x2;
107.         break;
108.       }
109.     }
110.     //
111.     // found?
112.     if (x>-1) {
113.       // yes?
114.       if (tiles[x].mouseInside()) {
115.         tiles[x].isShown=true;
116.         openImages++;
117.         if (openImages == 1) {
118.           lastImage=x;
119.         }
120.         else
121.         {
122.           currentImage=x;
123.           timer=millis();
124.         }
125.       }
126.     } // if
127.   } // if
128. } // func
129. void checkIfSolved() {
130.   int counter = 0;
131.   // Are all shown?
132.   for (int x2=0; x2<TOTAL_TILES; x2++) {
133.     if (tiles[x2].isShown) {
134.       counter ++;
135.     }
136.   }
137.   if (counter==4)
138.   {
139.     println ("You won.");
140.     gameWon = true;
141.   }
142. }
143. ////Button class
144. //class Button
145. //{
146. //  int x, y, w, h;
147. //  void draw()
148. //  {
149. //    stroke(0, 0, 0);
150. //    fill(EMPTY_GRAY);
151. //    rect(x, y, w, h);
152. //    rect(x, y, w, h);
153. //  }
154. //  boolean mouseInside()
155. //  {
156. //    return(this.x <= mouseX && mouseX <= this.x + this.w) &&
157. //      (this.y <= mouseY && mouseY <= this.y + this.h);
158. //  }
159. //}
160. ////Message class
161. //class Message
162. //{
163. //  int x, y, w, h;
164. //  PFont font;
165. //  String msg;
166. //
167. //  Message(String msg_) {
168. //    msg = msg_;
169. //  }
170. //  void display(String msg)
171. //  {
172. //    fill(0, 0, 0);
173. //    // Message.msg = (this.x, this.y);
174. //    text (msg, x, y);
175. //  }
176. //  void clear()
177. //  {
178. //    noStroke();
179. //    fill(EMPTY_GRAY);
180. //    rect(this.x, this.y - this.h * 3/4, this.w, this.h);
181. //  }
182. //}
183. //position class ====================================================================
184. class Position
185. {
186.   int row;
187.   int col;
188.   int pos;
189.   Position(int col, int row)
190.   {
191.     this.col = col;
192.     this.row = row;
193.   }
194.   //  boolean equals (Position that)
195.   //  {
196.   //    if (that != null) {
197.   //      if (this.pos == that.pos) return true;
198.   //    }
199.   //    else {
200.   //      return false;
201.   //    }
202.   //    return false;
203.   //  }
204. }
205. // ================================================================
206. //Tile Class
207. class Tile
208. {
209.   PImage img;
210.   Position p;
211.   boolean isShown = false;     // shown or covered?
212.   boolean isSolved = false;    // the duplicate is not only shown but correct and now permanently shown
213.   boolean hasDuplicate=false;  // while init not all images have a duplicate
214.   int theImageCode = -1;  // the partners are identified with the same number (which is otherwise meaningless, except both have the same.
215.   //
216.   // constr
217.   Tile ( Position p_, int originalPosition_ )
218.   {
219.     p=p_;
220.     img = fullImage.get( p_.col, p_.row, tileWidth-1, tileHeight-1 );
221.   }
222.   void draw()
223.   {
224.     if (isShown) {
225.       image(img, p.col, p.row);
226.       stroke(255);
227.       noFill();
228.       rect(p.col, p.row, tileWidth, tileHeight);
229.       if (isSolved)
230.       {
231.         fill(2, 255, 2);
232.         text( "OK", p.col+200, p.row+200 );
233.         fill(255);
234.       }
235.     }
236.     else
237.     {
238.       stroke(255);
239.       noFill();
240.       rect(p.col, p.row, tileWidth, tileHeight);
241.       text ("?", p.col + 120, p.row + 120 );
242.     }
243.   }
244.   boolean mouseInside()
245.   {
246.     return ((p.col <= mouseX && mouseX <= p.col + tileWidth) &&
247.       (p.row <= mouseY && mouseY <= p.row + tileHeight));
248.   }
249. }

• Increase the numbers of tiles after a level
• Restart after a complete game
• Use different images (at the moment he is cutting one image into tiles)
• Better text output (or a sign for done instead of ok, see image below)
  
• Handle different players? Necessary?

1. //
2. //Symbolic constants
3. //
4. // how many images on the hard drive? Must be in data folder and named 0.jpg, 1.jpg etc.
5. final int howManyImages = 11;
6. //
7. // state of program / game
8. final int stateGameStartUp  = 0;
9. final int stateGamePlay     = 1;
10. final int stateGameGoToNextLevelPhase1 = 2;
11. final int stateGameGoToNextLevelPhase2 = 3;
12. final int stateGameOver     = 4;
13. final int stateGameShowHelp = 5;
14. //
15. int state = stateGameStartUp;  // current
16. //
17. // level stuff
18. final int maxLevel = 4; // how many levels
19. int level;              // current
20. //
21. // data for tiles
22. int winningNumberOfTiles;
23. int TILES_HORZ ;
24. int TILES_VERT ;
25. int TOTAL_TILES ;
26. int tileWidth;
27. int tileHeight;
28. Tile[] tiles ;
29. // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
30. String allRandomNumberImage="#";
31. //
32. // image entering stuff
33. // this one controls the input logic while making a move (aka opening two tiles)
34. int openImages = 0;    // counter for current move: how many tiles are currently shown? 0, 1 or 2. (before the move, in the move and after the move)  
35. int lastImage = -1;    // which was the last tile?
36. int currentImage = -1; // which is the current tile / image?
37. //
38. // timer
39. int timer;
40. //
41. // ------------------------------------------------------------------
42. void setup()
43. {
44.   size(800, 800);
45.   level=1;
46.   timer=millis();
47. }
48. //
49. void draw()
50. {
51.   switch (state) {
52.   case stateGameStartUp:
53.     // start screen and new level
54.     startScreen() ;
55.     break;
56.   case stateGamePlay:
57.     // play
58.     gamePlay();    
59.     break;
60.   case stateGameGoToNextLevelPhase1:
61.     // go to next level but only after a while
62.     goToNextLevel_1();
63.     break;
64.   case stateGameGoToNextLevelPhase2:
65.     // go to next level but only after a while
66.     goToNextLevel_2();
67.     break;   
68.   case stateGameOver:
69.     // All levels done
70.     showWinScreen();
71.     break;
72.   case stateGameShowHelp:
73.     // help - to do
74.     println ( "This is your help / reached by F1 / not done yet...");
75.     break;
76.   default:
77.     println ("Error 86: unknown state");
78.     break;
79.   } // switch
80.   //
81. } // func
82. // ---------------------------------------------------------------
83. void startScreen() {
84.   // start screen
85.   background(0);
86.   textSize(34);
87.   fill(255, 0, 0);
88.   text ( "Your    ", 140, 101);
89.   text ( "      Great   ", 140, 201);
90.   text ( "            Memory   ", 140, 301);
91.   text ( "                     Game ", 140, 401);
92.   // go next state but only after a while
93.   if (timer + 3000 < millis()) {
94.     initNewLevel ();
95.     state=stateGamePlay;
96.   } // if
97. } // func
98. //
99. void gamePlay() {
100.   // play
101.   background(0);
102.   drawTiles();
103.   checkTwoShownTiles ();
104. } // func
105. void goToNextLevel_1() {
106.   // go to next level but only after a while
107.   background(0);
108.   drawTiles();
109.   // showHooray() ;
110.   if (timer + 1000 < millis()) {
111.     state=stateGameGoToNextLevelPhase2;
112.     timer=millis();
113.   } // if
114. } // func
115. void goToNextLevel_2() {
116.   // go to next level but only after a while
117.   background(0);
118.   drawTiles();
119.   showHooray() ;
120.   if (timer + 1000 < millis()) {
121.     state=stateGameStartUp;
122.     timer=millis();
123.   } // if
124. } // func
125. void showWinScreen() {
126.   background(0);
127.   drawTiles();
128.   showHooray() ;
129.   // show all levels done
130.   fill(0);   // black
131.   noStroke();
132.   rect (14, 104, 295, 100);
133.   fill(255, 1, 1);  // red
134.   text ( "   All levels done.", 10, 160);
135. } // func
136. //
137. void showHooray() {
138.   fill(0); // black
139.   noStroke();
140.   rect (4, 4, 140, 100);
141.   fill(255, 1, 1); // red
142.   text ( "Hooray!", 10, 60);
143. } // func
144. // -----------------------------------------------------------
145. void initNewLevel () {
146.   //
147.   println("Init New Level #"+level);
148.   //
149.   // depending on current level set some basic vars
150.   switch (level) {
151.   case 0:
152.     // to do
153.     TILES_HORZ =1;
154.     TILES_VERT =1;
155.     winningNumberOfTiles = 2;
156.     break ;
157.   case 1:
158.     TILES_HORZ =2;
159.     TILES_VERT =2;
160.     winningNumberOfTiles = 4;
161.     break;
162.   case 2:
163.     TILES_HORZ =3;
164.     TILES_VERT =3;
165.     winningNumberOfTiles = 9;
166.     break;
167.   case 3:
168.     TILES_HORZ =4;
169.     TILES_VERT =4;
170.     winningNumberOfTiles = 16;
171.     break;
172.   default:
173.     println("Error 55: Unknown Level");
174.     break;
175.   } // switch
176.   // 
177.   // have other vars based on that defined
178.   tileWidth=width/TILES_HORZ-1 ;
179.   tileHeight=height/TILES_VERT-1 ;
180.   TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
181.   // not even?
182.   if (winningNumberOfTiles%2 != 0 ) {
183.     // println (winningNumberOfTiles + " not even");
184.     winningNumberOfTiles--;
185.   }
186.   tiles = new Tile [TOTAL_TILES+1];
187.   // now define the tiles without the images
188.   int i=0;
189.   for (int x=0; x<TILES_HORZ; x++) {
190.     for (int y=0; y<TILES_VERT; y++) {  
191.       tiles[i] = new Tile (tileWidth*x, tileHeight*y, null );
192.       i++;
193.     }
194.   }
195.   // make duplicates -----
196.   // println ( "Now we make them having duplicates. " );
197.   i=0;
198.   // this arraylist "intTileIndexes" serves as a memory which
199.   // cards we already treated
200.   ArrayList <classInt> intTileIndexes = new ArrayList();
201.   intTileIndexes.clear();
202.   // fill the arraylist
203.   for (int x=0; x<TILES_HORZ; x++) {
204.     for (int y=0; y<TILES_VERT; y++) {
205.       intTileIndexes.add( new classInt(i) );
206.       i++;
207.     }
208.   }
209.   // still make duplicates ------
210.   i=0;
211.   int imageCode=0;
212.   allRandomNumberImage="#";
213.   for (int x=0; x<TILES_HORZ; x++) {
214.     for (int y=0; y<TILES_VERT; y++) {
215.       // if our tile doesn't have a duplicate yet, then it's on our to do list:
216.       if (!tiles[i].hasDuplicate) {
217.         // we search a random partner
218.         int safetyCounter = 0; // that avoids that the loop takes too long...
219.         // now we calculate a random number which is a index for intTileIndexes
220.         int j2 = int(random (0, intTileIndexes.size()));
221.         int j = intTileIndexes.get(j2).value;
222.         // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
223.         // then we get an error here but that's ok
224.         while ( (i==j || tiles[j].hasDuplicate )  && 
225.           (safetyCounter<50) ) {
226.           j2 = int(random (0, intTileIndexes.size()));
227.           j  = intTileIndexes.get(j2).value;
228.           // println ( j + " at " + millis() + " with " +  intTileIndexes.size());
229.           safetyCounter++;
230.         }
231.         // found one?
232.         if ( i!=j && !tiles[j].hasDuplicate ) {
233.           // yes
234.           // remove those from the arraylist
235.           removeFromArrayList (intTileIndexes, i);
236.           removeFromArrayList (intTileIndexes, j);
237.           // tiles[i].img  = tiles[j].img;
238.           tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
239.           tiles[j].hasDuplicate=true;
240.           tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
241.           tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
242.           String myImageName=giveImageName() ;
243.           tiles[i].loadImageIntoTile ( myImageName ); // same image
244.           tiles[j].loadImageIntoTile ( myImageName );
245.           //
246.           imageCode++;                      // increase the code since it must be unique
247.           //println ("success: "+imageCode+ " of " + TOTAL_TILES);  // for debug
248.         }
249.         else {
250.           // println ("error 119");
251.         } // else
252.       } // if
253.       i++;
254.     } // for
255.   } // for
256.   //
257.   // if not even, make one tile invisible
258.   i=0;
259.   for (int x=0; x<TILES_HORZ; x++) {
260.     for (int y=0; y<TILES_VERT; y++) {
261.       // if our tile doesn't have a duplicate yet
262.       if (!tiles[i].hasDuplicate) {
263.         // we don't show it
264.         tiles[i].visible=false;
265.       } // if
266.       i++;
267.     } // for
268.   } // for
269.   textSize(34);
270.   // println ( "setup() is finished." );
271. }
272. //
273. String giveImageName() {
274.   // gives a image file name (that is new)
275.   int randomNumberImage = int (random(0, howManyImages));
276.   int safetyCounter = 0;
277.   // while not a new image keep on searching
278.   while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
279.     (safetyCounter<30) ) {
280.     randomNumberImage = int (random(0, howManyImages));
281.     safetyCounter++;
282.   }
283.   // found a new one
284.   allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
285.   // return value
286.   return str( randomNumberImage ) +".jpg";
287. } // func
288. //
289. void removeFromArrayList (ArrayList<classInt> myArrayList, int i) {
290.   for ( classInt currentInt : myArrayList ) {
291.     if (currentInt.value==i) {
292.       myArrayList.remove(currentInt);
293.       return; // break; // exit();
294.     }
295.   } // for
296. } // func
297. //
298. void drawTiles() {
299.   // draw it
300.   for (int x=0; x<TOTAL_TILES; x++) {
301.     tiles[x].draw();
302.   }
303.   //
304. }
305. void checkTwoShownTiles () {
306.   // if two images are shown we have to check them
307.   if (openImages == 2) {
308.     // but only after a while
309.     if (timer + 1000 < millis()) {
310.       // two are shown (the user has made his move)
311.       openImages=0; // reset
312.       // check
313.       if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
314.       {
315.         //  correct
316.         println ("Good");
317.         tiles[currentImage].isSolved=true;
318.         tiles[lastImage].isSolved=true;
319.         checkIfSolved();
320.       }
321.       else
322.       {
323.         // not correct: the are hidden again 
324.         tiles[currentImage].isShown=false;
325.         tiles[lastImage].isShown=false;
326.       }
327.     }
328.   }
329. } // func
330. // Inputs -----------------------------------------------------------------
331. void mousePressed() {
332.   if (state==stateGamePlay) {
333.     if (openImages != 2) {
334.       // search  
335.       int x=-1;
336.       for (int x2=0; x2<TOTAL_TILES; x2++) {
337.         if (tiles[x2].mouseInside() && tiles[x2].visible) {
338.           x=x2;
339.           break;
340.         } // if
341.       } // for
342.       //
343.       // found?
344.       if (x>-1) {
345.         // when one image is open make sure that the 2nd is a different one
346.         if ( ((openImages == 1) && ( x != lastImage)) ||
347.           (openImages == 0) ) { 
348.           // yes?
349.           if (tiles[x].mouseInside()) {
350.             tiles[x].isShown=true;
351.             openImages++;
352.             if (openImages == 1) {
353.               lastImage=x;
354.             }
355.             else
356.             {
357.               currentImage=x;
358.               timer=millis();
359.             } // else
360.           } // if
361.         } // if
362.       } // if
363.     } // if
364.   } // if
365.   else if (state==stateGameOver) {
366.     level=1;
367.     state = stateGameStartUp;
368.   } // if
369.   //
370. } // func
371. void keyPressed () {
372.   if (state==stateGameOver) {
373.     level=1;
374.     state = stateGameStartUp;
375.   }
376. }
377. // -------------------------------------------------------
378. void checkIfSolved() {
379.   int counter = 0;
380.   // Are all shown?
381.   for (int x2=0; x2<TOTAL_TILES; x2++) {
382.     if (tiles[x2].isSolved) {
383.       counter ++;
384.     }
385.   }
386.   //
387.   if (counter==winningNumberOfTiles)
388.   {
389.     state=stateGameGoToNextLevelPhase1; // won this level
390.     println ("You won this level.");
391.     level++;
392.     if (level==maxLevel) {
393.       state=stateGameOver;   // won all levels
394.       println("game over (all levels done).");
395.     }
396.     timer=millis();
397.   }
398. }
399. // ================================================================
400. //Tile Class (one image card)
401. class Tile
402. {
403.   PImage img;   // the image
404.   float px;     // position
405.   float py;
406.   boolean isShown = false;     // shown or covered?
407.   boolean isSolved = false;    // the duplicate is not only shown but correct and now permanently shown
408.   boolean hasDuplicate=false;  // while init not all images have a duplicate yet
409.   int theImageCode = -1;       // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
410.   boolean visible=true;        // does the tile exist at all?
411.   //
412.   // constr
413.   Tile ( float px_, float py_, String imageName_ )
414.   {
415.     px=px_;
416.     py=py_;
417.     if (imageName_!=null) {
418.       img  = loadImage(imageName_);
419.       img.resize(tileWidth, tileHeight);
420.     }
421.     isShown = false;
422.     isSolved = false;
423.   }
424.   //
425.   void loadImageIntoTile ( String imageName_ ) {
426.     img  = loadImage(imageName_);
427.     img.resize(tileWidth, tileHeight);
428.   }
429.   //
430.   void draw()
431.   {
432.     if (visible) {
433.       if (isShown) {
434.         if (img!=null)
435.           image(img, px, py);
436.         else
437.           println ("image is null");
438.         stroke(255);
439.         noFill();
440.         rect(px, py, tileWidth, tileHeight);
441.         if (isSolved)
442.         {
443.           fill(255);
444.           ellipse(px+tileWidth-56, py+tileHeight-42, 80, 80);
445.           fill(2, 255, 2);
446.           text( "OK", px+tileWidth-76, py+tileHeight-27 );
447.           fill(255);
448.         }
449.       }
450.       else
451.       {
452.         // not shown / covered tile
453.         stroke(255);
454.         noFill();
455.         rect(px, py, tileWidth, tileHeight);
456.         fill (255, 1, 1);
457.         text ("?", px + tileWidth/2, py + tileHeight/2 );
458.       }
459.     }
460.   }
461.   boolean mouseInside()
462.   {
463.     return ((px <= mouseX && mouseX <= px + tileWidth) &&
464.       (py <= mouseY && mouseY <= py + tileHeight));
465.   }
466. } // class
467. // ===========================================================
468. class classInt
469. {
470.   // just a wrapper for int
471.   //
472.   int value=0;
473.   //
474.   // constr
475.   classInt (int value_) {
476.     value = value_;
477.   }// constr
478. } // class
479. // =============================================

1. //
2. //Symbolic constants
3. //
4. // how many images on the hard drive? Must be in data folder and named 0.jpg, 1.jpg etc.
5. final int howManyImages = 11;
6. //
7. // state of program / game
8. final int stateGameStartUp  = 0;
9. final int stateGamePlay     = 1;
10. final int stateGameGoToNextLevelPhase1 = 2; // these two provide a small delay
11. final int stateGameGoToNextLevelPhase2 = 3;
12. final int stateGameOver     = 4;
13. final int stateGameShowHelp = 5;
14. //
15. int state = stateGameStartUp;  // current
16. //
17. // level stuff
18. final int maxLevel = 4; // how many levels
19. int level;              // current
20. //
21. // data for tiles
22. int winningNumberOfTiles;
23. int TILES_HORZ ;
24. int TILES_VERT ;
25. int TOTAL_TILES ;
26. int tileWidth;
27. int tileHeight;
28. Tile[] tiles ;
29. // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
30. String allRandomNumberImage="#";
31. //
32. // image entering stuff
33. // this one controls the input logic while making a move (aka opening two tiles)
34. int openImages = 0;    // counter for current move: how many tiles are currently shown? 0, 1 or 2. (before the move, in the move and after the move)  
35. int lastImage = -1;    // which was the last tile?
36. int currentImage = -1; // which is the current tile / image?
37. //
38. // timer
39. int timer;
40. //
41. // bg
42. PGraphics imgBackground;
43. //
44. // ------------------------------------------------------------------
45. void setup()
46. {
47.   size(800, 800);
48.   //
49.   imgBackground = createGraphics (width, height );
50.   stroke(255);
51.   imgBackground.beginDraw();
52.   for (int x = -100; x < width; x+=30) {
53.     //
54.     imgBackground.stroke(255);
55.     imgBackground.line(x, 0, x+130, height);
56.   }
57.   imgBackground.endDraw();
58.   //
59.   level=0;
60.   timer=millis();
61. }
62. //
63. void draw()
64. {
65.   switch (state) {
66.   case stateGameStartUp:
67.     // start screen and new level
68.     startScreen() ;
69.     break;
70.   case stateGamePlay:
71.     // play
72.     gamePlay();    
73.     break;
74.   case stateGameGoToNextLevelPhase1:
75.     // go to next level but only after a while
76.     goToNextLevel_1();
77.     break;
78.   case stateGameGoToNextLevelPhase2:
79.     // go to next level but only after a while
80.     goToNextLevel_2();
81.     break;   
82.   case stateGameOver:
83.     // All levels done
84.     showWinScreen();
85.     break;
86.   case stateGameShowHelp:
87.     // help - to do
88.     println ( "This is your help / reached by F1 / not done yet...");
89.     break;
90.   default:
91.     println ("Error 86: unknown state");
92.     break;
93.   } // switch
94.   //
95. } // func
96. // ---------------------------------------------------------------
97. void startScreen() {
98.   // start screen
99.   background(0);
100.   textSize(34);
101.   fill(255, 0, 0);
102.   text ( "Your    ", 140, 101);
103.   text ( "      Great   ", 140, 201);
104.   text ( "            Memory   ", 140, 301);
105.   text ( "                     Game ", 140, 401);
106.   // go next state but only after a while
107.   if (timer + 3000 < millis()) {
108.     initNewLevel ();
109.     state=stateGamePlay;
110.   } // if
111. } // func
112. //
113. void gamePlay() {
114.   // play
115.   fill(0);
116.   rect(0, 0, width, height);
117.   background(imgBackground);
118.   fill(0);
119.   rect(0, 0, width, height);
120.   //background(imgBackground);
121.   image(imgBackground, 0, 0);
122.   drawTiles();
123.   checkTwoShownTiles ();
124. } // func
125. void goToNextLevel_1() {
126.   // go to next level but only after a while
127.   background(0);
128.   background(imgBackground);
129.   drawTiles();
130.   if (timer + 1000 < millis()) {
131.     state=stateGameGoToNextLevelPhase2;
132.     timer=millis();
133.   } // if
134. } // func
135. void goToNextLevel_2() {
136.   // go to next level but only after a while
137.   background(0);
138.   background(imgBackground);
139.   drawTiles();
140.   showHooray() ;
141.   if (timer + 1000 < millis()) {
142.     state=stateGameStartUp;
143.     timer=millis();
144.   } // if
145. } // func
146. void showWinScreen() {
147.   background(0);
148.   background(imgBackground);
149.   drawTiles();
150.   showHooray() ;
151.   // show all levels done
152.   fill(0);   // black
153.   noStroke();
154.   rect (14, 104, 295, 100);
155.   fill(255, 1, 1);  // red
156.   text ( "   All levels done.", 10, 160);
157. } // func
158. //
159. // ------------------
160. //
161. void showHooray() {
162.   fill(0); // black
163.   noStroke();
164.   rect (4, 4, 140, 100);
165.   fill(1, 255, 1); // red
166.   text ( "Hooray!", 10, 60);
167. } // func
168. // -----------------------------------------------------------
169. void initNewLevel () {
170.   //
171.   println("Init New Level #"+level);
172.   //
173.   // depending on current level set some basic vars
174.   switch (level) {
175.   case 0:
176.     // to do
177.     TILES_HORZ =1;
178.     TILES_VERT =1;
179.     winningNumberOfTiles = 2;
180.     break ;
181.   case 1:
182.     TILES_HORZ =2;
183.     TILES_VERT =2;
184.     winningNumberOfTiles = 4;
185.     break;
186.   case 2:
187.     TILES_HORZ =3;
188.     TILES_VERT =3;
189.     winningNumberOfTiles = 9;
190.     break;
191.   case 3:
192.     TILES_HORZ =4;
193.     TILES_VERT =4;
194.     winningNumberOfTiles = 16;
195.     break;
196.   default:
197.     println("Error 55: Unknown Level");
198.     break;
199.   } // switch
200.   //
201.   // have other vars based on that defined  
202.   if (level>0) {
203.     // level > 0
204.     defineNormalTileSet() ;
205.   }
206.   else
207.   {
208.     defineTileSetForLevel0() ;
209.   }
210.   textSize(54);
211.   //
212. } // func
213. //
214. void defineNormalTileSet() {
215.   //
216.   int i=0;
217.   tileWidth=width/TILES_HORZ-1 ;
218.   tileHeight=height/TILES_VERT-1 ;
219.   TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
220.   // not even?
221.   if (winningNumberOfTiles%2 != 0 ) {
222.     // println (winningNumberOfTiles + " not even");
223.     winningNumberOfTiles--;
224.   }
225.   tiles = new Tile [TOTAL_TILES+1];
226.   // now define the tiles without the images ------------------
227.   //
228.   for (int x=0; x<TILES_HORZ; x++) {
229.     for (int y=0; y<TILES_VERT; y++) {  
230.       tiles[i] = new Tile (tileWidth*x, tileHeight*y );
231.       i++;
232.     }
233.   }
234.   //
235.   // make duplicates ---------------------
236.   // println ( "Now we make them having duplicates. " );
237.   i=0;
238.   // this arraylist "intTileIndexes" serves as a memory which
239.   // cards we already treated
240.   ArrayList <Integer> intTileIndexes = new ArrayList();
241.   intTileIndexes.clear();
242.   // fill the arraylist
243.   for (int x=0; x<TILES_HORZ; x++) {
244.     for (int y=0; y<TILES_VERT; y++) {
245.       intTileIndexes.add( i );
246.       i++;
247.     }
248.   }
249.   // still make duplicates ------
250.   i=0;
251.   int imageCode=0;
252.   allRandomNumberImage="#";
253.   for (int x=0; x<TILES_HORZ; x++) {
254.     for (int y=0; y<TILES_VERT; y++) {
255.       // if our tile doesn't have a duplicate yet, then it's on our to do list:
256.       if (!tiles[i].hasDuplicate) {
257.         // we search a random partner
258.         int safetyCounter = 0; // that avoids that the loop takes too long...
259.         // now we calculate a random number which is a index for intTileIndexes
260.         int j2 = int(random (0, intTileIndexes.size()));
261.         int j = intTileIndexes.get(j2);
262.         // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
263.         // then we get an error here but that's ok
264.         while ( (i==j || tiles[j].hasDuplicate )  && 
265.           (safetyCounter<50) ) {
266.           j2 = int(random (0, intTileIndexes.size()));
267.           j  = intTileIndexes.get(j2);
268.           safetyCounter++;
269.         }
270.         // found one?
271.         if ( i!=j ) {
272.           // yes
273.           // remove those from the arraylist
274.           removeFromArrayList (intTileIndexes, i);
275.           removeFromArrayList (intTileIndexes, j);
276.           tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
277.           tiles[j].hasDuplicate=true;
278.           tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
279.           tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
280.           String myImageName=giveImageName(); // get a name
281.           tiles[i].loadImageIntoTile ( myImageName ); // same image
282.           tiles[j].loadImageIntoTile ( myImageName );
283.           //
284.           imageCode++;                    // increase the code since it must be unique
285.         }
286.         else {
287.           // println ("error 119");
288.         } // else
289.       } // if
290.       i++;
291.     } // for
292.   } // for
293.   //
294.   // if not even, make one tile invisible
295.   i=0;
296.   for (int x=0; x<TILES_HORZ; x++) {
297.     for (int y=0; y<TILES_VERT; y++) {
298.       // if our tile doesn't have a duplicate yet
299.       if (!tiles[i].hasDuplicate) {
300.         // we don't show it
301.         tiles[i].visible=false;
302.       } // if
303.       i++;
304.     } // for
305.   } // for
306.   //
307. } // func
308. //
309. void defineTileSetForLevel0() {
310.   // level is 0
311.   //
312.   tileWidth=width/2;
313.   tileHeight=height/2;
314.   TOTAL_TILES = 2;
315.   tiles = new Tile [TOTAL_TILES+1];
316.   tiles[0] = new Tile (0, 110 );
317.   tiles[1] = new Tile (tileWidth, tileHeight-110);
318.   //
319.   //
320.   // make duplicates ---------------------
321.   // println ( "Now we make them having duplicates. " );
322.   //
323.   tiles[0].hasDuplicate=true;   // both tiles have a duplicate now
324.   tiles[1].hasDuplicate=true;
325.   tiles[0].theImageCode=44;  // both tiles get the same imageCode
326.   tiles[1].theImageCode=44;  // saying: you two are belonging together
327.   String myImageName=giveImageName(); // get a name
328.   tiles[0].loadImageIntoTile ( myImageName ); // same image
329.   tiles[1].loadImageIntoTile ( myImageName );
330.   //
331. }
332. //
333. String giveImageName() {
334.   // gives a image file name (that is new)
335.   int randomNumberImage = int (random(0, howManyImages));
336.   int safetyCounter = 0;
337.   // while not a new image keep on searching
338.   while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
339.     (safetyCounter<30) ) {
340.     randomNumberImage = int (random(0, howManyImages));
341.     safetyCounter++;
342.   }
343.   // found a new one
344.   allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
345.   // return value
346.   return str( randomNumberImage ) +".jpg";
347. } // func
348. //
349. void removeFromArrayList (ArrayList<Integer> myArrayList, int iToBeRemoved) {
350.   // removes one item iToBeRemoved.
351.   // With an array, we say balls.length. With an ArrayList,
352.   // we say balls.size(). The length of an ArrayList is dynamic.
353.   // Notice how we are looping through the ArrayList backwards.
354.   // This is because we are deleting elements from the list.
355.   for (int i = myArrayList.size()-1; i >= 0; i--) {
356.     int iFromArrayList = int ( myArrayList.get(i));
357.     if ( iFromArrayList==iToBeRemoved ) {
358.       myArrayList.remove(i);
359.       return;
360.     }
361.   } // for
362. } // func
363. //
364. void drawTiles() {
365.   // draw it
366.   for (int x=0; x<TOTAL_TILES; x++) {
367.     tiles[x].draw();
368.   }
369.   //
370. }
371. void checkTwoShownTiles () {
372.   // if two images are shown we have to check them
373.   if (openImages == 2) {
374.     // but only after a while
375.     if (timer + 1000 < millis()) {
376.       // two are shown (the user has made his move)
377.       openImages=0; // reset
378.       // check
379.       if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
380.       {
381.         //  correct
382.         println ("Good");
383.         tiles[currentImage].isSolved=true;
384.         tiles[lastImage].isSolved=true;
385.         checkIfSolved();
386.       }
387.       else
388.       {
389.         // not correct: the are hidden again 
390.         tiles[currentImage].isShown=false;
391.         tiles[lastImage].isShown=false;
392.       }
393.     }
394.   }
395. } // func
396. // Inputs -----------------------------------------------------------------
397. void mousePressed() {
398.   if (state==stateGamePlay) {
399.     if (openImages != 2) {
400.       // search  
401.       int x=-1;
402.       for (int x2=0; x2<TOTAL_TILES; x2++) {
403.         if (tiles[x2].mouseInside() && tiles[x2].visible) {
404.           x=x2;
405.           break;
406.         } // if
407.       } // for
408.       //
409.       // found?
410.       if (x>-1) {
411.         // when one image is open make sure that the 2nd is a different one
412.         if ( ((openImages == 1) && ( x != lastImage)) ||
413.           (openImages == 0) ) { 
414.           // yes?
415.           if (tiles[x].mouseInside()) {
416.             tiles[x].isShown=true;
417.             openImages++;
418.             if (openImages == 1) {
419.               lastImage=x;
420.             }
421.             else
422.             {
423.               currentImage=x;
424.               timer=millis();
425.             } // else
426.           } // if
427.         } // if
428.       } // if
429.     } // if
430.   } // if
431.   else if (state==stateGameOver) {
432.     level=0;
433.     state = stateGameStartUp;
434.   } // if
435.   //
436. } // func
437. void keyPressed () {
438.   if (state==stateGameOver) {
439.     level=0;
440.     state = stateGameStartUp;
441.   }
442. }
443. // -------------------------------------------------------
444. void checkIfSolved() {
445.   int counter = 0;
446.   // Are all shown?
447.   for (int x2=0; x2<TOTAL_TILES; x2++) {
448.     if (tiles[x2].isSolved) {
449.       counter ++;
450.     }
451.   }
452.   //
453.   if (counter==winningNumberOfTiles)
454.   {
455.     state=stateGameGoToNextLevelPhase1; // won this level
456.     println ("You won this level.");
457.     level++;
458.     if (level==maxLevel) {
459.       state=stateGameOver;   // won all levels
460.       println("game over (all levels done).");
461.     }
462.     timer=millis();
463.   }
464. }
465. // ================================================================
466. //Tile Class (one image card)
467. class Tile
468. {
469.   PImage img;   // the image
470.   float px;     // position
471.   float py;
472.   boolean isShown = false;     // shown or covered?
473.   boolean isSolved = false;    // the duplicate is not only shown but correct and now permanently shown
474.   boolean hasDuplicate=false;  // while init not all images have a duplicate yet
475.   int theImageCode = -1;       // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
476.   boolean visible=true;        // does the tile exist at all?
477.   //
478.   // constr
479.   Tile ( float px_, float py_ )
480.   {
481.     px=px_;
482.     py=py_;
483.     //isShown = false;
484.     //isSolved = false;
485.   } // constr
486.   //
487.   void loadImageIntoTile ( String imageName_ ) {
488.     img  = loadImage(imageName_);
489.     img.resize(tileWidth, tileHeight);
490.   } // method
491.   //
492.   void draw()
493.   {
494.     if (visible) {
495.       // uncovered or covered?
496.       if (isShown) {
497.         // open
498.         if (img!=null)
499.           image(img, px, py);
500.         else
501.           println ("image is null");
502.         stroke(255);
503.         noFill();
504.         //fill(0);
505.         rect(px, py, tileWidth, tileHeight);
506.         if (isSolved)
507.         {
508.           textSize(34);
509.           fill(255);
510.           ellipse(px+tileWidth-42, py+tileHeight-42, 80, 80);
511.           fill(2, 255, 2);
512.           text( "OK", px+tileWidth-66, py+tileHeight-27 );
513.           fill(255);
514.         }
515.       }
516.       else
517.       {
518.         // not shown / covered tile with a "?"
519.         textSize(54);
520.         stroke(255);
521.         //noFill();
522.         fill(0);
523.         rect(px, py, tileWidth, tileHeight);
524.         fill (255, 1, 1);
525.         text ("?", px + tileWidth/2, py + tileHeight/2 );
526.       } // else
527.     } //  if (visible) {
528.   } // method
529.   //
530.   boolean mouseInside()
531.   {
532.     return ((px <= mouseX && mouseX <= px + tileWidth) &&
533.       (py <= mouseY && mouseY <= py + tileHeight));
534.   } // method
535.   //
536. } // class
537. // ===========================================================

1. //
2. // to do (optional): if uneven, place non-existent tile into right lower corner? With 8 tiles.
3. //        have each level twice? Twice two cards, twice 4 cards etc.
4. //
5. // global vars and constants
6. //
7. // how many images on the hard drive? Must be in data folder and named 0.jpg, 1.jpg etc.
8. final int howManyImages = 11;
9. //
10. //
11. // level stuff
12. final int maxLevel = 6; // how many levels, e.g. 6
13. int level = 0;          // current level: 0
14. //
15. // state of program / game
16. final int stateGameStartUp  = 0;
17. final int stateGamePlay     = 1;
18. final int stateGameGoToNextLevelPhase1 = 2; // these two provide a small delay
19. final int stateGameGoToNextLevelPhase2 = 3;
20. final int stateGameOver     = 4;
21. final int stateGameShowHelp = 5;
22. //
23. int state = stateGameStartUp;  // current
24. //
25. //
26. // data for tiles
27. int winningNumberOfTiles;
28. int TILES_HORZ ;
29. int TILES_VERT ;
30. int TOTAL_TILES ;
31. int tileWidth;
32. int tileHeight;
33. Tile[] tiles ;
34. int imageCode;
35. //
36. // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
37. String allRandomNumberImage="#";
38. //
39. // image entering stuff
40. // The var "openImages" is a counter that controls the input logic while making a move (aka opening two tiles).
41. // It says how many tiles are currently shown? 0, 1 or 2. (before the move, during the move and after the move).
42. // Only when openImages is == 2 we need to compare the two images (and reset openImages to 0 then).
43. int openImages = 0;    // counter for current move  
44. int lastImage = -1;    // which was the last tile? (1st tile opened)
45. int currentImage = -1; // which is the current tile / image? (2nd tile opened)
46. //
47. // timer
48. int timer;
49. //
50. // background
51. // PGraphics imgBackground;
52. PImage imgBackground;
53. //
54. //
55. // ------------------------------------------------------------------
56. // two main funcs
57. //
58. void setup()
59. {
60.   size(800, 800);
61.   // e.g. from here: http://free-textures.got3d.com/architectural/free-wood-textures/pages/free-wood-texture-009.html
62.   imgBackground=loadImage("free-wood-texture-009.jpg");
63.   imgBackground.resize(width, height);
64.   //makeABackgroundImage();
65.   timer=millis();
66. }
67. //
68. void draw()
69. {
70.   switch (state) {
71.   case stateGameStartUp:
72.     // start screen and new level
73.     startScreen() ;
74.     break;
75.   case stateGamePlay:
76.     // play
77.     gamePlay();    
78.     break;
79.   case stateGameGoToNextLevelPhase1:
80.     // go to next level but only after a while
81.     goToNextLevel_1();
82.     break;
83.   case stateGameGoToNextLevelPhase2:
84.     // go to next level but only after a while
85.     goToNextLevel_2();
86.     break;   
87.   case stateGameOver:
88.     // All levels done
89.     showWinScreen();
90.     break;
91.   case stateGameShowHelp:
92.     // help - to do
93.     println ( "This is your help / reached by F1 / not done yet...");
94.     break;
95.   default:
96.     // error; shouldn't get here 
97.     println ("Error 86: unknown state");
98.     break;
99.   } // switch
100.   //
101. } // func
102. // ---------------------------------------------------------------
103. // all funcs that get called from draw()
104. //
105. void startScreen() {
106.   // start screen : to do: make a cool start screen image
107.   background(0);
108.   textSize(34);
109.   fill(255, 0, 0);
110.   text ( "Your    ", 140, 101);
111.   text ( "      Great   ", 140, 201);
112.   text ( "            Memory   ", 140, 301);
113.   text ( "                     Game ", 140, 401);
114.   // go next state but only after a while
115.   if (timer + 3000 < millis()) {
116.     initNewLevel ();
117.     state=stateGamePlay;
118.   } // if
119. } // func
120. //
121. void gamePlay() {
122.   // play
123.   fill(0);
124.   rect(0, 0, width, height);
125.   background(imgBackground);
126.   fill(0);
127.   rect(0, 0, width, height);
128.   image(imgBackground, 0, 0);
129.   drawTiles();
130.   checkTwoShownTiles ();
131. } // func
132. //
133. void goToNextLevel_1() {
134.   // wait before go to next level but only after a while
135.   fill(0);
136.   rect(0, 0, width, height);
137.   background(imgBackground);
138.   drawTiles();
139.   if (timer + 1000 < millis()) {
140.     state=stateGameGoToNextLevelPhase2;
141.     timer=millis();
142.   } // if
143. } // func
144. //
145. void goToNextLevel_2() {
146.   // go to next level but only after a while
147.   // background(0);
148.   fill(0);
149.   rect(0, 0, width, height);
150.   background(imgBackground);
151.   drawTiles();
152.   showHooray(); 
153.   if (timer + 1000 < millis()) {
154.     // Was this the last level?
155.     if (level==maxLevel) {
156.       // yes, last level, game over.
157.       state = stateGameOver;   // won all levels
158.       println("game over (all levels done).");
159.     }
160.     else
161.     {
162.       // no, go to next level.
163.       state = stateGameStartUp;
164.       timer=millis();
165.     }
166.   } // if
167. } // func
168. //
169. void showWinScreen() {
170.   background(0);
171.   fill(0);
172.   rect(0, 0, width, height);
173.   background(imgBackground);
174.   drawTiles();
175.   showHooray() ;
176.   // show all levels done
177.   fill(0);   // black
178.   noStroke();
179.   rect (14, 104, 295, 100);
180.   fill(255, 1, 1);  // red
181.   text ( "   All levels done.", 10, 160);
182.   textSize(15);
183.   text ( "                 Click mouse", 10, 190);
184. } // func
185. //
186. // ------------------
187. //
188. void showHooray() {
189.   fill(0); // black
190.   noStroke();
191.   rect (4, 4, 140, 100);
192.   fill(1, 255, 1); // red
193.   text ( "Hooray!", 10, 60);
194. } // func
195. // -----------------------------------------------------------
196. // all funcs for inits
197. //
198. void initNewLevel () {
199.   //
200.   println("Init New Level #"+level);
201.   //
202.   // depending on current level set some basic vars
203.   switch (level) {
204.   case 0:
205.     // just 2 pieces
206.     TILES_HORZ =1;
207.     TILES_VERT =1;
208.     winningNumberOfTiles = 2;
209.     break ;
210.   case 1:
211.     // 4 pieces
212.     TILES_HORZ =2;
213.     TILES_VERT =2;
214.     winningNumberOfTiles = 4;
215.     break;
216.   case 2:
217.     TILES_HORZ =3;
218.     TILES_VERT =2;
219.     winningNumberOfTiles = 6;
220.     break;
221.   case 3:
222.     TILES_HORZ =3;
223.     TILES_VERT =3;
224.     winningNumberOfTiles = 9; // is 8
225.     break;
226.   case 4:
227.     TILES_HORZ =4;
228.     TILES_VERT =3;
229.     winningNumberOfTiles = 12; // is 12
230.     break;
231.   case 5:
232.     TILES_HORZ =4;
233.     TILES_VERT =4;
234.     winningNumberOfTiles = 16; // is 16
235.     break;
236.   default:
237.     println("Error 55: Unknown Level");
238.     break;
239.   } // switch
240.   //
241.   // have other vars based on that defined  
242.   if (level>0) {
243.     // level > 0
244.     defineNormalTileSet() ;
245.   }
246.   else
247.   {
248.     // level is 0
249.     defineTileSetForLevelZero() ;
250.   }
251.   textSize(54);
252.   //
253. } // func
254. //
255. void defineTileSetForLevelZero() {
256.   // level is 0
257.   //
258.   // make data for tiles and the tiles
259.   tileWidth=width/2;
260.   tileHeight=height/2;
261.   TOTAL_TILES = 2;
262.   tiles = new Tile [TOTAL_TILES+1];
263.   tiles[0] = new Tile (0, random(height-tileHeight) );
264.   tiles[1] = new Tile (tileWidth, random(height-tileHeight) );
265.   //
266.   //
267.   // make duplicates ---------------------
268.   tiles[0].hasDuplicate=true;   // both tiles have a duplicate now
269.   tiles[1].hasDuplicate=true;
270.   tiles[0].theImageCode=44;  // both tiles get the same imageCode
271.   tiles[1].theImageCode=44;  // saying: you two are belonging together
272.   String myImageName=giveImageName(); // get a name
273.   tiles[0].loadImageIntoTile ( myImageName ); // same image
274.   tiles[1].loadImageIntoTile ( myImageName );
275.   //
276. }
277. //
278. void defineNormalTileSet() {
279.   //
280.   int i=0;
281.   tileWidth=width/TILES_HORZ-1 ;
282.   // try this tileHeight=height/TILES_VERT-1 ;
283.   // or this
284.   tileHeight=tileWidth;
285.   TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
286.   // not even?
287.   if (winningNumberOfTiles%2 != 0 ) {
288.     // println (winningNumberOfTiles + " not even");
289.     winningNumberOfTiles--;
290.   }
291.   tiles = new Tile [TOTAL_TILES+1];
292.   // now define the tiles without the images ------------------
293.   for (int x=0; x<TILES_HORZ; x++) {
294.     for (int y=0; y<TILES_VERT; y++) {  
295.       tiles[i] = new Tile (tileWidth*x, tileHeight*y );
296.       i++;
297.     }
298.   }
299.   //
300.   // make duplicates ---------------------
301.   // println ( "Now we make them having duplicates. " );
302.   i=0;
303.   // this arraylist "intTileIndexes" serves as a memory which
304.   // cards we already treated
305.   ArrayList <Integer> intTileIndexes = new ArrayList();
306.   intTileIndexes.clear();
307.   // fill the arraylist
308.   for (int x=0; x<TILES_HORZ; x++) {
309.     for (int y=0; y<TILES_VERT; y++) {
310.       intTileIndexes.add( i );
311.       i++;
312.     }
313.   }
314.   // still make duplicates ------
315.   i=0;
316.   imageCode=0;
317.   allRandomNumberImage="#";
318.   for (int x=0; x<TILES_HORZ; x++) {
319.     for (int y=0; y<TILES_VERT; y++) {
320.       makeItHaveAnDuplicate( intTileIndexes, i );
321.       i++;
322.     } // for
323.   } // for
324.   //
325.   // if not even, make one tile inexistent
326.   i=0;
327.   for (int x=0; x<TILES_HORZ; x++) {
328.     for (int y=0; y<TILES_VERT; y++) {
329.       // if our tile doesn't have a duplicate yet
330.       if (!tiles[i].hasDuplicate) {
331.         // we don't show it
332.         tiles[i].exists=false;
333.       } // if
334.       i++;
335.     } // for
336.   } // for
337.   //
338. } // func
339. //
340. void makeItHaveAnDuplicate(  ArrayList <Integer> intTileIndexes, int i ) {
341.   // makeItHaveAnDuplicate
342.   // if our tile doesn't have a duplicate yet, then it's on our to do list:
343.   if (!tiles[i].hasDuplicate) {
344.     // we search a random partner
345.     int safetyCounter = 0; // that avoids that the loop takes too long...
346.     // now we calculate a random number which is a index for intTileIndexes
347.     int j2 = int(random (0, intTileIndexes.size()));
348.     int j  = intTileIndexes.get(j2);
349.     // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
350.     // then we get an error here but that's ok
351.     while ( (i==j || tiles[j].hasDuplicate )  && 
352.       (safetyCounter<50) ) {
353.       j2 = int(random (0, intTileIndexes.size()));
354.       j  = intTileIndexes.get(j2);
355.       safetyCounter++;
356.     }
357.     // Did he found one?
358.     if ( (i!=j) && (!tiles[j].hasDuplicate) ) {
359.       // yes
360.       // remove those from the arraylist
361.       removeFromArrayList (intTileIndexes, i);
362.       removeFromArrayList (intTileIndexes, j);
363.       tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
364.       tiles[j].hasDuplicate=true;
365.       tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
366.       tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
367.       String myImageName=giveImageName(); // get a name
368.       tiles[i].loadImageIntoTile ( myImageName ); // same image
369.       tiles[j].loadImageIntoTile ( myImageName );
370.       //
371.       imageCode++;                    // increase the code since it must be unique
372.     }
373.     else {
374.       // println ("error 119");
375.     } // else
376.   } // if
377. }
378. //
379. String giveImageName() {
380.   // gives a image file name (that is new)
381.   int randomNumberImage = int (random(0, howManyImages));
382.   int safetyCounter = 0;
383.   // while not a new image keep on searching
384.   while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
385.     (safetyCounter<30) ) {
386.     randomNumberImage = int (random(0, howManyImages));
387.     safetyCounter++;
388.   }
389.   // found a new one
390.   allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
391.   // return value
392.   return str( randomNumberImage ) +".jpg";
393. } // func
394. //
395. void removeFromArrayList (ArrayList<Integer> myArrayList, int iToBeRemoved) {
396.   // removes one item iToBeRemoved.
397.   // With an array, we say balls.length. With an ArrayList,
398.   // we say balls.size(). The length of an ArrayList is dynamic.
399.   // Notice how we are looping through the ArrayList backwards.
400.   // This is because we are deleting elements from the list.
401.   for (int i = myArrayList.size()-1; i >= 0; i--) {
402.     int iFromArrayList = int ( myArrayList.get(i));
403.     if ( iFromArrayList==iToBeRemoved ) {
404.       myArrayList.remove(i);
405.       return;
406.     }
407.   } // for
408. } // func
409. //
410. //
411. //void makeABackgroundImage () {
412. //  //
413. //  imgBackground = createGraphics (width, height );
414. //  imgBackground.beginDraw();
415. //  imgBackground.noFill();
416. //  imgBackground.stroke(255);
417. //  imgBackground.strokeWeight(1);
418. //  // diagonal lines
419. //  for (int x = -100; x < width; x+=30) {
420. //    imgBackground.line(x, 0, x+130, height);
421. //  }
422. //  imgBackground.endDraw();
423. //  //
424. //} // func
425. //
426. // Inputs -----------------------------------------------------------------
427. //
428. void mousePressed() {
429.   // switch state
430.   switch (state) {
431.   case stateGamePlay:
432.     if (openImages != 2) {
433.       // search  
434.       int x=-1;
435.       for (int x2=0; x2<TOTAL_TILES; x2++) {
436.         if (tiles[x2].mouseInside() && tiles[x2].exists) {
437.           x=x2;
438.           break;
439.         } // if
440.       } // for
441.       //
442.       // found?
443.       if (x>-1) {
444.         // when one image is open make sure that the 2nd is a different one
445.         if ( ((openImages == 1) && ( x != lastImage)) ||
446.           (openImages == 0) ) { 
447.           // yes?
448.           if (tiles[x].mouseInside()) {
449.             tiles[x].isShown=true;
450.             openImages++;
451.             if (openImages == 1) {
452.               lastImage=x;
453.             }
454.             else
455.             {
456.               currentImage=x;
457.               timer=millis();
458.             } // else
459.           } // if
460.         } // if
461.       } // if
462.     } // if
463.     break;
464.   case stateGameOver:
465.     level=0;
466.     state = stateGameStartUp;
467.     timer=millis();
468.     break;
469.   default:
470.     // do nothing
471.     break;
472.   } // switch
473.   //
474. } // func
475. void keyPressed () {
476.   if (state==stateGameOver) {
477.     level=0;
478.     state = stateGameStartUp;
479.     timer=millis();
480.   }
481. }
482. // -------------------------------------------------------
483. // smaller tools
484. //
485. //
486. void drawTiles() {
487.   // draw it
488.   for (int x=0; x<TOTAL_TILES; x++) {
489.     tiles[x].draw();
490.   }
491.   //
492. }
493. //
494. void checkTwoShownTiles () {
495.   // after a move:
496.   // if two images are shown we have to check them
497.   if (openImages == 2) {
498.     // but only after a while
499.     if (timer + 1000 < millis()) {
500.       // two are shown (the user has made his move)
501.       openImages=0; // reset
502.       // check
503.       if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
504.       {
505.         //  correct
506.         println ("Good");
507.         tiles[currentImage].isSolved=true;
508.         tiles[lastImage].isSolved=true;
509.         checkIfSolved();
510.       }
511.       else
512.       {
513.         // not correct: the are hidden again 
514.         tiles[currentImage].isShown=false;
515.         tiles[lastImage].isShown=false;
516.       }
517.     }
518.   }
519. } // func
520. //
521. void checkIfSolved() {
522.   // check if this level is complete 
523.   int counter = 0;
524.   // Are all shown and solved?
525.   for (int x2=0; x2<TOTAL_TILES; x2++) {
526.     if (tiles[x2].isSolved) {
527.       counter ++;
528.     }
529.   }
530.   //
531.   if (counter==winningNumberOfTiles)
532.   {
533.     state=stateGameGoToNextLevelPhase1; // won this level -> stateGameGoToNextLevelPhase1
534.     println ("You won this level.");
535.     level++;
536.     timer=millis();
537.   }
538. }
539. //
540. // ================================================================
541. //Tile Class (one image card)
542. class Tile
543. {
544.   PImage img;   // the image
545.   float px;     // position
546.   float py;
547.   // those three (4) could be unified to a var stateOfTile : nonExistent, withoutDuplicate, covered, shown, solved
548.   boolean isShown  = false;      // shown or covered?
549.   boolean isSolved = false;      // the duplicate is not only shown but correct and now permanently shown
550.   boolean exists   = true;       // does the tile exist at all?
551.   boolean hasDuplicate = false;  // while init not all images have a duplicate yet
552.   int theImageCode = -1;         // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
553.   //
554.   // constr
555.   Tile ( float px_, float py_ )
556.   {
557.     px=px_;
558.     py=py_;
559.   } // constr
560.   //
561.   void loadImageIntoTile ( String imageName_ ) {
562.     img  = loadImage(imageName_);
563.     img.resize(tileWidth, 0);
564.     // or try img.resize(tileWidth, tileHeight);
565.   } // method
566.   //
567.   void draw()
568.   {
569.     // if it exists at all?
570.     if (exists) {
571.       // we show it.
572.       // uncovered or covered?
573.       if (isShown) {
574.         // open
575.         if (img!=null)
576.           image(img, px, py);
577.         else
578.           println ("image is null");
579.         stroke(255);
580.         noFill();
581.         rect(px, py, tileWidth, tileHeight);
582.         // if tile is solved correctly
583.         if (isSolved)
584.         {
585.           // we show the OK sign
586.           textSize(34);
587.           fill(255);
588.           ellipse(px+tileWidth-42, py+tileHeight-42, 80, 80);
589.           fill(2, 255, 2);
590.           text( "OK", px+tileWidth-66, py+tileHeight-27 );
591.           fill(255);
592.         }
593.       }
594.       else
595.       {
596.         // not shown / covered tile with a "?"
597.         textSize(54);
598.         stroke(255);
599.         //noFill();
600.         fill(0);
601.         rect(px, py, tileWidth, tileHeight);
602.         fill (255, 1, 1);
603.         text ("?", px + tileWidth/2, py + tileHeight/2 );
604.       } // else
605.     } //  if (exists) {
606.   } // method
607.   //
608.   boolean mouseInside()
609.   {
610.     return ((px <= mouseX && mouseX <= px + tileWidth) &&
611.       (py <= mouseY && mouseY <= py + tileHeight));
612.   } // method
613.   //
614. } // class
615. // ===========================================================

1. //
2. // to do (optional): have each level twice? Twice two cards, twice 4 cards etc. to make it easier
3. //
4. // global vars and constants
5. //
6. // how many images on the hard drive? Must be in data folder and named 0.jpg, 1.jpg etc.
7. final int howManyImages = 11;
8. //
9. //
10. // level stuff
11. final int maxLevel = 7;  // how many levels, e.g. 7
12. int level = 0;           // current level: 0
13. //
14. // state of program / game
15. final int stateGameStartUp  = 0;
16. final int stateGamePlay     = 1;
17. final int stateGameGoToNextLevelPhase1 = 2; // these two provide a small delay
18. final int stateGameGoToNextLevelPhase2 = 3;
19. final int stateGameOver     = 4;
20. final int stateGameShowHelp = 5;
21. //
22. int state = stateGameStartUp;  // current
23. //
24. //
25. // data for tiles
26. int TILES_HORZ;
27. int TILES_VERT;
28. int TOTAL_TILES;
29. int tileWidth;
30. int tileHeight;
31. Tile[] tiles;
32. int imageCode;
33. //
34. // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
35. String allRandomNumberImage="#";
36. //
37. // image entering stuff
38. // The var "openImages" is a counter that controls the input logic while making a move (aka opening two tiles).
39. // It says how many tiles are currently shown? 0, 1 or 2. (before the move, during the move and after the move).
40. // Only when openImages is == 2 we need to compare the two images (and reset openImages to 0 then).
41. int openImages = 0;    // counter for current move  
42. int lastImage = -1;    // which was the last tile? (1st tile opened)
43. int currentImage = -1; // which is the current tile / image? (2nd tile opened)
44. //
45. // timer
46. int timer;
47. //
48. // background
49. // PGraphics imgBackground;
50. PImage imgBackground;
51. //
52. //
53. // ------------------------------------------------------------------
54. // two main funcs
55. //
56. void setup()
57. {
58.   size(800, 800);
59.   // e.g. from here: http://free-textures.got3d.com/architectural/free-wood-textures/pages/free-wood-texture-009.html
60.   imgBackground=loadImage("free-wood-texture-009.jpg");
61.   imgBackground.resize(width, height);
62.   //makeABackgroundImage();
63.   timer=millis();
64. }
65. //
66. void draw()
67. {
68.   switch (state) {
69.   case stateGameStartUp:
70.     // start screen and new level
71.     startScreen() ;
72.     break;
73.   case stateGamePlay:
74.     // play
75.     gamePlay();    
76.     break;
77.   case stateGameGoToNextLevelPhase1:
78.     // go to next level but only after a while
79.     goToNextLevel_1();
80.     break;
81.   case stateGameGoToNextLevelPhase2:
82.     // go to next level but only after a while
83.     goToNextLevel_2();
84.     break;   
85.   case stateGameOver:
86.     // All levels done
87.     showWinScreen();
88.     break;
89.   case stateGameShowHelp:
90.     // help - to do
91.     println ( "This is your help / reached by F1 / not done yet...");
92.     break;
93.   default:
94.     // error; shouldn't get here 
95.     println ("Error 86: unknown state");
96.     break;
97.   } // switch
98.   //
99. } // func
100. // ---------------------------------------------------------------
101. // all funcs that get called from draw()
102. //
103. void startScreen() {
104.   // start screen : to do: make a cool start screen image
105.   background(0);
106.   textSize(34);
107.   fill(255, 0, 0);
108.   text ( "Your    ", 140, 101);
109.   text ( "      Great   ", 140, 201);
110.   text ( "            Memory   ", 140, 301);
111.   text ( "                     Game ", 140, 401);
112.   // go next state but only after a while
113.   if (timer + 3000 < millis()) {
114.     initNewLevel ();
115.     state=stateGamePlay;
116.   } // if
117. } // func
118. //
119. void gamePlay() {
120.   // play
121.   fill(0);
122.   rect(0, 0, width, height);
123.   background(imgBackground);
124.   fill(0);
125.   rect(0, 0, width, height);
126.   image(imgBackground, 0, 0);
127.   drawTiles();
128.   checkTwoShownTiles ();
129. } // func
130. //
131. void goToNextLevel_1() {
132.   // wait before go to next level but only after a while
133.   fill(0);
134.   rect(0, 0, width, height);
135.   background(imgBackground);
136.   drawTiles();
137.   if (timer + 1000 < millis()) {
138.     state=stateGameGoToNextLevelPhase2;
139.     timer=millis();
140.   } // if
141. } // func
142. //
143. void goToNextLevel_2() {
144.   // go to next level but only after a while
145.   // background(0);
146.   fill(0);
147.   rect(0, 0, width, height);
148.   background(imgBackground);
149.   drawTiles();
150.   showHooray(); 
151.   if (timer + 1000 < millis()) {
152.     // Was this the last level?
153.     if (level==maxLevel) {
154.       // yes, last level, game over.
155.       state = stateGameOver;   // won all levels
156.       println("game over (all levels done).");
157.     }
158.     else
159.     {
160.       // no, go to next level.
161.       state = stateGameStartUp;
162.       timer=millis();
163.     }
164.   } // if
165. } // func
166. //
167. void showWinScreen() {
168.   background(0);
169.   fill(0);
170.   rect(0, 0, width, height);
171.   background(imgBackground);
172.   drawTiles();
173.   showHooray() ;
174.   // show all levels done
175.   fill(0);   // black
176.   noStroke();
177.   rect (14, 104, 295, 100);
178.   fill(255, 1, 1);  // red
179.   text ( "   All levels done.", 10, 160);
180.   textSize(15);
181.   text ( "                 Click mouse", 10, 190);
182. } // func
183. //
184. // ------------------
185. //
186. void showHooray() {
187.   fill(0); // black
188.   noStroke();
189.   rect (4, 4, 140, 100);
190.   fill(1, 255, 1); // red
191.   text ( "Hooray!", 10, 60);
192. } // func
193. // -----------------------------------------------------------
194. // all funcs for inits
195. //
196. void initNewLevel () {
197.   //
198.   println("Init New Level #"+level);
199.   //
200.   // depending on current level set some basic vars
201.   switch (level) {
202.   case 0:
203.     // just 2 pieces
204.     TILES_HORZ =1;
205.     TILES_VERT =1;
206.     TOTAL_TILES = 2;
207.     break ;
208.   case 1:
209.     // 4 pieces
210.     TILES_HORZ =2;
211.     TILES_VERT =2;
212.     TOTAL_TILES = 4;
213.     break;
214.   case 2:
215.     TILES_HORZ =3;
216.     TILES_VERT =2;
217.     TOTAL_TILES = 6;
218.     break;
219.   case 3:
220.     TILES_HORZ =3;
221.     TILES_VERT =3;
222.     TOTAL_TILES = 8;  // here it's not 3x3 but 8
223.     break;
224.   case 4:
225.     TILES_HORZ =4;
226.     TILES_VERT =3;
227.     TOTAL_TILES = 10;   // here it's not 4x3 but 10
228.     break;
229.   case 5:
230.     TILES_HORZ =4;
231.     TILES_VERT =3;
232.     TOTAL_TILES = 12;
233.     break;
234.   case 6:
235.     TILES_HORZ =4;
236.     TILES_VERT =4;
237.     TOTAL_TILES = 16;
238.     break;
239.   default:
240.     println("Error 55: Unknown Level");
241.     break;
242.   } // switch
243.   //
244.   // have other vars based on that defined  
245.   if (level>0) {
246.     // level > 0
247.     defineNormalTileSet() ;
248.   }
249.   else
250.   {
251.     // level is 0
252.     defineTileSetForLevelZero() ;
253.   }
254.   textSize(54);
255.   //
256. } // func
257. //
258. void defineTileSetForLevelZero() {
259.   // level is 0
260.   //
261.   // make data for tiles and the tiles
262.   tileWidth=width/2;
263.   tileHeight=tileWidth; // height/2;
264.   TOTAL_TILES = 2;
265.   tiles = new Tile [TOTAL_TILES+1];
266.   tiles[0] = new Tile (0, random(height-tileHeight) );
267.   tiles[1] = new Tile (tileWidth, random(height-tileHeight) );
268.   //
269.   //
270.   // make duplicates ---------------------
271.   tiles[0].hasDuplicate=true;   // both tiles have a duplicate now
272.   tiles[1].hasDuplicate=true;
273.   tiles[0].theImageCode=44;  // both tiles get the same imageCode
274.   tiles[1].theImageCode=44;  // saying: you two are belonging together
275.   String myImageName=giveImageName(); // get a name
276.   tiles[0].loadImageIntoTile ( myImageName ); // same image
277.   tiles[1].loadImageIntoTile ( myImageName );
278.   //
279. } // func
280. //
281. void defineNormalTileSet() {
282.   //
283.   // this function does the same as 
284.   // defineTileSetForLevelZero() above but looks
285.   // more complicate since there are more tiles...
286.   tileWidth=width/TILES_HORZ-1 ;
287.   // try this tileHeight=height/TILES_VERT-1 ;
288.   // or this
289.   tileHeight=tileWidth;
290.   //
291.   tiles = new Tile [TOTAL_TILES];
292.   // now define the tiles without the images ------------------
293.   int i=0;
294.   for (int x=0; x<TILES_HORZ; x++) {
295.     for (int y=0; y<TILES_VERT; y++) {
296.       if (i<TOTAL_TILES) {
297.         tiles[i] = new Tile (tileWidth*x, tileHeight*y );
298.       }
299.       i++;
300.     }
301.   }
302.   //
303.   // make duplicates ---------------------
304.   // println ( "Now we make them having duplicates. " );
305.   // this arraylist "intTileIndexes" serves as a memory which
306.   // cards we already treated
307.   ArrayList <Integer> intTileIndexes = new ArrayList();
308.   intTileIndexes.clear();
309.   // fill the arraylist
310.   for (int x=0; x<TOTAL_TILES; x++) {
311.     intTileIndexes.add( x );
312.   }
313.   // still make duplicates ------
314.   imageCode=0;
315.   allRandomNumberImage="#";
316.   for (int x=0; x<TOTAL_TILES; x++) {
317.     makeItHaveAnDuplicate( intTileIndexes, x );
318.   } // for
319.   //
320. } // func
321. //
322. void makeItHaveAnDuplicate(  ArrayList <Integer> intTileIndexes, int i ) {
323.   // makeItHaveAnDuplicate
324.   // if our tile doesn't have a duplicate yet, then it's on our to do list:
325.   if (!tiles[i].hasDuplicate) {
326.     // we search a random partner
327.     int safetyCounter = 0; // that avoids that the loop takes too long...
328.     // now we calculate a random number which is a index for intTileIndexes
329.     int j2 = int(random (0, intTileIndexes.size()));
330.     int j  = intTileIndexes.get(j2);
331.     // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
332.     // then we get an error here but that's ok
333.     while ( (i==j || tiles[j].hasDuplicate )  && 
334.       (safetyCounter<50) ) {
335.       j2 = int(random (0, intTileIndexes.size()));
336.       j  = intTileIndexes.get(j2);
337.       safetyCounter++;
338.     }
339.     // Did he found one?
340.     if ( (i!=j) && (!tiles[j].hasDuplicate) ) {
341.       // yes
342.       // remove those from the arraylist
343.       removeFromArrayList (intTileIndexes, i);
344.       removeFromArrayList (intTileIndexes, j);
345.       tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
346.       tiles[j].hasDuplicate=true;
347.       tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
348.       tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
349.       String myImageName=giveImageName(); // get a name
350.       tiles[i].loadImageIntoTile ( myImageName ); // same image
351.       tiles[j].loadImageIntoTile ( myImageName );
352.       //
353.       imageCode++;                    // increase the code since it must be unique
354.     }
355.     else {
356.       // println ("error 119");
357.     } // else
358.   } // if
359. }
360. //
361. String giveImageName() {
362.   // gives a image file name (that is new)
363.   int randomNumberImage = int (random(0, howManyImages));
364.   int safetyCounter = 0;
365.   // while not a new image keep on searching
366.   while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
367.     (safetyCounter<30) ) {
368.     randomNumberImage = int (random(0, howManyImages));
369.     safetyCounter++;
370.   }
371.   // found a new one
372.   allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
373.   // return value
374.   return str( randomNumberImage ) +".jpg";
375. } // func
376. //
377. void removeFromArrayList (ArrayList<Integer> myArrayList, int iToBeRemoved) {
378.   // removes one item iToBeRemoved from myArrayList.
379.   // With an array, we say balls.length. With an ArrayList,
380.   // we say balls.size(). The length of an ArrayList is dynamic.
381.   // Notice how we are looping through the ArrayList backwards.
382.   // This is because we are deleting elements from the list.
383.   for (int i = myArrayList.size()-1; i >= 0; i--) {
384.     int iFromArrayList = int ( myArrayList.get(i));
385.     if ( iFromArrayList==iToBeRemoved ) {
386.       myArrayList.remove(i);
387.       return;
388.     }
389.   } // for
390. } // func
391. //
392. //
393. //void makeABackgroundImage () {
394. //  //
395. //  imgBackground = createGraphics (width, height );
396. //  imgBackground.beginDraw();
397. //  imgBackground.noFill();
398. //  imgBackground.stroke(255);
399. //  imgBackground.strokeWeight(1);
400. //  // diagonal lines
401. //  for (int x = -100; x < width; x+=30) {
402. //    imgBackground.line(x, 0, x+130, height);
403. //  }
404. //  imgBackground.endDraw();
405. //  //
406. //} // func
407. //
408. // Inputs -----------------------------------------------------------------
409. //
410. void mousePressed() {
411.   // switch state
412.   switch (state) {
413.   case stateGamePlay:
414.     if (openImages != 2) {
415.       // search  
416.       int x=-1;
417.       for (int x2=0; x2<TOTAL_TILES; x2++) {
418.         if (tiles[x2].mouseInside() && tiles[x2].exists && !tiles[x2].isSolved &&  !tiles[x2].isShown ) {
419.           x=x2;
420.           break;
421.         } // if
422.       } // for
423.       //
424.       // found?
425.       if (x>-1) {
426.         // when one image is open make sure that the 2nd is a different one
427.         // when no image is open proceed
428.         if ( ((openImages == 1) && ( x != lastImage)) ||
429.           (openImages == 0) ) { 
430.           // yes?
431.           if (tiles[x].mouseInside()) {
432.             tiles[x].isShown=true;
433.             openImages++;
434.             if (openImages == 1) {
435.               lastImage=x;
436.             }
437.             else
438.             {
439.               currentImage=x;
440.               timer=millis();
441.             } // else
442.           } // if
443.         } // if
444.       } // if
445.     } // if
446.     break;
447.   case stateGameOver:
448.     startGameAllOverAfterLastLevel();
449.     break;
450.   default:
451.     // do nothing
452.     break;
453.   } // switch
454.   //
455. } // func
456. void keyPressed () {
457.   if (state==stateGameOver) {
458.     startGameAllOverAfterLastLevel();
459.   }
460. }
461. // -------------------------------------------------------
462. // smaller tools
463. //
464. //
465. void startGameAllOverAfterLastLevel() {
466.   level=0;
467.   state = stateGameStartUp;
468.   timer=millis();
469. }
470. //
471. void drawTiles() {
472.   // draw it
473.   for (int x=0; x<TOTAL_TILES; x++) {
474.     tiles[x].draw();
475.   }
476.   //
477. }
478. //
479. void checkTwoShownTiles () {
480.   // after a move:
481.   // if two images are shown we have to check them
482.   if (openImages == 2) {
483.     // but only after a while
484.     if (timer + 1000 < millis()) {
485.       // two are shown (the user has made his move)
486.       openImages=0; // reset
487.       // check
488.       if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
489.       {
490.         //  correct
491.         println ("Good");
492.         tiles[currentImage].isSolved=true;
493.         tiles[lastImage].isSolved=true;
494.         checkIfSolved();
495.       }
496.       else
497.       {
498.         // not correct: the are hidden again 
499.         tiles[currentImage].isShown=false;
500.         tiles[lastImage].isShown=false;
501.       }
502.     }
503.   }
504. } // func
505. //
506. void checkIfSolved() {
507.   // check if this level is complete 
508.   int counter = 0;
509.   // Are all shown and solved?
510.   for (int x2=0; x2<TOTAL_TILES; x2++) {
511.     if (tiles[x2].isSolved) {
512.       counter ++;
513.     }
514.   }
515.   //
516.   if (counter==TOTAL_TILES)
517.   {
518.     state=stateGameGoToNextLevelPhase1; // won this level -> stateGameGoToNextLevelPhase1
519.     println ("You won this level.");
520.     level++;
521.     timer=millis();
522.   }
523. }
524. //
525. // ================================================================
526. //Tile Class (one image card)
527. class Tile
528. {
529.   PImage img;   // the image
530.   float px;     // position
531.   float py;
532.   // those three (4) could be unified to a var stateOfTile : nonExistent, withoutDuplicate, covered, shown, solved
533.   boolean isShown  = false;      // shown or covered?
534.   boolean isSolved = false;      // the duplicate is not only shown but correct and now permanently shown
535.   boolean exists   = true;       // does the tile exist at all?
536.   boolean hasDuplicate = false;  // while init not all images have a duplicate yet
537.   int theImageCode = -1;         // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
538.   //
539.   // constr
540.   Tile ( float px_, float py_ )
541.   {
542.     px=px_;
543.     py=py_;
544.   } // constr
545.   //
546.   void loadImageIntoTile ( String imageName_ ) {
547.     img  = loadImage(imageName_);
548.     img.resize(tileWidth, 0);
549.     // or try img.resize(tileWidth, tileHeight);
550.   } // method
551.   //
552.   void draw()
553.   {
554.     // if it exists at all?
555.     if (exists) {
556.       // we show it.
557.       // uncovered or covered?
558.       if (isShown) {
559.         // open
560.         if (img!=null)
561.           image(img, px, py);
562.         else
563.           println ("image is null");
564.         stroke(255);
565.         noFill();
566.         rect(px, py, tileWidth, tileHeight);
567.         // if tile is solved correctly
568.         if (isSolved)
569.         {
570.           // we show the OK sign
571.           textSize(34);
572.           fill(255);
573.           ellipse(px+tileWidth-42, py+tileHeight-42, 80, 80);
574.           fill(2, 255, 2);
575.           text( "OK", px+tileWidth-66, py+tileHeight-27 );
576.           fill(255);
577.         }
578.       }
579.       else
580.       {
581.         // not shown / covered tile with a "?"
582.         textSize(54);
583.         stroke(255);
584.         //noFill();
585.         fill(0);
586.         rect(px, py, tileWidth, tileHeight);
587.         fill (255, 1, 1);
588.         text ("?", px + tileWidth/2, py + tileHeight/2 );
589.       } // else
590.     } //  if (exists) {
591.   } // method
592.   //
593.   boolean mouseInside()
594.   {
595.     return ((px <= mouseX && mouseX <= px + tileWidth) &&
596.       (py <= mouseY && mouseY <= py + tileHeight));
597.   } // method
598.   //
599. } // class
600. // ===========================================================

1.         if (tiles[x2].mouseInside() && tiles[x2].exists && !tiles[x2].isSolved &&  !tiles[x2].isShown ) {

1. //
   // to do (optional): if uneven, place non-existent tile into right lower corner? With 8 tiles.
   //        have each level twice? Twice two cards, twice 4 cards etc.
   //
   // global vars and constants
   //
   // how many images on the hard drive? Must be in data folder and named 0.jpg, 1.jpg etc.
   final int howManyImages = 12;
   //********IMAGE FILES SHOULD BE 400 wide X 200 HIGH*****************
   //
   // level stuff
   final int maxLevel = 6; // how many levels, e.g. 6
   int level = 0;          // current level: 0
   //
   // state of program / game
   final int stateGameStartUp  = 0;
   final int stateGamePlay     = 1;
   final int stateGameGoToNextLevelPhase1 = 2; // these two provide a small delay
   final int stateGameGoToNextLevelPhase2 = 3;
   final int stateGameOver     = 4;
   final int stateGameShowHelp = 5;
   //
   int state = stateGameStartUp;  // current
   //
   //
   // data for tiles
   int winningNumberOfTiles;
   int TILES_HORZ ;
   int TILES_VERT ;
   int TOTAL_TILES ;
   int tileWidth;
   int tileHeight;
   Tile[] tiles ;
   int imageCode;
   //
   // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
   String allRandomNumberImage="#";
   //
   // image entering stuff
   // The var "openImages" is a counter that controls the input logic while making a move (aka opening two tiles).
   // It says how many tiles are currently shown? 0, 1 or 2. (before the move, during the move and after the move).
   // Only when openImages is == 2 we need to compare the two images (and reset openImages to 0 then).
   int openImages = 0;    // counter for current move  
   int lastImage = -1;    // which was the last tile? (1st tile opened)
   int currentImage = -1; // which is the current tile / image? (2nd tile opened)
   //
   // timer
   int timer;
   //
   // background
   // PGraphics imgBackground;
   PImage imgBackground;
   PImage imgLogo;
3. //
   //
   // ------------------------------------------------------------------
   // two main funcs
   //
   void setup()
   {
     size(1800, 900);
     // e.g. from here: http://free-textures.got3d.com/architectural/free-wood-textures/pages/free-wood-texture-009.html
     imgBackground=loadImage("black.jpg");
     imgBackground.resize(width, height);
     //makeABackgroundImage();
      imgLogo=loadImage("logo.jpg");
4.   timer=millis();
   }
   //
   void draw()
   {
     switch (state) {
     case stateGameStartUp:
       // start screen and new level
       startScreen() ;
       break;
     case stateGamePlay:
       // play
       gamePlay();    
       break;
     case stateGameGoToNextLevelPhase1:
       // go to next level but only after a while
       goToNextLevel_1();
       break;
     case stateGameGoToNextLevelPhase2:
       // go to next level but only after a while
       goToNextLevel_2();
       break;   
     case stateGameOver:
       // All levels done
       showWinScreen();
       break;
     case stateGameShowHelp:
       // help - to do
       println ( "This is your help / reached by F1 / not done yet...");
       break;
     default:
       // error; shouldn't get here 
       println ("Error 86: unknown state");
       break;
     } // switch
     //
   } // func
   // ---------------------------------------------------------------
   // all funcs that get called from draw()
   //
   void startScreen() {
     // start screen : to do: make a cool start screen image
     background(0);
       fill(2,2, 255);
       image(imgLogo,width/4.3,height/3.3);
     
     
     textSize(80);
   fill(255,255, 255);
     text ( " MEMORY GAME", width/3.5+200, height/2.2);
       textSize(100);
     text ( "LEVEL: "+(level+1), width/2.2, height/1.7);
     text ( "           ", 140, 301);
     text ( "                   ", 140, 401);
     // go next state but only after a while
     if (timer + 3000 < millis()) {
       initNewLevel ();
       state=stateGamePlay;
     } // if
   } // func
   //
   void gamePlay() {
     // play
     fill(0);
     rect(0, 0, width, height);
     background(imgBackground);
     fill(0);
     rect(0, 0, width, height);
     image(imgBackground, 0, 0);
     drawTiles();
     checkTwoShownTiles ();
   } // func
   //
   void goToNextLevel_1() {
     // wait before go to next level but only after a while
     fill(0);
     rect(0, 0, width, height);
     background(imgBackground);
     drawTiles();
     if (timer + 1000 < millis()) {
       state=stateGameGoToNextLevelPhase2;
       timer=millis();
     } // if
   } // func
   //
   void goToNextLevel_2() {
     // go to next level but only after a while
     // background(0);
     fill(0);
     rect(0, 0, width, height);
     background(imgBackground);
     drawTiles();
     showHooray(); 
     if (timer + 1000 < millis()) {
       // Was this the last level?
       if (level==maxLevel) {
         // yes, last level, game over.
         state = stateGameOver;   // won all levels
         println("game over (all levels done).");
       }
       else
       {
         // no, go to next level.
         state = stateGameStartUp;
         timer=millis();
       }
     } // if
   } // func
   //
   void showWinScreen() {
     background(0);
     fill(0);
     rect(0, 0, width, height);
     background(imgBackground);
     drawTiles();
     showHooray() ;
     // show all levels done
     fill(0);   // black
     noStroke();
     rect (14, 104, 295, 100);
     fill(255, 255, 255);  // red
     text ( "   All levels done.", 10, 160);
     textSize(15);
     text ( "                 Click mouse", 10, 190);
   } // func
   //
   // ------------------
   //
   void showHooray() {
     fill(255); // black
     strokeWeight(3);
     stroke(0);
     rect (4, 4, 325, 100);
     fill(2, 2, 255); // red
     text ( "LEVEL FINISHED!!!", 10, 60);
   } // func
   // -----------------------------------------------------------
   // all funcs for inits
   //
   void initNewLevel () {
     //
     println("Init New Level #"+level);
     //
     // depending on current level set some basic vars
     switch (level) {
     case 0:
       // just 2 pieces
       TILES_HORZ =1;
       TILES_VERT =1;
       winningNumberOfTiles = 2;
       break ;
     case 1:
       // 4 pieces
       TILES_HORZ =2;
       TILES_VERT =2;
       winningNumberOfTiles = 4;
       break;
     case 2:
       TILES_HORZ =3;
       TILES_VERT =2;
       winningNumberOfTiles = 6;
       break;
     case 3:
       TILES_HORZ =3;
       TILES_VERT =3;
       winningNumberOfTiles = 9; // is 8
       break;
     case 4:
       TILES_HORZ =4;
       TILES_VERT =3;
       winningNumberOfTiles = 12; // is 12
       break;
     case 5:
       TILES_HORZ =4;
       TILES_VERT =4;
       winningNumberOfTiles = 16; // is 16
       break;
     default:
       println("Error 55: Unknown Level");
       break;
     } // switch
     //
     // have other vars based on that defined  
     if (level>0) {
       // level > 0
       defineNormalTileSet() ;
     }
     else
     {
       // level is 0
       defineTileSetForLevelZero() ;
     }
     textSize(54);
     //
   } // func
   //
   void defineTileSetForLevelZero() {
     // level is 0
     //
     // make data for tiles and the tiles
     tileWidth=width/2;
     tileHeight=height/2;
     TOTAL_TILES = 2;
     tiles = new Tile [TOTAL_TILES+1];
     tiles[0] = new Tile (0, height-tileHeight);
     tiles[1] = new Tile (tileWidth, height-tileHeight);
     //
     //
     // make duplicates ---------------------
     tiles[0].hasDuplicate=true;   // both tiles have a duplicate now
     tiles[1].hasDuplicate=true;
     tiles[0].theImageCode=44;  // both tiles get the same imageCode
     tiles[1].theImageCode=44;  // saying: you two are belonging together
     String myImageName=giveImageName(); // get a name
     tiles[0].loadImageIntoTile ( myImageName ); // same image
     tiles[1].loadImageIntoTile ( myImageName );
     //
   }
   //
   void defineNormalTileSet() {
     //
     int i=0;
     tileWidth=width/TILES_HORZ-1 ;
     // try this tileHeight=height/TILES_VERT-1 ;
     // or this
     tileHeight=tileWidth/2;
     TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
     // not even?
     if (winningNumberOfTiles%2 != 0 ) {
       // println (winningNumberOfTiles + " not even");
       winningNumberOfTiles--;
     }
     tiles = new Tile [TOTAL_TILES+1];
     // now define the tiles without the images ------------------
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {  
         tiles[i] = new Tile (tileWidth*x, tileHeight*y );
         i++;
       }
     }
     //
     // make duplicates ---------------------
     // println ( "Now we make them having duplicates. " );
     i=0;
     // this arraylist "intTileIndexes" serves as a memory which
     // cards we already treated
     ArrayList <Integer> intTileIndexes = new ArrayList();
     intTileIndexes.clear();
     // fill the arraylist
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         intTileIndexes.add( i );
         i++;
       }
     }
     // still make duplicates ------
     i=0;
     imageCode=0;
     allRandomNumberImage="#";
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         makeItHaveAnDuplicate( intTileIndexes, i );
         i++;
       } // for
     } // for
     //
     // if not even, make one tile inexistent
     i=0;
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         // if our tile doesn't have a duplicate yet
         if (!tiles[i].hasDuplicate) {
           // we don't show it
           tiles[i].exists=false;
         } // if
         i++;
       } // for
     } // for
     //
   } // func
   //
   void makeItHaveAnDuplicate(  ArrayList <Integer> intTileIndexes, int i ) {
     // makeItHaveAnDuplicate
     // if our tile doesn't have a duplicate yet, then it's on our to do list:
     if (!tiles[i].hasDuplicate) {
       // we search a random partner
       int safetyCounter = 0; // that avoids that the loop takes too long...
       // now we calculate a random number which is a index for intTileIndexes
       int j2 = int(random (0, intTileIndexes.size()));
       int j  = intTileIndexes.get(j2);
       // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
       // then we get an error here but that's ok
       while ( (i==j || tiles[j].hasDuplicate )  && 
         (safetyCounter<50) ) {
         j2 = int(random (0, intTileIndexes.size()));
         j  = intTileIndexes.get(j2);
         safetyCounter++;
       }
       // Did he found one?
       if ( (i!=j) && (!tiles[j].hasDuplicate) ) {
         // yes
         // remove those from the arraylist
         removeFromArrayList (intTileIndexes, i);
         removeFromArrayList (intTileIndexes, j);
         tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
         tiles[j].hasDuplicate=true;
         tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
         tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
         String myImageName=giveImageName(); // get a name
         tiles[i].loadImageIntoTile ( myImageName ); // same image
         tiles[j].loadImageIntoTile ( myImageName );
         //
         imageCode++;                    // increase the code since it must be unique
       }
       else {
         // println ("error 119");
       } // else
     } // if
   }
   //
   String giveImageName() {
     // gives a image file name (that is new)
     int randomNumberImage = int (random(0, howManyImages));
     int safetyCounter = 0;
     // while not a new image keep on searching
     while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
       (safetyCounter<30) ) {
       randomNumberImage = int (random(0, howManyImages));
       safetyCounter++;
     }
     // found a new one
     allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
     // return value
     return str( randomNumberImage ) +".jpg";
   } // func
   //
   void removeFromArrayList (ArrayList<Integer> myArrayList, int iToBeRemoved) {
     // removes one item iToBeRemoved.
     // With an array, we say balls.length. With an ArrayList,
     // we say balls.size(). The length of an ArrayList is dynamic.
     // Notice how we are looping through the ArrayList backwards.
     // This is because we are deleting elements from the list.
     for (int i = myArrayList.size()-1; i >= 0; i--) {
       int iFromArrayList = int ( myArrayList.get(i));
       if ( iFromArrayList==iToBeRemoved ) {
         myArrayList.remove(i);
         return;
       }
     } // for
   } // func
   //
   //
   //void makeABackgroundImage () {
   //  //
   //  imgBackground = createGraphics (width, height );
   //  imgBackground.beginDraw();
   //  imgBackground.noFill();
   //  imgBackground.stroke(255);
   //  imgBackground.strokeWeight(1);
   //  // diagonal lines
   //  for (int x = -100; x < width; x+=30) {
   //    imgBackground.line(x, 0, x+130, height);
   //  }
   //  imgBackground.endDraw();
   //  //
   //} // func
   //
   // Inputs -----------------------------------------------------------------
   //
   void mousePressed() {
     // switch state
     switch (state) {
     case stateGamePlay:
       if (openImages != 2) {
         // search  
         int x=-1;
         for (int x2=0; x2<TOTAL_TILES; x2++) {
                   if (tiles[x2].mouseInside() && tiles[x2].exists
   && !tiles[x2].isSolved &&  !tiles[x2].isShown ) {
5.           x=x2;
             break;
           } // if
         } // for
         //
         // found?
         if (x>-1) {
           // when one image is open make sure that the 2nd is a different one
           if ( ((openImages == 1) && ( x != lastImage)) ||
             (openImages == 0) ) { 
             // yes?
             if (tiles[x].mouseInside()) {
               tiles[x].isShown=true;
               openImages++;
               if (openImages == 1) {
                 lastImage=x;
               }
               else
               {
                 currentImage=x;
                 timer=millis();
               } // else
             } // if
           } // if
         } // if
       } // if
       break;
     case stateGameOver:
       level=0;
       state = stateGameStartUp;
       timer=millis();
       break;
     default:
       // do nothing
       break;
     } // switch
     //
   } // func
   void keyPressed () {
     if (state==stateGameOver) {
       level=0;
       state = stateGameStartUp;
       timer=millis();
     }
   }
   // -------------------------------------------------------
   // smaller tools
   //
   //
   void drawTiles() {
     // draw it
     for (int x=0; x<TOTAL_TILES; x++) {
       tiles[x].draw();
     }
     //
   }
   //
   void checkTwoShownTiles () {
     // after a move:
     // if two images are shown we have to check them
     if (openImages == 2) {
       // but only after a while
       if (timer + 1000 < millis()) {
         // two are shown (the user has made his move)
         openImages=0; // reset
         // check
         if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
         {
           //  correct
           println ("Good");
           tiles[currentImage].isSolved=true;
           tiles[lastImage].isSolved=true;
           checkIfSolved();
         }
         else
         {
           // not correct: the are hidden again 
           tiles[currentImage].isShown=false;
           tiles[lastImage].isShown=false;
         }
       }
     }
   } // func
   //
   void checkIfSolved() {
     // check if this level is complete 
     int counter = 0;
     // Are all shown and solved?
     for (int x2=0; x2<TOTAL_TILES; x2++) {
       if (tiles[x2].isSolved) {
         counter ++;
       }
     }
     //
     if (counter==winningNumberOfTiles)
     {
       state=stateGameGoToNextLevelPhase1; // won this level -> stateGameGoToNextLevelPhase1
       println ("You won this level.");
       level++;
       timer=millis();
     }
   }
   //
   // ================================================================
   //Tile Class (one image card)
   class Tile
   {
     PImage img;   // the image
    
    
     //**********************************
     PImage imgBack;// image of back of card
     //**********************************
    
    
     float px;     // position
     float py;
     // those three (4) could be unified to a var stateOfTile : nonExistent, withoutDuplicate, covered, shown, solved
     boolean isShown  = false;      // shown or covered?
     boolean isSolved = false;      // the duplicate is not only shown but correct and now permanently shown
     boolean exists   = true;       // does the tile exist at all?
     boolean hasDuplicate = false;  // while init not all images have a duplicate yet
     int theImageCode = -1;         // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
     //
     // constr
     Tile ( float px_, float py_ )
     {
       px=px_;
       py=py_;
     } // constr
     //
     void loadImageIntoTile ( String imageName_ ) {
       img  = loadImage(imageName_);
       img.resize(tileWidth, 0);
      
      
       //****************************
       imgBack  = loadImage("cardback2.jpg");
       imgBack.resize(tileWidth, 0);
       //****************************
      
      
      
       // or try img.resize(tileWidth, tileHeight);
     } // method
     //
     void draw()
     {
       // if it exists at all?
       if (exists) {
         // we show it.
         // uncovered or covered?
         if (isShown) {
           // open
           if (img!=null)
             image(img, px, py);
           else
             println ("image is null");
           stroke(255);
           noFill();
           rect(px, py, tileWidth, tileHeight);
           // if tile is solved correctly
           if (isSolved)
           {
             // we show the OK sign
             textSize(34);
             fill(255);
             strokeWeight(4);
             stroke(0);
             rect(px+tileWidth-170, py+tileHeight-58, 160, 40);
             fill(2, 2, 255);
             text( "MATCH!", px+tileWidth-150, py+tileHeight-27 );
             fill(255);
           }
         }
         else
         {
           // not shown / covered tile with a "?"
6. 
   //*********************************
       image(imgBack, px, py);
   //*********************************
7.         textSize(54);
           stroke(255);
           noFill();
           //fill(0);
           rect(px, py, tileWidth, tileHeight);
           fill (255, 255, 255);
           //text ("?", px + tileWidth/2, py + tileHeight/2 );
         } // else
       } //  if (exists) {
     } // method
     //
     boolean mouseInside()
     {
       return ((px <= mouseX && mouseX <= px + tileWidth) &&
         (py <= mouseY && mouseY <= py + tileHeight));
     } // method
     //
   } // class
   // ===========================================================
   

Basically the game cycles through level 1-6 finishes then starts over but the second time when it reaches level 5 or 6 it errors out with an out of memory error...

• you have one array images with all images of the cards and load it once in setup()
  

• when assigning an image to the card in the class you only assign the index of the image to it - that's the trick

1. background(0);

1. //
2. // to do (optional): if uneven, place non-existent tile into right lower corner? With 8 tiles.
3. //        have each level twice? Twice two cards, twice 4 cards etc.
4. //
5. // global vars and constants
6. //
7. // how many images on the hard drive? (this+1) Must be in data folder and named 0.jpg, 1.jpg etc.
8. final int howManyImages = 12;
9. //
10. //
11. // level stuff
12. final int maxLevel = 6; // how many levels, e.g. 6
13. int level = 0;          // current level: 0
14. //
15. // state of program / game
16. final int stateGameStartUp  = 0;
17. final int stateGamePlay     = 1;
18. final int stateGameGoToNextLevelPhase1 = 2; // these two provide a small delay
19. final int stateGameGoToNextLevelPhase2 = 3;
20. final int stateGameOver     = 4;
21. final int stateGameShowHelp = 5;
22. //
23. int state = stateGameStartUp;  // current
24. //
25. //
26. // data for tiles
27. int winningNumberOfTiles;
28. int TILES_HORZ ;
29. int TILES_VERT ;
30. int TOTAL_TILES ;
31. int tileWidth;
32. int tileHeight;
33. Tile[] tiles ;
34. int imageCode;
35. //
36. // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
37. String allRandomNumberImage="#";
38. PImage[] images = new PImage [howManyImages];
39. //
40. // image entering stuff
41. // The var "openImages" is a counter that controls the input logic while making a move (aka opening two tiles).
42. // It says how many tiles are currently shown? 0, 1 or 2. (before the move, during the move and after the move).
43. // Only when openImages is == 2 we need to compare the two images (and reset openImages to 0 then).
44. int openImages = 0;    // counter for current move  
45. int lastImage = -1;    // which was the last tile? (1st tile opened)
46. int currentImage = -1; // which is the current tile / image? (2nd tile opened)
47. //
48. // timer
49. int timer;
50. //
51. // background
52. // PGraphics imgBackground;
53. // PImage imgBackground;
54. PImage imgLogo;
55. //
56. PImage imgBackGlobal;
57. PImage imgBack = new PImage();// image of back of card
58. //
59. //
60. // ------------------------------------------------------------------
61. // two main funcs
62. //
63. void setup()
64. {
65.   size( 800, 600);
66.   println("start of setup() ");
67.   //
68.   imgLogo       = loadImage("logo.jpg");
69.   imgBackGlobal = loadImage("cardback2.jpg");
70.   imgBack       = loadImage("cardback2.jpg");
71.   //
72.   for (int x=0; x<howManyImages; x++) {
73.     images[x]=loadImage(str(x)+".jpg");
74.   } // for
75.   //
76.   timer=millis();
77.   println("end of setup()");
78. }
79. //
80. void draw()
81. {
82.   switch (state) {
83.   case stateGameStartUp:
84.     // start screen and new level
85.     startScreen() ;
86.     break;
87.   case stateGamePlay:
88.     // play
89.     gamePlay();    
90.     break;
91.   case stateGameGoToNextLevelPhase1:
92.     // go to next level but only after a while
93.     goToNextLevel_1();
94.     break;
95.   case stateGameGoToNextLevelPhase2:
96.     // go to next level but only after a while
97.     goToNextLevel_2();
98.     break;   
99.   case stateGameOver:
100.     // All levels done
101.     showWinScreen();
102.     break;
103.   case stateGameShowHelp:
104.     // help - to do
105.     println ( "This is your help / reached by F1 / not done yet...");
106.     break;
107.   default:
108.     // error; shouldn't get here 
109.     println ("Error 86: unknown state");
110.     break;
111.   } // switch
112.   //
113. } // func
114. // ---------------------------------------------------------------
115. // all funcs that get called from draw()
116. //
117. void startScreen() {
118.   // start screen : to do: make a cool start screen image
119.   background(0);
120.   // fill(2, 2, 255);
121.   // image(imgLogo, width/4.3, height/3.3);
122.   textSize(80);
123.   fill(255, 255, 255);
124.   text ( " MEMORY GAME", width/3.5+200, height/2.2);
125.   textSize(100);
126.   text ( "LEVEL:  "+(level+1), width/2.2, height/1.7);
127.   text ( "           ", 140, 301);
128.   text ( "                   ", 140, 401);
129.   // go next state but only after a while
130.   if (timer + 3000 < millis()) {
131.     initNewLevel();
132.     state = stateGamePlay;
133.   } // if
134. } // func
135. //
136. void gamePlay() {
137.   // play
138.   background(0);
139.   drawTiles();
140.   checkTwoShownTiles ();
141. } // func
142. //
143. void goToNextLevel_1() {
144.   // wait before go to next level but only after a while
145.   background(0);
146.   drawTiles();
147.   if (timer + 1000 < millis()) {
148.     state=stateGameGoToNextLevelPhase2;
149.     timer=millis();
150.   } // if
151. } // func
152. //
153. void goToNextLevel_2() {
154.   // go to next level but only after a while
155.   background(0);
156.   drawTiles();
157.   showHooray(); 
158.   if (timer + 1000 < millis()) {
159.     // Was this the last level?
160.     if (level==maxLevel) {
161.       // yes, last level, game over.
162.       state = stateGameOver;   // won all levels
163.       println("game over (all levels done).");
164.     }
165.     else
166.     {
167.       // no, go to next level.
168.       state = stateGameStartUp;
169.       timer=millis();
170.     }
171.   } // if
172. } // func
173. //
174. void showWinScreen() {
175.   background(0);
176.   drawTiles();
177.   showHooray() ;
178.   // show all levels done
179.   fill(0);   // black
180.   noStroke();
181.   rect (14, 104, 295, 100);
182.   fill(255, 255, 255);  // red
183.   text ( "   All levels done.", 10, 160);
184.   textSize(15);
185.   text ( "                 Click mouse", 10, 190);
186. } // func
187. //
188. // ------------------
189. //
190. void showHooray() {
191.   fill(255);
192.   strokeWeight(3);
193.   stroke(0);
194.   rect (4, 4, 325, 100);
195.   fill(2, 2, 255);
196.   text ( "LEVEL FINISHED!!!", 10, 60);
197. } // func
198. // -----------------------------------------------------------
199. // all funcs for inits
200. //
201. void initNewLevel () {
202.   //
203.   println("Init New Level #"+level);
204.   //
205.   // depending on current level set some basic vars
206.   switch (level) {
207.   case 0:
208.     // just 2 pieces
209.     TILES_HORZ =1;
210.     TILES_VERT =1;
211.     winningNumberOfTiles = 2;
212.     break;
213.   case 1:
214.     // 4 pieces
215.     TILES_HORZ =2;
216.     TILES_VERT =2;
217.     winningNumberOfTiles = 4;
218.     break;
219.   case 2:
220.     TILES_HORZ =3;
221.     TILES_VERT =2;
222.     winningNumberOfTiles = 6;
223.     break;
224.   case 3:
225.     TILES_HORZ =3;
226.     TILES_VERT =3;
227.     winningNumberOfTiles = 9; // is 8
228.     break;
229.   case 4:
230.     TILES_HORZ =4;
231.     TILES_VERT =3;
232.     winningNumberOfTiles = 12; // is 12
233.     break;
234.   case 5:
235.     TILES_HORZ =4;
236.     TILES_VERT =4;
237.     winningNumberOfTiles = 16; // is 16
238.     break;
239.   default:
240.     println("Error 55: Unknown Level");
241.     break;
242.   } // switch
243.   //
244.   // have other vars based on that defined  
245.   if (level>0) {
246.     // level > 0
247.     defineNormalTileSet() ;
248.   }
249.   else
250.   {
251.     // level is 0
252.     defineTileSetForLevelZero() ;
253.   }
254.   textSize(54);
255.   //
256.   println("Finishing Init process for level #"+level);
257.   //
258. } // func
259. //
260. void defineTileSetForLevelZero() {
261.   // level is 0
262.   //
263.   println ("Level zero");
264.   // make data for tiles and the tiles
265.   tileWidth=width/2;
266.   tileHeight=height/2;
267.   TOTAL_TILES = 2;
268.   tiles = new Tile [TOTAL_TILES+1];
269.   tiles[0] = new Tile (0, height-tileHeight);
270.   tiles[1] = new Tile (tileWidth, height-tileHeight);
271.   //
272.   //
273.   // make duplicates ---------------------
274.   tiles[0].hasDuplicate=true;   // both tiles have a duplicate now
275.   tiles[1].hasDuplicate=true;
276.   tiles[0].theImageCode=44;  // both tiles get the same imageCode
277.   tiles[1].theImageCode=44;  // saying: you two are belonging together
278.   int myImageIndex = giveImageIndex(); // get an index
279.   println ("2nd point " + myImageIndex);
280.   tiles[0].loadImageIntoTile ( myImageIndex ); // same image
281.   tiles[1].loadImageIntoTile ( myImageIndex );
282.   println ("3rd point");
283.   //****************************
284.   // imgBack = loadImage("cardback2.jpg");
285.   imgBack.copy(imgBackGlobal,
286.   0, 0, imgBackGlobal.width, imgBackGlobal.height,
287.   0, 0, tileWidth, 0);
288.   imgBack.resize(tileWidth, 0);
289.   //****************************
290.   //
291. }
292. //
293. void defineNormalTileSet() {
294.   //
295.   int i=0;
296.   tileWidth=width/TILES_HORZ-1 ;
297.   // try this tileHeight=height/TILES_VERT-1 ;
298.   // or this
299.   tileHeight=tileWidth/2;
300.   TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
301.   // not even?
302.   if (winningNumberOfTiles%2 != 0 ) {
303.     // println (winningNumberOfTiles + " not even");
304.     winningNumberOfTiles--;
305.   }
306.   tiles = new Tile [TOTAL_TILES+1];
307.   // now define the tiles without the images ------------------
308.   for (int x=0; x<TILES_HORZ; x++) {
309.     for (int y=0; y<TILES_VERT; y++) {  
310.       tiles[i] = new Tile (tileWidth*x, tileHeight*y );
311.       i++;
312.     }
313.   }
314.   //
315.   // make duplicates ---------------------
316.   // println ( "Now we make them having duplicates. " );
317.   i=0;
318.   // this arraylist "intTileIndexes" serves as a memory which
319.   // cards we already treated
320.   ArrayList <Integer> intTileIndexes = new ArrayList();
321.   intTileIndexes.clear();
322.   // fill the arraylist
323.   for (int x=0; x<TILES_HORZ; x++) {
324.     for (int y=0; y<TILES_VERT; y++) {
325.       intTileIndexes.add( i );
326.       i++;
327.     }
328.   }
329.   // still make duplicates ------
330.   i=0;
331.   imageCode=0;
332.   allRandomNumberImage="#";
333.   for (int x=0; x<TILES_HORZ; x++) {
334.     for (int y=0; y<TILES_VERT; y++) {
335.       makeItHaveAnDuplicate( intTileIndexes, i );
336.       i++;
337.     } // for
338.   } // for
339.   //
340.   // if not even, make one tile inexistent
341.   i=0;
342.   for (int x=0; x<TILES_HORZ; x++) {
343.     for (int y=0; y<TILES_VERT; y++) {
344.       // if our tile doesn't have a duplicate yet
345.       if (!tiles[i].hasDuplicate) {
346.         // we don't show it
347.         tiles[i].exists=false;
348.       } // if
349.       i++;
350.     } // for
351.   } // for
352.   // 
353.   //****************************
354.   // imgBackGlobal  = loadImage("cardback2.jpg");
355.   //imgBack=imgBackGlobal;
356.   imgBack.copy(imgBackGlobal,
357.   0, 0, imgBackGlobal.width, imgBackGlobal.height,
358.   0, 0, tileWidth, tileWidth);
359.   imgBack.resize(tileWidth, 0);
360.   //****************************
361.   //
362. } // func
363. //
364. void makeItHaveAnDuplicate(  ArrayList <Integer> intTileIndexes, int i ) {
365.   // makeItHaveAnDuplicate
366.   // if our tile doesn't have a duplicate yet, then it's on our to do list:
367.   if (!tiles[i].hasDuplicate) {
368.     // we search a random partner
369.     int safetyCounter = 0; // that avoids that the loop takes too long...
370.     // now we calculate a random number which is a index for intTileIndexes
371.     int j2 = int(random (0, intTileIndexes.size()));
372.     int j  = intTileIndexes.get(j2);
373.     // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
374.     // then we get an error here but that's ok
375.     while ( (i==j || tiles[j].hasDuplicate )  && 
376.       (safetyCounter<50) ) {
377.       j2 = int(random (0, intTileIndexes.size()));
378.       j  = intTileIndexes.get(j2);
379.       safetyCounter++;
380.     }
381.     // Did he found one?
382.     if ( (i!=j) && (!tiles[j].hasDuplicate) ) {
383.       // yes
384.       // remove those from the arraylist
385.       removeFromArrayList (intTileIndexes, i);
386.       removeFromArrayList (intTileIndexes, j);
387.       tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
388.       tiles[j].hasDuplicate=true;
389.       tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
390.       tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
391.       int myImageIndex=giveImageIndex(); // get a name
392.       tiles[i].loadImageIntoTile ( myImageIndex ); // same image
393.       tiles[j].loadImageIntoTile ( myImageIndex );
394.       //
395.       imageCode++;                    // increase the code since it must be unique
396.     }
397.     else {
398.       // println ("error 119");
399.     } // else
400.   } // if
401. }
402. //
403. int giveImageIndex() {
404.   // gives a image file name (that is new)
405.   int randomNumberImage = int (random(0, howManyImages));
406.   int safetyCounter = 0;
407.   // while not a new image keep on searching
408.   while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
409.     (safetyCounter<30) ) {
410.     randomNumberImage = int (random(0, howManyImages));
411.     safetyCounter++;
412.   }
413.   // found a new one
414.   allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
415.   // return value
416.   // return str( randomNumberImage ) +".jpg";
417.   return randomNumberImage;
418. } // func
419. //
420. void removeFromArrayList (ArrayList<Integer> myArrayList, int iToBeRemoved) {
421.   // removes one item iToBeRemoved.
422.   // With an array, we say balls.length. With an ArrayList,
423.   // we say balls.size(). The length of an ArrayList is dynamic.
424.   // Notice how we are looping through the ArrayList backwards.
425.   // This is because we are deleting elements from the list.
426.   for (int i = myArrayList.size()-1; i >= 0; i--) {
427.     int iFromArrayList = int ( myArrayList.get(i));
428.     if ( iFromArrayList==iToBeRemoved ) {
429.       myArrayList.remove(i);
430.       return;
431.     }
432.   } // for
433. } // func
434. //
435. //
436. //void makeABackgroundImage () {
437. //  //
438. //  imgBackground = createGraphics (width, height );
439. //  imgBackground.beginDraw();
440. //  imgBackground.noFill();
441. //  imgBackground.stroke(255);
442. //  imgBackground.strokeWeight(1);
443. //  // diagonal lines
444. //  for (int x = -100; x < width; x+=30) {
445. //    imgBackground.line(x, 0, x+130, height);
446. //  }
447. //  imgBackground.endDraw();
448. //  //
449. //} // func
450. //
451. // Inputs -----------------------------------------------------------------
452. //
453. void mousePressed() {
454.   // switch state
455.   switch (state) {
456.   case stateGamePlay:
457.     if (openImages != 2) {
458.       // search  
459.       int x=-1;
460.       for (int x2=0; x2<TOTAL_TILES; x2++) {
461.         if (tiles[x2].mouseInside() && tiles[x2].exists
462.           && !tiles[x2].isSolved &&  !tiles[x2].isShown ) {
463.           x=x2;
464.           break;
465.         } // if
466.       } // for
467.       //
468.       // found?
469.       if (x>-1) {
470.         // when one image is open make sure that the 2nd is a different one
471.         if ( ((openImages == 1) && ( x != lastImage)) ||
472.           (openImages == 0) ) { 
473.           // yes?
474.           if (tiles[x].mouseInside()) {
475.             tiles[x].isShown=true;
476.             openImages++;
477.             if (openImages == 1) {
478.               lastImage=x;
479.             }
480.             else
481.             {
482.               currentImage=x;
483.               timer=millis();
484.             } // else
485.           } // if
486.         } // if
487.       } // if
488.     } // if
489.     break;
490.   case stateGameOver:
491.     level=0;
492.     state = stateGameStartUp;
493.     timer=millis();
494.     break;
495.   default:
496.     // do nothing
497.     break;
498.   } // switch
499.   //
500. } // func
501. void keyPressed () {
502.   if (state==stateGameOver) {
503.     level=0;
504.     state = stateGameStartUp;
505.     timer=millis();
506.   }
507. }
508. // -------------------------------------------------------
509. // smaller tools
510. //
511. //
512. void drawTiles() {
513.   // draw it
514.   for (int x=0; x<TOTAL_TILES; x++) {
515.     tiles[x].draw();
516.   }
517.   //
518. }
519. //
520. void checkTwoShownTiles () {
521.   // after a move:
522.   // if two images are shown we have to check them
523.   if (openImages == 2) {
524.     // but only after a while
525.     if (timer + 1000 < millis()) {
526.       // two are shown (the user has made his move)
527.       openImages=0; // reset
528.       // check
529.       if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
530.       {
531.         //  correct
532.         println ("Good");
533.         tiles[currentImage].isSolved=true;
534.         tiles[lastImage].isSolved=true;
535.         checkIfSolved();
536.       }
537.       else
538.       {
539.         // not correct: the are hidden again 
540.         tiles[currentImage].isShown=false;
541.         tiles[lastImage].isShown=false;
542.       }
543.     }
544.   }
545. } // func
546. //
547. void checkIfSolved() {
548.   // check if this level is complete 
549.   int counter = 0;
550.   // Are all shown and solved?
551.   for (int x2=0; x2<TOTAL_TILES; x2++) {
552.     if (tiles[x2].isSolved) {
553.       counter ++;
554.     }
555.   }
556.   //
557.   if (counter==winningNumberOfTiles)
558.   {
559.     state=stateGameGoToNextLevelPhase1; // won this level -> stateGameGoToNextLevelPhase1
560.     println ("You won this level.");
561.     level++;
562.     timer=millis();
563.   }
564. }
565. //
566. // ================================================================
567. //Tile Class (one image card)
568. class Tile
569. {
570.   int imgIndex;   // the image index
571.   float px;     // position
572.   float py;
573.   // those three (4) could be unified to a var stateOfTile : nonExistent, withoutDuplicate, covered, shown, solved
574.   boolean isShown  = false;      // shown or covered?
575.   boolean isSolved = false;      // the duplicate is not only shown but correct and now permanently shown
576.   boolean exists   = true;       // does the tile exist at all?
577.   boolean hasDuplicate = false;  // while init not all images have a duplicate yet
578.   //
579.   int theImageCode = -1;         // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
580.   //
581.   // constr
582.   Tile ( float px_, float py_ )
583.   {
584.     px=px_;
585.     py=py_;
586.   } // constr
587.   //
588.   void loadImageIntoTile ( int imageName_ ) {
589.     imgIndex  = imageName_;
590.     images[imgIndex].resize(tileWidth, 0);
591.     // or try img.resize(tileWidth, tileHeight);
592.   } // method
593.   //
594.   void draw()
595.   {
596.     // if it exists at all?
597.     if (exists) {
598.       // we show it.
599.       // uncovered or covered?
600.       if (isShown) {
601.         // open
602.         if (images[imgIndex]!=null)
603.           image(images[imgIndex], px, py);
604.         else
605.           println ("images[imgIndex] is null");
606.         stroke(255);
607.         noFill();
608.         rect(px, py, tileWidth, tileHeight);
609.         // if tile is solved correctly
610.         if (isSolved)
611.         {
612.           // we show the OK sign
613.           textSize(34);
614.           fill(255);
615.           strokeWeight(4);
616.           stroke(0);
617.           rect(px+tileWidth-170, py+tileHeight-58, 160, 40);
618.           fill(2, 2, 255);
619.           text( "MATCH!", px+tileWidth-150, py+tileHeight-27 );
620.           fill(255);
621.         }
622.       }
623.       else
624.       {
625.         // not shown / covered tile with a "?" or imgBack
626.         //*********************************
627.         image(imgBack, px, py);
628.         //*********************************
629.         textSize(54);
630.         stroke(255);
631.         noFill();
632.         //fill(0);
633.         rect(px, py, tileWidth, tileHeight);
634.         //fill (255, 255, 255);
635.         //text ("?", px + tileWidth/2, py + tileHeight/2 );
636.       } // else
637.     } //  if (exists) {
638.   } // method
639.   //
640.   boolean mouseInside()
641.   {
642.     return ((px <= mouseX && mouseX <= px + tileWidth) &&
643.       (py <= mouseY && mouseY <= py + tileHeight));
644.   } // method
645.   //
646. } // class

1. //
   // to do (optional): if uneven, place non-existent tile into right lower corner? With 8 tiles.
   //        have each level twice? Twice two cards, twice 4 cards etc.
   //
   // global vars and constants
   //
   // how many images on the hard drive? (this+1) Must be in data folder and named 0.jpg, 1.jpg etc.
   final int howManyImages = 12;
   //
   //
   // level stuff
   final int maxLevel = 6; // how many levels, e.g. 6
   int level = 0;          // current level: 0
   //
   // state of program / game
   final int stateGameStartUp  = 0;
   final int stateGamePlay     = 1;
   final int stateGameGoToNextLevelPhase1 = 2; // these two provide a small delay
   final int stateGameGoToNextLevelPhase2 = 3;
   final int stateGameOver     = 4;
   final int stateGameShowHelp = 5;
   //
   int state = stateGameStartUp;  // current
   //
   //
   // data for tiles
   int winningNumberOfTiles;
   int TILES_HORZ ;
   int TILES_VERT ;
   int TOTAL_TILES ;
   int tileWidth;
   int tileHeight;
   Tile[] tiles ;
   int imageCode;
   //
   // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
   String allRandomNumberImage="#";
   PImage[] images = new PImage [howManyImages];
   //
   // image entering stuff
   // The var "openImages" is a counter that controls the input logic while making a move (aka opening two tiles).
   // It says how many tiles are currently shown? 0, 1 or 2. (before the move, during the move and after the move).
   // Only when openImages is == 2 we need to compare the two images (and reset openImages to 0 then).
   int openImages = 0;    // counter for current move  
   int lastImage = -1;    // which was the last tile? (1st tile opened)
   int currentImage = -1; // which is the current tile / image? (2nd tile opened)
   //
   // timer
   int timer;
   //
   // background
   // PGraphics imgBackground;
   // PImage imgBackground;
   PImage imgLogo;
   //
   PImage imgBackGlobal;
   PImage imgBack = new PImage();// image of back of card
   //
   //
   // ------------------------------------------------------------------
   // two main funcs
   //
   void setup()
   {
     size( 1800, 900);
     println("start of setup() ");
     //
     imgLogo       = loadImage("logo.jpg");
     imgBackGlobal = loadImage("cardback2.jpg");
     imgBack       = loadImage("cardback2.jpg");
     //
     for (int x=0; x<howManyImages; x++) {
       images[x]=loadImage(str(x)+".jpg");
     } // for
     //
     timer=millis();
     println("end of setup()");
   }
   //
   void draw()
   {
     switch (state) {
     case stateGameStartUp:
       // start screen and new level
       startScreen() ;
       break;
     case stateGamePlay:
       // play
       gamePlay();    
       break;
     case stateGameGoToNextLevelPhase1:
       // go to next level but only after a while
       goToNextLevel_1();
       break;
     case stateGameGoToNextLevelPhase2:
       // go to next level but only after a while
       goToNextLevel_2();
       break;   
     case stateGameOver:
       // All levels done
       showWinScreen();
       break;
     case stateGameShowHelp:
       // help - to do
       println ( "This is your help / reached by F1 / not done yet...");
       break;
     default:
       // error; shouldn't get here 
       println ("Error 86: unknown state");
       break;
     } // switch
     //
   } // func
   // ---------------------------------------------------------------
   // all funcs that get called from draw()
   //
   void startScreen() {
     // start screen : to do: make a cool start screen image
     background(0);
     // fill(2, 2, 255);
     // image(imgLogo, width/4.3, height/3.3);
     textSize(80);
     fill(255, 255, 255);
     text ( " MEMORY GAME", width/3.5+200, height/2.2);
     textSize(100);
     text ( "LEVEL:  "+(level+1), width/2.2, height/1.7);
     text ( "           ", 140, 301);
     text ( "                   ", 140, 401);
     // go next state but only after a while
     if (timer + 3000 < millis()) {
       initNewLevel();
       state = stateGamePlay;
     } // if
   } // func
   //
   void gamePlay() {
     // play
     background(0);
     drawTiles();
     checkTwoShownTiles ();
   } // func
   //
   void goToNextLevel_1() {
     // wait before go to next level but only after a while
     background(0);
     drawTiles();
     if (timer + 1000 < millis()) {
       state=stateGameGoToNextLevelPhase2;
       timer=millis();
     } // if
   } // func
   //
   void goToNextLevel_2() {
     // go to next level but only after a while
     background(0);
     drawTiles();
     showHooray(); 
     if (timer + 1000 < millis()) {
       // Was this the last level?
       if (level==maxLevel) {
         // yes, last level, game over.
         state = stateGameOver;   // won all levels
         println("game over (all levels done).");
       }
       else
       {
         // no, go to next level.
         state = stateGameStartUp;
         timer=millis();
       }
     } // if
   } // func
   //
   void showWinScreen() {
     background(0);
     drawTiles();
     showHooray() ;
     // show all levels done
     fill(0);   // black
     noStroke();
     rect (14, 104, 295, 100);
     fill(255, 255, 255);  // red
     text ( "   All levels done.", 10, 160);
     textSize(15);
     text ( "                 Click mouse", 10, 190);
   } // func
   //
   // ------------------
   //
   void showHooray() {
     fill(255);
     strokeWeight(3);
     stroke(0);
     rect (4, 4, 325, 100);
     fill(2, 2, 255);
     text ( "LEVEL FINISHED!!!", 10, 60);
   } // func
   // -----------------------------------------------------------
   // all funcs for inits
   //
   void initNewLevel () {
     //
     println("Init New Level #"+level);
     //
     // depending on current level set some basic vars
     switch (level) {
     case 0:
       // just 2 pieces
       TILES_HORZ =2;
       TILES_VERT =1;
       winningNumberOfTiles = 2;
       break;
     case 1:
       // 4 pieces
       TILES_HORZ =2;
       TILES_VERT =2;
       winningNumberOfTiles = 4;
       break;
     case 2:
       TILES_HORZ =3;
       TILES_VERT =2;
       winningNumberOfTiles = 6;
       break;
     case 3:
       TILES_HORZ =3;
       TILES_VERT =3;
       winningNumberOfTiles = 9; // is 8
       break;
     case 4:
       TILES_HORZ =4;
       TILES_VERT =3;
       winningNumberOfTiles = 12; // is 12
       break;
     case 5:
       TILES_HORZ =4;
       TILES_VERT =4;
       winningNumberOfTiles = 16; // is 16
       break;
     default:
       println("Error 55: Unknown Level");
       break;
     } // switch
     //
     // have other vars based on that defined  
     if (level>0) {
       // level > 0
       defineNormalTileSet() ;
     }
     else
     {
       // level is 0
       defineTileSetForLevelZero() ;
     }
     textSize(54);
     //
     println("Finishing Init process for level #"+level);
     //
   } // func
   //
   void defineTileSetForLevelZero() {
     // level is 0
     //
     println ("Level zero");
     // make data for tiles and the tiles
     tileWidth=width/2;
     tileHeight=tileWidth/2;
     TOTAL_TILES = 2;
     tiles = new Tile [TOTAL_TILES+1];
     tiles[0] = new Tile (0, height-tileHeight);
     tiles[1] = new Tile (tileWidth, height-tileHeight);
     //
     //
     // make duplicates ---------------------
     tiles[0].hasDuplicate=true;   // both tiles have a duplicate now
     tiles[1].hasDuplicate=true;
     tiles[0].theImageCode=44;  // both tiles get the same imageCode
     tiles[1].theImageCode=44;  // saying: you two are belonging together
     int myImageIndex = giveImageIndex(); // get an index
     println ("2nd point " + myImageIndex);
     tiles[0].loadImageIntoTile ( myImageIndex ); // same image
     tiles[1].loadImageIntoTile ( myImageIndex );
     println ("3rd point");
     //****************************
     // imgBack = loadImage("cardback2.jpg");
     imgBack.copy(imgBackGlobal,
     0, 0, imgBackGlobal.width, imgBackGlobal.height,
     0, 0, tileWidth, 0);
     imgBack.resize(tileWidth, tileHeight);
     //****************************
     //
   }
   //
   void defineNormalTileSet() {
     //
     int i=0;
     tileWidth=width/TILES_HORZ-1 ;
     // try this tileHeight=height/TILES_VERT-1 ;
     // or this
     tileHeight=tileWidth/2;
     TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
     // not even?
     if (winningNumberOfTiles%2 != 0 ) {
       // println (winningNumberOfTiles + " not even");
       winningNumberOfTiles--;
     }
     tiles = new Tile [TOTAL_TILES+1];
     // now define the tiles without the images ------------------
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {  
         tiles[i] = new Tile (tileWidth*x, tileHeight*y );
         i++;
       }
     }
     //
     // make duplicates ---------------------
     // println ( "Now we make them having duplicates. " );
     i=0;
     // this arraylist "intTileIndexes" serves as a memory which
     // cards we already treated
     ArrayList <Integer> intTileIndexes = new ArrayList();
     intTileIndexes.clear();
     // fill the arraylist
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         intTileIndexes.add( i );
         i++;
       }
     }
     // still make duplicates ------
     i=0;
     imageCode=0;
     allRandomNumberImage="#";
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         makeItHaveAnDuplicate( intTileIndexes, i );
         i++;
       } // for
     } // for
     //
     // if not even, make one tile inexistent
     i=0;
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         // if our tile doesn't have a duplicate yet
         if (!tiles[i].hasDuplicate) {
           // we don't show it
           tiles[i].exists=false;
         } // if
         i++;
       } // for
     } // for
     // 
     //****************************
     // imgBackGlobal  = loadImage("cardback2.jpg");
     //imgBack=imgBackGlobal;
     imgBack.copy(imgBackGlobal,
     0, 0, imgBackGlobal.width, imgBackGlobal.height,
     0, 0, tileWidth, 0);
     imgBack.resize(tileWidth, tileHeight);
     //****************************
     //
   } // func
   //
   void makeItHaveAnDuplicate(  ArrayList <Integer> intTileIndexes, int i ) {
     // makeItHaveAnDuplicate
     // if our tile doesn't have a duplicate yet, then it's on our to do list:
     if (!tiles[i].hasDuplicate) {
       // we search a random partner
       int safetyCounter = 0; // that avoids that the loop takes too long...
       // now we calculate a random number which is a index for intTileIndexes
       int j2 = int(random (0, intTileIndexes.size()));
       int j  = intTileIndexes.get(j2);
       // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
       // then we get an error here but that's ok
       while ( (i==j || tiles[j].hasDuplicate )  && 
         (safetyCounter<50) ) {
         j2 = int(random (0, intTileIndexes.size()));
         j  = intTileIndexes.get(j2);
         safetyCounter++;
       }
       // Did he found one?
       if ( (i!=j) && (!tiles[j].hasDuplicate) ) {
         // yes
         // remove those from the arraylist
         removeFromArrayList (intTileIndexes, i);
         removeFromArrayList (intTileIndexes, j);
         tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
         tiles[j].hasDuplicate=true;
         tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
         tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
         int myImageIndex=giveImageIndex(); // get a name
         tiles[i].loadImageIntoTile ( myImageIndex ); // same image
         tiles[j].loadImageIntoTile ( myImageIndex );
         //
         imageCode++;                    // increase the code since it must be unique
       }
       else {
         // println ("error 119");
       } // else
     } // if
   }
   //
   int giveImageIndex() {
     // gives a image file name (that is new)
     int randomNumberImage = int (random(0, howManyImages));
     int safetyCounter = 0;
     // while not a new image keep on searching
     while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
       (safetyCounter<30) ) {
       randomNumberImage = int (random(0, howManyImages));
       safetyCounter++;
     }
     // found a new one
     allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
     // return value
     // return str( randomNumberImage ) +".jpg";
     return randomNumberImage;
   } // func
   //
   void removeFromArrayList (ArrayList<Integer> myArrayList, int iToBeRemoved) {
     // removes one item iToBeRemoved.
     // With an array, we say balls.length. With an ArrayList,
     // we say balls.size(). The length of an ArrayList is dynamic.
     // Notice how we are looping through the ArrayList backwards.
     // This is because we are deleting elements from the list.
     for (int i = myArrayList.size()-1; i >= 0; i--) {
       int iFromArrayList = int ( myArrayList.get(i));
       if ( iFromArrayList==iToBeRemoved ) {
         myArrayList.remove(i);
         return;
       }
     } // for
   } // func
   //
   //
   //void makeABackgroundImage () {
   //  //
   //  imgBackground = createGraphics (width, height );
   //  imgBackground.beginDraw();
   //  imgBackground.noFill();
   //  imgBackground.stroke(255);
   //  imgBackground.strokeWeight(1);
   //  // diagonal lines
   //  for (int x = -100; x < width; x+=30) {
   //    imgBackground.line(x, 0, x+130, height);
   //  }
   //  imgBackground.endDraw();
   //  //
   //} // func
   //
   // Inputs -----------------------------------------------------------------
   //
   void mousePressed() {
     // switch state
     switch (state) {
     case stateGamePlay:
       if (openImages != 2) {
         // search  
         int x=-1;
         for (int x2=0; x2<TOTAL_TILES; x2++) {
           if (tiles[x2].mouseInside() && tiles[x2].exists
             && !tiles[x2].isSolved &&  !tiles[x2].isShown ) {
             x=x2;
             break;
           } // if
         } // for
         //
         // found?
         if (x>-1) {
           // when one image is open make sure that the 2nd is a different one
           if ( ((openImages == 1) && ( x != lastImage)) ||
             (openImages == 0) ) { 
             // yes?
             if (tiles[x].mouseInside()) {
               tiles[x].isShown=true;
               openImages++;
               if (openImages == 1) {
                 lastImage=x;
               }
               else
               {
                 currentImage=x;
                 timer=millis();
               } // else
             } // if
           } // if
         } // if
       } // if
       break;
     case stateGameOver:
       level=0;
       state = stateGameStartUp;
       timer=millis();
       break;
     default:
       // do nothing
       break;
     } // switch
     //
   } // func
   void keyPressed () {
     if (state==stateGameOver) {
       level=0;
       state = stateGameStartUp;
       timer=millis();
     }
   }
   // -------------------------------------------------------
   // smaller tools
   //
   //
   void drawTiles() {
     // draw it
     for (int x=0; x<TOTAL_TILES; x++) {
       tiles[x].draw();
     }
     //
   }
   //
   void checkTwoShownTiles () {
     // after a move:
     // if two images are shown we have to check them
     if (openImages == 2) {
       // but only after a while
       if (timer + 1000 < millis()) {
         // two are shown (the user has made his move)
         openImages=0; // reset
         // check
         if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
         {
           //  correct
           println ("Good");
           tiles[currentImage].isSolved=true;
           tiles[lastImage].isSolved=true;
           checkIfSolved();
         }
         else
         {
           // not correct: the are hidden again 
           tiles[currentImage].isShown=false;
           tiles[lastImage].isShown=false;
         }
       }
     }
   } // func
   //
   void checkIfSolved() {
     // check if this level is complete 
     int counter = 0;
     // Are all shown and solved?
     for (int x2=0; x2<TOTAL_TILES; x2++) {
       if (tiles[x2].isSolved) {
         counter ++;
       }
     }
     //
     if (counter==winningNumberOfTiles)
     {
       state=stateGameGoToNextLevelPhase1; // won this level -> stateGameGoToNextLevelPhase1
       println ("You won this level.");
       level++;
       timer=millis();
     }
   }
   //
   // ================================================================
   //Tile Class (one image card)
   class Tile
   {
     int imgIndex;   // the image index
     float px;     // position
     float py;
     // those three (4) could be unified to a var stateOfTile : nonExistent, withoutDuplicate, covered, shown, solved
     boolean isShown  = false;      // shown or covered?
     boolean isSolved = false;      // the duplicate is not only shown but correct and now permanently shown
     boolean exists   = true;       // does the tile exist at all?
     boolean hasDuplicate = false;  // while init not all images have a duplicate yet
     //
     int theImageCode = -1;         // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
     //
     // constr
     Tile ( float px_, float py_ )
     {
       px=px_;
       py=py_;
     } // constr
     //
     void loadImageIntoTile ( int imageName_ ) {
       imgIndex  = imageName_;
       images[imgIndex].resize(tileWidth, 0);
       // or try img.resize(tileWidth, tileHeight);
     } // method
     //
     void draw()
     {
       // if it exists at all?
       if (exists) {
         // we show it.
         // uncovered or covered?
         if (isShown) {
           // open
           if (images[imgIndex]!=null)
             image(images[imgIndex], px, py);
           else
             println ("images[imgIndex] is null");
           stroke(255);
           noFill();
           rect(px, py, tileWidth, tileHeight);
           // if tile is solved correctly
           if (isSolved)
           {
             // we show the OK sign
             textSize(34);
             fill(255);
             strokeWeight(4);
             stroke(0);
             rect(px+tileWidth-170, py+tileHeight-58, 160, 40);
             fill(2, 2, 255);
             text( "MATCH!", px+tileWidth-150, py+tileHeight-27 );
             fill(255);
           }
         }
         else
         {
           // not shown / covered tile with a "?" or imgBack
           //*********************************
           image(imgBack, px, py);
           //*********************************
           textSize(54);
           stroke(255);
           noFill();
           //fill(0);
           rect(px, py, tileWidth, tileHeight);
           //fill (255, 255, 255);
           //text ("?", px + tileWidth/2, py + tileHeight/2 );
         } // else
       } //  if (exists) {
     } // method
     //
     boolean mouseInside()
     {
       return ((px <= mouseX && mouseX <= px + tileWidth) &&
         (py <= mouseY && mouseY <= py + tileHeight));
     } // method
     //
   } // class
   

• imgBack.copy and
• imgBack.resize

1. //
2. // to do (optional): if uneven, place non-existent tile into right lower corner? With 8 tiles.
3. //        have each level twice? Twice two cards, twice 4 cards etc.
4. //
5. // global vars and constants
6. //
7. // how many images on the hard drive? (this+1) Must be in data folder and named 0.jpg, 1.jpg etc.
8. final int howManyImages = 12;
9. //
10. //
11. // level stuff
12. final int maxLevel = 6; // how many levels, e.g. 6
13. int level = 0;          // current level: 0
14. //
15. // state of program / game
16. final int stateGameStartUp  = 0;
17. final int stateGamePlay     = 1;
18. final int stateGameGoToNextLevelPhase1 = 2; // these two provide a small delay
19. final int stateGameGoToNextLevelPhase2 = 3;
20. final int stateGameOver     = 4; // win
21. final int stateGameShowHelp = 5; // help - not done yet
22. //
23. int state = stateGameStartUp;  // current
24. //
25. //
26. // data for tiles
27. int winningNumberOfTiles;
28. int TILES_HORZ ;
29. int TILES_VERT ;
30. int TOTAL_TILES ;
31. int tileWidth;
32. int tileHeight;
33. Tile[] tiles ;
34. int imageCode;
35. //
36. // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
37. String allRandomNumberImage="#";
38. PImage[] images = new PImage [howManyImages];
39. //
40. // image entering stuff
41. // The var "openImages" is a counter that controls the input logic while making a move (aka opening two tiles).
42. // It says how many tiles are currently shown? 0, 1 or 2. (before the move, during the move and after the move).
43. // Only when openImages is == 2 we need to compare the two images (and reset openImages to 0 then).
44. int openImages = 0;    // counter for current move 
45. int lastImage = -1;    // which was the last tile? (1st tile opened)
46. int currentImage = -1; // which is the current tile / image? (2nd tile opened)
47. //
48. // timer
49. int timer;
50. //
51. // background
52. // PGraphics imgBackground;
53. // PImage imgBackground;
54. PImage imgLogo;
55. //
56. PImage imgBackGlobal;
57. PImage imgBack = new PImage();// image of back of card
58. //
59. //
60. // ------------------------------------------------------------------
61. // two main funcs
62. //
63. void setup()
64. {
65.   size( 1800, 900);
66.   println("start of setup() ");
67.   //
68.   imgLogo       = loadImage("logo.jpg");
69.   imgBackGlobal = loadImage("cardback2.jpg");
70.   imgBack       = loadImage("cardback2.jpg");
71.   //
72.   for (int x=0; x<howManyImages; x++) {
73.     images[x]=loadImage(str(x)+".jpg");
74.   } // for
75.   //
76.   timer=millis();
77.   println("end of setup()");
78. }
79. //
80. void draw()
81. {
82.   switch (state) {
83.   case stateGameStartUp:
84.     // start screen and new level
85.     startScreen() ;
86.     break;
87.   case stateGamePlay:
88.     // play
89.     gamePlay();   
90.     break;
91.   case stateGameGoToNextLevelPhase1:
92.     // go to next level but only after a while
93.     goToNextLevel_1();
94.     break;
95.   case stateGameGoToNextLevelPhase2:
96.     // go to next level but only after a while
97.     goToNextLevel_2();
98.     break;  
99.   case stateGameOver:
100.     // All levels done
101.     showWinScreen();
102.     break;
103.   case stateGameShowHelp:
104.     // help - to do
105.     println ( "This is your help / reached by F1 / not done yet...");
106.     break;
107.   default:
108.     // error; shouldn't get here
109.     println ("Error 86: unknown state");
110.     break;
111.   } // switch
112.   //
113. } // func
114. // ---------------------------------------------------------------
115. // all funcs that get called from draw()
116. //
117. void startScreen() {
118.   // start screen : to do: make a cool start screen image
119.   background(0);
120.   // fill(2, 2, 255);
121.   // image(imgLogo, width/4.3, height/3.3);
122.   textSize(80);
123.   fill(255, 255, 255);
124.   text ( " MEMORY GAME", width/3.5+200, height/2.2);
125.   textSize(100);
126.   text ( "LEVEL:  "+(level+1), width/2.2, height/1.7);
127.   text ( "           ", 140, 301);
128.   text ( "                   ", 140, 401);
129.   // go next state but only after a while
130.   if (timer + 3000 < millis()) {
131.     initNewLevel();
132.     state = stateGamePlay;
133.   } // if
134. } // func
135. //
136. void gamePlay() {
137.   // play
138.   background(0);
139.   drawTiles();
140.   checkTwoShownTiles ();
141. } // func
142. //
143. void goToNextLevel_1() {
144.   // wait before go to next level but only after a while
145.   background(0);
146.   drawTiles();
147.   if (timer + 1000 < millis()) {
148.     state=stateGameGoToNextLevelPhase2;
149.     timer=millis();
150.   } // if
151. } // func
152. //
153. void goToNextLevel_2() {
154.   // go to next level but only after a while
155.   background(0);
156.   drawTiles();
157.   showHooray();
158.   if (timer + 1000 < millis()) {
159.     // Was this the last level?
160.     if (level==maxLevel) {
161.       // yes, last level, game over.
162.       state = stateGameOver;   // won all levels
163.       println("game over (all levels done).");
164.     }
165.     else
166.     {
167.       // no, go to next level.
168.       state = stateGameStartUp;
169.       timer=millis();
170.     }
171.   } // if
172. } // func
173. //
174. void showWinScreen() {
175.   background(0);
176.   drawTiles();
177.   showHooray() ;
178.   // show all levels done
179.   fill(0);   // black
180.   noStroke();
181.   rect (14, 104, 295, 100);
182.   fill(255, 255, 255);  // red
183.   text ( "   All levels done.", 10, 160);
184.   textSize(15);
185.   text ( "                 Click mouse", 10, 190);
186. } // func
187. //
188. // ------------------
189. //
190. void showHooray() {
191.   fill(255);
192.   strokeWeight(3);
193.   stroke(0);
194.   rect (4, 4, 325, 100);
195.   fill(2, 2, 255);
196.   text ( "LEVEL FINISHED!!!", 10, 60);
197. } // func
198. // -----------------------------------------------------------
199. // all funcs for inits
200. //
201. void initNewLevel () {
202.   //
203.   println("Init New Level #"+level);
204.   //
205.   // depending on current level set some basic vars
206.   switch (level) {
207.   case 0:
208.     // just 2 pieces
209.     TILES_HORZ =2;
210.     TILES_VERT =1;
211.     winningNumberOfTiles = 2;
212.     break;
213.   case 1:
214.     // 4 pieces
215.     TILES_HORZ =2;
216.     TILES_VERT =2;
217.     winningNumberOfTiles = 4;
218.     break;
219.   case 2:
220.     TILES_HORZ =3;
221.     TILES_VERT =2;
222.     winningNumberOfTiles = 6;
223.     break;
224.   case 3:
225.     TILES_HORZ =3;
226.     TILES_VERT =3;
227.     winningNumberOfTiles = 9; // is 8
228.     break;
229.   case 4:
230.     TILES_HORZ =4;
231.     TILES_VERT =3;
232.     winningNumberOfTiles = 12; // is 12
233.     break;
234.   case 5:
235.     TILES_HORZ =4;
236.     TILES_VERT =4;
237.     winningNumberOfTiles = 16; // is 16
238.     break;
239.   default:
240.     println("Error 55: Unknown Level");
241.     break;
242.   } // switch
243.   //
244.   // have other vars based on that defined 
245.   if (level>0) {
246.     // level > 0 (the normal levels)
247.     defineNormalTileSet() ;
248.   }
249.   else
250.   {
251.     // level is 0 (Level zero, only two tiles)
252.     defineTileSetForLevelZero() ;
253.   }
254.   textSize(54);
255.   //
256.   println("Finishing Init process for level #"+level);
257.   //
258. } // func
259. //
260. void defineTileSetForLevelZero() {
261.   // level is 0
262.   //
263.   println ("Level zero: defineTileSetForLevelZero()");
264.   // make data for tiles and the tiles
265.   tileWidth=width/2;
266.   tileHeight=tileWidth/2;
267.   TOTAL_TILES = 2;
268.   tiles = new Tile [TOTAL_TILES+1];
269.   tiles[0] = new Tile (0, height-tileHeight);
270.   tiles[1] = new Tile (tileWidth, height-tileHeight);
271.   //
272.   //
273.   // make duplicates ---------------------
274.   tiles[0].hasDuplicate=true;   // both tiles have a duplicate now
275.   tiles[1].hasDuplicate=true;
276.   tiles[0].theImageCode=44;  // both tiles get the same imageCode
277.   tiles[1].theImageCode=44;  // saying: you two are belonging together
278.   println ("before giveImageIndex (280)");
279.   int myImageIndex = giveImageIndex(); // get an index
280.   println ("after giveImageIndex (282)");
281.   println ("2nd point; img index " + myImageIndex);
282.   tiles[0].loadImageIntoTile ( myImageIndex ); // same image
283.   tiles[1].loadImageIntoTile ( myImageIndex );
284.   println ("3rd point");
285.   //****************************
286.   // imgBack = loadImage("cardback2.jpg");
287.   //  imgBack.copy(imgBackGlobal,
288.   //  0, 0, imgBackGlobal.width, imgBackGlobal.height,
289.   //  0, 0, tileWidth, 0);
290.   // imgBack.resize(tileWidth, tileHeight);
291.   //****************************
292.   //
293. }
294. //
295. void defineNormalTileSet() {
296.   //
297.   int i=0;
298.   tileWidth=width/TILES_HORZ-1 ;
299.   // try this tileHeight=height/TILES_VERT-1 ;
300.   // or this
301.   tileHeight=tileWidth/2;
302.   TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
303.   // not even?
304.   if (winningNumberOfTiles%2 != 0 ) {
305.     // println (winningNumberOfTiles + " not even");
306.     winningNumberOfTiles--;
307.   }
308.   tiles = new Tile [TOTAL_TILES+1];
309.   // now define the tiles without the images ------------------
310.   for (int x=0; x<TILES_HORZ; x++) {
311.     for (int y=0; y<TILES_VERT; y++) { 
312.       tiles[i] = new Tile (tileWidth*x, tileHeight*y );
313.       i++;
314.     }
315.   }
316.   //
317.   // make duplicates ---------------------
318.   // println ( "Now we make them having duplicates. " );
319.   i=0;
320.   // this arraylist "intTileIndexes" serves as a memory which
321.   // cards we already treated
322.   ArrayList <Integer> intTileIndexes = new ArrayList();
323.   intTileIndexes.clear();
324.   // fill the arraylist
325.   for (int x=0; x<TILES_HORZ; x++) {
326.     for (int y=0; y<TILES_VERT; y++) {
327.       intTileIndexes.add( i );
328.       i++;
329.     }
330.   }
331.   // still make duplicates ------
332.   i=0;
333.   imageCode=0;
334.   allRandomNumberImage="#";
335.   for (int x=0; x<TILES_HORZ; x++) {
336.     for (int y=0; y<TILES_VERT; y++) {
337.       makeItHaveAnDuplicate( intTileIndexes, i );
338.       i++;
339.     } // for
340.   } // for
341.   //
342.   // if not even, make one tile inexistent
343.   i=0;
344.   for (int x=0; x<TILES_HORZ; x++) {
345.     for (int y=0; y<TILES_VERT; y++) {
346.       // if our tile doesn't have a duplicate yet
347.       if (!tiles[i].hasDuplicate) {
348.         // we don't show it
349.         tiles[i].exists=false;
350.       } // if
351.       i++;
352.     } // for
353.   } // for
354.   //
355.   //****************************
356.   // imgBackGlobal  = loadImage("cardback2.jpg");
357.   //imgBack=imgBackGlobal;
358.   //  imgBack.copy(imgBackGlobal,
359.   //  0, 0, imgBackGlobal.width, imgBackGlobal.height,
360.   //  0, 0, tileWidth, 0);
361.   //  imgBack.resize(tileWidth, tileHeight);
362.   //****************************
363.   //
364. } // func
365. //
366. void makeItHaveAnDuplicate(  ArrayList <Integer> intTileIndexes, int i ) {
367.   // makeItHaveAnDuplicate
368.   // if our tile doesn't have a duplicate yet, then it's on our to do list:
369.   if (!tiles[i].hasDuplicate) {
370.     // we search a random partner
371.     int safetyCounter = 0; // that avoids that the loop takes too long...
372.     // now we calculate a random number which is a index for intTileIndexes
373.     int j2 = int(random (0, intTileIndexes.size()));
374.     int j  = intTileIndexes.get(j2);
375.     // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
376.     // then we get an error here but that's ok
377.     while ( (i==j || tiles[j].hasDuplicate )  &&
378.       (safetyCounter<50) ) {
379.       j2 = int(random (0, intTileIndexes.size()));
380.       j  = intTileIndexes.get(j2);
381.       safetyCounter++;
382.     }
383.     // Did he found one?
384.     if ( (i!=j) && (!tiles[j].hasDuplicate) ) {
385.       // yes
386.       // remove those from the arraylist
387.       removeFromArrayList (intTileIndexes, i);
388.       removeFromArrayList (intTileIndexes, j);
389.       tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
390.       tiles[j].hasDuplicate=true;
391.       tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
392.       tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
393.       int myImageIndex=giveImageIndex(); // get a name
394.       tiles[i].loadImageIntoTile ( myImageIndex ); // same image
395.       tiles[j].loadImageIntoTile ( myImageIndex );
396.       //
397.       imageCode++;                    // increase the code since it must be unique
398.     }
399.     else {
400.       // println ("error 119");
401.     } // else
402.   } // if
403. }
404. //
405. int giveImageIndex() {
406.   // gives a image file name (that is new)
407.   int randomNumberImage = int (random(0, howManyImages));
408.   int safetyCounter = 0;
409.   // while not a new image keep on searching
410.   while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
411.     (safetyCounter<30) ) {
412.     randomNumberImage = int (random(0, howManyImages));
413.     safetyCounter++;
414.   }
415.   // found a new one
416.   allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
417.   // return value
418.   // return str( randomNumberImage ) +".jpg";
419.   return randomNumberImage;
420. } // func
421. //
422. void removeFromArrayList (ArrayList<Integer> myArrayList, int iToBeRemoved) {
423.   // removes one item iToBeRemoved.
424.   // With an array, we say balls.length. With an ArrayList,
425.   // we say balls.size(). The length of an ArrayList is dynamic.
426.   // Notice how we are looping through the ArrayList backwards.
427.   // This is because we are deleting elements from the list.
428.   for (int i = myArrayList.size()-1; i >= 0; i--) {
429.     int iFromArrayList = int ( myArrayList.get(i));
430.     if ( iFromArrayList==iToBeRemoved ) {
431.       myArrayList.remove(i);
432.       return;
433.     }
434.   } // for
435. } // func
436. //
437. //
438. //void makeABackgroundImage () {
439. //  //
440. //  imgBackground = createGraphics (width, height );
441. //  imgBackground.beginDraw();
442. //  imgBackground.noFill();
443. //  imgBackground.stroke(255);
444. //  imgBackground.strokeWeight(1);
445. //  // diagonal lines
446. //  for (int x = -100; x < width; x+=30) {
447. //    imgBackground.line(x, 0, x+130, height);
448. //  }
449. //  imgBackground.endDraw();
450. //  //
451. //} // func
452. //
453. // Inputs -----------------------------------------------------------------
454. //
455. void mousePressed() {
456.   // switch state
457.   switch (state) {
458.   case stateGamePlay:
459.     if (openImages != 2) {
460.       // search 
461.       int x=-1;
462.       for (int x2=0; x2<TOTAL_TILES; x2++) {
463.         if (tiles[x2].mouseInside() && tiles[x2].exists
464.           && !tiles[x2].isSolved &&  !tiles[x2].isShown ) {
465.           x=x2;
466.           break;
467.         } // if
468.       } // for
469.       //
470.       // found?
471.       if (x>-1) {
472.         // when one image is open make sure that the 2nd is a different one
473.         if ( ((openImages == 1) && ( x != lastImage)) ||
474.           (openImages == 0) ) {
475.           // yes?
476.           if (tiles[x].mouseInside()) {
477.             tiles[x].isShown=true;
478.             openImages++;
479.             if (openImages == 1) {
480.               lastImage=x;
481.             }
482.             else
483.             {
484.               currentImage=x;
485.               timer=millis();
486.             } // else
487.           } // if
488.         } // if
489.       } // if
490.     } // if
491.     break;
492.   case stateGameOver:
493.     level=0;
494.     state = stateGameStartUp;
495.     timer=millis();
496.     break;
497.   default:
498.     // do nothing
499.     break;
500.   } // switch
501.   //
502. } // func
503. void keyPressed () {
504.   if (state==stateGameOver) {
505.     level=0;
506.     state = stateGameStartUp;
507.     timer=millis();
508.   }
509. }
510. // -------------------------------------------------------
511. // smaller tools
512. //
513. //
514. void drawTiles() {
515.   // draw it
516.   for (int x=0; x<TOTAL_TILES; x++) {
517.     tiles[x].draw();
518.   }
519.   //
520. }
521. //
522. void checkTwoShownTiles () {
523.   // after a move:
524.   // if two images are shown we have to check them
525.   if (openImages == 2) {
526.     // but only after a while
527.     if (timer + 1000 < millis()) {
528.       // two are shown (the user has made his move)
529.       openImages=0; // reset
530.       // check
531.       if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
532.       {
533.         //  correct
534.         println ("Good");
535.         tiles[currentImage].isSolved=true;
536.         tiles[lastImage].isSolved=true;
537.         checkIfSolved();
538.       }
539.       else
540.       {
541.         // not correct: the are hidden again
542.         tiles[currentImage].isShown=false;
543.         tiles[lastImage].isShown=false;
544.       }
545.     }
546.   }
547. } // func
548. //
549. void checkIfSolved() {
550.   // check if this level is complete
551.   int counter = 0;
552.   // Are all shown and solved?
553.   for (int x2=0; x2<TOTAL_TILES; x2++) {
554.     if (tiles[x2].isSolved) {
555.       counter ++;
556.     }
557.   }
558.   //
559.   if (counter==winningNumberOfTiles)
560.   {
561.     state=stateGameGoToNextLevelPhase1; // won this level -> stateGameGoToNextLevelPhase1
562.     println ("You won this level.");
563.     level++;
564.     timer=millis();
565.   }
566. }
567. //
568. // ================================================================
569. //Tile Class (one image card)
570. class Tile
571. {
572.   int imgIndex=-1;   // the image index
573.   PImage img;
574.   float px;     // position
575.   float py;
576.   // those three (4) could be unified to a var stateOfTile : nonExistent, withoutDuplicate, covered, shown, solved
577.   boolean isShown  = false;      // shown or covered?
578.   boolean isSolved = false;      // the duplicate is not only shown but correct and now permanently shown
579.   boolean exists   = true;       // does the tile exist at all?
580.   boolean hasDuplicate = false;  // while init not all images have a duplicate yet
581.   //
582.   int theImageCode = -1;         // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
583.   //
584.   // constr
585.   Tile ( float px_, float py_ )
586.   {
587.     px=px_;
588.     py=py_;
589.   } // constr
590.   //
591.   void loadImageIntoTile ( int imageIndex_ ) {
592.     // imgIndex  = imageName_;
593.     img = images[imageIndex_].get();
594.     // img.resize(tileWidth, 0);
595.     // or try img.resize(tileWidth, tileHeight);
596.   } // method
597.   //
598.   void draw()
599.   {
600.     // if it exists at all?
601.     if (exists) {
602.       // we show it.
603.       // uncovered or covered?
604.       if (isShown) {
605.         // open
606.         if (img!=null)
607.           image(img, px, py);
608.         else
609.           println ("img is null");
610.         stroke(255);
611.         noFill();
612.         rect(px, py, tileWidth, tileHeight);
613.         // if tile is solved correctly
614.         if (isSolved)
615.         {
616.           // we show the OK sign
617.           textSize(34);
618.           fill(255);
619.           strokeWeight(4);
620.           stroke(0);
621.           rect(px+tileWidth-170, py+tileHeight-58, 160, 40);
622.           fill(2, 2, 255);
623.           text( "MATCH!", px+tileWidth-150, py+tileHeight-27 );
624.           fill(255);
625.         }
626.       }
627.       else
628.       {
629.         // not shown / covered tile with a "?" or imgBack
630.         //*********************************
631.         image(imgBack, px, py);
632.         //*********************************
633.         textSize(54);
634.         stroke(255);
635.         noFill();
636.         //fill(0);
637.         rect(px, py, tileWidth, tileHeight);
638.         //fill (255, 255, 255);
639.         //text ("?", px + tileWidth/2, py + tileHeight/2 );
640.       } // else
641.     } //  if (exists) {
642.   } // method
643.   //
644.   boolean mouseInside()
645.   {
646.     return ((px <= mouseX && mouseX <= px + tileWidth) &&
647.       (py <= mouseY && mouseY <= py + tileHeight));
648.   } // method
649.   //
650. } // class

1. 
   import ddf.minim.*;
   Minim minim;
   AudioPlayer player;
   AudioPlayer player1;
   AudioPlayer player2;
   //
   // to do (optional): if uneven, place non-existent tile into right lower corner? With 8 tiles.
   //        have each level twice? Twice two cards, twice 4 cards etc.
   //
   // global vars and constants
   //
   // how many images on the hard drive? (this+1) Must be in data folder and named 0.jpg, 1.jpg etc.
   final int howManyImages = 18;
   //
   //
   // level stuff
   final int maxLevel = 10; // how many levels, e.g. 6
   int level = 0;          // current level: 0
   //
   // state of program / game
   final int stateGameStartUp  = 0;
   final int stateGamePlay     = 1;
   final int stateGameGoToNextLevelPhase1 = 2; // these two provide a small delay
   final int stateGameGoToNextLevelPhase2 = 3;
   final int stateGameOver     = 4;
   final int stateGameShowHelp = 5;
   //
   int state = stateGameStartUp;  // current
   //
   //
   // data for tiles
   int winningNumberOfTiles;
   int TILES_HORZ ;
   int TILES_VERT ;
   int TOTAL_TILES ;
   int tileWidth;
   int tileHeight;
   Tile[] tiles ;
   int imageCode;
   //
   // allRandomNumberImage is a check list to avoid using the same image twice as long as possible...
   String allRandomNumberImage="#";
   PImage[] images = new PImage [howManyImages];
   //
   // image entering stuff
   // The var "openImages" is a counter that controls the input logic while making a move (aka opening two tiles).
   // It says how many tiles are currently shown? 0, 1 or 2. (before the move, during the move and after the move).
   // Only when openImages is == 2 we need to compare the two images (and reset openImages to 0 then).
   int openImages = 0;    // counter for current move  
   int lastImage = -1;    // which was the last tile? (1st tile opened)
   int currentImage = -1; // which is the current tile / image? (2nd tile opened)
   int timer;
   PImage imgLogo;
   PImage imgWin;
   PImage imgBackGlobal;
   PImage imgBack = new PImage();// image of back of card
   //
   //
   // ------------------------------------------------------------------
   // two main funcs
   //
   void setup()
   {
     size( 1800, 900);
     println("start of setup() ");
     //
       minim = new Minim(this);
           player = minim.loadFile("nfl.wav");
       player1 = minim.loadFile("mixdown.wav");
       player2 = minim.loadFile("crowd.wav");
     imgLogo       = loadImage("logo.jpg");
     imgBackGlobal = loadImage("cardBack.jpg");
     imgBack       = loadImage("cardBack.jpg");
     imgWin  = loadImage("youWon.jpg");
     //
     for (int x=0; x<howManyImages; x++) {
       images[x]=loadImage(str(x)+".jpg");
     } // for
     //
     timer=millis();
     println("end of setup()");
   }
   //
   void draw()
   {
     switch (state) {
     case stateGameStartUp:
       // start screen and new level
       println("STARTUP");
       startScreen() ;
2.     break;
     case stateGamePlay:
       // play
       //println("gameplay");
       gamePlay();    
       break;
     case stateGameGoToNextLevelPhase1:
       // go to next level but only after a while
       println("GTNL1");
       goToNextLevel_1();
       break;
     case stateGameGoToNextLevelPhase2:
       // go to next level but only after a while
       println("GTNL2");
       goToNextLevel_2();
       break;   
     case stateGameOver:
       // All levels done
       println("gameover");
       showWinScreen();
       break;
     case stateGameShowHelp:
       // help - to do
       println ( "This is your help / reached by F1 / not done yet...");
       break;
     default:
       // error; shouldn't get here 
       println ("Error 86: unknown state");
       break;
     } // switch
     //
   } // func
   // ---------------------------------------------------------------
   // all funcs that get called from draw()
   //
   void startScreen() {
     player.play();
     player2.play();
     // start screen : to do: make a cool start screen image
     background(0);
     // fill(2, 2, 255);
    image(imgLogo, width/4.3, height/3.3);
     textSize(80);
     fill(255, 255, 255);
     text ( " MEMORY GAME", width/3.5+200, height/2.2);
     textSize(100);
     text ( "LEVEL:  "+(level+1), width/2.2, height/1.7);
     text ( "           ", 140, 301);
     text ( "                   ", 140, 401);
     // go next state but only after a while
     if (timer + 5200 < millis()) {
       initNewLevel();
       state = stateGamePlay;
     } // if
   } // func
   //
   void gamePlay() {
     // play
     background(0);
     drawTiles();
     checkTwoShownTiles ();
   } // func
   //
   void goToNextLevel_1() {
     // wait before go to next level but only after a while
     background(0);
     drawTiles();
     if (timer + 1000 < millis()) {
       state=stateGameGoToNextLevelPhase2;
       timer=millis();
     } // if
   } // func
   //
   void goToNextLevel_2() {
     // go to next level but only after a while
     background(0);
     drawTiles();
     showHooray(); 
     if (timer + 1000 < millis()) {
       // Was this the last level?
       if (level==maxLevel) {
         // yes, last level, game over.
         state = stateGameOver;   // won all levels
         println("game over (all levels done).");
       }
       else
       {
         // no, go to next level.
         state = stateGameStartUp;
         timer=millis();
       }
     } // if
   } // func
   //
   void showWinScreen() {
     background(0);
     drawTiles();
     showHooray() ;
     // show all levels done
    background(0) ;
    image(imgWin, 750,100);
     fill(0);   // black
     noStroke();
     rect (14, 104, 295, 100);
     fill(255, 255, 255);  // red
     text ( "   CONGRADULATIONS YOU FINISHED THE GAME!!!", 40, 160);
     textSize(20);
     text ( "                 CLICK MOUSE TO PLAY AGAIN", 40, 190);
     player1.play();
   } // func
   //
   // ------------------
   //
   void showHooray() {
3.   fill(255);
     strokeWeight(3);
     stroke(0);
     rect (4, 4, 325, 100);
     fill(2, 2, 255);
     text ( "LEVEL FINISHED!!!", 10, 60);
    
   } // func
   // -----------------------------------------------------------
   // all funcs for inits
   //
   void initNewLevel () {
     //
4.   println("Init New Level #"+level);
     //
     // depending on current level set some basic vars
     switch (level) {
     case 0:
       // just 2 pieces
       TILES_HORZ =2;
       TILES_VERT =1;
       winningNumberOfTiles = 2;
       break;
     case 1:
       // 4 pieces
       TILES_HORZ =2;
       TILES_VERT =2;
       winningNumberOfTiles = 4;
       break;
     case 2:
       TILES_HORZ =3;
       TILES_VERT =2;
       winningNumberOfTiles = 6;
       break;
     case 3:
       TILES_HORZ =3;
       TILES_VERT =3;
       winningNumberOfTiles = 9; // is 8
       break;
     case 4:
       TILES_HORZ =4;
       TILES_VERT =3;
       winningNumberOfTiles = 12; // is 12
       break;
     case 5:
       TILES_HORZ =4;
       TILES_VERT =4;
       winningNumberOfTiles = 16; // is 16
       break;
         case 6:
       TILES_HORZ =5;
       TILES_VERT =4;
       winningNumberOfTiles = 20; // is 20
       break;
         case 7:
       TILES_HORZ =5;
       TILES_VERT =5;
       winningNumberOfTiles = 25; // is 24
       break;
         case 8:
       TILES_HORZ =6;
       TILES_VERT =5;
       winningNumberOfTiles = 30; // is 30
       break;
         case 9:
       TILES_HORZ =6;
       TILES_VERT =6;
       winningNumberOfTiles = 36; // is 36
       break;
5.    
     default:
       println("Error 55: Unknown Level");
       break;
     } // switch
     //
     // have other vars based on that defined  
     if (level>0) {
       // level > 0
       defineNormalTileSet() ;
     }
     else
     {
       // level is 0
       defineTileSetForLevelZero() ;
     }
     textSize(54);
6. } // func
   //
   void defineTileSetForLevelZero() {
     // level is 0
     //
     println ("******************LEVEL ZERO********************************");
     // make data for tiles and the tiles
     tileWidth=width/2;
     tileHeight=height/2;
     TOTAL_TILES = 2;
     tiles = new Tile [TOTAL_TILES+1];
     tiles[0] = new Tile (0, height-tileHeight);
     tiles[1] = new Tile (tileWidth, height-tileHeight);
     println("ENDTILES");
     //
     //
     // make duplicates ---------------------
     tiles[0].hasDuplicate=true;   // both tiles have a duplicate now
     tiles[1].hasDuplicate=true;
     tiles[0].theImageCode=44;  // both tiles get the same imageCode
     tiles[1].theImageCode=44;  // saying: you two are belonging together
     int myImageIndex = giveImageIndex(); // get an index
     tiles[0].loadImageIntoTile ( myImageIndex ); // same image
     tiles[1].loadImageIntoTile ( myImageIndex );
7.   imgBack.copy(imgBackGlobal,
     0, 0, imgBackGlobal.width, imgBackGlobal.height,
     0, 0, tileWidth, 0);
8. }
   //
   void defineNormalTileSet() {
     //
     int i=0;
     tileWidth=width/TILES_HORZ-1 ;
     tileHeight=tileWidth/2;
     TOTAL_TILES = (TILES_HORZ)*(TILES_VERT);
     // not even?
     if (winningNumberOfTiles%2 != 0 ) {
9.     winningNumberOfTiles--;
     }
     tiles = new Tile [TOTAL_TILES+1];
     // now define the tiles without the images ------------------
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {  
         tiles[i] = new Tile (tileWidth*x, tileHeight*y );
         i++;
       }
     }
     //
     // make duplicates ---------------------
     i=0;
     // this arraylist "intTileIndexes" serves as a memory which
     // cards we already treated
     ArrayList <Integer> intTileIndexes = new ArrayList();
     intTileIndexes.clear();
     // fill the arraylist
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         intTileIndexes.add( i );
         i++;
       }
     }
     // still make duplicates ------
     i=0;
     imageCode=0;
     allRandomNumberImage="#";
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         makeItHaveAnDuplicate( intTileIndexes, i );
         i++;
       } // for
     } // for
     //
     // if not even, make one tile inexistent
     i=0;
     for (int x=0; x<TILES_HORZ; x++) {
       for (int y=0; y<TILES_VERT; y++) {
         // if our tile doesn't have a duplicate yet
         if (!tiles[i].hasDuplicate) {
           // we don't show it
           tiles[i].exists=false;
         } // if
         i++;
       } // for
     } // for
     // 
     imgBack.copy(imgBackGlobal,
     0, 0, imgBackGlobal.width, imgBackGlobal.height,
     0, 0, tileWidth, 0);
   } // func
   //
   void makeItHaveAnDuplicate(  ArrayList <Integer> intTileIndexes, int i ) {
     // makeItHaveAnDuplicate
     // if our tile doesn't have a duplicate yet, then it's on our to do list:
     if (!tiles[i].hasDuplicate) {
       // we search a random partner
       int safetyCounter = 0; // that avoids that the loop takes too long...
       // now we calculate a random number which is a index for intTileIndexes
       int j2 = int(random (0, intTileIndexes.size()));
       int j  = intTileIndexes.get(j2);
       // remark: he can't find a partner when the tiles are e.g. 9 (uneven),
       // then we get an error here but that's ok
       while ( (i==j || tiles[j].hasDuplicate )  && 
         (safetyCounter<50) ) {
         j2 = int(random (0, intTileIndexes.size()));
         j  = intTileIndexes.get(j2);
         safetyCounter++;
       }
       // Did he found one?
       if ( (i!=j) && (!tiles[j].hasDuplicate) ) {
         // yes
         // remove those from the arraylist
         removeFromArrayList (intTileIndexes, i);
         removeFromArrayList (intTileIndexes, j);
         tiles[i].hasDuplicate=true;   // both tiles have a duplicate now
         tiles[j].hasDuplicate=true;
         tiles[i].theImageCode=imageCode;  // both tiles get the same imageCode
         tiles[j].theImageCode=imageCode;  // saying: you two are belonging together
         int myImageIndex=giveImageIndex(); // get a name
         tiles[i].loadImageIntoTile ( myImageIndex ); // same image
         tiles[j].loadImageIntoTile ( myImageIndex );
         //
         imageCode++;                    // increase the code since it must be unique
       }
       else {
         // println ("error 119");
       } // else
     } // if
   }
   //
   int giveImageIndex() {
     // gives a image file name (that is new)
     int randomNumberImage = int (random(0, howManyImages));
     int safetyCounter = 0;
     // while not a new image keep on searching
     while ( (allRandomNumberImage.indexOf ( "#"+ str ( randomNumberImage ) + "#" ) >  -1 ) &&
       (safetyCounter<30) ) {
       randomNumberImage = int (random(0, howManyImages));
       safetyCounter++;
     }
     // found a new one
     allRandomNumberImage = allRandomNumberImage + "#" +  str( randomNumberImage ) + "#" ;
     // return value
     // return str( randomNumberImage ) +".jpg";
     return randomNumberImage;
   } // func
   //
   void removeFromArrayList (ArrayList<Integer> myArrayList, int iToBeRemoved) {
     // removes one item iToBeRemoved.
     // With an array, we say balls.length. With an ArrayList,
     // we say balls.size(). The length of an ArrayList is dynamic.
     // Notice how we are looping through the ArrayList backwards.
     // This is because we are deleting elements from the list.
     for (int i = myArrayList.size()-1; i >= 0; i--) {
       int iFromArrayList = int ( myArrayList.get(i));
       if ( iFromArrayList==iToBeRemoved ) {
         myArrayList.remove(i);
         return;
       }
     } // for
   } // func
   //
   // Inputs -----------------------------------------------------------------
   //
   void mousePressed() {
     // switch state
     switch (state) {
     case stateGamePlay:
       if (openImages != 2) {
         // search  
         int x=-1;
         for (int x2=0; x2<TOTAL_TILES; x2++) {
           if (tiles[x2].mouseInside() && tiles[x2].exists
             && !tiles[x2].isSolved &&  !tiles[x2].isShown ) {
             x=x2;
             break;
           } // if
         } // for
         //
         // found?
         if (x>-1) {
           // when one image is open make sure that the 2nd is a different one
           if ( ((openImages == 1) && ( x != lastImage)) ||
             (openImages == 0) ) { 
             // yes?
             if (tiles[x].mouseInside()) {
               tiles[x].isShown=true;
               openImages++;
               if (openImages == 1) {
                 lastImage=x;
               }
               else
               {
                 currentImage=x;
                 timer=millis();
               } // else
             } // if
           } // if
         } // if
       } // if
       break;
     case stateGameOver:
       level=0;
   println("Blammo");
        //   initNewLevel();
     //  state = stateGamePlay;
        state = stateGameStartUp;
       timer=millis();
       break;
     default:
       // do nothing
       break;
     } // switch
     //
   } // func
   void keyPressed () {
     if (state==stateGameOver) {
       level=0;
       openImages = 0;    // counter for current move  
    lastImage = -1;    // which was the last tile? (1st tile opened)
   currentImage = -1; // which is the current tile / image? (2nd tile opened)
       state = stateGameStartUp;
       timer=millis();
     }
   }
   // -------------------------------------------------------
   // smaller tools
   //
   //
   void drawTiles() {
     // draw it
     for (int x=0; x<TOTAL_TILES; x++) {//println("X: "+x+"  TOTTILES: "+TOTAL_TILES);
       tiles[x].draw();
     }
     //
   }
   //
   void checkTwoShownTiles () {
     // after a move:
     // if two images are shown we have to check them
     if (openImages == 2) {
       // but only after a while
       if (timer + 1000 < millis()) {
         // two are shown (the user has made his move)
         openImages=0; // reset
         // check
         if ( tiles[currentImage].theImageCode == tiles[lastImage].theImageCode)
         {
           //  correct
           println ("Good");
           tiles[currentImage].isSolved=true;
           tiles[lastImage].isSolved=true;
           checkIfSolved();
         }
         else
         {
           // not correct: the are hidden again 
           tiles[currentImage].isShown=false;
           tiles[lastImage].isShown=false;
         }
       }
     }
   } // func
   //
   void checkIfSolved() {
     // check if this level is complete 
     int counter = 0;
     // Are all shown and solved?
     for (int x2=0; x2<TOTAL_TILES; x2++) {
       if (tiles[x2].isSolved) {
         counter ++;
       }
     }
     //
     if (counter==winningNumberOfTiles)
     {
       state=stateGameGoToNextLevelPhase1; // won this level -> stateGameGoToNextLevelPhase1
       println ("You won this level.");
       level++;
       timer=millis();
     }
   }
   //
   // ================================================================
   //Tile Class (one image card)
   class Tile
   {
     int imgIndex;   // the image index
     float px;     // position
     float py;
     // those three (4) could be unified to a var stateOfTile : nonExistent, withoutDuplicate, covered, shown, solved
     boolean isShown  = false;      // shown or covered?
     boolean isSolved = false;      // the duplicate is not only shown but correct and now permanently shown
     boolean exists   = true;       // does the tile exist at all?
     boolean hasDuplicate = false;  // while init not all images have a duplicate yet
     //
     int theImageCode = -1;         // the partners are identified with the same number (which is otherwise meaningless, except both have the same).
     //
     // constr
     Tile ( float px_, float py_ )
     {
       px=px_;
       py=py_;
     } // constr
     //
     void loadImageIntoTile ( int imageName_ ) {
       imgIndex  = imageName_;
     } // method
     //
     void draw()
     {
       // if it exists at all?
       if (exists) {
         // we show it.
         // uncovered or covered?
         if (isShown) {
           // open
           if (images[imgIndex]!=null){
             image(images[imgIndex], px, py,tileWidth,tileHeight);}
           else
             println ("images[imgIndex] is null");
           stroke(255);
           noFill();
           rect(px, py, tileWidth, tileHeight);
           // if tile is solved correctly
           if (isSolved)
           {
             // we show the OK sign
             textSize(34);
             fill(255);
             strokeWeight(4);
             stroke(0);
             rect(px+tileWidth-170, py+tileHeight-58, 160, 40);
             fill(2, 2, 255);
             text( "MATCH!", px+tileWidth-150, py+tileHeight-27 );
             fill(255);
           }
         }
         else
         {println("Tiles not shown");
           // not shown / covered tile with a "?" or imgBack
           image(imgBack, px, py,tileWidth,tileHeight);
           textSize(54);
           stroke(255);
           noFill();
           //fill(0);
           rect(px, py, tileWidth, tileHeight);
10.       } // else
        } //  if (exists) {
      } // method
      //
      boolean mouseInside()
      {
        return ((px <= mouseX && mouseX <= px + tileWidth) &&
          (py <= mouseY && mouseY <= py + tileHeight));
      } // method
      //
    } // class