I am trying to make a multi-state CA similar to the image above.  The code was shared on the website but when I copied and pasted it I only got coloured points, not coloured cells, as in the image above.  Can someone help me figure out what is going on?  The code is long, but I can't tell what parts are actually doing something and what's fat. Thanks

2. class WuXingCell
3. 
   
4. 
   
5. {
6.   float[] element;
7. };
8. 
   
9. int worldScale = 8;
10. int worldSize = 64;
11. int mode = 1;
12. 
    
13. WuXingCell[][] world;
14. WuXingCell[][] nextWorld;
15. 
    
16. color[] WuXingColor;
17. float waterLevel = .25;
18. int dayBand = 0;
19. float natLog = 0.36787944118;
20. float eLog = 2.7182818284;
21. float growRate = .2;
22. float destroyRate = .11;
23. float insultRate = .1;
24. float growThresh = .1;
25. float destroyThresh = .2;
26. float insultThresh = .4;
27. 
    
28. float[] elementFlow; //how much is moved when it erodes
29. float[] elementStrength; //when element decides to erode
30. float[] elementDistScale; //distance from strongest points
31. float[] elementReactivity;
32. int dominantElement = 0;
33. float seaLevel = 0;
34. 
    
35. int water = 0; //we do this so the code is more readable, also showing the cyclical order
36. int wood = 1;
37. int fire = 2;
38. int earth = 3;
39. int metal = 4;
40. int mouseElement = 0;
41. 
    
42. float[] alchemyAmounts;
43. float[] alchemyAdditives;
44. boolean elementPoles = true;
45. boolean react = false;
46. 
    
47. 
    
48. ///////////////////////////////
49. 
    
50. void updateWorld() {
51.   for (int i = 0; i < worldSize; i++) {
52.     for (int j = 0; j < worldSize; j++) {
53.       for (int k = 0; k < 5; k++) {
54.         world[i][j].element[k] = nextWorld[i][j].element[k];
55.       }
56.     }
57.   }
58. }
59. 
    
60. 
    
61. //////////////////////////////
62. 
    
63. void ProcessWorld() {
64.   for (int i = 0; i < worldSize; i++) {
65.     for (int j = 0; j < worldSize; j++) {
66.       for (int k = 0; k < 5; k++) { //imagine 5 buckets in each cell, we look at them and their neighbors…
67.         alchemyAmounts[k] = world[i][j].element[k];
68.         for (int adjI = -1; adjI < 2; adjI++) {
69.           for (int adjJ = -1; adjJ < 2; adjJ++) {
70.             alchemyAmounts[k] += (world[LoopVar(i + adjI)][LoopVar(j + adjJ)].element[k]) * (0.125); //0.125 = 1/8th, averaging the 8 adjacent cells
71.           }
72.         }
73.       }
74.       ProcessAlchemy(); //now that we have the amounts, process what they do…
75.       for (int k = 0; k < 5; k++) { //a little bit of hacky averaging, and updating the old board
76.         alchemyAmounts[k]/=2;
77.         nextWorld[i][j].element[k] = alchemyAmounts[k];
78.       }
79.     }
80.   }
81. }
82. 
    
83. 
    
84. /////////////////////////////
85. 
    
86. void ProcessAlchemy() {
87.   float[] newAlchemy = new float[5];
88.   float[] fractionOf = new float[5];
89.   float totalAmount = 0;
90. 
    
91.   for (int k = 0; k < 5; k++) {
92.     newAlchemy[k] = alchemyAmounts[k];
93.     totalAmount += alchemyAmounts[k];
94.   }
95.   for (int k = 0; k < 5; k++) {
96.     fractionOf[k] = totalAmount/alchemyAmounts[k];
97.   }
98.   int grandParent, parent, child, grandChild;
99.   for (int k = 0; k < 5; k++) { //figure out what elements are “parent”, “child” etc. relative to the one you’re on
100.     grandParent = 6;
101.     parent = 6;
102.     child = 6;
103.     grandChild = 6;
104. 
     
105.     if (k == water) {
106.       grandParent = earth;
107.       parent = metal;
108.       child = wood;
109.       grandChild = fire;
110.     }
111. 
     
112.     if (k == wood) {
113.       grandParent = metal;
114.       parent = water;
115.       child = fire;
116.       grandChild = earth;
117.     }
118. 
     
119.     if (k == fire) {
120.       grandParent = water;
121.       parent = wood;
122.       child = earth;
123.       grandChild = metal;
124.     }
125. 
     
126.     if (k == earth) {
127.       grandParent = wood;
128.       parent = fire;
129.       child = metal;
130.       grandChild = water;
131.     }
132. 
     
133.     if (k == metal) {
134.       grandParent = fire;
135.       parent = earth;
136.       child = water;
137.       grandChild = wood;
138.     }
139. 
     
140.     elementReactivity[k] = 1;// *= 1.5; //how much do we react the elements (scalar, multply by this amount)
141.     //natLog = .3;
142.     newAlchemy[k] += (alchemyAmounts[parent] * natLog);
143.     newAlchemy[k] -= (alchemyAmounts[child] * natLog);
144. 
     
145.     if (alchemyAmounts[grandParent] > alchemyAmounts[k]) { //grandfather destroys…
146.       newAlchemy[k] -= (alchemyAmounts[grandParent] * natLog);
147.     }
148.     // else //…or it’s too big and we’re insulted
149. 
     
150.     if (alchemyAmounts[grandChild] > alchemyAmounts[k]) {  //grandfather destroys…
151.       newAlchemy[k] -= (alchemyAmounts[grandParent] * natLog);
152.     }
153. 
     
154.     if ( newAlchemy[k] > 1.0) newAlchemy[k] = 1.0;
155.     if ( newAlchemy[k] < 0.0) newAlchemy[k] = 0.0;
156.   }
157.   for (int k = 0; k < 5; k++) {
158.     alchemyAmounts[k] = newAlchemy[k];
159.   }
160. }
161. 
     
