hello,

I made a test with 6 different patterns with two tile sizes:  30x60 and 3x30.

How it works
The principle is always to have two loops that are within each other.
One is for the x-value (the columns) the other for y (the rows).
Thus you lay out the tiles.

Via asking if ((x%2) == 0) you can check whether a row is even or not (modulo is zero).
Depending on that, different tiles are chosen (either row or column or both).


Change the pattern
you can change the pattern in use via comment and uncomment.

Greetings, Chrisir  

1. // idea: http://forum.processing.org/topic/total-newbie-floor-tile-patterns
2. //
3. // ---------------------------------------------------------------
4. //
5. void setup()
6. {
7.   // init
8.   size(800, 600);
9. } // func
10. //
11. //
12. void draw()
13. {
14.   background(255);
15.   // chose one
16.   // pattern1();
17.   // pattern2();
18.   // pattern3();
19.   // pattern4();
20.   // pattern5();
21.   pattern6();
22. } // func
23. //
24. // =====================================================================
25. void pattern1() {
26.   // all big tiles
27.   for (int x=0; x < 10; x++) {
28.     for (int y=0; y < 30; y++) {
29.       rect (x*30, y*60, 30, 60);
30.     }
31.   }
32. }
33. void pattern2() {
34.   // big tile, 2 small ones, big tile
35.   for (int x=0; x < 10; x++) {
36.     for (int y=0; y < 30; y++) {
37.       if (x % 2 == 0)
38.       {
39.         // do 2 small tiles
40.         for (int k=0; k < 2; k++) {
41.           fill (k*200, 255, 255); 
42.           rect (x*30, y*60+k*30, 30, 30);
43.         }
44.       }
45.       else
46.       {
47.         fill (0, 0, 255); 
48.         rect (x*30, y*60, 30, 60);
49.       }
50.     }
51.   }
52. }
53. void pattern3() {
54.   // big tile, 2 small ones, big tile
55.   // but this time alternate rows
56.   for (int i=0; i < 30; i++) {
57.     for (int j=0; j < 30; j++) {
58.       // if row (aka y) is even
59.       if (j % 2 == 0) {
60.         // now check column
61.         if (i % 2 == 0)
62.         {
63.           for (int k=0; k < 2; k++) {
64.             fill (k*200, 255, 255); 
65.             rect (i*30, j*60+k*30, 30, 30);
66.           }
67.         }
68.         else
69.         {
70.           fill (0, 0, 255); 
71.           rect (i*30, j*60, 30, 60);
72.         }
73.       }
74.       // if row (aka y) is NOT even
75.       else
76.       {
77.         // now check column
78.         if (i % 2 == 0)
79.         {
80.           fill (0, 0, 255); 
81.           rect (i*30, j*60, 30, 60);
82.         }
83.         else
84.         {
85.           for (int k=0; k < 2; k++) {
86.             //fill (0, 255, 255); 
87.             fill (200, 255, k*255);
88.             rect (i*30, j*60+k*30, 30, 30);
89.           }
90.         }
91.       }
92.     }
93.   }
94. }
95. void pattern4() {
96.   // all small tiles
97.   for (int x=0; x < 10; x++) {
98.     for (int y=0; y < 30; y++) {
99.       rect (x*30, y*30, 30, 30);
100.     }
101.   }
102. }
103. void pattern5() {
104.   // small tiles and big ones (big ones are lying)
105.   boolean bigOne=false;
106.   for (int y=0; y < 30; y++) {
107.     for (int x=0; x < 11; x++) {
108.       if (!bigOne) {
109.         // small one
110.         rect (x*30, y*30, 30, 30);
111.         bigOne=true;
112.       }
113.       else
114.       {
115.         rect (x*30, y*30, 60, 30);
116.         x++;
117.         bigOne=false;
118.       }
119.     }
120.   }
121. }
122. void pattern6() {
123.   // small tiles and big ones (big ones are lying)
124.   // alternates in rows
125.   boolean bigOne=false;
126.   for (int y=0; y < 30; y++) {
127.     //
128.     for (int x=0; x < 34; x++) {
129.       if (!bigOne) {
130.         // small one
131.         fill(255, 2, 2);
132.         rect (x*30, y*30, 30, 30);
133.         bigOne=true;
134.       }
135.       else
136.       {
137.         // big
138.         fill(2, 2, 255);
139.         rect (x*30, y*30, 60, 30);
140.         x++;
141.         bigOne=false;
142.       }
143.     }
144.   } // for
145. } // func
146. // =====================================================================