162. 
     
163. ////////////////////////////////////////////
164. 
     
165. void draw() {
166.   dominantElement += 1;
167.   if (dominantElement >= 5) dominantElement = 0;
168.   ProcessWorld();
169.   ProcessAlchemy();
170.   updateWorld();
171.   background(0);
172. 
     
173.   color pixelColor = color(0, 0, 0);
174.   float finRed, finGreen, finBlue;
175. 
     
176.   if (keyPressed) {
177.     if (key == '0') {
178.       alchemyAdditives[water] += .1;
179.       //mouseElement = water;
180.     }
181. 
     
182.     if (key == '1') {
183.       alchemyAdditives[wood] += .1;
184.       //mouseElement = wood;
185.     }
186. 
     
187.     if (key == '2') {
188.       alchemyAdditives[fire] += .1;
189.       //mouseElement = fire;
190.     }
191. 
     
192.     if (key == '3') {
193.       alchemyAdditives[earth] += .1;
194.       //mouseElement = earth;
195.     }
196. 
     
197.     if (key == '4') {
198.       alchemyAdditives[metal] += .1;
199.       //mouseElement = metal;
200.     }
201. 
     
202.     if (key == 'r') {
203.       for (int k = 0; k < 5; k++) {
204.         alchemyAmounts[k]= random(0, 1.0);
205.       }
206.     }
207. 
     
208.     if (key == 'e') {
209.       for (int k = 0; k < 5; k++) {
210.         alchemyAmounts[k]= 0;
211.         alchemyAdditives[k] = 0;
212.       }
213.       //mouseElement = water;
214.     }
215. 
     
216.     if (key == 't') {
217.       for (int k = 0; k < 5; k++) {
218.         alchemyAmounts[k] += alchemyAdditives[k];
219.         alchemyAdditives[k] = 0;
220.       }
221.       //mouseElement = water;
222.     }
223. }
224. 
     
225.   float maxElement = 0;
226.   int theMaxElement = 0;
227.   int numElements = 0;
228. 
     
229.   for (int i = 0; i < worldSize; i++) { //do a bunch of comparisons to get colors, but we’re basically looping through the board and drawing
230.     for (int j = 0; j < worldSize; j++) {
231. 
     
232.       finRed = 0;
233.       finGreen = 0;
234.       finBlue = 0;
235.       maxElement = 0;
236.       theMaxElement = 0;
237.       numElements = 0;
238. 
     
239.       for (int k = 0; k < 5; k++) {
240.         if (world[i][j].element[k] > maxElement) {
241.           maxElement = world[i][j].element[k];
242.           theMaxElement = k;
243.         }
244. 
     
245.         if (world[i][j].element[k] > 0) {
246.           numElements++;
247.         }
248. 
     
249.         finRed += (red(WuXingColor[k]) * world[i][j].element[k]);
250.         finGreen += (green(WuXingColor[k]) * world[i][j].element[k]);
251.         finBlue += (blue(WuXingColor[k]) * world[i][j].element[k]);
252.       }
253. 
     
254.       finRed /= numElements;
255.       finGreen /= numElements;
256.       finBlue /= numElements;
257. 
     
258.       if (((world[i][j].element[earth] + world[i][j].element[metal])/2) <= seaLevel) {
259.         pixelColor = color(0, 0, seaLevel);
260.       }
261. 
     
262.       else {
263.       // pixelColor = WuXingColor[theMaxElement];//color(finRed,finGreen,finBlue);
264.        // pixelColor *= world[i][j].element[theMaxElement];
265.         pixelColor = color(world[i][j].element[3],world[i][j].element[2],0);
266. 
     
267.         switch(theMaxElement) {
268. 
     
269.         case 0:
270.           pixelColor = color(0, world[i][j].element[0], world[i][j].element[0]);
271.           break;
272. 
     
273.         case 1:
274.           pixelColor = color(0, world[i][j].element[1], 0);
275.           break;
276. 
     
277.         case 2:
278. 
     
279.           pixelColor = color(1.0, 0, 0);
280.           break;
281. 
     
282.         case 3:
283.           pixelColor = color(world[i][j].element[3], world[i][j].element[2], 0);
284.           break;
285. 
     
286.         case 4:
287.           pixelColor = color(world[i][j].element[3], world[i][j].element[3], world[i][j].element[2]);
288.           break;
289.         }
290. 
     
291.         pixelColor = color(finRed, finGreen, finBlue);//color(finRed,finGreen,finBlue);
292.       }
293. 
     
294. //      if (((world[i][j].element[earth] + world[i][j].element[earth])/2) > seaLevel) {
295. //       // pixelColor = color(0,(world[i][j].element[earth] + world[i][j].element[earth])/2,0);
296. //      }
297. //
298. //      else {
299. //       // pixelColor = color(0,(world[i][j].element[earth] + world[i][j].element[earth])/2,.75);
300. //      }
301. //
302. //      if (((world[i][j].element[earth] + world[i][j].element[metal])/2) <= seaLevel) {
303. //      // pixelColor = color(0,0,seaLevel);
304. //      }
305. //
306. //      else {
307. //        //pixelColor = color(finRed,finGreen,finBlue);
308. //      }
309. 
     
310.       // if (elementVision != 5) pixelColor = color(0,world[i][j].element[elementVision],0);
311.       //pixelColor = color(0,world[i][j].element[metal],0);
312.        //pixelColor = color(0,0, world[i][j].element[0] );
313.       //pixelColor = color (world[i][j].element[0],0,0);
314.       set (i * 10,j * 10, pixelColor);
315.       fill(pixelColor);
316.     }
317.   }
318. }
319. 
     
320. 
     
321. 
     
322. float Clamp(float tempVar, float low, float high) {
323.   if (tempVar < low) tempVar = low;
324.   if (tempVar > high) tempVar = high;
325.   return tempVar;
326. }
327. 
     
328. int LoopVar(int theVar) { //clamps var to make sure we loop, assume error is never more than one or two “off map”
329.   if (theVar < 0) {
330.     theVar += worldSize;
331.   }
332. 
     
333.   if (theVar >= worldSize) {
334.     theVar -= worldSize;
335.   }
336.   return theVar;
337. }
338. 
     
339. 
     
340. /////////////////////////////////////////////////
341. 
     
342. void setup() {
343.   //worldScale = 2;
344.   frameRate(24);
345.   colorMode(RGB, 1.0);
346.   size(worldSize * worldScale, worldSize * worldScale);
347.   world = new WuXingCell[worldSize][worldSize];
348.   nextWorld = new WuXingCell[worldSize][worldSize];
349.   growRate = .2;
350.   destroyRate = .2;
351.   insultRate = .1;
352.   WuXingColor = new color[5];
353.   WuXingColor[water] = color(0, 0, 1);//water
354.   WuXingColor[wood] = color(0, 1, 0);//wood
355.   WuXingColor[fire] = color(1, 0, 0);//fire
356.   WuXingColor[earth] = color(1, 1, 0);//earth
357.   WuXingColor[metal] = color(1, 1, 1);//metal
358.   elementFlow = new float[5];
359.   elementStrength = new float[5];
360.   elementDistScale = new float[5];
361.   elementReactivity = new float[5];
362.   alchemyAmounts = new float[5];
363.   alchemyAdditives = new float[5];
364. 
     
365.   for (int k = 0; k < 5; k++) {
366.     elementFlow[k] = 0;
367.     elementStrength[k] = 0;
368.     elementDistScale[k] = 1;
369.     elementReactivity[k] = 1;
370.     alchemyAmounts[k] = 0.5;//random(0,1.0);
371.     alchemyAdditives[k] = 0;
372.   }
373. 
     
374.   elementFlow[earth] = .05; //earth
375.   elementStrength[earth] = .1;
376.   elementFlow[metal] = .25; //metal
377.   elementStrength[metal] = .3;
378.   elementFlow[metal] = .4; //metal
379.   elementStrength[metal] = .5;
380.   elementFlow[fire] = .21;
381.   elementStrength[fire] = .11;
382. 
     
383.   for (int i = 0; i < worldSize; i++) {
384.     for (int j = 0; j < worldSize; j++) {
385.       world[i][j] = new WuXingCell();
386.       world[i][j].element = new float[5];
387.       for (int k = 0; k < 5; k++) {
388.         world[i][j].element[k] = random(.1, .9);//.25 + random(0,.5);//random(0.0,1.0);//.5;
389.          //world[i][j].element[k] = 0.5;
390.         //world[i][j].element[k]/=255;
391.       }
392.       //world[i][j].element[0] = .6;
393.       //world[i][j].element[0] = .2;
394.       nextWorld[i][j] = new WuXingCell();
395.       nextWorld[i][j].element = new float[5];
396.       for (int k = 0; k < 5; k++) {
397.         nextWorld[i][j].element[k] = 1;//random(0,1);
398.       }
399.     }
400.   }
401. }